sqlite3/pragma.c

   1 /*
   2 ** 2003 April 6
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   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.
  10 **
  11 *************************************************************************
  12 ** This file contains code used to implement the PRAGMA command.
  13 **
  14 ** $Id$
  15 */
  16 #include "sqliteInt.h"
  17 #include "os.h"
  18 #include <ctype.h>
  19
  20 /* Ignore this whole file if pragmas are disabled
  21 */
  22 #if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER)
  23
  24 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
  25 # include "pager.h"
  26 # include "btree.h"
  27 #endif
  28
  29 /*
  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.
  33 **
  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.
  38 */
  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};
  45   int i, n;
  46   if( isdigit(*z) ){
  47     return atoi(z);
  48   }
  49   n = strlen(z);
  50   for(i=0; i<sizeof(iLength); i++){
  51     if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
  52       return iValue[i];
  53     }
  54   }
  55   return 1;
  56 }
  57
  58 /*
  59 ** Interpret the given string as a boolean value.
  60 */
  61 static int getBoolean(const u8 *z){
  62   return getSafetyLevel(z)&1;
  63 }
  64
  65 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  66 /*
  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.
  70 */
  71 static int getTempStore(const char *z){
  72   if( z[0]>='0' && z[0]<='2' ){
  73     return z[0] - '0';
  74   }else if( sqlite3StrICmp(z, "file")==0 ){
  75     return 1;
  76   }else if( sqlite3StrICmp(z, "memory")==0 ){
  77     return 2;
  78   }else{
  79     return 0;
  80   }
  81 }
  82 #endif /* SQLITE_PAGER_PRAGMAS */
  83
  84 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  85 /*
  86 ** Invalidate temp storage, either when the temp storage is changed
  87 ** from default, or when 'file' and the temp_store_directory has changed
  88 */
  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");
  95       return SQLITE_ERROR;
  96     }
  97     sqlite3BtreeClose(db->aDb[1].pBt);
  98     db->aDb[1].pBt = 0;
  99     sqlite3ResetInternalSchema(db, 0);
 100   }
 101   return SQLITE_OK;
 102 }
 103 #endif /* SQLITE_PAGER_PRAGMAS */
 104
 105 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 106 /*
 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.
 110 */
 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 ){
 116     return SQLITE_ERROR;
 117   }
 118   db->temp_store = ts;
 119   return SQLITE_OK;
 120 }
 121 #endif /* SQLITE_PAGER_PRAGMAS */
 122
 123 /*
 124 ** Generate code to return a single integer value.
 125 */
 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);
 132   }
 133   sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
 134 }
 135
 136 #ifndef SQLITE_OMIT_FLAG_PRAGMAS
 137 /*
 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.
 141 */
 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 */
 146   } aPragma[] = {
 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    },
 157   };
 158   int i;
 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;
 163       Vdbe *v;
 164       v = sqlite3GetVdbe(pParse);
 165       if( v ){
 166         if( zRight==0 ){
 167           returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
 168         }else{
 169           if( getBoolean(zRight) ){
 170             db->flags |= p->mask;
 171           }else{
 172             db->flags &= ~p->mask;
 173           }
 174         }
 175         /* If one of these pragmas is executed, any prepared statements
 176         ** need to be recompiled.
 177         */
 178         sqlite3VdbeAddOp(v, OP_Expire, 0, 0);
 179       }
 180       return 1;
 181     }
 182   }
 183   return 0;
 184 }
 185 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
 186
 187 /*
 188 ** Process a pragma statement.
 189 **
 190 ** Pragmas are of this form:
 191 **
 192 **      PRAGMA [database.]id [= value]
 193 **
 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.
 197 **
 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.
 201 */
 202 void sqlite3Pragma(
 203   Parse *pParse,
 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> */
 208 ){
 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;
 215   Db *pDb;
 216   Vdbe *v = sqlite3GetVdbe(pParse);
 217   if( v==0 ) return;
 218
 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);
 222   if( iDb<0 ) return;
 223   pDb = &db->aDb[iDb];
 224
 225   zLeft = sqlite3NameFromToken(pId);
 226   if( !zLeft ) return;
 227   if( minusFlag ){
 228     zRight = sqlite3MPrintf("-%T", pValue);
 229   }else{
 230     zRight = sqlite3NameFromToken(pValue);
 231   }
 232
 233   zDb = ((iDb>0)?pDb->zName:0);
 234   if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
 235     goto pragma_out;
 236   }
 237
 238 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 239   /*
 240   **  PRAGMA [database.]default_cache_size
 241   **  PRAGMA [database.]default_cache_size=N
 242   **
 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.
 248   **
 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.
 254   */
 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},
 259       { OP_Dup,         0, 0,        0},
 260       { OP_Integer,     0, 0,        0},
 261       { OP_Ne,          0, 6,        0},
 262       { OP_Integer,     0, 0,        0},  /* 5 */
 263       { OP_Callback,    1, 0,        0},
 264     };
 265     int addr;
 266     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 267     if( !zRight ){
 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);
 273     }else{
 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);
 285     }
 286   }else
 287
 288   /*
 289   **  PRAGMA [database.]page_size
 290   **  PRAGMA [database.]page_size=N
 291   **
 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.
 296   */
 297   if( sqlite3StrICmp(zLeft,"page_size")==0 ){
 298     Btree *pBt = pDb->pBt;
 299     if( !zRight ){
 300       int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0;
 301       returnSingleInt(pParse, "page_size", size);
 302     }else{
 303       sqlite3BtreeSetPageSize(pBt, atoi(zRight), -1);
 304     }
 305   }else
 306 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
 307
 308   /*
 309   **  PRAGMA [database.]auto_vacuum
 310   **  PRAGMA [database.]auto_vacuum=N
 311   **
 312   ** Get or set the (boolean) value of the database 'auto-vacuum' parameter.
 313   */
 314 #ifndef SQLITE_OMIT_AUTOVACUUM
 315   if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
 316     Btree *pBt = pDb->pBt;
 317     if( !zRight ){
 318       int auto_vacuum =
 319           pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM;
 320       returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
 321     }else{
 322       sqlite3BtreeSetAutoVacuum(pBt, getBoolean(zRight));
 323     }
 324   }else
 325 #endif
 326
 327 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 328   /*
 329   **  PRAGMA [database.]cache_size
 330   **  PRAGMA [database.]cache_size=N
 331   **
 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.
 341   */
 342   if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
 343     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 344     if( !zRight ){
 345       returnSingleInt(pParse, "cache_size", pDb->cache_size);
 346     }else{
 347       int size = atoi(zRight);
 348       if( size<0 ) size = -size;
 349       pDb->cache_size = size;
 350       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->cache_size);
 351     }
 352   }else
 353
 354   /*
 355   **   PRAGMA temp_store
 356   **   PRAGMA temp_store = "default"|"memory"|"file"
 357   **
 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.
 361   **
 362   ** Note that it is possible for the library compile-time options to
 363   ** override this setting
 364   */
 365   if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
 366     if( !zRight ){
 367       returnSingleInt(pParse, "temp_store", db->temp_store);
 368     }else{
 369       changeTempStorage(pParse, zRight);
 370     }
 371   }else
 372
 373   /*
 374   **   PRAGMA temp_store_directory
 375   **   PRAGMA temp_store_directory = ""|"directory_name"
 376   **
 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.
 381   **
 382   */
 383   if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
 384     if( !zRight ){
 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);
 390       }
 391     }else{
 392       if( zRight[0] && !sqlite3OsIsDirWritable(zRight) ){
 393         sqlite3ErrorMsg(pParse, "not a writable directory");
 394         goto pragma_out;
 395       }
 396       if( TEMP_STORE==0
 397        || (TEMP_STORE==1 && db->temp_store<=1)
 398        || (TEMP_STORE==2 && db->temp_store==1)
 399       ){
 400         invalidateTempStorage(pParse);
 401       }
 402       sqliteFree(sqlite3_temp_directory);
 403       if( zRight[0] ){
 404         sqlite3_temp_directory = zRight;
 405         zRight = 0;
 406       }else{
 407         sqlite3_temp_directory = 0;
 408       }
 409     }
 410   }else
 411
 412   /*
 413   **   PRAGMA [database.]synchronous
 414   **   PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
 415   **
 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
 419   ** opened.
 420   */
 421   if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
 422     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 423     if( !zRight ){
 424       returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
 425     }else{
 426       if( !db->autoCommit ){
 427         sqlite3ErrorMsg(pParse,
 428             "Safety level may not be changed inside a transaction");
 429       }else{
 430         pDb->safety_level = getSafetyLevel(zRight)+1;
 431         sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level);
 432       }
 433     }
 434   }else
 435 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
 436
 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 */
 441   }else
 442 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
 443
 444 #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
 445   /*
 446   **   PRAGMA table_info(<table>)
 447   **
 448   ** Return a single row for each column of the named table. The columns of
 449   ** the returned data set are:
 450   **
 451   ** cid:        Column id (numbered from left to right, starting at 0)
 452   ** name:       Column name
 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.
 456   */
 457   if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
 458     Table *pTab;
 459     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 460     pTab = sqlite3FindTable(db, zRight, zDb);
 461     if( pTab ){
 462       int i;
 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);
 480       }
 481     }
 482   }else
 483
 484   if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
 485     Index *pIdx;
 486     Table *pTab;
 487     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 488     pIdx = sqlite3FindIndex(db, zRight, zDb);
 489     if( pIdx ){
 490       int i;
 491       pTab = pIdx->pTable;
 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);
 503       }
 504     }
 505   }else
 506
 507   if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
 508     Index *pIdx;
 509     Table *pTab;
 510     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 511     pTab = sqlite3FindTable(db, zRight, zDb);
 512     if( pTab ){
 513       v = sqlite3GetVdbe(pParse);
 514       pIdx = pTab->pIndex;
 515       if( pIdx ){
 516         int i = 0;
 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);
 521         while(pIdx){
 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);
 526           ++i;
 527           pIdx = pIdx->pNext;
 528         }
 529       }
 530     }
 531   }else
 532
 533   if( sqlite3StrICmp(zLeft, "database_list")==0 ){
 534     int i;
 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);
 548     }
 549   }else
 550
 551   if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
 552     int i = 0;
 553     HashElem *p;
 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);
 562     }
 563   }else
 564 #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
 565
 566 #ifndef SQLITE_OMIT_FOREIGN_KEY
 567   if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
 568     FKey *pFK;
 569     Table *pTab;
 570     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 571     pTab = sqlite3FindTable(db, zRight, zDb);
 572     if( pTab ){
 573       v = sqlite3GetVdbe(pParse);
 574       pFK = pTab->pFKey;
 575       if( pFK ){
 576         int i = 0;
 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);
 583         while(pFK){
 584           int j;
 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);
 593           }
 594           ++i;
 595           pFK = pFK->pNextFrom;
 596         }
 597       }
 598     }
 599   }else
 600 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
 601
 602 #ifndef NDEBUG
 603   if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
 604     extern void sqlite3ParserTrace(FILE*, char *);
 605     if( getBoolean(zRight) ){
 606       sqlite3ParserTrace(stdout, "parser: ");
 607     }else{
 608       sqlite3ParserTrace(0, 0);
 609     }
 610   }else
 611 #endif
 612
 613 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
 614   if( sqlite3StrICmp(zLeft, "integrity_check")==0 ){
 615     int i, j, addr;
 616
 617     /* Code that initializes the integrity check program.  Set the
 618     ** error count 0
 619     */
 620     static const VdbeOpList initCode[] = {
 621       { OP_Integer,     0, 0,        0},
 622       { OP_MemStore,    0, 1,        0},
 623     };
 624
 625     /* Code that appears at the end of the integrity check.  If no error
 626     ** messages have been generated, output OK.  Otherwise output the
 627     ** error message
 628     */
 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},
 635     };
 636
 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);
 642
 643     /* Do an integrity check on each database file */
 644     for(i=0; i<db->nDb; i++){
 645       HashElem *x;
 646       int cnt = 0;
 647
 648       if( OMIT_TEMPDB && i==1 ) continue;
 649
 650       sqlite3CodeVerifySchema(pParse, i);
 651
 652       /* Do an integrity check of the B-Tree
 653       */
 654       for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){
 655         Table *pTab = sqliteHashData(x);
 656         Index *pIdx;
 657         sqlite3VdbeAddOp(v, OP_Integer, pTab->tnum, 0);
 658         cnt++;
 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);
 662           cnt++;
 663         }
 664       }
 665       assert( cnt>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),
 672          P3_DYNAMIC);
 673       sqlite3VdbeAddOp(v, OP_Pull, 1, 0);
 674       sqlite3VdbeAddOp(v, OP_Concat, 0, 1);
 675       sqlite3VdbeAddOp(v, OP_Callback, 1, 0);
 676
 677       /* Make sure all the indices are constructed correctly.
 678       */
 679       sqlite3CodeVerifySchema(pParse, i);
 680       for(x=sqliteHashFirst(&db->aDb[i].tblHash); x; x=sqliteHashNext(x)){
 681         Table *pTab = sqliteHashData(x);
 682         Index *pIdx;
 683         int loopTop;
 684
 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++){
 692           int jmp2;
 693           static const VdbeOpList idxErr[] = {
 694             { OP_MemIncr,     0,  0,  0},
 695             { OP_String8,     0,  0,  "rowid "},
 696             { OP_Rowid,       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},
 701           };
 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));
 707         }
 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},
 725           };
 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);
 734         }
 735       }
 736     }
 737     addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
 738     sqlite3VdbeChangeP2(v, addr+2, addr+ArraySize(endCode));
 739   }else
 740 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
 741
 742 #ifndef SQLITE_OMIT_UTF16
 743   /*
 744   **   PRAGMA encoding
 745   **   PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
 746   **
 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.
 749   **
 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.
 755   **
 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.
 760   **
 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
 764   */
 765   if( sqlite3StrICmp(zLeft, "encoding")==0 ){
 766     static struct EncName {
 767       char *zName;
 768       u8 enc;
 769     } encnames[] = {
 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 */ },
 778       { 0, 0 }
 779     };
 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);
 790           break;
 791         }
 792       }
 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.
 799       */
 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;
 804             break;
 805           }
 806         }
 807         if( !pEnc->zName ){
 808           sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
 809         }
 810       }
 811     }
 812   }else
 813 #endif /* SQLITE_OMIT_UTF16 */
 814
 815 #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
 816   /*
 817   **   PRAGMA [database.]schema_version
 818   **   PRAGMA [database.]schema_version = <integer>
 819   **
 820   **   PRAGMA [database.]user_version
 821   **   PRAGMA [database.]user_version = <integer>
 822   **
 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.
 827   **
 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!
 837   **
 838   ** The user-version is not used internally by SQLite. It may be used by
 839   ** applications for any purpose.
 840   */
 841   if( sqlite3StrICmp(zLeft, "schema_version")==0 ||
 842       sqlite3StrICmp(zLeft, "user_version")==0 ){
 843
 844     int iCookie;   /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */
 845     if( zLeft[0]=='s' || zLeft[0]=='S' ){
 846       iCookie = 0;
 847     }else{
 848       iCookie = 5;
 849     }
 850
 851     if( zRight ){
 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 */
 857       };
 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);
 863     }else{
 864       /* Read the specified cookie value */
 865       static const VdbeOpList readCookie[] = {
 866         { OP_ReadCookie,      0,  0,  0},    /* 0 */
 867         { OP_Callback,        1,  0,  0}
 868       };
 869       int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
 870       sqlite3VdbeChangeP1(v, addr, iDb);
 871       sqlite3VdbeChangeP2(v, addr, iCookie);
 872       sqlite3VdbeSetNumCols(v, 1);
 873     }
 874   }
 875 #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
 876
 877 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
 878   /*
 879   ** Report the current state of file logs for all databases
 880   */
 881   if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
 882     static const char *const azLockName[] = {
 883       "unlocked", "shared", "reserved", "pending", "exclusive"
 884     };
 885     int i;
 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++){
 891       Btree *pBt;
 892       Pager *pPager;
 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);
 898       }else{
 899         int j = sqlite3pager_lockstate(pPager);
 900         sqlite3VdbeOp3(v, OP_String, 0, 0,
 901             (j>=0 && j<=4) ? azLockName[j] : "unknown", P3_STATIC);
 902       }
 903       sqlite3VdbeAddOp(v, OP_Callback, 2, 0);
 904     }
 905   }else
 906 #endif
 907
 908 #ifdef SQLITE_SSE
 909   /*
 910   ** Check to see if the sqlite_statements table exists.  Create it
 911   ** if it does not.
 912   */
 913   if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){
 914     extern int sqlite3CreateStatementsTable(Parse*);
 915     sqlite3CreateStatementsTable(pParse);
 916   }else
 917 #endif
 918
 919   {}
 920
 921   if( v ){
 922     /* Code an OP_Expire at the end of each PRAGMA program to cause
 923     ** the VDBE implementing the pragma to expire. Most (all?) pragmas
 924     ** are only valid for a single execution.
 925     */
 926     sqlite3VdbeAddOp(v, OP_Expire, 1, 0);
 927   }
 928 pragma_out:
 929   sqliteFree(zLeft);
 930   sqliteFree(zRight);
 931 }
 932
 933 #endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */