src/third_party/sqlite/src/src/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 #include "sqliteInt.h"
  15
  16 /* Ignore this whole file if pragmas are disabled
  17 */
  18 #if !defined(SQLITE_OMIT_PRAGMA)
  19
  20 /*
  21 ** Interpret the given string as a safety level.  Return 0 for OFF,
  22 ** 1 for ON or NORMAL and 2 for FULL.  Return 1 for an empty or
  23 ** unrecognized string argument.
  24 **
  25 ** Note that the values returned are one less that the values that
  26 ** should be passed into sqlite3BtreeSetSafetyLevel().  The is done
  27 ** to support legacy SQL code.  The safety level used to be boolean
  28 ** and older scripts may have used numbers 0 for OFF and 1 for ON.
  29 */
  30 static u8 getSafetyLevel(const char *z){
  31                              /* 123456789 123456789 */
  32   static const char zText[] = "onoffalseyestruefull";
  33   static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
  34   static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
  35   static const u8 iValue[] =  {1, 0, 0, 0, 1, 1, 2};
  36   int i, n;
  37   if( sqlite3Isdigit(*z) ){
  38     return (u8)sqlite3Atoi(z);
  39   }
  40   n = sqlite3Strlen30(z);
  41   for(i=0; i<ArraySize(iLength); i++){
  42     if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
  43       return iValue[i];
  44     }
  45   }
  46   return 1;
  47 }
  48
  49 /*
  50 ** Interpret the given string as a boolean value.
  51 */
  52 static u8 getBoolean(const char *z){
  53   return getSafetyLevel(z)&1;
  54 }
  55
  56 /*
  57 ** Interpret the given string as a locking mode value.
  58 */
  59 static int getLockingMode(const char *z){
  60   if( z ){
  61     if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
  62     if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
  63   }
  64   return PAGER_LOCKINGMODE_QUERY;
  65 }
  66
  67 #ifndef SQLITE_OMIT_AUTOVACUUM
  68 /*
  69 ** Interpret the given string as an auto-vacuum mode value.
  70 **
  71 ** The following strings, "none", "full" and "incremental" are
  72 ** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
  73 */
  74 static int getAutoVacuum(const char *z){
  75   int i;
  76   if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
  77   if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
  78   if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
  79   i = sqlite3Atoi(z);
  80   return (u8)((i>=0&&i<=2)?i:0);
  81 }
  82 #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
  83
  84 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
  85 /*
  86 ** Interpret the given string as a temp db location. Return 1 for file
  87 ** backed temporary databases, 2 for the Red-Black tree in memory database
  88 ** and 0 to use the compile-time default.
  89 */
  90 static int getTempStore(const char *z){
  91   if( z[0]>='0' && z[0]<='2' ){
  92     return z[0] - '0';
  93   }else if( sqlite3StrICmp(z, "file")==0 ){
  94     return 1;
  95   }else if( sqlite3StrICmp(z, "memory")==0 ){
  96     return 2;
  97   }else{
  98     return 0;
  99   }
 100 }
 101 #endif /* SQLITE_PAGER_PRAGMAS */
 102
 103 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 104 /*
 105 ** Invalidate temp storage, either when the temp storage is changed
 106 ** from default, or when 'file' and the temp_store_directory has changed
 107 */
 108 static int invalidateTempStorage(Parse *pParse){
 109   sqlite3 *db = pParse->db;
 110   if( db->aDb[1].pBt!=0 ){
 111     if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
 112       sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
 113         "from within a transaction");
 114       return SQLITE_ERROR;
 115     }
 116     sqlite3BtreeClose(db->aDb[1].pBt);
 117     db->aDb[1].pBt = 0;
 118     sqlite3ResetInternalSchema(db, -1);
 119   }
 120   return SQLITE_OK;
 121 }
 122 #endif /* SQLITE_PAGER_PRAGMAS */
 123
 124 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 125 /*
 126 ** If the TEMP database is open, close it and mark the database schema
 127 ** as needing reloading.  This must be done when using the SQLITE_TEMP_STORE
 128 ** or DEFAULT_TEMP_STORE pragmas.
 129 */
 130 static int changeTempStorage(Parse *pParse, const char *zStorageType){
 131   int ts = getTempStore(zStorageType);
 132   sqlite3 *db = pParse->db;
 133   if( db->temp_store==ts ) return SQLITE_OK;
 134   if( invalidateTempStorage( pParse ) != SQLITE_OK ){
 135     return SQLITE_ERROR;
 136   }
 137   db->temp_store = (u8)ts;
 138   return SQLITE_OK;
 139 }
 140 #endif /* SQLITE_PAGER_PRAGMAS */
 141
 142 /*
 143 ** Generate code to return a single integer value.
 144 */
 145 static void returnSingleInt(Parse *pParse, const char *zLabel, i64 value){
 146   Vdbe *v = sqlite3GetVdbe(pParse);
 147   int mem = ++pParse->nMem;
 148   i64 *pI64 = sqlite3DbMallocRaw(pParse->db, sizeof(value));
 149   if( pI64 ){
 150     memcpy(pI64, &value, sizeof(value));
 151   }
 152   sqlite3VdbeAddOp4(v, OP_Int64, 0, mem, 0, (char*)pI64, P4_INT64);
 153   sqlite3VdbeSetNumCols(v, 1);
 154   sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, SQLITE_STATIC);
 155   sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
 156 }
 157
 158 #ifndef SQLITE_OMIT_FLAG_PRAGMAS
 159 /*
 160 ** Check to see if zRight and zLeft refer to a pragma that queries
 161 ** or changes one of the flags in db->flags.  Return 1 if so and 0 if not.
 162 ** Also, implement the pragma.
 163 */
 164 static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
 165   static const struct sPragmaType {
 166     const char *zName;  /* Name of the pragma */
 167     int mask;           /* Mask for the db->flags value */
 168   } aPragma[] = {
 169     { "full_column_names",        SQLITE_FullColNames  },
 170     { "short_column_names",       SQLITE_ShortColNames },
 171     { "count_changes",            SQLITE_CountRows     },
 172     { "empty_result_callbacks",   SQLITE_NullCallback  },
 173     { "legacy_file_format",       SQLITE_LegacyFileFmt },
 174     { "fullfsync",                SQLITE_FullFSync     },
 175     { "checkpoint_fullfsync",     SQLITE_CkptFullFSync },
 176     { "reverse_unordered_selects", SQLITE_ReverseOrder  },
 177 #ifndef SQLITE_OMIT_AUTOMATIC_INDEX
 178     { "automatic_index",          SQLITE_AutoIndex     },
 179 #endif
 180 #ifdef SQLITE_DEBUG
 181     { "sql_trace",                SQLITE_SqlTrace      },
 182     { "vdbe_listing",             SQLITE_VdbeListing   },
 183     { "vdbe_trace",               SQLITE_VdbeTrace     },
 184 #endif
 185 #ifndef SQLITE_OMIT_CHECK
 186     { "ignore_check_constraints", SQLITE_IgnoreChecks  },
 187 #endif
 188     /* The following is VERY experimental */
 189     { "writable_schema",          SQLITE_WriteSchema|SQLITE_RecoveryMode },
 190     { "omit_readlock",            SQLITE_NoReadlock    },
 191
 192     /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
 193     ** flag if there are any active statements. */
 194     { "read_uncommitted",         SQLITE_ReadUncommitted },
 195     { "recursive_triggers",       SQLITE_RecTriggers },
 196
 197     /* This flag may only be set if both foreign-key and trigger support
 198     ** are present in the build.  */
 199 #if !defined(SQLITE_OMIT_FOREIGN_KEY) && !defined(SQLITE_OMIT_TRIGGER)
 200     { "foreign_keys",             SQLITE_ForeignKeys },
 201 #endif
 202   };
 203   int i;
 204   const struct sPragmaType *p;
 205   for(i=0, p=aPragma; i<ArraySize(aPragma); i++, p++){
 206     if( sqlite3StrICmp(zLeft, p->zName)==0 ){
 207       sqlite3 *db = pParse->db;
 208       Vdbe *v;
 209       v = sqlite3GetVdbe(pParse);
 210       assert( v!=0 );  /* Already allocated by sqlite3Pragma() */
 211       if( ALWAYS(v) ){
 212         if( zRight==0 ){
 213           returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
 214         }else{
 215           int mask = p->mask;          /* Mask of bits to set or clear. */
 216           if( db->autoCommit==0 ){
 217             /* Foreign key support may not be enabled or disabled while not
 218             ** in auto-commit mode.  */
 219             mask &= ~(SQLITE_ForeignKeys);
 220           }
 221
 222           if( getBoolean(zRight) ){
 223             db->flags |= mask;
 224           }else{
 225             db->flags &= ~mask;
 226           }
 227
 228           /* Many of the flag-pragmas modify the code generated by the SQL
 229           ** compiler (eg. count_changes). So add an opcode to expire all
 230           ** compiled SQL statements after modifying a pragma value.
 231           */
 232           sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
 233         }
 234       }
 235
 236       return 1;
 237     }
 238   }
 239   return 0;
 240 }
 241 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
 242
 243 /*
 244 ** Return a human-readable name for a constraint resolution action.
 245 */
 246 #ifndef SQLITE_OMIT_FOREIGN_KEY
 247 static const char *actionName(u8 action){
 248   const char *zName;
 249   switch( action ){
 250     case OE_SetNull:  zName = "SET NULL";        break;
 251     case OE_SetDflt:  zName = "SET DEFAULT";     break;
 252     case OE_Cascade:  zName = "CASCADE";         break;
 253     case OE_Restrict: zName = "RESTRICT";        break;
 254     default:          zName = "NO ACTION";
 255                       assert( action==OE_None ); break;
 256   }
 257   return zName;
 258 }
 259 #endif
 260
 261
 262 /*
 263 ** Parameter eMode must be one of the PAGER_JOURNALMODE_XXX constants
 264 ** defined in pager.h. This function returns the associated lowercase
 265 ** journal-mode name.
 266 */
 267 const char *sqlite3JournalModename(int eMode){
 268   static char * const azModeName[] = {
 269     "delete", "persist", "off", "truncate", "memory"
 270 #ifndef SQLITE_OMIT_WAL
 271      , "wal"
 272 #endif
 273   };
 274   assert( PAGER_JOURNALMODE_DELETE==0 );
 275   assert( PAGER_JOURNALMODE_PERSIST==1 );
 276   assert( PAGER_JOURNALMODE_OFF==2 );
 277   assert( PAGER_JOURNALMODE_TRUNCATE==3 );
 278   assert( PAGER_JOURNALMODE_MEMORY==4 );
 279   assert( PAGER_JOURNALMODE_WAL==5 );
 280   assert( eMode>=0 && eMode<=ArraySize(azModeName) );
 281
 282   if( eMode==ArraySize(azModeName) ) return 0;
 283   return azModeName[eMode];
 284 }
 285
 286 /*
 287 ** Process a pragma statement.
 288 **
 289 ** Pragmas are of this form:
 290 **
 291 **      PRAGMA [database.]id [= value]
 292 **
 293 ** The identifier might also be a string.  The value is a string, and
 294 ** identifier, or a number.  If minusFlag is true, then the value is
 295 ** a number that was preceded by a minus sign.
 296 **
 297 ** If the left side is "database.id" then pId1 is the database name
 298 ** and pId2 is the id.  If the left side is just "id" then pId1 is the
 299 ** id and pId2 is any empty string.
 300 */
 301 void sqlite3Pragma(
 302   Parse *pParse,
 303   Token *pId1,        /* First part of [database.]id field */
 304   Token *pId2,        /* Second part of [database.]id field, or NULL */
 305   Token *pValue,      /* Token for <value>, or NULL */
 306   int minusFlag       /* True if a '-' sign preceded <value> */
 307 ){
 308   char *zLeft = 0;       /* Nul-terminated UTF-8 string <id> */
 309   char *zRight = 0;      /* Nul-terminated UTF-8 string <value>, or NULL */
 310   const char *zDb = 0;   /* The database name */
 311   Token *pId;            /* Pointer to <id> token */
 312   int iDb;               /* Database index for <database> */
 313   sqlite3 *db = pParse->db;
 314   Db *pDb;
 315   Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
 316   if( v==0 ) return;
 317   sqlite3VdbeRunOnlyOnce(v);
 318   pParse->nMem = 2;
 319
 320   /* Interpret the [database.] part of the pragma statement. iDb is the
 321   ** index of the database this pragma is being applied to in db.aDb[]. */
 322   iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
 323   if( iDb<0 ) return;
 324   pDb = &db->aDb[iDb];
 325
 326   /* If the temp database has been explicitly named as part of the
 327   ** pragma, make sure it is open.
 328   */
 329   if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
 330     return;
 331   }
 332
 333   zLeft = sqlite3NameFromToken(db, pId);
 334   if( !zLeft ) return;
 335   if( minusFlag ){
 336     zRight = sqlite3MPrintf(db, "-%T", pValue);
 337   }else{
 338     zRight = sqlite3NameFromToken(db, pValue);
 339   }
 340
 341   assert( pId2 );
 342   zDb = pId2->n>0 ? pDb->zName : 0;
 343   if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
 344     goto pragma_out;
 345   }
 346
 347 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 348   /*
 349   **  PRAGMA [database.]default_cache_size
 350   **  PRAGMA [database.]default_cache_size=N
 351   **
 352   ** The first form reports the current persistent setting for the
 353   ** page cache size.  The value returned is the maximum number of
 354   ** pages in the page cache.  The second form sets both the current
 355   ** page cache size value and the persistent page cache size value
 356   ** stored in the database file.
 357   **
 358   ** Older versions of SQLite would set the default cache size to a
 359   ** negative number to indicate synchronous=OFF.  These days, synchronous
 360   ** is always on by default regardless of the sign of the default cache
 361   ** size.  But continue to take the absolute value of the default cache
 362   ** size of historical compatibility.
 363   */
 364   if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
 365     static const VdbeOpList getCacheSize[] = {
 366       { OP_Transaction, 0, 0,        0},                         /* 0 */
 367       { OP_ReadCookie,  0, 1,        BTREE_DEFAULT_CACHE_SIZE},  /* 1 */
 368       { OP_IfPos,       1, 7,        0},
 369       { OP_Integer,     0, 2,        0},
 370       { OP_Subtract,    1, 2,        1},
 371       { OP_IfPos,       1, 7,        0},
 372       { OP_Integer,     0, 1,        0},                         /* 6 */
 373       { OP_ResultRow,   1, 1,        0},
 374     };
 375     int addr;
 376     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 377     sqlite3VdbeUsesBtree(v, iDb);
 378     if( !zRight ){
 379       sqlite3VdbeSetNumCols(v, 1);
 380       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", SQLITE_STATIC);
 381       pParse->nMem += 2;
 382       addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
 383       sqlite3VdbeChangeP1(v, addr, iDb);
 384       sqlite3VdbeChangeP1(v, addr+1, iDb);
 385       sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);
 386     }else{
 387       int size = sqlite3AbsInt32(sqlite3Atoi(zRight));
 388       sqlite3BeginWriteOperation(pParse, 0, iDb);
 389       sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
 390       sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);
 391       assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
 392       pDb->pSchema->cache_size = size;
 393       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
 394     }
 395   }else
 396
 397   /*
 398   **  PRAGMA [database.]page_size
 399   **  PRAGMA [database.]page_size=N
 400   **
 401   ** The first form reports the current setting for the
 402   ** database page size in bytes.  The second form sets the
 403   ** database page size value.  The value can only be set if
 404   ** the database has not yet been created.
 405   */
 406   if( sqlite3StrICmp(zLeft,"page_size")==0 ){
 407     Btree *pBt = pDb->pBt;
 408     assert( pBt!=0 );
 409     if( !zRight ){
 410       int size = ALWAYS(pBt) ? sqlite3BtreeGetPageSize(pBt) : 0;
 411       returnSingleInt(pParse, "page_size", size);
 412     }else{
 413       /* Malloc may fail when setting the page-size, as there is an internal
 414       ** buffer that the pager module resizes using sqlite3_realloc().
 415       */
 416       db->nextPagesize = sqlite3Atoi(zRight);
 417       if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
 418         db->mallocFailed = 1;
 419       }
 420     }
 421   }else
 422
 423   /*
 424   **  PRAGMA [database.]secure_delete
 425   **  PRAGMA [database.]secure_delete=ON/OFF
 426   **
 427   ** The first form reports the current setting for the
 428   ** secure_delete flag.  The second form changes the secure_delete
 429   ** flag setting and reports thenew value.
 430   */
 431   if( sqlite3StrICmp(zLeft,"secure_delete")==0 ){
 432     Btree *pBt = pDb->pBt;
 433     int b = -1;
 434     assert( pBt!=0 );
 435     if( zRight ){
 436       b = getBoolean(zRight);
 437     }
 438     if( pId2->n==0 && b>=0 ){
 439       int ii;
 440       for(ii=0; ii<db->nDb; ii++){
 441         sqlite3BtreeSecureDelete(db->aDb[ii].pBt, b);
 442       }
 443     }
 444     b = sqlite3BtreeSecureDelete(pBt, b);
 445     returnSingleInt(pParse, "secure_delete", b);
 446   }else
 447
 448   /*
 449   **  PRAGMA [database.]max_page_count
 450   **  PRAGMA [database.]max_page_count=N
 451   **
 452   ** The first form reports the current setting for the
 453   ** maximum number of pages in the database file.  The
 454   ** second form attempts to change this setting.  Both
 455   ** forms return the current setting.
 456   **
 457   **  PRAGMA [database.]page_count
 458   **
 459   ** Return the number of pages in the specified database.
 460   */
 461   if( sqlite3StrICmp(zLeft,"page_count")==0
 462    || sqlite3StrICmp(zLeft,"max_page_count")==0
 463   ){
 464     int iReg;
 465     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 466     sqlite3CodeVerifySchema(pParse, iDb);
 467     iReg = ++pParse->nMem;
 468     if( zLeft[0]=='p' ){
 469       sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
 470     }else{
 471       sqlite3VdbeAddOp3(v, OP_MaxPgcnt, iDb, iReg, sqlite3Atoi(zRight));
 472     }
 473     sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
 474     sqlite3VdbeSetNumCols(v, 1);
 475     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
 476   }else
 477
 478   /*
 479   **  PRAGMA [database.]locking_mode
 480   **  PRAGMA [database.]locking_mode = (normal|exclusive)
 481   */
 482   if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){
 483     const char *zRet = "normal";
 484     int eMode = getLockingMode(zRight);
 485
 486     if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
 487       /* Simple "PRAGMA locking_mode;" statement. This is a query for
 488       ** the current default locking mode (which may be different to
 489       ** the locking-mode of the main database).
 490       */
 491       eMode = db->dfltLockMode;
 492     }else{
 493       Pager *pPager;
 494       if( pId2->n==0 ){
 495         /* This indicates that no database name was specified as part
 496         ** of the PRAGMA command. In this case the locking-mode must be
 497         ** set on all attached databases, as well as the main db file.
 498         **
 499         ** Also, the sqlite3.dfltLockMode variable is set so that
 500         ** any subsequently attached databases also use the specified
 501         ** locking mode.
 502         */
 503         int ii;
 504         assert(pDb==&db->aDb[0]);
 505         for(ii=2; ii<db->nDb; ii++){
 506           pPager = sqlite3BtreePager(db->aDb[ii].pBt);
 507           sqlite3PagerLockingMode(pPager, eMode);
 508         }
 509         db->dfltLockMode = (u8)eMode;
 510       }
 511       pPager = sqlite3BtreePager(pDb->pBt);
 512       eMode = sqlite3PagerLockingMode(pPager, eMode);
 513     }
 514
 515     assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
 516     if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
 517       zRet = "exclusive";
 518     }
 519     sqlite3VdbeSetNumCols(v, 1);
 520     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", SQLITE_STATIC);
 521     sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
 522     sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
 523   }else
 524
 525   /*
 526   **  PRAGMA [database.]journal_mode
 527   **  PRAGMA [database.]journal_mode =
 528   **                      (delete|persist|off|truncate|memory|wal|off)
 529   */
 530   if( sqlite3StrICmp(zLeft,"journal_mode")==0 ){
 531     int eMode;        /* One of the PAGER_JOURNALMODE_XXX symbols */
 532     int ii;           /* Loop counter */
 533
 534     /* Force the schema to be loaded on all databases.  This cases all
 535     ** database files to be opened and the journal_modes set. */
 536     if( sqlite3ReadSchema(pParse) ){
 537       goto pragma_out;
 538     }
 539
 540     sqlite3VdbeSetNumCols(v, 1);
 541     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", SQLITE_STATIC);
 542
 543     if( zRight==0 ){
 544       /* If there is no "=MODE" part of the pragma, do a query for the
 545       ** current mode */
 546       eMode = PAGER_JOURNALMODE_QUERY;
 547     }else{
 548       const char *zMode;
 549       int n = sqlite3Strlen30(zRight);
 550       for(eMode=0; (zMode = sqlite3JournalModename(eMode))!=0; eMode++){
 551         if( sqlite3StrNICmp(zRight, zMode, n)==0 ) break;
 552       }
 553       if( !zMode ){
 554         /* If the "=MODE" part does not match any known journal mode,
 555         ** then do a query */
 556         eMode = PAGER_JOURNALMODE_QUERY;
 557       }
 558     }
 559     if( eMode==PAGER_JOURNALMODE_QUERY && pId2->n==0 ){
 560       /* Convert "PRAGMA journal_mode" into "PRAGMA main.journal_mode" */
 561       iDb = 0;
 562       pId2->n = 1;
 563     }
 564     for(ii=db->nDb-1; ii>=0; ii--){
 565       if( db->aDb[ii].pBt && (ii==iDb || pId2->n==0) ){
 566         sqlite3VdbeUsesBtree(v, ii);
 567         sqlite3VdbeAddOp3(v, OP_JournalMode, ii, 1, eMode);
 568       }
 569     }
 570     sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
 571   }else
 572
 573   /*
 574   **  PRAGMA [database.]journal_size_limit
 575   **  PRAGMA [database.]journal_size_limit=N
 576   **
 577   ** Get or set the size limit on rollback journal files.
 578   */
 579   if( sqlite3StrICmp(zLeft,"journal_size_limit")==0 ){
 580     Pager *pPager = sqlite3BtreePager(pDb->pBt);
 581     i64 iLimit = -2;
 582     if( zRight ){
 583       sqlite3Atoi64(zRight, &iLimit, 1000000, SQLITE_UTF8);
 584       if( iLimit<-1 ) iLimit = -1;
 585     }
 586     iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
 587     returnSingleInt(pParse, "journal_size_limit", iLimit);
 588   }else
 589
 590 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
 591
 592   /*
 593   **  PRAGMA [database.]auto_vacuum
 594   **  PRAGMA [database.]auto_vacuum=N
 595   **
 596   ** Get or set the value of the database 'auto-vacuum' parameter.
 597   ** The value is one of:  0 NONE 1 FULL 2 INCREMENTAL
 598   */
 599 #ifndef SQLITE_OMIT_AUTOVACUUM
 600   if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
 601     Btree *pBt = pDb->pBt;
 602     assert( pBt!=0 );
 603     if( sqlite3ReadSchema(pParse) ){
 604       goto pragma_out;
 605     }
 606     if( !zRight ){
 607       int auto_vacuum;
 608       if( ALWAYS(pBt) ){
 609          auto_vacuum = sqlite3BtreeGetAutoVacuum(pBt);
 610       }else{
 611          auto_vacuum = SQLITE_DEFAULT_AUTOVACUUM;
 612       }
 613       returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
 614     }else{
 615       int eAuto = getAutoVacuum(zRight);
 616       assert( eAuto>=0 && eAuto<=2 );
 617       db->nextAutovac = (u8)eAuto;
 618       if( ALWAYS(eAuto>=0) ){
 619         /* Call SetAutoVacuum() to set initialize the internal auto and
 620         ** incr-vacuum flags. This is required in case this connection
 621         ** creates the database file. It is important that it is created
 622         ** as an auto-vacuum capable db.
 623         */
 624         int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
 625         if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
 626           /* When setting the auto_vacuum mode to either "full" or
 627           ** "incremental", write the value of meta[6] in the database
 628           ** file. Before writing to meta[6], check that meta[3] indicates
 629           ** that this really is an auto-vacuum capable database.
 630           */
 631           static const VdbeOpList setMeta6[] = {
 632             { OP_Transaction,    0,         1,                 0},    /* 0 */
 633             { OP_ReadCookie,     0,         1,         BTREE_LARGEST_ROOT_PAGE},
 634             { OP_If,             1,         0,                 0},    /* 2 */
 635             { OP_Halt,           SQLITE_OK, OE_Abort,          0},    /* 3 */
 636             { OP_Integer,        0,         1,                 0},    /* 4 */
 637             { OP_SetCookie,      0,         BTREE_INCR_VACUUM, 1},    /* 5 */
 638           };
 639           int iAddr;
 640           iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
 641           sqlite3VdbeChangeP1(v, iAddr, iDb);
 642           sqlite3VdbeChangeP1(v, iAddr+1, iDb);
 643           sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
 644           sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
 645           sqlite3VdbeChangeP1(v, iAddr+5, iDb);
 646           sqlite3VdbeUsesBtree(v, iDb);
 647         }
 648       }
 649     }
 650   }else
 651 #endif
 652
 653   /*
 654   **  PRAGMA [database.]incremental_vacuum(N)
 655   **
 656   ** Do N steps of incremental vacuuming on a database.
 657   */
 658 #ifndef SQLITE_OMIT_AUTOVACUUM
 659   if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){
 660     int iLimit, addr;
 661     if( sqlite3ReadSchema(pParse) ){
 662       goto pragma_out;
 663     }
 664     if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
 665       iLimit = 0x7fffffff;
 666     }
 667     sqlite3BeginWriteOperation(pParse, 0, iDb);
 668     sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
 669     addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
 670     sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
 671     sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
 672     sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);
 673     sqlite3VdbeJumpHere(v, addr);
 674   }else
 675 #endif
 676
 677 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
 678   /*
 679   **  PRAGMA [database.]cache_size
 680   **  PRAGMA [database.]cache_size=N
 681   **
 682   ** The first form reports the current local setting for the
 683   ** page cache size.  The local setting can be different from
 684   ** the persistent cache size value that is stored in the database
 685   ** file itself.  The value returned is the maximum number of
 686   ** pages in the page cache.  The second form sets the local
 687   ** page cache size value.  It does not change the persistent
 688   ** cache size stored on the disk so the cache size will revert
 689   ** to its default value when the database is closed and reopened.
 690   ** N should be a positive integer.
 691   */
 692   if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
 693     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 694     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
 695     if( !zRight ){
 696       returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
 697     }else{
 698       int size = sqlite3AbsInt32(sqlite3Atoi(zRight));
 699       pDb->pSchema->cache_size = size;
 700       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
 701     }
 702   }else
 703
 704   /*
 705   **   PRAGMA temp_store
 706   **   PRAGMA temp_store = "default"|"memory"|"file"
 707   **
 708   ** Return or set the local value of the temp_store flag.  Changing
 709   ** the local value does not make changes to the disk file and the default
 710   ** value will be restored the next time the database is opened.
 711   **
 712   ** Note that it is possible for the library compile-time options to
 713   ** override this setting
 714   */
 715   if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
 716     if( !zRight ){
 717       returnSingleInt(pParse, "temp_store", db->temp_store);
 718     }else{
 719       changeTempStorage(pParse, zRight);
 720     }
 721   }else
 722
 723   /*
 724   **   PRAGMA temp_store_directory
 725   **   PRAGMA temp_store_directory = ""|"directory_name"
 726   **
 727   ** Return or set the local value of the temp_store_directory flag.  Changing
 728   ** the value sets a specific directory to be used for temporary files.
 729   ** Setting to a null string reverts to the default temporary directory search.
 730   ** If temporary directory is changed, then invalidateTempStorage.
 731   **
 732   */
 733   if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
 734     if( !zRight ){
 735       if( sqlite3_temp_directory ){
 736         sqlite3VdbeSetNumCols(v, 1);
 737         sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
 738             "temp_store_directory", SQLITE_STATIC);
 739         sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);
 740         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
 741       }
 742     }else{
 743 #ifndef SQLITE_OMIT_WSD
 744       if( zRight[0] ){
 745         int rc;
 746         int res;
 747         rc = sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
 748         if( rc!=SQLITE_OK || res==0 ){
 749           sqlite3ErrorMsg(pParse, "not a writable directory");
 750           goto pragma_out;
 751         }
 752       }
 753       if( SQLITE_TEMP_STORE==0
 754        || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
 755        || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
 756       ){
 757         invalidateTempStorage(pParse);
 758       }
 759       sqlite3_free(sqlite3_temp_directory);
 760       if( zRight[0] ){
 761         sqlite3_temp_directory = sqlite3_mprintf("%s", zRight);
 762       }else{
 763         sqlite3_temp_directory = 0;
 764       }
 765 #endif /* SQLITE_OMIT_WSD */
 766     }
 767   }else
 768
 769 #if !defined(SQLITE_ENABLE_LOCKING_STYLE)
 770 #  if defined(__APPLE__)
 771 #    define SQLITE_ENABLE_LOCKING_STYLE 1
 772 #  else
 773 #    define SQLITE_ENABLE_LOCKING_STYLE 0
 774 #  endif
 775 #endif
 776 #if SQLITE_ENABLE_LOCKING_STYLE
 777   /*
 778    **   PRAGMA [database.]lock_proxy_file
 779    **   PRAGMA [database.]lock_proxy_file = ":auto:"|"lock_file_path"
 780    **
 781    ** Return or set the value of the lock_proxy_file flag.  Changing
 782    ** the value sets a specific file to be used for database access locks.
 783    **
 784    */
 785   if( sqlite3StrICmp(zLeft, "lock_proxy_file")==0 ){
 786     if( !zRight ){
 787       Pager *pPager = sqlite3BtreePager(pDb->pBt);
 788       char *proxy_file_path = NULL;
 789       sqlite3_file *pFile = sqlite3PagerFile(pPager);
 790       sqlite3OsFileControl(pFile, SQLITE_GET_LOCKPROXYFILE,
 791                            &proxy_file_path);
 792
 793       if( proxy_file_path ){
 794         sqlite3VdbeSetNumCols(v, 1);
 795         sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
 796                               "lock_proxy_file", SQLITE_STATIC);
 797         sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, proxy_file_path, 0);
 798         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
 799       }
 800     }else{
 801       Pager *pPager = sqlite3BtreePager(pDb->pBt);
 802       sqlite3_file *pFile = sqlite3PagerFile(pPager);
 803       int res;
 804       if( zRight[0] ){
 805         res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
 806                                      zRight);
 807       } else {
 808         res=sqlite3OsFileControl(pFile, SQLITE_SET_LOCKPROXYFILE,
 809                                      NULL);
 810       }
 811       if( res!=SQLITE_OK ){
 812         sqlite3ErrorMsg(pParse, "failed to set lock proxy file");
 813         goto pragma_out;
 814       }
 815     }
 816   }else
 817 #endif /* SQLITE_ENABLE_LOCKING_STYLE */
 818
 819   /*
 820   **   PRAGMA [database.]synchronous
 821   **   PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
 822   **
 823   ** Return or set the local value of the synchronous flag.  Changing
 824   ** the local value does not make changes to the disk file and the
 825   ** default value will be restored the next time the database is
 826   ** opened.
 827   */
 828   if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
 829     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 830     if( !zRight ){
 831       returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
 832     }else{
 833       if( !db->autoCommit ){
 834         sqlite3ErrorMsg(pParse,
 835             "Safety level may not be changed inside a transaction");
 836       }else{
 837         pDb->safety_level = getSafetyLevel(zRight)+1;
 838       }
 839     }
 840   }else
 841 #endif /* SQLITE_OMIT_PAGER_PRAGMAS */
 842
 843 #ifndef SQLITE_OMIT_FLAG_PRAGMAS
 844   if( flagPragma(pParse, zLeft, zRight) ){
 845     /* The flagPragma() subroutine also generates any necessary code
 846     ** there is nothing more to do here */
 847   }else
 848 #endif /* SQLITE_OMIT_FLAG_PRAGMAS */
 849
 850 #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
 851   /*
 852   **   PRAGMA table_info(<table>)
 853   **
 854   ** Return a single row for each column of the named table. The columns of
 855   ** the returned data set are:
 856   **
 857   ** cid:        Column id (numbered from left to right, starting at 0)
 858   ** name:       Column name
 859   ** type:       Column declaration type.
 860   ** notnull:    True if 'NOT NULL' is part of column declaration
 861   ** dflt_value: The default value for the column, if any.
 862   */
 863   if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
 864     Table *pTab;
 865     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 866     pTab = sqlite3FindTable(db, zRight, zDb);
 867     if( pTab ){
 868       int i;
 869       int nHidden = 0;
 870       Column *pCol;
 871       sqlite3VdbeSetNumCols(v, 6);
 872       pParse->nMem = 6;
 873       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", SQLITE_STATIC);
 874       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
 875       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", SQLITE_STATIC);
 876       sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", SQLITE_STATIC);
 877       sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", SQLITE_STATIC);
 878       sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", SQLITE_STATIC);
 879       sqlite3ViewGetColumnNames(pParse, pTab);
 880       for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
 881         if( IsHiddenColumn(pCol) ){
 882           nHidden++;
 883           continue;
 884         }
 885         sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
 886         sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
 887         sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
 888            pCol->zType ? pCol->zType : "", 0);
 889         sqlite3VdbeAddOp2(v, OP_Integer, (pCol->notNull ? 1 : 0), 4);
 890         if( pCol->zDflt ){
 891           sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pCol->zDflt, 0);
 892         }else{
 893           sqlite3VdbeAddOp2(v, OP_Null, 0, 5);
 894         }
 895         sqlite3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6);
 896         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6);
 897       }
 898     }
 899   }else
 900
 901   if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
 902     Index *pIdx;
 903     Table *pTab;
 904     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 905     pIdx = sqlite3FindIndex(db, zRight, zDb);
 906     if( pIdx ){
 907       int i;
 908       pTab = pIdx->pTable;
 909       sqlite3VdbeSetNumCols(v, 3);
 910       pParse->nMem = 3;
 911       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", SQLITE_STATIC);
 912       sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", SQLITE_STATIC);
 913       sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", SQLITE_STATIC);
 914       for(i=0; i<pIdx->nColumn; i++){
 915         int cnum = pIdx->aiColumn[i];
 916         sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
 917         sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
 918         assert( pTab->nCol>cnum );
 919         sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
 920         sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
 921       }
 922     }
 923   }else
 924
 925   if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
 926     Index *pIdx;
 927     Table *pTab;
 928     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 929     pTab = sqlite3FindTable(db, zRight, zDb);
 930     if( pTab ){
 931       v = sqlite3GetVdbe(pParse);
 932       pIdx = pTab->pIndex;
 933       if( pIdx ){
 934         int i = 0;
 935         sqlite3VdbeSetNumCols(v, 3);
 936         pParse->nMem = 3;
 937         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
 938         sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
 939         sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", SQLITE_STATIC);
 940         while(pIdx){
 941           sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
 942           sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
 943           sqlite3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3);
 944           sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
 945           ++i;
 946           pIdx = pIdx->pNext;
 947         }
 948       }
 949     }
 950   }else
 951
 952   if( sqlite3StrICmp(zLeft, "database_list")==0 ){
 953     int i;
 954     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 955     sqlite3VdbeSetNumCols(v, 3);
 956     pParse->nMem = 3;
 957     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
 958     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
 959     sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", SQLITE_STATIC);
 960     for(i=0; i<db->nDb; i++){
 961       if( db->aDb[i].pBt==0 ) continue;
 962       assert( db->aDb[i].zName!=0 );
 963       sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
 964       sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
 965       sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
 966            sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
 967       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
 968     }
 969   }else
 970
 971   if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
 972     int i = 0;
 973     HashElem *p;
 974     sqlite3VdbeSetNumCols(v, 2);
 975     pParse->nMem = 2;
 976     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", SQLITE_STATIC);
 977     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", SQLITE_STATIC);
 978     for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
 979       CollSeq *pColl = (CollSeq *)sqliteHashData(p);
 980       sqlite3VdbeAddOp2(v, OP_Integer, i++, 1);
 981       sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
 982       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
 983     }
 984   }else
 985 #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
 986
 987 #ifndef SQLITE_OMIT_FOREIGN_KEY
 988   if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
 989     FKey *pFK;
 990     Table *pTab;
 991     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
 992     pTab = sqlite3FindTable(db, zRight, zDb);
 993     if( pTab ){
 994       v = sqlite3GetVdbe(pParse);
 995       pFK = pTab->pFKey;
 996       if( pFK ){
 997         int i = 0;
 998         sqlite3VdbeSetNumCols(v, 8);
 999         pParse->nMem = 8;
1000         sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", SQLITE_STATIC);
1001         sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", SQLITE_STATIC);
1002         sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", SQLITE_STATIC);
1003         sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", SQLITE_STATIC);
1004         sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", SQLITE_STATIC);
1005         sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "on_update", SQLITE_STATIC);
1006         sqlite3VdbeSetColName(v, 6, COLNAME_NAME, "on_delete", SQLITE_STATIC);
1007         sqlite3VdbeSetColName(v, 7, COLNAME_NAME, "match", SQLITE_STATIC);
1008         while(pFK){
1009           int j;
1010           for(j=0; j<pFK->nCol; j++){
1011             char *zCol = pFK->aCol[j].zCol;
1012             char *zOnDelete = (char *)actionName(pFK->aAction[0]);
1013             char *zOnUpdate = (char *)actionName(pFK->aAction[1]);
1014             sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1015             sqlite3VdbeAddOp2(v, OP_Integer, j, 2);
1016             sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
1017             sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
1018                               pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
1019             sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
1020             sqlite3VdbeAddOp4(v, OP_String8, 0, 6, 0, zOnUpdate, 0);
1021             sqlite3VdbeAddOp4(v, OP_String8, 0, 7, 0, zOnDelete, 0);
1022             sqlite3VdbeAddOp4(v, OP_String8, 0, 8, 0, "NONE", 0);
1023             sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 8);
1024           }
1025           ++i;
1026           pFK = pFK->pNextFrom;
1027         }
1028       }
1029     }
1030   }else
1031 #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
1032
1033 #ifndef NDEBUG
1034   if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
1035     if( zRight ){
1036       if( getBoolean(zRight) ){
1037         sqlite3ParserTrace(stderr, "parser: ");
1038       }else{
1039         sqlite3ParserTrace(0, 0);
1040       }
1041     }
1042   }else
1043 #endif
1044
1045   /* Reinstall the LIKE and GLOB functions.  The variant of LIKE
1046   ** used will be case sensitive or not depending on the RHS.
1047   */
1048   if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){
1049     if( zRight ){
1050       sqlite3RegisterLikeFunctions(db, getBoolean(zRight));
1051     }
1052   }else
1053
1054 #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
1055 # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
1056 #endif
1057
1058 #ifndef SQLITE_OMIT_INTEGRITY_CHECK
1059   /* Pragma "quick_check" is an experimental reduced version of
1060   ** integrity_check designed to detect most database corruption
1061   ** without most of the overhead of a full integrity-check.
1062   */
1063   if( sqlite3StrICmp(zLeft, "integrity_check")==0
1064    || sqlite3StrICmp(zLeft, "quick_check")==0
1065   ){
1066     int i, j, addr, mxErr;
1067
1068     /* Code that appears at the end of the integrity check.  If no error
1069     ** messages have been generated, output OK.  Otherwise output the
1070     ** error message
1071     */
1072     static const VdbeOpList endCode[] = {
1073       { OP_AddImm,      1, 0,        0},    /* 0 */
1074       { OP_IfNeg,       1, 0,        0},    /* 1 */
1075       { OP_String8,     0, 3,        0},    /* 2 */
1076       { OP_ResultRow,   3, 1,        0},
1077     };
1078
1079     int isQuick = (zLeft[0]=='q');
1080
1081     /* Initialize the VDBE program */
1082     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1083     pParse->nMem = 6;
1084     sqlite3VdbeSetNumCols(v, 1);
1085     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", SQLITE_STATIC);
1086
1087     /* Set the maximum error count */
1088     mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1089     if( zRight ){
1090       sqlite3GetInt32(zRight, &mxErr);
1091       if( mxErr<=0 ){
1092         mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1093       }
1094     }
1095     sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1);  /* reg[1] holds errors left */
1096
1097     /* Do an integrity check on each database file */
1098     for(i=0; i<db->nDb; i++){
1099       HashElem *x;
1100       Hash *pTbls;
1101       int cnt = 0;
1102
1103       if( OMIT_TEMPDB && i==1 ) continue;
1104
1105       sqlite3CodeVerifySchema(pParse, i);
1106       addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
1107       sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1108       sqlite3VdbeJumpHere(v, addr);
1109
1110       /* Do an integrity check of the B-Tree
1111       **
1112       ** Begin by filling registers 2, 3, ... with the root pages numbers
1113       ** for all tables and indices in the database.
1114       */
1115       assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
1116       pTbls = &db->aDb[i].pSchema->tblHash;
1117       for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
1118         Table *pTab = sqliteHashData(x);
1119         Index *pIdx;
1120         sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
1121         cnt++;
1122         for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1123           sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
1124           cnt++;
1125         }
1126       }
1127
1128       /* Make sure sufficient number of registers have been allocated */
1129       if( pParse->nMem < cnt+4 ){
1130         pParse->nMem = cnt+4;
1131       }
1132
1133       /* Do the b-tree integrity checks */
1134       sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
1135       sqlite3VdbeChangeP5(v, (u8)i);
1136       addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2);
1137       sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1138          sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
1139          P4_DYNAMIC);
1140       sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
1141       sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
1142       sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
1143       sqlite3VdbeJumpHere(v, addr);
1144
1145       /* Make sure all the indices are constructed correctly.
1146       */
1147       for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
1148         Table *pTab = sqliteHashData(x);
1149         Index *pIdx;
1150         int loopTop;
1151
1152         if( pTab->pIndex==0 ) continue;
1153         addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);  /* Stop if out of errors */
1154         sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1155         sqlite3VdbeJumpHere(v, addr);
1156         sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
1157         sqlite3VdbeAddOp2(v, OP_Integer, 0, 2);  /* reg(2) will count entries */
1158         loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0);
1159         sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1);   /* increment entry count */
1160         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1161           int jmp2;
1162           int r1;
1163           static const VdbeOpList idxErr[] = {
1164             { OP_AddImm,      1, -1,  0},
1165             { OP_String8,     0,  3,  0},    /* 1 */
1166             { OP_Rowid,       1,  4,  0},
1167             { OP_String8,     0,  5,  0},    /* 3 */
1168             { OP_String8,     0,  6,  0},    /* 4 */
1169             { OP_Concat,      4,  3,  3},
1170             { OP_Concat,      5,  3,  3},
1171             { OP_Concat,      6,  3,  3},
1172             { OP_ResultRow,   3,  1,  0},
1173             { OP_IfPos,       1,  0,  0},    /* 9 */
1174             { OP_Halt,        0,  0,  0},
1175           };
1176           r1 = sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 0);
1177           jmp2 = sqlite3VdbeAddOp4Int(v, OP_Found, j+2, 0, r1, pIdx->nColumn+1);
1178           addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
1179           sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
1180           sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
1181           sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_TRANSIENT);
1182           sqlite3VdbeJumpHere(v, addr+9);
1183           sqlite3VdbeJumpHere(v, jmp2);
1184         }
1185         sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1);
1186         sqlite3VdbeJumpHere(v, loopTop);
1187         for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1188           static const VdbeOpList cntIdx[] = {
1189              { OP_Integer,      0,  3,  0},
1190              { OP_Rewind,       0,  0,  0},  /* 1 */
1191              { OP_AddImm,       3,  1,  0},
1192              { OP_Next,         0,  0,  0},  /* 3 */
1193              { OP_Eq,           2,  0,  3},  /* 4 */
1194              { OP_AddImm,       1, -1,  0},
1195              { OP_String8,      0,  2,  0},  /* 6 */
1196              { OP_String8,      0,  3,  0},  /* 7 */
1197              { OP_Concat,       3,  2,  2},
1198              { OP_ResultRow,    2,  1,  0},
1199           };
1200           addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);
1201           sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1202           sqlite3VdbeJumpHere(v, addr);
1203           addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
1204           sqlite3VdbeChangeP1(v, addr+1, j+2);
1205           sqlite3VdbeChangeP2(v, addr+1, addr+4);
1206           sqlite3VdbeChangeP1(v, addr+3, j+2);
1207           sqlite3VdbeChangeP2(v, addr+3, addr+2);
1208           sqlite3VdbeJumpHere(v, addr+4);
1209           sqlite3VdbeChangeP4(v, addr+6,
1210                      "wrong # of entries in index ", P4_STATIC);
1211           sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_TRANSIENT);
1212         }
1213       }
1214     }
1215     addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
1216     sqlite3VdbeChangeP2(v, addr, -mxErr);
1217     sqlite3VdbeJumpHere(v, addr+1);
1218     sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
1219   }else
1220 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
1221
1222 #ifndef SQLITE_OMIT_UTF16
1223   /*
1224   **   PRAGMA encoding
1225   **   PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
1226   **
1227   ** In its first form, this pragma returns the encoding of the main
1228   ** database. If the database is not initialized, it is initialized now.
1229   **
1230   ** The second form of this pragma is a no-op if the main database file
1231   ** has not already been initialized. In this case it sets the default
1232   ** encoding that will be used for the main database file if a new file
1233   ** is created. If an existing main database file is opened, then the
1234   ** default text encoding for the existing database is used.
1235   **
1236   ** In all cases new databases created using the ATTACH command are
1237   ** created to use the same default text encoding as the main database. If
1238   ** the main database has not been initialized and/or created when ATTACH
1239   ** is executed, this is done before the ATTACH operation.
1240   **
1241   ** In the second form this pragma sets the text encoding to be used in
1242   ** new database files created using this database handle. It is only
1243   ** useful if invoked immediately after the main database i
1244   */
1245   if( sqlite3StrICmp(zLeft, "encoding")==0 ){
1246     static const struct EncName {
1247       char *zName;
1248       u8 enc;
1249     } encnames[] = {
1250       { "UTF8",     SQLITE_UTF8        },
1251       { "UTF-8",    SQLITE_UTF8        },  /* Must be element [1] */
1252       { "UTF-16le", SQLITE_UTF16LE     },  /* Must be element [2] */
1253       { "UTF-16be", SQLITE_UTF16BE     },  /* Must be element [3] */
1254       { "UTF16le",  SQLITE_UTF16LE     },
1255       { "UTF16be",  SQLITE_UTF16BE     },
1256       { "UTF-16",   0                  }, /* SQLITE_UTF16NATIVE */
1257       { "UTF16",    0                  }, /* SQLITE_UTF16NATIVE */
1258       { 0, 0 }
1259     };
1260     const struct EncName *pEnc;
1261     if( !zRight ){    /* "PRAGMA encoding" */
1262       if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1263       sqlite3VdbeSetNumCols(v, 1);
1264       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", SQLITE_STATIC);
1265       sqlite3VdbeAddOp2(v, OP_String8, 0, 1);
1266       assert( encnames[SQLITE_UTF8].enc==SQLITE_UTF8 );
1267       assert( encnames[SQLITE_UTF16LE].enc==SQLITE_UTF16LE );
1268       assert( encnames[SQLITE_UTF16BE].enc==SQLITE_UTF16BE );
1269       sqlite3VdbeChangeP4(v, -1, encnames[ENC(pParse->db)].zName, P4_STATIC);
1270       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1271     }else{                        /* "PRAGMA encoding = XXX" */
1272       /* Only change the value of sqlite.enc if the database handle is not
1273       ** initialized. If the main database exists, the new sqlite.enc value
1274       ** will be overwritten when the schema is next loaded. If it does not
1275       ** already exists, it will be created to use the new encoding value.
1276       */
1277       if(
1278         !(DbHasProperty(db, 0, DB_SchemaLoaded)) ||
1279         DbHasProperty(db, 0, DB_Empty)
1280       ){
1281         for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
1282           if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
1283             ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
1284             break;
1285           }
1286         }
1287         if( !pEnc->zName ){
1288           sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
1289         }
1290       }
1291     }
1292   }else
1293 #endif /* SQLITE_OMIT_UTF16 */
1294
1295 #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
1296   /*
1297   **   PRAGMA [database.]schema_version
1298   **   PRAGMA [database.]schema_version = <integer>
1299   **
1300   **   PRAGMA [database.]user_version
1301   **   PRAGMA [database.]user_version = <integer>
1302   **
1303   ** The pragma's schema_version and user_version are used to set or get
1304   ** the value of the schema-version and user-version, respectively. Both
1305   ** the schema-version and the user-version are 32-bit signed integers
1306   ** stored in the database header.
1307   **
1308   ** The schema-cookie is usually only manipulated internally by SQLite. It
1309   ** is incremented by SQLite whenever the database schema is modified (by
1310   ** creating or dropping a table or index). The schema version is used by
1311   ** SQLite each time a query is executed to ensure that the internal cache
1312   ** of the schema used when compiling the SQL query matches the schema of
1313   ** the database against which the compiled query is actually executed.
1314   ** Subverting this mechanism by using "PRAGMA schema_version" to modify
1315   ** the schema-version is potentially dangerous and may lead to program
1316   ** crashes or database corruption. Use with caution!
1317   **
1318   ** The user-version is not used internally by SQLite. It may be used by
1319   ** applications for any purpose.
1320   */
1321   if( sqlite3StrICmp(zLeft, "schema_version")==0
1322    || sqlite3StrICmp(zLeft, "user_version")==0
1323    || sqlite3StrICmp(zLeft, "freelist_count")==0
1324   ){
1325     int iCookie;   /* Cookie index. 1 for schema-cookie, 6 for user-cookie. */
1326     sqlite3VdbeUsesBtree(v, iDb);
1327     switch( zLeft[0] ){
1328       case 'f': case 'F':
1329         iCookie = BTREE_FREE_PAGE_COUNT;
1330         break;
1331       case 's': case 'S':
1332         iCookie = BTREE_SCHEMA_VERSION;
1333         break;
1334       default:
1335         iCookie = BTREE_USER_VERSION;
1336         break;
1337     }
1338
1339     if( zRight && iCookie!=BTREE_FREE_PAGE_COUNT ){
1340       /* Write the specified cookie value */
1341       static const VdbeOpList setCookie[] = {
1342         { OP_Transaction,    0,  1,  0},    /* 0 */
1343         { OP_Integer,        0,  1,  0},    /* 1 */
1344         { OP_SetCookie,      0,  0,  1},    /* 2 */
1345       };
1346       int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
1347       sqlite3VdbeChangeP1(v, addr, iDb);
1348       sqlite3VdbeChangeP1(v, addr+1, sqlite3Atoi(zRight));
1349       sqlite3VdbeChangeP1(v, addr+2, iDb);
1350       sqlite3VdbeChangeP2(v, addr+2, iCookie);
1351     }else{
1352       /* Read the specified cookie value */
1353       static const VdbeOpList readCookie[] = {
1354         { OP_Transaction,     0,  0,  0},    /* 0 */
1355         { OP_ReadCookie,      0,  1,  0},    /* 1 */
1356         { OP_ResultRow,       1,  1,  0}
1357       };
1358       int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
1359       sqlite3VdbeChangeP1(v, addr, iDb);
1360       sqlite3VdbeChangeP1(v, addr+1, iDb);
1361       sqlite3VdbeChangeP3(v, addr+1, iCookie);
1362       sqlite3VdbeSetNumCols(v, 1);
1363       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
1364     }
1365   }else
1366 #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
1367
1368 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
1369   /*
1370   **   PRAGMA compile_options
1371   **
1372   ** Return the names of all compile-time options used in this build,
1373   ** one option per row.
1374   */
1375   if( sqlite3StrICmp(zLeft, "compile_options")==0 ){
1376     int i = 0;
1377     const char *zOpt;
1378     sqlite3VdbeSetNumCols(v, 1);
1379     pParse->nMem = 1;
1380     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "compile_option", SQLITE_STATIC);
1381     while( (zOpt = sqlite3_compileoption_get(i++))!=0 ){
1382       sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zOpt, 0);
1383       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1384     }
1385   }else
1386 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
1387
1388 #ifndef SQLITE_OMIT_WAL
1389   /*
1390   **   PRAGMA [database.]wal_checkpoint = passive|full|restart
1391   **
1392   ** Checkpoint the database.
1393   */
1394   if( sqlite3StrICmp(zLeft, "wal_checkpoint")==0 ){
1395     int iBt = (pId2->z?iDb:SQLITE_MAX_ATTACHED);
1396     int eMode = SQLITE_CHECKPOINT_PASSIVE;
1397     if( zRight ){
1398       if( sqlite3StrICmp(zRight, "full")==0 ){
1399         eMode = SQLITE_CHECKPOINT_FULL;
1400       }else if( sqlite3StrICmp(zRight, "restart")==0 ){
1401         eMode = SQLITE_CHECKPOINT_RESTART;
1402       }
1403     }
1404     if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1405     sqlite3VdbeSetNumCols(v, 3);
1406     pParse->nMem = 3;
1407     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "busy", SQLITE_STATIC);
1408     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "log", SQLITE_STATIC);
1409     sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "checkpointed", SQLITE_STATIC);
1410
1411     sqlite3VdbeAddOp3(v, OP_Checkpoint, iBt, eMode, 1);
1412     sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1413   }else
1414
1415   /*
1416   **   PRAGMA wal_autocheckpoint
1417   **   PRAGMA wal_autocheckpoint = N
1418   **
1419   ** Configure a database connection to automatically checkpoint a database
1420   ** after accumulating N frames in the log. Or query for the current value
1421   ** of N.
1422   */
1423   if( sqlite3StrICmp(zLeft, "wal_autocheckpoint")==0 ){
1424     if( zRight ){
1425       sqlite3_wal_autocheckpoint(db, sqlite3Atoi(zRight));
1426     }
1427     returnSingleInt(pParse, "wal_autocheckpoint",
1428        db->xWalCallback==sqlite3WalDefaultHook ?
1429            SQLITE_PTR_TO_INT(db->pWalArg) : 0);
1430   }else
1431 #endif
1432
1433 #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
1434   /*
1435   ** Report the current state of file logs for all databases
1436   */
1437   if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
1438     static const char *const azLockName[] = {
1439       "unlocked", "shared", "reserved", "pending", "exclusive"
1440     };
1441     int i;
1442     sqlite3VdbeSetNumCols(v, 2);
1443     pParse->nMem = 2;
1444     sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", SQLITE_STATIC);
1445     sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", SQLITE_STATIC);
1446     for(i=0; i<db->nDb; i++){
1447       Btree *pBt;
1448       Pager *pPager;
1449       const char *zState = "unknown";
1450       int j;
1451       if( db->aDb[i].zName==0 ) continue;
1452       sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
1453       pBt = db->aDb[i].pBt;
1454       if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
1455         zState = "closed";
1456       }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
1457                                      SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
1458          zState = azLockName[j];
1459       }
1460       sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
1461       sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
1462     }
1463
1464   }else
1465 #endif
1466
1467 #ifdef SQLITE_HAS_CODEC
1468   if( sqlite3StrICmp(zLeft, "key")==0 && zRight ){
1469     sqlite3_key(db, zRight, sqlite3Strlen30(zRight));
1470   }else
1471   if( sqlite3StrICmp(zLeft, "rekey")==0 && zRight ){
1472     sqlite3_rekey(db, zRight, sqlite3Strlen30(zRight));
1473   }else
1474   if( zRight && (sqlite3StrICmp(zLeft, "hexkey")==0 ||
1475                  sqlite3StrICmp(zLeft, "hexrekey")==0) ){
1476     int i, h1, h2;
1477     char zKey[40];
1478     for(i=0; (h1 = zRight[i])!=0 && (h2 = zRight[i+1])!=0; i+=2){
1479       h1 += 9*(1&(h1>>6));
1480       h2 += 9*(1&(h2>>6));
1481       zKey[i/2] = (h2 & 0x0f) | ((h1 & 0xf)<<4);
1482     }
1483     if( (zLeft[3] & 0xf)==0xb ){
1484       sqlite3_key(db, zKey, i/2);
1485     }else{
1486       sqlite3_rekey(db, zKey, i/2);
1487     }
1488   }else
1489 #endif
1490 #if defined(SQLITE_HAS_CODEC) || defined(SQLITE_ENABLE_CEROD)
1491   if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){
1492 #ifdef SQLITE_HAS_CODEC
1493     if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){
1494       sqlite3_activate_see(&zRight[4]);
1495     }
1496 #endif
1497 #ifdef SQLITE_ENABLE_CEROD
1498     if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
1499       sqlite3_activate_cerod(&zRight[6]);
1500     }
1501 #endif
1502   }else
1503 #endif
1504
1505
1506   {/* Empty ELSE clause */}
1507
1508   /*
1509   ** Reset the safety level, in case the fullfsync flag or synchronous
1510   ** setting changed.
1511   */
1512 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
1513   if( db->autoCommit ){
1514     sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
1515                (db->flags&SQLITE_FullFSync)!=0,
1516                (db->flags&SQLITE_CkptFullFSync)!=0);
1517   }
1518 #endif
1519 pragma_out:
1520   sqlite3DbFree(db, zLeft);
1521   sqlite3DbFree(db, zRight);
1522 }
1523
1524 #endif /* SQLITE_OMIT_PRAGMA */