4
** The author disclaims copyright to this source code. In place of
5
** a legal notice, here is a blessing:
7
** May you do good and not evil.
8
** May you find forgiveness for yourself and forgive others.
9
** May you share freely, never taking more than you give.
11
*************************************************************************
12
** This file contains code used to implement the PRAGMA command.
14
** $Id: pragma.c,v 1.91 2005/03/29 03:10:59 danielk1977 Exp $
16
#include "sqliteInt.h"
20
/* Ignore this whole file if pragmas are disabled
22
#ifndef SQLITE_OMIT_PRAGMA
24
#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
30
** Interpret the given string as a safety level. Return 0 for OFF,
31
** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or
32
** unrecognized string argument.
34
** Note that the values returned are one less that the values that
35
** should be passed into sqlite3BtreeSetSafetyLevel(). The is done
36
** to support legacy SQL code. The safety level used to be boolean
37
** and older scripts may have used numbers 0 for OFF and 1 for ON.
39
static int getSafetyLevel(const u8 *z){
40
/* 123456789 123456789 */
41
static const char zText[] = "onoffalseyestruefull";
42
static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
43
static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
44
static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2};
50
for(i=0; i<sizeof(iLength); i++){
51
if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
59
** Interpret the given string as a boolean value.
61
static int getBoolean(const u8 *z){
62
return getSafetyLevel(z)&1;
65
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
67
** Interpret the given string as a temp db location. Return 1 for file
68
** backed temporary databases, 2 for the Red-Black tree in memory database
69
** and 0 to use the compile-time default.
71
static int getTempStore(const char *z){
72
if( z[0]>='0' && z[0]<='2' ){
74
}else if( sqlite3StrICmp(z, "file")==0 ){
76
}else if( sqlite3StrICmp(z, "memory")==0 ){
82
#endif /* SQLITE_PAGER_PRAGMAS */
84
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
86
** Invalidate temp storage, either when the temp storage is changed
87
** from default, or when 'file' and the temp_store_directory has changed
89
static int invalidateTempStorage(Parse *pParse){
90
sqlite3 *db = pParse->db;
91
if( db->aDb[1].pBt!=0 ){
92
if( db->flags & SQLITE_InTrans ){
93
sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
94
"from within a transaction");
97
sqlite3BtreeClose(db->aDb[1].pBt);
99
sqlite3ResetInternalSchema(db, 0);
103
#endif /* SQLITE_PAGER_PRAGMAS */
105
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
107
** If the TEMP database is open, close it and mark the database schema
108
** as needing reloading. This must be done when using the TEMP_STORE
109
** or DEFAULT_TEMP_STORE pragmas.
111
static int changeTempStorage(Parse *pParse, const char *zStorageType){
112
int ts = getTempStore(zStorageType);
113
sqlite3 *db = pParse->db;
114
if( db->temp_store==ts ) return SQLITE_OK;
115
if( invalidateTempStorage( pParse ) != SQLITE_OK ){
121
#endif /* SQLITE_PAGER_PRAGMAS */
124
** Generate code to return a single integer value.
126
static void returnSingleInt(Parse *pParse, const char *zLabel, int value){
127
Vdbe *v = sqlite3GetVdbe(pParse);
128
sqlite3VdbeAddOp(v, OP_Integer, value, 0);
129
if( pParse->explain==0 ){
130
sqlite3VdbeSetNumCols(v, 1);
131
sqlite3VdbeSetColName(v, 0, zLabel, P3_STATIC);
133
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
136
#ifndef SQLITE_OMIT_FLAG_PRAGMAS
138
** Check to see if zRight and zLeft refer to a pragma that queries
139
** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
140
** Also, implement the pragma.
142
static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
143
static const struct sPragmaType {
144
const char *zName; /* Name of the pragma */
145
int mask; /* Mask for the db->flags value */
147
{ "vdbe_trace", SQLITE_VdbeTrace },
148
{ "sql_trace", SQLITE_SqlTrace },
149
{ "vdbe_listing", SQLITE_VdbeListing },
150
{ "full_column_names", SQLITE_FullColNames },
151
{ "short_column_names", SQLITE_ShortColNames },
152
{ "count_changes", SQLITE_CountRows },
153
{ "empty_result_callbacks", SQLITE_NullCallback },
154
/* The following is VERY experimental */
155
{ "writable_schema", SQLITE_WriteSchema },
156
{ "omit_readlock", SQLITE_NoReadlock },
159
const struct sPragmaType *p;
160
for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){
161
if( sqlite3StrICmp(zLeft, p->zName)==0 ){
162
sqlite3 *db = pParse->db;
164
v = sqlite3GetVdbe(pParse);
167
returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
169
if( getBoolean(zRight) ){
170
db->flags |= p->mask;
172
db->flags &= ~p->mask;
175
/* If one of these pragmas is executed, any prepared statements
176
** need to be recompiled.
178
sqlite3VdbeAddOp(v, OP_Expire, 0, 0);
185
#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
188
** Process a pragma statement.
190
** Pragmas are of this form:
192
** PRAGMA [database.]id [= value]
194
** The identifier might also be a string. The value is a string, and
195
** identifier, or a number. If minusFlag is true, then the value is
196
** a number that was preceded by a minus sign.
198
** If the left side is "database.id" then pId1 is the database name
199
** and pId2 is the id. If the left side is just "id" then pId1 is the
200
** id and pId2 is any empty string.
204
Token *pId1, /* First part of [database.]id field */
205
Token *pId2, /* Second part of [database.]id field, or NULL */
206
Token *pValue, /* Token for <value>, or NULL */
207
int minusFlag /* True if a '-' sign preceded <value> */
209
char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
210
char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
211
const char *zDb = 0; /* The database name */
212
Token *pId; /* Pointer to <id> token */
213
int iDb; /* Database index for <database> */
214
sqlite3 *db = pParse->db;
216
Vdbe *v = sqlite3GetVdbe(pParse);
219
/* Interpret the [database.] part of the pragma statement. iDb is the
220
** index of the database this pragma is being applied to in db.aDb[]. */
221
iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
225
zLeft = sqlite3NameFromToken(pId);
228
zRight = sqlite3MPrintf("-%T", pValue);
230
zRight = sqlite3NameFromToken(pValue);
233
zDb = ((iDb>0)?pDb->zName:0);
234
if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
238
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
240
** PRAGMA [database.]default_cache_size
241
** PRAGMA [database.]default_cache_size=N
243
** The first form reports the current persistent setting for the
244
** page cache size. The value returned is the maximum number of
245
** pages in the page cache. The second form sets both the current
246
** page cache size value and the persistent page cache size value
247
** stored in the database file.
249
** The default cache size is stored in meta-value 2 of page 1 of the
250
** database file. The cache size is actually the absolute value of
251
** this memory location. The sign of meta-value 2 determines the
252
** synchronous setting. A negative value means synchronous is off
253
** and a positive value means synchronous is on.
255
if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
256
static const VdbeOpList getCacheSize[] = {
257
{ OP_ReadCookie, 0, 2, 0}, /* 0 */
258
{ OP_AbsValue, 0, 0, 0},
260
{ OP_Integer, 0, 0, 0},
262
{ OP_Integer, 0, 0, 0}, /* 5 */
263
{ OP_Callback, 1, 0, 0},
266
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
268
sqlite3VdbeSetNumCols(v, 1);
269
sqlite3VdbeSetColName(v, 0, "cache_size", P3_STATIC);
270
addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
271
sqlite3VdbeChangeP1(v, addr, iDb);
272
sqlite3VdbeChangeP1(v, addr+5, MAX_PAGES);
274
int size = atoi(zRight);
275
if( size<0 ) size = -size;
276
sqlite3BeginWriteOperation(pParse, 0, iDb);
277
sqlite3VdbeAddOp(v, OP_Integer, size, 0);
278
sqlite3VdbeAddOp(v, OP_ReadCookie, iDb, 2);
279
addr = sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
280
sqlite3VdbeAddOp(v, OP_Ge, 0, addr+3);
281
sqlite3VdbeAddOp(v, OP_Negative, 0, 0);
282
sqlite3VdbeAddOp(v, OP_SetCookie, iDb, 2);
283
pDb->cache_size = size;
284
sqlite3BtreeSetCacheSize(pDb->pBt, pDb->cache_size);
289
** PRAGMA [database.]page_size
290
** PRAGMA [database.]page_size=N
292
** The first form reports the current setting for the
293
** database page size in bytes. The second form sets the
294
** database page size value. The value can only be set if
295
** the database has not yet been created.
297
if( sqlite3StrICmp(zLeft,"page_size")==0 ){
298
Btree *pBt = pDb->pBt;
300
int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0;
301
returnSingleInt(pParse, "page_size", size);
303
sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1);
306
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
309
** PRAGMA [database.]auto_vacuum
310
** PRAGMA [database.]auto_vacuum=N
312
** Get or set the (boolean) value of the database 'auto-vacuum' parameter.
314
#ifndef SQLITE_OMIT_AUTOVACUUM
315
if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
316
Btree *pBt = pDb->pBt;
319
pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM;
320
returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
322
sqlite3BtreeSetAutoVacuum(pBt, getBoolean(zRight));
327
#ifndef SQLITE_OMIT_PAGER_PRAGMAS
329
** PRAGMA [database.]cache_size
330
** PRAGMA [database.]cache_size=N
332
** The first form reports the current local setting for the
333
** page cache size. The local setting can be different from
334
** the persistent cache size value that is stored in the database
335
** file itself. The value returned is the maximum number of
336
** pages in the page cache. The second form sets the local
337
** page cache size value. It does not change the persistent
338
** cache size stored on the disk so the cache size will revert
339
** to its default value when the database is closed and reopened.
340
** N should be a positive integer.
342
if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
343
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
345
returnSingleInt(pParse, "cache_size", pDb->cache_size);
347
int size = atoi(zRight);
348
if( size<0 ) size = -size;
349
pDb->cache_size = size;
350
sqlite3BtreeSetCacheSize(pDb->pBt, pDb->cache_size);
356
** PRAGMA temp_store = "default"|"memory"|"file"
358
** Return or set the local value of the temp_store flag. Changing
359
** the local value does not make changes to the disk file and the default
360
** value will be restored the next time the database is opened.
362
** Note that it is possible for the library compile-time options to
363
** override this setting
365
if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
367
returnSingleInt(pParse, "temp_store", db->temp_store);
369
changeTempStorage(pParse, zRight);
374
** PRAGMA temp_store_directory
375
** PRAGMA temp_store_directory = ""|"directory_name"
377
** Return or set the local value of the temp_store_directory flag. Changing
378
** the value sets a specific directory to be used for temporary files.
379
** Setting to a null string reverts to the default temporary directory search.
380
** If temporary directory is changed, then invalidateTempStorage.
383
if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
385
if( sqlite3_temp_directory ){
386
sqlite3VdbeSetNumCols(v, 1);
387
sqlite3VdbeSetColName(v, 0, "temp_store_directory", P3_STATIC);
388
sqlite3VdbeOp3(v, OP_String8, 0, 0, sqlite3_temp_directory, 0);
389
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
392
if( zRight[0] && !sqlite3OsIsDirWritable(zRight) ){
393
sqlite3ErrorMsg(pParse, "not a writable directory");
397
|| (TEMP_STORE==1 && db->temp_store<=1)
398
|| (TEMP_STORE==2 && db->temp_store==1)
400
invalidateTempStorage(pParse);
402
sqliteFree(sqlite3_temp_directory);
404
sqlite3_temp_directory = zRight;
407
sqlite3_temp_directory = 0;
413
** PRAGMA [database.]synchronous
414
** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
416
** Return or set the local value of the synchronous flag. Changing
417
** the local value does not make changes to the disk file and the
418
** default value will be restored the next time the database is
421
if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
422
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
424
returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
426
if( !db->autoCommit ){
427
sqlite3ErrorMsg(pParse,
428
"Safety level may not be changed inside a transaction");
430
pDb->safety_level = getSafetyLevel(zRight)+1;
431
sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level);
435
#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
437
#ifndef SQLITE_OMIT_FLAG_PRAGMAS
438
if( flagPragma(pParse, zLeft, zRight) ){
439
/* The flagPragma() subroutine also generates any necessary code
440
** there is nothing more to do here */
442
#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
444
#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
446
** PRAGMA table_info(<table>)
448
** Return a single row for each column of the named table. The columns of
449
** the returned data set are:
451
** cid: Column id (numbered from left to right, starting at 0)
453
** type: Column declaration type.
454
** notnull: True if 'NOT NULL' is part of column declaration
455
** dflt_value: The default value for the column, if any.
457
if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
459
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
460
pTab = sqlite3FindTable(db, zRight, zDb);
463
sqlite3VdbeSetNumCols(v, 6);
464
sqlite3VdbeSetColName(v, 0, "cid", P3_STATIC);
465
sqlite3VdbeSetColName(v, 1, "name", P3_STATIC);
466
sqlite3VdbeSetColName(v, 2, "type", P3_STATIC);
467
sqlite3VdbeSetColName(v, 3, "notnull", P3_STATIC);
468
sqlite3VdbeSetColName(v, 4, "dflt_value", P3_STATIC);
469
sqlite3VdbeSetColName(v, 5, "pk", P3_STATIC);
470
sqlite3ViewGetColumnNames(pParse, pTab);
471
for(i=0; i<pTab->nCol; i++){
472
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
473
sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[i].zName, 0);
474
sqlite3VdbeOp3(v, OP_String8, 0, 0,
475
pTab->aCol[i].zType ? pTab->aCol[i].zType : "numeric", 0);
476
sqlite3VdbeAddOp(v, OP_Integer, pTab->aCol[i].notNull, 0);
477
sqlite3ExprCode(pParse, pTab->aCol[i].pDflt);
478
sqlite3VdbeAddOp(v, OP_Integer, pTab->aCol[i].isPrimKey, 0);
479
sqlite3VdbeAddOp(v, OP_Callback, 6, 0);
484
if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
487
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
488
pIdx = sqlite3FindIndex(db, zRight, zDb);
492
sqlite3VdbeSetNumCols(v, 3);
493
sqlite3VdbeSetColName(v, 0, "seqno", P3_STATIC);
494
sqlite3VdbeSetColName(v, 1, "cid", P3_STATIC);
495
sqlite3VdbeSetColName(v, 2, "name", P3_STATIC);
496
for(i=0; i<pIdx->nColumn; i++){
497
int cnum = pIdx->aiColumn[i];
498
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
499
sqlite3VdbeAddOp(v, OP_Integer, cnum, 0);
500
assert( pTab->nCol>cnum );
501
sqlite3VdbeOp3(v, OP_String8, 0, 0, pTab->aCol[cnum].zName, 0);
502
sqlite3VdbeAddOp(v, OP_Callback, 3, 0);
507
if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
510
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
511
pTab = sqlite3FindTable(db, zRight, zDb);
513
v = sqlite3GetVdbe(pParse);
517
sqlite3VdbeSetNumCols(v, 3);
518
sqlite3VdbeSetColName(v, 0, "seq", P3_STATIC);
519
sqlite3VdbeSetColName(v, 1, "name", P3_STATIC);
520
sqlite3VdbeSetColName(v, 2, "unique", P3_STATIC);
522
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
523
sqlite3VdbeOp3(v, OP_String8, 0, 0, pIdx->zName, 0);
524
sqlite3VdbeAddOp(v, OP_Integer, pIdx->onError!=OE_None, 0);
525
sqlite3VdbeAddOp(v, OP_Callback, 3, 0);
533
if( sqlite3StrICmp(zLeft, "database_list")==0 ){
535
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
536
sqlite3VdbeSetNumCols(v, 3);
537
sqlite3VdbeSetColName(v, 0, "seq", P3_STATIC);
538
sqlite3VdbeSetColName(v, 1, "name", P3_STATIC);
539
sqlite3VdbeSetColName(v, 2, "file", P3_STATIC);
540
for(i=0; i<db->nDb; i++){
541
if( db->aDb[i].pBt==0 ) continue;
542
assert( db->aDb[i].zName!=0 );
543
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
544
sqlite3VdbeOp3(v, OP_String8, 0, 0, db->aDb[i].zName, 0);
545
sqlite3VdbeOp3(v, OP_String8, 0, 0,
546
sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
547
sqlite3VdbeAddOp(v, OP_Callback, 3, 0);
551
if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
554
sqlite3VdbeSetNumCols(v, 2);
555
sqlite3VdbeSetColName(v, 0, "seq", P3_STATIC);
556
sqlite3VdbeSetColName(v, 1, "name", P3_STATIC);
557
for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
558
CollSeq *pColl = (CollSeq *)sqliteHashData(p);
559
sqlite3VdbeAddOp(v, OP_Integer, i++, 0);
560
sqlite3VdbeOp3(v, OP_String8, 0, 0, pColl->zName, 0);
561
sqlite3VdbeAddOp(v, OP_Callback, 2, 0);
564
#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
566
#ifndef SQLITE_OMIT_FOREIGN_KEY
567
if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
570
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
571
pTab = sqlite3FindTable(db, zRight, zDb);
573
v = sqlite3GetVdbe(pParse);
577
sqlite3VdbeSetNumCols(v, 5);
578
sqlite3VdbeSetColName(v, 0, "id", P3_STATIC);
579
sqlite3VdbeSetColName(v, 1, "seq", P3_STATIC);
580
sqlite3VdbeSetColName(v, 2, "table", P3_STATIC);
581
sqlite3VdbeSetColName(v, 3, "from", P3_STATIC);
582
sqlite3VdbeSetColName(v, 4, "to", P3_STATIC);
585
for(j=0; j<pFK->nCol; j++){
586
sqlite3VdbeAddOp(v, OP_Integer, i, 0);
587
sqlite3VdbeAddOp(v, OP_Integer, j, 0);
588
sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->zTo, 0);
589
sqlite3VdbeOp3(v, OP_String8, 0, 0,
590
pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
591
sqlite3VdbeOp3(v, OP_String8, 0, 0, pFK->aCol[j].zCol, 0);
592
sqlite3VdbeAddOp(v, OP_Callback, 5, 0);
595
pFK = pFK->pNextFrom;
600
#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
603
if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
604
extern void sqlite3ParserTrace(FILE*, char *);
605
if( getBoolean(zRight) ){
606
sqlite3ParserTrace(stdout, "parser: ");
608
sqlite3ParserTrace(0, 0);
613
#ifndef SQLITE_OMIT_INTEGRITY_CHECK
614
if( sqlite3StrICmp(zLeft, "integrity_check")==0 ){
617
/* Code that initializes the integrity check program. Set the
620
static const VdbeOpList initCode[] = {
621
{ OP_Integer, 0, 0, 0},
622
{ OP_MemStore, 0, 1, 0},
625
/* Code that appears at the end of the integrity check. If no error
626
** messages have been generated, output OK. Otherwise output the
629
static const VdbeOpList endCode[] = {
630
{ OP_MemLoad, 0, 0, 0},
631
{ OP_Integer, 0, 0, 0},
632
{ OP_Ne, 0, 0, 0}, /* 2 */
633
{ OP_String8, 0, 0, "ok"},
634
{ OP_Callback, 1, 0, 0},
637
/* Initialize the VDBE program */
638
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
639
sqlite3VdbeSetNumCols(v, 1);
640
sqlite3VdbeSetColName(v, 0, "integrity_check", P3_STATIC);
641
sqlite3VdbeAddOpList(v, ArraySize(initCode), initCode);
643
/* Do an integrity check on each database file */
644
for(i=0; i<db->nDb; i++){
648
if( OMIT_TEMPDB && i==1 ) continue;
650
sqlite3CodeVerifySchema(pParse, i);
652
/* Do an integrity check of the B-Tree
654
for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){
655
Table *pTab = sqliteHashData(x);
657
sqlite3VdbeAddOp(v, OP_Integer, pTab->tnum, 0);
659
for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
660
if( sqlite3CheckIndexCollSeq(pParse, pIdx) ) goto pragma_out;
661
sqlite3VdbeAddOp(v, OP_Integer, pIdx->tnum, 0);
666
sqlite3VdbeAddOp(v, OP_IntegrityCk, cnt, i);
667
sqlite3VdbeAddOp(v, OP_Dup, 0, 1);
668
addr = sqlite3VdbeOp3(v, OP_String8, 0, 0, "ok", P3_STATIC);
669
sqlite3VdbeAddOp(v, OP_Eq, 0, addr+6);
670
sqlite3VdbeOp3(v, OP_String8, 0, 0,
671
sqlite3MPrintf("*** in database %s ***\n", db->aDb[i].zName),
673
sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
674
sqlite3VdbeAddOp(v, OP_Concat, 0, 1);
675
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
677
/* Make sure all the indices are constructed correctly.
679
sqlite3CodeVerifySchema(pParse, i);
680
for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){
681
Table *pTab = sqliteHashData(x);
685
if( pTab->pIndex==0 ) continue;
686
sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
687
sqlite3VdbeAddOp(v, OP_Integer, 0, 0);
688
sqlite3VdbeAddOp(v, OP_MemStore, 1, 1);
689
loopTop = sqlite3VdbeAddOp(v, OP_Rewind, 1, 0);
690
sqlite3VdbeAddOp(v, OP_MemIncr, 1, 0);
691
for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
693
static const VdbeOpList idxErr[] = {
694
{ OP_MemIncr, 0, 0, 0},
695
{ OP_String8, 0, 0, "rowid "},
696
{ OP_Recno, 1, 0, 0},
697
{ OP_String8, 0, 0, " missing from index "},
698
{ OP_String8, 0, 0, 0}, /* 4 */
699
{ OP_Concat, 2, 0, 0},
700
{ OP_Callback, 1, 0, 0},
702
sqlite3GenerateIndexKey(v, pIdx, 1);
703
jmp2 = sqlite3VdbeAddOp(v, OP_Found, j+2, 0);
704
addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
705
sqlite3VdbeChangeP3(v, addr+4, pIdx->zName, P3_STATIC);
706
sqlite3VdbeChangeP2(v, jmp2, sqlite3VdbeCurrentAddr(v));
708
sqlite3VdbeAddOp(v, OP_Next, 1, loopTop+1);
709
sqlite3VdbeChangeP2(v, loopTop, sqlite3VdbeCurrentAddr(v));
710
for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
711
static const VdbeOpList cntIdx[] = {
712
{ OP_Integer, 0, 0, 0},
713
{ OP_MemStore, 2, 1, 0},
714
{ OP_Rewind, 0, 0, 0}, /* 2 */
715
{ OP_MemIncr, 2, 0, 0},
716
{ OP_Next, 0, 0, 0}, /* 4 */
717
{ OP_MemLoad, 1, 0, 0},
718
{ OP_MemLoad, 2, 0, 0},
719
{ OP_Eq, 0, 0, 0}, /* 7 */
720
{ OP_MemIncr, 0, 0, 0},
721
{ OP_String8, 0, 0, "wrong # of entries in index "},
722
{ OP_String8, 0, 0, 0}, /* 10 */
723
{ OP_Concat, 0, 0, 0},
724
{ OP_Callback, 1, 0, 0},
726
if( pIdx->tnum==0 ) continue;
727
addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
728
sqlite3VdbeChangeP1(v, addr+2, j+2);
729
sqlite3VdbeChangeP2(v, addr+2, addr+5);
730
sqlite3VdbeChangeP1(v, addr+4, j+2);
731
sqlite3VdbeChangeP2(v, addr+4, addr+3);
732
sqlite3VdbeChangeP2(v, addr+7, addr+ArraySize(cntIdx));
733
sqlite3VdbeChangeP3(v, addr+10, pIdx->zName, P3_STATIC);
737
addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
738
sqlite3VdbeChangeP2(v, addr+2, addr+ArraySize(endCode));
740
#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
742
#ifndef SQLITE_OMIT_UTF16
745
** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
747
** In it's first form, this pragma returns the encoding of the main
748
** database. If the database is not initialized, it is initialized now.
750
** The second form of this pragma is a no-op if the main database file
751
** has not already been initialized. In this case it sets the default
752
** encoding that will be used for the main database file if a new file
753
** is created. If an existing main database file is opened, then the
754
** default text encoding for the existing database is used.
756
** In all cases new databases created using the ATTACH command are
757
** created to use the same default text encoding as the main database. If
758
** the main database has not been initialized and/or created when ATTACH
759
** is executed, this is done before the ATTACH operation.
761
** In the second form this pragma sets the text encoding to be used in
762
** new database files created using this database handle. It is only
763
** useful if invoked immediately after the main database i
765
if( sqlite3StrICmp(zLeft, "encoding")==0 ){
766
static struct EncName {
770
{ "UTF-8", SQLITE_UTF8 },
771
{ "UTF8", SQLITE_UTF8 },
772
{ "UTF-16le", SQLITE_UTF16LE },
773
{ "UTF16le", SQLITE_UTF16LE },
774
{ "UTF-16be", SQLITE_UTF16BE },
775
{ "UTF16be", SQLITE_UTF16BE },
776
{ "UTF-16", 0 /* Filled in at run-time */ },
777
{ "UTF16", 0 /* Filled in at run-time */ },
780
struct EncName *pEnc;
781
encnames[6].enc = encnames[7].enc = SQLITE_UTF16NATIVE;
782
if( !zRight ){ /* "PRAGMA encoding" */
783
if( sqlite3ReadSchema(pParse) ) goto pragma_out;
784
sqlite3VdbeSetNumCols(v, 1);
785
sqlite3VdbeSetColName(v, 0, "encoding", P3_STATIC);
786
sqlite3VdbeAddOp(v, OP_String8, 0, 0);
787
for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
788
if( pEnc->enc==pParse->db->enc ){
789
sqlite3VdbeChangeP3(v, -1, pEnc->zName, P3_STATIC);
793
sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
794
}else{ /* "PRAGMA encoding = XXX" */
795
/* Only change the value of sqlite.enc if the database handle is not
796
** initialized. If the main database exists, the new sqlite.enc value
797
** will be overwritten when the schema is next loaded. If it does not
798
** already exists, it will be created to use the new encoding value.
800
if( !(pParse->db->flags&SQLITE_Initialized) ){
801
for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
802
if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
803
pParse->db->enc = pEnc->enc;
808
sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
813
#endif /* SQLITE_OMIT_UTF16 */
815
#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
817
** PRAGMA [database.]schema_version
818
** PRAGMA [database.]schema_version = <integer>
820
** PRAGMA [database.]user_version
821
** PRAGMA [database.]user_version = <integer>
823
** The pragma's schema_version and user_version are used to set or get
824
** the value of the schema-version and user-version, respectively. Both
825
** the schema-version and the user-version are 32-bit signed integers
826
** stored in the database header.
828
** The schema-cookie is usually only manipulated internally by SQLite. It
829
** is incremented by SQLite whenever the database schema is modified (by
830
** creating or dropping a table or index). The schema version is used by
831
** SQLite each time a query is executed to ensure that the internal cache
832
** of the schema used when compiling the SQL query matches the schema of
833
** the database against which the compiled query is actually executed.
834
** Subverting this mechanism by using "PRAGMA schema_version" to modify
835
** the schema-version is potentially dangerous and may lead to program
836
** crashes or database corruption. Use with caution!
838
** The user-version is not used internally by SQLite. It may be used by
839
** applications for any purpose.
841
if( sqlite3StrICmp(zLeft, "schema_version")==0 ||
842
sqlite3StrICmp(zLeft, "user_version")==0 ){
844
int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */
845
if( zLeft[0]=='s' || zLeft[0]=='S' ){
852
/* Write the specified cookie value */
853
static const VdbeOpList setCookie[] = {
854
{ OP_Transaction, 0, 1, 0}, /* 0 */
855
{ OP_Integer, 0, 0, 0}, /* 1 */
856
{ OP_SetCookie, 0, 0, 0}, /* 2 */
858
int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
859
sqlite3VdbeChangeP1(v, addr, iDb);
860
sqlite3VdbeChangeP1(v, addr+1, atoi(zRight));
861
sqlite3VdbeChangeP1(v, addr+2, iDb);
862
sqlite3VdbeChangeP2(v, addr+2, iCookie);
864
/* Read the specified cookie value */
865
static const VdbeOpList readCookie[] = {
866
{ OP_ReadCookie, 0, 0, 0}, /* 0 */
867
{ OP_Callback, 1, 0, 0}
869
int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
870
sqlite3VdbeChangeP1(v, addr, iDb);
871
sqlite3VdbeChangeP2(v, addr, iCookie);
872
sqlite3VdbeSetNumCols(v, 1);
875
#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
877
#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
879
** Report the current state of file logs for all databases
881
if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
882
static const char *const azLockName[] = {
883
"unlocked", "shared", "reserved", "pending", "exclusive"
886
Vdbe *v = sqlite3GetVdbe(pParse);
887
sqlite3VdbeSetNumCols(v, 2);
888
sqlite3VdbeSetColName(v, 0, "database", P3_STATIC);
889
sqlite3VdbeSetColName(v, 1, "status", P3_STATIC);
890
for(i=0; i<db->nDb; i++){
893
if( db->aDb[i].zName==0 ) continue;
894
sqlite3VdbeOp3(v, OP_String, 0, 0, db->aDb[i].zName, P3_STATIC);
895
pBt = db->aDb[i].pBt;
896
if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
897
sqlite3VdbeOp3(v, OP_String, 0, 0, "closed", P3_STATIC);
899
int j = sqlite3pager_lockstate(pPager);
900
sqlite3VdbeOp3(v, OP_String, 0, 0,
901
(j>=0 && j<=4) ? azLockName[j] : "unknown", P3_STATIC);
903
sqlite3VdbeAddOp(v, OP_Callback, 2, 0);
911
/* Code an OP_Expire at the end of each PRAGMA program to cause
912
** the VDBE implementing the pragma to expire. Most (all?) pragmas
913
** are only valid for a single execution.
915
sqlite3VdbeAddOp(v, OP_Expire, 1, 0);
922
#endif /* SQLITE_OMIT_PRAGMA */
added
removed
src/3rdparty/sqlite/pragma.c
