1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite/pragma.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1329 @@
1.4 +/*
1.5 +** 2003 April 6
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** This file contains code used to implement the PRAGMA command.
1.16 +**
1.17 +** $Id: pragma.c,v 1.183 2008/07/28 19:34:53 drh Exp $
1.18 +*/
1.19 +#include "sqliteInt.h"
1.20 +#include <ctype.h>
1.21 +
1.22 +/* Ignore this whole file if pragmas are disabled
1.23 +*/
1.24 +#if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER)
1.25 +
1.26 +/*
1.27 +** Interpret the given string as a safety level. Return 0 for OFF,
1.28 +** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or
1.29 +** unrecognized string argument.
1.30 +**
1.31 +** Note that the values returned are one less that the values that
1.32 +** should be passed into sqlite3BtreeSetSafetyLevel(). The is done
1.33 +** to support legacy SQL code. The safety level used to be boolean
1.34 +** and older scripts may have used numbers 0 for OFF and 1 for ON.
1.35 +*/
1.36 +static int getSafetyLevel(const char *z){
1.37 + /* 123456789 123456789 */
1.38 + static const char zText[] = "onoffalseyestruefull";
1.39 + static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
1.40 + static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
1.41 + static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2};
1.42 + int i, n;
1.43 + if( isdigit(*z) ){
1.44 + return atoi(z);
1.45 + }
1.46 + n = strlen(z);
1.47 + for(i=0; i<sizeof(iLength); i++){
1.48 + if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
1.49 + return iValue[i];
1.50 + }
1.51 + }
1.52 + return 1;
1.53 +}
1.54 +
1.55 +/*
1.56 +** Interpret the given string as a boolean value.
1.57 +*/
1.58 +static int getBoolean(const char *z){
1.59 + return getSafetyLevel(z)&1;
1.60 +}
1.61 +
1.62 +/*
1.63 +** Interpret the given string as a locking mode value.
1.64 +*/
1.65 +static int getLockingMode(const char *z){
1.66 + if( z ){
1.67 + if( 0==sqlite3StrICmp(z, "exclusive") ) return PAGER_LOCKINGMODE_EXCLUSIVE;
1.68 + if( 0==sqlite3StrICmp(z, "normal") ) return PAGER_LOCKINGMODE_NORMAL;
1.69 + }
1.70 + return PAGER_LOCKINGMODE_QUERY;
1.71 +}
1.72 +
1.73 +#ifndef SQLITE_OMIT_AUTOVACUUM
1.74 +/*
1.75 +** Interpret the given string as an auto-vacuum mode value.
1.76 +**
1.77 +** The following strings, "none", "full" and "incremental" are
1.78 +** acceptable, as are their numeric equivalents: 0, 1 and 2 respectively.
1.79 +*/
1.80 +static int getAutoVacuum(const char *z){
1.81 + int i;
1.82 + if( 0==sqlite3StrICmp(z, "none") ) return BTREE_AUTOVACUUM_NONE;
1.83 + if( 0==sqlite3StrICmp(z, "full") ) return BTREE_AUTOVACUUM_FULL;
1.84 + if( 0==sqlite3StrICmp(z, "incremental") ) return BTREE_AUTOVACUUM_INCR;
1.85 + i = atoi(z);
1.86 + return ((i>=0&&i<=2)?i:0);
1.87 +}
1.88 +#endif /* ifndef SQLITE_OMIT_AUTOVACUUM */
1.89 +
1.90 +#ifndef SQLITE_OMIT_PAGER_PRAGMAS
1.91 +/*
1.92 +** Interpret the given string as a temp db location. Return 1 for file
1.93 +** backed temporary databases, 2 for the Red-Black tree in memory database
1.94 +** and 0 to use the compile-time default.
1.95 +*/
1.96 +static int getTempStore(const char *z){
1.97 + if( z[0]>='0' && z[0]<='2' ){
1.98 + return z[0] - '0';
1.99 + }else if( sqlite3StrICmp(z, "file")==0 ){
1.100 + return 1;
1.101 + }else if( sqlite3StrICmp(z, "memory")==0 ){
1.102 + return 2;
1.103 + }else{
1.104 + return 0;
1.105 + }
1.106 +}
1.107 +#endif /* SQLITE_PAGER_PRAGMAS */
1.108 +
1.109 +#ifndef SQLITE_OMIT_PAGER_PRAGMAS
1.110 +/*
1.111 +** Invalidate temp storage, either when the temp storage is changed
1.112 +** from default, or when 'file' and the temp_store_directory has changed
1.113 +*/
1.114 +static int invalidateTempStorage(Parse *pParse){
1.115 + sqlite3 *db = pParse->db;
1.116 + if( db->aDb[1].pBt!=0 ){
1.117 + if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){
1.118 + sqlite3ErrorMsg(pParse, "temporary storage cannot be changed "
1.119 + "from within a transaction");
1.120 + return SQLITE_ERROR;
1.121 + }
1.122 + sqlite3BtreeClose(db->aDb[1].pBt);
1.123 + db->aDb[1].pBt = 0;
1.124 + sqlite3ResetInternalSchema(db, 0);
1.125 + }
1.126 + return SQLITE_OK;
1.127 +}
1.128 +#endif /* SQLITE_PAGER_PRAGMAS */
1.129 +
1.130 +#ifndef SQLITE_OMIT_PAGER_PRAGMAS
1.131 +/*
1.132 +** If the TEMP database is open, close it and mark the database schema
1.133 +** as needing reloading. This must be done when using the SQLITE_TEMP_STORE
1.134 +** or DEFAULT_TEMP_STORE pragmas.
1.135 +*/
1.136 +static int changeTempStorage(Parse *pParse, const char *zStorageType){
1.137 + int ts = getTempStore(zStorageType);
1.138 + sqlite3 *db = pParse->db;
1.139 + if( db->temp_store==ts ) return SQLITE_OK;
1.140 + if( invalidateTempStorage( pParse ) != SQLITE_OK ){
1.141 + return SQLITE_ERROR;
1.142 + }
1.143 + db->temp_store = ts;
1.144 + return SQLITE_OK;
1.145 +}
1.146 +#endif /* SQLITE_PAGER_PRAGMAS */
1.147 +
1.148 +/*
1.149 +** Generate code to return a single integer value.
1.150 +*/
1.151 +static void returnSingleInt(Parse *pParse, const char *zLabel, int value){
1.152 + Vdbe *v = sqlite3GetVdbe(pParse);
1.153 + int mem = ++pParse->nMem;
1.154 + sqlite3VdbeAddOp2(v, OP_Integer, value, mem);
1.155 + if( pParse->explain==0 ){
1.156 + sqlite3VdbeSetNumCols(v, 1);
1.157 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P4_STATIC);
1.158 + }
1.159 + sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1);
1.160 +}
1.161 +
1.162 +#ifndef SQLITE_OMIT_FLAG_PRAGMAS
1.163 +/*
1.164 +** Check to see if zRight and zLeft refer to a pragma that queries
1.165 +** or changes one of the flags in db->flags. Return 1 if so and 0 if not.
1.166 +** Also, implement the pragma.
1.167 +*/
1.168 +static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){
1.169 + static const struct sPragmaType {
1.170 + const char *zName; /* Name of the pragma */
1.171 + int mask; /* Mask for the db->flags value */
1.172 + } aPragma[] = {
1.173 + { "full_column_names", SQLITE_FullColNames },
1.174 + { "short_column_names", SQLITE_ShortColNames },
1.175 + { "count_changes", SQLITE_CountRows },
1.176 + { "empty_result_callbacks", SQLITE_NullCallback },
1.177 + { "legacy_file_format", SQLITE_LegacyFileFmt },
1.178 + { "fullfsync", SQLITE_FullFSync },
1.179 +#ifdef SQLITE_DEBUG
1.180 + { "sql_trace", SQLITE_SqlTrace },
1.181 + { "vdbe_listing", SQLITE_VdbeListing },
1.182 + { "vdbe_trace", SQLITE_VdbeTrace },
1.183 +#endif
1.184 +#ifndef SQLITE_OMIT_CHECK
1.185 + { "ignore_check_constraints", SQLITE_IgnoreChecks },
1.186 +#endif
1.187 + /* The following is VERY experimental */
1.188 + { "writable_schema", SQLITE_WriteSchema|SQLITE_RecoveryMode },
1.189 + { "omit_readlock", SQLITE_NoReadlock },
1.190 +
1.191 + /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted
1.192 + ** flag if there are any active statements. */
1.193 + { "read_uncommitted", SQLITE_ReadUncommitted },
1.194 + };
1.195 + int i;
1.196 + const struct sPragmaType *p;
1.197 + for(i=0, p=aPragma; i<sizeof(aPragma)/sizeof(aPragma[0]); i++, p++){
1.198 + if( sqlite3StrICmp(zLeft, p->zName)==0 ){
1.199 + sqlite3 *db = pParse->db;
1.200 + Vdbe *v;
1.201 + v = sqlite3GetVdbe(pParse);
1.202 + if( v ){
1.203 + if( zRight==0 ){
1.204 + returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 );
1.205 + }else{
1.206 + if( getBoolean(zRight) ){
1.207 + db->flags |= p->mask;
1.208 + }else{
1.209 + db->flags &= ~p->mask;
1.210 + }
1.211 +
1.212 + /* Many of the flag-pragmas modify the code generated by the SQL
1.213 + ** compiler (eg. count_changes). So add an opcode to expire all
1.214 + ** compiled SQL statements after modifying a pragma value.
1.215 + */
1.216 + sqlite3VdbeAddOp2(v, OP_Expire, 0, 0);
1.217 + }
1.218 + }
1.219 +
1.220 + return 1;
1.221 + }
1.222 + }
1.223 + return 0;
1.224 +}
1.225 +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
1.226 +
1.227 +/*
1.228 +** Process a pragma statement.
1.229 +**
1.230 +** Pragmas are of this form:
1.231 +**
1.232 +** PRAGMA [database.]id [= value]
1.233 +**
1.234 +** The identifier might also be a string. The value is a string, and
1.235 +** identifier, or a number. If minusFlag is true, then the value is
1.236 +** a number that was preceded by a minus sign.
1.237 +**
1.238 +** If the left side is "database.id" then pId1 is the database name
1.239 +** and pId2 is the id. If the left side is just "id" then pId1 is the
1.240 +** id and pId2 is any empty string.
1.241 +*/
1.242 +void sqlite3Pragma(
1.243 + Parse *pParse,
1.244 + Token *pId1, /* First part of [database.]id field */
1.245 + Token *pId2, /* Second part of [database.]id field, or NULL */
1.246 + Token *pValue, /* Token for <value>, or NULL */
1.247 + int minusFlag /* True if a '-' sign preceded <value> */
1.248 +){
1.249 + char *zLeft = 0; /* Nul-terminated UTF-8 string <id> */
1.250 + char *zRight = 0; /* Nul-terminated UTF-8 string <value>, or NULL */
1.251 + const char *zDb = 0; /* The database name */
1.252 + Token *pId; /* Pointer to <id> token */
1.253 + int iDb; /* Database index for <database> */
1.254 + sqlite3 *db = pParse->db;
1.255 + Db *pDb;
1.256 + Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db);
1.257 + if( v==0 ) return;
1.258 + pParse->nMem = 2;
1.259 +
1.260 + /* Interpret the [database.] part of the pragma statement. iDb is the
1.261 + ** index of the database this pragma is being applied to in db.aDb[]. */
1.262 + iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId);
1.263 + if( iDb<0 ) return;
1.264 + pDb = &db->aDb[iDb];
1.265 +
1.266 + /* If the temp database has been explicitly named as part of the
1.267 + ** pragma, make sure it is open.
1.268 + */
1.269 + if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){
1.270 + return;
1.271 + }
1.272 +
1.273 + zLeft = sqlite3NameFromToken(db, pId);
1.274 + if( !zLeft ) return;
1.275 + if( minusFlag ){
1.276 + zRight = sqlite3MPrintf(db, "-%T", pValue);
1.277 + }else{
1.278 + zRight = sqlite3NameFromToken(db, pValue);
1.279 + }
1.280 +
1.281 + zDb = ((iDb>0)?pDb->zName:0);
1.282 + if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){
1.283 + goto pragma_out;
1.284 + }
1.285 +
1.286 +#ifndef SQLITE_OMIT_PAGER_PRAGMAS
1.287 + /*
1.288 + ** PRAGMA [database.]default_cache_size
1.289 + ** PRAGMA [database.]default_cache_size=N
1.290 + **
1.291 + ** The first form reports the current persistent setting for the
1.292 + ** page cache size. The value returned is the maximum number of
1.293 + ** pages in the page cache. The second form sets both the current
1.294 + ** page cache size value and the persistent page cache size value
1.295 + ** stored in the database file.
1.296 + **
1.297 + ** The default cache size is stored in meta-value 2 of page 1 of the
1.298 + ** database file. The cache size is actually the absolute value of
1.299 + ** this memory location. The sign of meta-value 2 determines the
1.300 + ** synchronous setting. A negative value means synchronous is off
1.301 + ** and a positive value means synchronous is on.
1.302 + */
1.303 + if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){
1.304 + static const VdbeOpList getCacheSize[] = {
1.305 + { OP_ReadCookie, 0, 1, 2}, /* 0 */
1.306 + { OP_IfPos, 1, 6, 0},
1.307 + { OP_Integer, 0, 2, 0},
1.308 + { OP_Subtract, 1, 2, 1},
1.309 + { OP_IfPos, 1, 6, 0},
1.310 + { OP_Integer, 0, 1, 0}, /* 5 */
1.311 + { OP_ResultRow, 1, 1, 0},
1.312 + };
1.313 + int addr;
1.314 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.315 + sqlite3VdbeUsesBtree(v, iDb);
1.316 + if( !zRight ){
1.317 + sqlite3VdbeSetNumCols(v, 1);
1.318 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P4_STATIC);
1.319 + pParse->nMem += 2;
1.320 + addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize);
1.321 + sqlite3VdbeChangeP1(v, addr, iDb);
1.322 + sqlite3VdbeChangeP1(v, addr+5, SQLITE_DEFAULT_CACHE_SIZE);
1.323 + }else{
1.324 + int size = atoi(zRight);
1.325 + if( size<0 ) size = -size;
1.326 + sqlite3BeginWriteOperation(pParse, 0, iDb);
1.327 + sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
1.328 + sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, 2, 2);
1.329 + addr = sqlite3VdbeAddOp2(v, OP_IfPos, 2, 0);
1.330 + sqlite3VdbeAddOp2(v, OP_Integer, -size, 1);
1.331 + sqlite3VdbeJumpHere(v, addr);
1.332 + sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 2, 1);
1.333 + pDb->pSchema->cache_size = size;
1.334 + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
1.335 + }
1.336 + }else
1.337 +
1.338 + /*
1.339 + ** PRAGMA [database.]page_size
1.340 + ** PRAGMA [database.]page_size=N
1.341 + **
1.342 + ** The first form reports the current setting for the
1.343 + ** database page size in bytes. The second form sets the
1.344 + ** database page size value. The value can only be set if
1.345 + ** the database has not yet been created.
1.346 + */
1.347 + if( sqlite3StrICmp(zLeft,"page_size")==0 ){
1.348 + Btree *pBt = pDb->pBt;
1.349 + if( !zRight ){
1.350 + int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0;
1.351 + returnSingleInt(pParse, "page_size", size);
1.352 + }else{
1.353 + /* Malloc may fail when setting the page-size, as there is an internal
1.354 + ** buffer that the pager module resizes using sqlite3_realloc().
1.355 + */
1.356 + db->nextPagesize = atoi(zRight);
1.357 + if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1) ){
1.358 + db->mallocFailed = 1;
1.359 + }
1.360 + }
1.361 + }else
1.362 +
1.363 + /*
1.364 + ** PRAGMA [database.]max_page_count
1.365 + ** PRAGMA [database.]max_page_count=N
1.366 + **
1.367 + ** The first form reports the current setting for the
1.368 + ** maximum number of pages in the database file. The
1.369 + ** second form attempts to change this setting. Both
1.370 + ** forms return the current setting.
1.371 + */
1.372 + if( sqlite3StrICmp(zLeft,"max_page_count")==0 ){
1.373 + Btree *pBt = pDb->pBt;
1.374 + int newMax = 0;
1.375 + if( zRight ){
1.376 + newMax = atoi(zRight);
1.377 + }
1.378 + if( pBt ){
1.379 + newMax = sqlite3BtreeMaxPageCount(pBt, newMax);
1.380 + }
1.381 + returnSingleInt(pParse, "max_page_count", newMax);
1.382 + }else
1.383 +
1.384 + /*
1.385 + ** PRAGMA [database.]page_count
1.386 + **
1.387 + ** Return the number of pages in the specified database.
1.388 + */
1.389 + if( sqlite3StrICmp(zLeft,"page_count")==0 ){
1.390 + Vdbe *v;
1.391 + int iReg;
1.392 + v = sqlite3GetVdbe(pParse);
1.393 + if( !v || sqlite3ReadSchema(pParse) ) goto pragma_out;
1.394 + sqlite3CodeVerifySchema(pParse, iDb);
1.395 + iReg = ++pParse->nMem;
1.396 + sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg);
1.397 + sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1);
1.398 + sqlite3VdbeSetNumCols(v, 1);
1.399 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "page_count", P4_STATIC);
1.400 + }else
1.401 +
1.402 + /*
1.403 + ** PRAGMA [database.]locking_mode
1.404 + ** PRAGMA [database.]locking_mode = (normal|exclusive)
1.405 + */
1.406 + if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){
1.407 + const char *zRet = "normal";
1.408 + int eMode = getLockingMode(zRight);
1.409 +
1.410 + if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){
1.411 + /* Simple "PRAGMA locking_mode;" statement. This is a query for
1.412 + ** the current default locking mode (which may be different to
1.413 + ** the locking-mode of the main database).
1.414 + */
1.415 + eMode = db->dfltLockMode;
1.416 + }else{
1.417 + Pager *pPager;
1.418 + if( pId2->n==0 ){
1.419 + /* This indicates that no database name was specified as part
1.420 + ** of the PRAGMA command. In this case the locking-mode must be
1.421 + ** set on all attached databases, as well as the main db file.
1.422 + **
1.423 + ** Also, the sqlite3.dfltLockMode variable is set so that
1.424 + ** any subsequently attached databases also use the specified
1.425 + ** locking mode.
1.426 + */
1.427 + int ii;
1.428 + assert(pDb==&db->aDb[0]);
1.429 + for(ii=2; ii<db->nDb; ii++){
1.430 + pPager = sqlite3BtreePager(db->aDb[ii].pBt);
1.431 + sqlite3PagerLockingMode(pPager, eMode);
1.432 + }
1.433 + db->dfltLockMode = eMode;
1.434 + }
1.435 + pPager = sqlite3BtreePager(pDb->pBt);
1.436 + eMode = sqlite3PagerLockingMode(pPager, eMode);
1.437 + }
1.438 +
1.439 + assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE);
1.440 + if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){
1.441 + zRet = "exclusive";
1.442 + }
1.443 + sqlite3VdbeSetNumCols(v, 1);
1.444 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", P4_STATIC);
1.445 + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0);
1.446 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1.447 + }else
1.448 +
1.449 + /*
1.450 + ** PRAGMA [database.]journal_mode
1.451 + ** PRAGMA [database.]journal_mode = (delete|persist|off)
1.452 + */
1.453 + if( sqlite3StrICmp(zLeft,"journal_mode")==0 ){
1.454 + int eMode;
1.455 + static const char *azModeName[] = {"delete", "persist", "off"};
1.456 +
1.457 + if( zRight==0 ){
1.458 + eMode = PAGER_JOURNALMODE_QUERY;
1.459 + }else{
1.460 + int n = strlen(zRight);
1.461 + eMode = 2;
1.462 + while( eMode>=0 && sqlite3StrNICmp(zRight, azModeName[eMode], n)!=0 ){
1.463 + eMode--;
1.464 + }
1.465 + }
1.466 + if( pId2->n==0 && eMode==PAGER_JOURNALMODE_QUERY ){
1.467 + /* Simple "PRAGMA journal_mode;" statement. This is a query for
1.468 + ** the current default journal mode (which may be different to
1.469 + ** the journal-mode of the main database).
1.470 + */
1.471 + eMode = db->dfltJournalMode;
1.472 + }else{
1.473 + Pager *pPager;
1.474 + if( pId2->n==0 ){
1.475 + /* This indicates that no database name was specified as part
1.476 + ** of the PRAGMA command. In this case the journal-mode must be
1.477 + ** set on all attached databases, as well as the main db file.
1.478 + **
1.479 + ** Also, the sqlite3.dfltJournalMode variable is set so that
1.480 + ** any subsequently attached databases also use the specified
1.481 + ** journal mode.
1.482 + */
1.483 + int ii;
1.484 + assert(pDb==&db->aDb[0]);
1.485 + for(ii=1; ii<db->nDb; ii++){
1.486 + if( db->aDb[ii].pBt ){
1.487 + pPager = sqlite3BtreePager(db->aDb[ii].pBt);
1.488 + sqlite3PagerJournalMode(pPager, eMode);
1.489 + }
1.490 + }
1.491 + db->dfltJournalMode = eMode;
1.492 + }
1.493 + pPager = sqlite3BtreePager(pDb->pBt);
1.494 + eMode = sqlite3PagerJournalMode(pPager, eMode);
1.495 + }
1.496 + assert( eMode==PAGER_JOURNALMODE_DELETE
1.497 + || eMode==PAGER_JOURNALMODE_PERSIST
1.498 + || eMode==PAGER_JOURNALMODE_OFF );
1.499 + sqlite3VdbeSetNumCols(v, 1);
1.500 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", P4_STATIC);
1.501 + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0,
1.502 + azModeName[eMode], P4_STATIC);
1.503 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1.504 + }else
1.505 +
1.506 + /*
1.507 + ** PRAGMA [database.]journal_size_limit
1.508 + ** PRAGMA [database.]journal_size_limit=N
1.509 + **
1.510 + ** Get or set the (boolean) value of the database 'auto-vacuum' parameter.
1.511 + */
1.512 + if( sqlite3StrICmp(zLeft,"journal_size_limit")==0 ){
1.513 + Pager *pPager = sqlite3BtreePager(pDb->pBt);
1.514 + i64 iLimit = -2;
1.515 + if( zRight ){
1.516 + int iLimit32 = atoi(zRight);
1.517 + if( iLimit32<-1 ){
1.518 + iLimit32 = -1;
1.519 + }
1.520 + iLimit = iLimit32;
1.521 + }
1.522 + iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit);
1.523 + returnSingleInt(pParse, "journal_size_limit", (int)iLimit);
1.524 + }else
1.525 +
1.526 +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
1.527 +
1.528 + /*
1.529 + ** PRAGMA [database.]auto_vacuum
1.530 + ** PRAGMA [database.]auto_vacuum=N
1.531 + **
1.532 + ** Get or set the (boolean) value of the database 'auto-vacuum' parameter.
1.533 + */
1.534 +#ifndef SQLITE_OMIT_AUTOVACUUM
1.535 + if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){
1.536 + Btree *pBt = pDb->pBt;
1.537 + if( sqlite3ReadSchema(pParse) ){
1.538 + goto pragma_out;
1.539 + }
1.540 + if( !zRight ){
1.541 + int auto_vacuum =
1.542 + pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM;
1.543 + returnSingleInt(pParse, "auto_vacuum", auto_vacuum);
1.544 + }else{
1.545 + int eAuto = getAutoVacuum(zRight);
1.546 + db->nextAutovac = eAuto;
1.547 + if( eAuto>=0 ){
1.548 + /* Call SetAutoVacuum() to set initialize the internal auto and
1.549 + ** incr-vacuum flags. This is required in case this connection
1.550 + ** creates the database file. It is important that it is created
1.551 + ** as an auto-vacuum capable db.
1.552 + */
1.553 + int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto);
1.554 + if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){
1.555 + /* When setting the auto_vacuum mode to either "full" or
1.556 + ** "incremental", write the value of meta[6] in the database
1.557 + ** file. Before writing to meta[6], check that meta[3] indicates
1.558 + ** that this really is an auto-vacuum capable database.
1.559 + */
1.560 + static const VdbeOpList setMeta6[] = {
1.561 + { OP_Transaction, 0, 1, 0}, /* 0 */
1.562 + { OP_ReadCookie, 0, 1, 3}, /* 1 */
1.563 + { OP_If, 1, 0, 0}, /* 2 */
1.564 + { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */
1.565 + { OP_Integer, 0, 1, 0}, /* 4 */
1.566 + { OP_SetCookie, 0, 6, 1}, /* 5 */
1.567 + };
1.568 + int iAddr;
1.569 + iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6);
1.570 + sqlite3VdbeChangeP1(v, iAddr, iDb);
1.571 + sqlite3VdbeChangeP1(v, iAddr+1, iDb);
1.572 + sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
1.573 + sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
1.574 + sqlite3VdbeChangeP1(v, iAddr+5, iDb);
1.575 + sqlite3VdbeUsesBtree(v, iDb);
1.576 + }
1.577 + }
1.578 + }
1.579 + }else
1.580 +#endif
1.581 +
1.582 + /*
1.583 + ** PRAGMA [database.]incremental_vacuum(N)
1.584 + **
1.585 + ** Do N steps of incremental vacuuming on a database.
1.586 + */
1.587 +#ifndef SQLITE_OMIT_AUTOVACUUM
1.588 + if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){
1.589 + int iLimit, addr;
1.590 + if( sqlite3ReadSchema(pParse) ){
1.591 + goto pragma_out;
1.592 + }
1.593 + if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){
1.594 + iLimit = 0x7fffffff;
1.595 + }
1.596 + sqlite3BeginWriteOperation(pParse, 0, iDb);
1.597 + sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1);
1.598 + addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb);
1.599 + sqlite3VdbeAddOp1(v, OP_ResultRow, 1);
1.600 + sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1);
1.601 + sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr);
1.602 + sqlite3VdbeJumpHere(v, addr);
1.603 + }else
1.604 +#endif
1.605 +
1.606 +#ifndef SQLITE_OMIT_PAGER_PRAGMAS
1.607 + /*
1.608 + ** PRAGMA [database.]cache_size
1.609 + ** PRAGMA [database.]cache_size=N
1.610 + **
1.611 + ** The first form reports the current local setting for the
1.612 + ** page cache size. The local setting can be different from
1.613 + ** the persistent cache size value that is stored in the database
1.614 + ** file itself. The value returned is the maximum number of
1.615 + ** pages in the page cache. The second form sets the local
1.616 + ** page cache size value. It does not change the persistent
1.617 + ** cache size stored on the disk so the cache size will revert
1.618 + ** to its default value when the database is closed and reopened.
1.619 + ** N should be a positive integer.
1.620 + */
1.621 + if( sqlite3StrICmp(zLeft,"cache_size")==0 ){
1.622 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.623 + if( !zRight ){
1.624 + returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size);
1.625 + }else{
1.626 + int size = atoi(zRight);
1.627 + if( size<0 ) size = -size;
1.628 + pDb->pSchema->cache_size = size;
1.629 + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
1.630 + }
1.631 + }else
1.632 +
1.633 + /*
1.634 + ** PRAGMA temp_store
1.635 + ** PRAGMA temp_store = "default"|"memory"|"file"
1.636 + **
1.637 + ** Return or set the local value of the temp_store flag. Changing
1.638 + ** the local value does not make changes to the disk file and the default
1.639 + ** value will be restored the next time the database is opened.
1.640 + **
1.641 + ** Note that it is possible for the library compile-time options to
1.642 + ** override this setting
1.643 + */
1.644 + if( sqlite3StrICmp(zLeft, "temp_store")==0 ){
1.645 + if( !zRight ){
1.646 + returnSingleInt(pParse, "temp_store", db->temp_store);
1.647 + }else{
1.648 + changeTempStorage(pParse, zRight);
1.649 + }
1.650 + }else
1.651 +
1.652 + /*
1.653 + ** PRAGMA temp_store_directory
1.654 + ** PRAGMA temp_store_directory = ""|"directory_name"
1.655 + **
1.656 + ** Return or set the local value of the temp_store_directory flag. Changing
1.657 + ** the value sets a specific directory to be used for temporary files.
1.658 + ** Setting to a null string reverts to the default temporary directory search.
1.659 + ** If temporary directory is changed, then invalidateTempStorage.
1.660 + **
1.661 + */
1.662 + if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){
1.663 + if( !zRight ){
1.664 + if( sqlite3_temp_directory ){
1.665 + sqlite3VdbeSetNumCols(v, 1);
1.666 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME,
1.667 + "temp_store_directory", P4_STATIC);
1.668 + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0);
1.669 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1.670 + }
1.671 + }else{
1.672 + if( zRight[0] ){
1.673 + int res;
1.674 + sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res);
1.675 + if( res==0 ){
1.676 + sqlite3ErrorMsg(pParse, "not a writable directory");
1.677 + goto pragma_out;
1.678 + }
1.679 + }
1.680 + if( SQLITE_TEMP_STORE==0
1.681 + || (SQLITE_TEMP_STORE==1 && db->temp_store<=1)
1.682 + || (SQLITE_TEMP_STORE==2 && db->temp_store==1)
1.683 + ){
1.684 + invalidateTempStorage(pParse);
1.685 + }
1.686 + sqlite3_free(sqlite3_temp_directory);
1.687 + if( zRight[0] ){
1.688 + sqlite3_temp_directory = sqlite3DbStrDup(0, zRight);
1.689 + }else{
1.690 + sqlite3_temp_directory = 0;
1.691 + }
1.692 + }
1.693 + }else
1.694 +
1.695 + /*
1.696 + ** PRAGMA [database.]synchronous
1.697 + ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL
1.698 + **
1.699 + ** Return or set the local value of the synchronous flag. Changing
1.700 + ** the local value does not make changes to the disk file and the
1.701 + ** default value will be restored the next time the database is
1.702 + ** opened.
1.703 + */
1.704 + if( sqlite3StrICmp(zLeft,"synchronous")==0 ){
1.705 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.706 + if( !zRight ){
1.707 + returnSingleInt(pParse, "synchronous", pDb->safety_level-1);
1.708 + }else{
1.709 + if( !db->autoCommit ){
1.710 + sqlite3ErrorMsg(pParse,
1.711 + "Safety level may not be changed inside a transaction");
1.712 + }else{
1.713 + pDb->safety_level = getSafetyLevel(zRight)+1;
1.714 + }
1.715 + }
1.716 + }else
1.717 +#endif /* SQLITE_OMIT_PAGER_PRAGMAS */
1.718 +
1.719 +#ifndef SQLITE_OMIT_FLAG_PRAGMAS
1.720 + if( flagPragma(pParse, zLeft, zRight) ){
1.721 + /* The flagPragma() subroutine also generates any necessary code
1.722 + ** there is nothing more to do here */
1.723 + }else
1.724 +#endif /* SQLITE_OMIT_FLAG_PRAGMAS */
1.725 +
1.726 +#ifndef SQLITE_OMIT_SCHEMA_PRAGMAS
1.727 + /*
1.728 + ** PRAGMA table_info(<table>)
1.729 + **
1.730 + ** Return a single row for each column of the named table. The columns of
1.731 + ** the returned data set are:
1.732 + **
1.733 + ** cid: Column id (numbered from left to right, starting at 0)
1.734 + ** name: Column name
1.735 + ** type: Column declaration type.
1.736 + ** notnull: True if 'NOT NULL' is part of column declaration
1.737 + ** dflt_value: The default value for the column, if any.
1.738 + */
1.739 + if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){
1.740 + Table *pTab;
1.741 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.742 + pTab = sqlite3FindTable(db, zRight, zDb);
1.743 + if( pTab ){
1.744 + int i;
1.745 + int nHidden = 0;
1.746 + Column *pCol;
1.747 + sqlite3VdbeSetNumCols(v, 6);
1.748 + pParse->nMem = 6;
1.749 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P4_STATIC);
1.750 + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
1.751 + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P4_STATIC);
1.752 + sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P4_STATIC);
1.753 + sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P4_STATIC);
1.754 + sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P4_STATIC);
1.755 + sqlite3ViewGetColumnNames(pParse, pTab);
1.756 + for(i=0, pCol=pTab->aCol; i<pTab->nCol; i++, pCol++){
1.757 + const Token *pDflt;
1.758 + if( IsHiddenColumn(pCol) ){
1.759 + nHidden++;
1.760 + continue;
1.761 + }
1.762 + sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1);
1.763 + sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0);
1.764 + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1.765 + pCol->zType ? pCol->zType : "", 0);
1.766 + sqlite3VdbeAddOp2(v, OP_Integer, pCol->notNull, 4);
1.767 + if( pCol->pDflt && (pDflt = &pCol->pDflt->span)->z ){
1.768 + sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pDflt->z, pDflt->n);
1.769 + }else{
1.770 + sqlite3VdbeAddOp2(v, OP_Null, 0, 5);
1.771 + }
1.772 + sqlite3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6);
1.773 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6);
1.774 + }
1.775 + }
1.776 + }else
1.777 +
1.778 + if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){
1.779 + Index *pIdx;
1.780 + Table *pTab;
1.781 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.782 + pIdx = sqlite3FindIndex(db, zRight, zDb);
1.783 + if( pIdx ){
1.784 + int i;
1.785 + pTab = pIdx->pTable;
1.786 + sqlite3VdbeSetNumCols(v, 3);
1.787 + pParse->nMem = 3;
1.788 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P4_STATIC);
1.789 + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P4_STATIC);
1.790 + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P4_STATIC);
1.791 + for(i=0; i<pIdx->nColumn; i++){
1.792 + int cnum = pIdx->aiColumn[i];
1.793 + sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1.794 + sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2);
1.795 + assert( pTab->nCol>cnum );
1.796 + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0);
1.797 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1.798 + }
1.799 + }
1.800 + }else
1.801 +
1.802 + if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){
1.803 + Index *pIdx;
1.804 + Table *pTab;
1.805 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.806 + pTab = sqlite3FindTable(db, zRight, zDb);
1.807 + if( pTab ){
1.808 + v = sqlite3GetVdbe(pParse);
1.809 + pIdx = pTab->pIndex;
1.810 + if( pIdx ){
1.811 + int i = 0;
1.812 + sqlite3VdbeSetNumCols(v, 3);
1.813 + pParse->nMem = 3;
1.814 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
1.815 + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
1.816 + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P4_STATIC);
1.817 + while(pIdx){
1.818 + sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1.819 + sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0);
1.820 + sqlite3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3);
1.821 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1.822 + ++i;
1.823 + pIdx = pIdx->pNext;
1.824 + }
1.825 + }
1.826 + }
1.827 + }else
1.828 +
1.829 + if( sqlite3StrICmp(zLeft, "database_list")==0 ){
1.830 + int i;
1.831 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.832 + sqlite3VdbeSetNumCols(v, 3);
1.833 + pParse->nMem = 3;
1.834 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
1.835 + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
1.836 + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P4_STATIC);
1.837 + for(i=0; i<db->nDb; i++){
1.838 + if( db->aDb[i].pBt==0 ) continue;
1.839 + assert( db->aDb[i].zName!=0 );
1.840 + sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1.841 + sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0);
1.842 + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1.843 + sqlite3BtreeGetFilename(db->aDb[i].pBt), 0);
1.844 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3);
1.845 + }
1.846 + }else
1.847 +
1.848 + if( sqlite3StrICmp(zLeft, "collation_list")==0 ){
1.849 + int i = 0;
1.850 + HashElem *p;
1.851 + sqlite3VdbeSetNumCols(v, 2);
1.852 + pParse->nMem = 2;
1.853 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC);
1.854 + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC);
1.855 + for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){
1.856 + CollSeq *pColl = (CollSeq *)sqliteHashData(p);
1.857 + sqlite3VdbeAddOp2(v, OP_Integer, i++, 1);
1.858 + sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0);
1.859 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
1.860 + }
1.861 + }else
1.862 +#endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */
1.863 +
1.864 +#ifndef SQLITE_OMIT_FOREIGN_KEY
1.865 + if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){
1.866 + FKey *pFK;
1.867 + Table *pTab;
1.868 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.869 + pTab = sqlite3FindTable(db, zRight, zDb);
1.870 + if( pTab ){
1.871 + v = sqlite3GetVdbe(pParse);
1.872 + pFK = pTab->pFKey;
1.873 + if( pFK ){
1.874 + int i = 0;
1.875 + sqlite3VdbeSetNumCols(v, 5);
1.876 + pParse->nMem = 5;
1.877 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P4_STATIC);
1.878 + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P4_STATIC);
1.879 + sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P4_STATIC);
1.880 + sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P4_STATIC);
1.881 + sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P4_STATIC);
1.882 + while(pFK){
1.883 + int j;
1.884 + for(j=0; j<pFK->nCol; j++){
1.885 + char *zCol = pFK->aCol[j].zCol;
1.886 + sqlite3VdbeAddOp2(v, OP_Integer, i, 1);
1.887 + sqlite3VdbeAddOp2(v, OP_Integer, j, 2);
1.888 + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0);
1.889 + sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0,
1.890 + pTab->aCol[pFK->aCol[j].iFrom].zName, 0);
1.891 + sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0);
1.892 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5);
1.893 + }
1.894 + ++i;
1.895 + pFK = pFK->pNextFrom;
1.896 + }
1.897 + }
1.898 + }
1.899 + }else
1.900 +#endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */
1.901 +
1.902 +#ifndef NDEBUG
1.903 + if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){
1.904 + if( zRight ){
1.905 + if( getBoolean(zRight) ){
1.906 + sqlite3ParserTrace(stderr, "parser: ");
1.907 + }else{
1.908 + sqlite3ParserTrace(0, 0);
1.909 + }
1.910 + }
1.911 + }else
1.912 +#endif
1.913 +
1.914 + /* Reinstall the LIKE and GLOB functions. The variant of LIKE
1.915 + ** used will be case sensitive or not depending on the RHS.
1.916 + */
1.917 + if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){
1.918 + if( zRight ){
1.919 + sqlite3RegisterLikeFunctions(db, getBoolean(zRight));
1.920 + }
1.921 + }else
1.922 +
1.923 +#ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX
1.924 +# define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100
1.925 +#endif
1.926 +
1.927 +#ifndef SQLITE_OMIT_INTEGRITY_CHECK
1.928 + /* Pragma "quick_check" is an experimental reduced version of
1.929 + ** integrity_check designed to detect most database corruption
1.930 + ** without most of the overhead of a full integrity-check.
1.931 + */
1.932 + if( sqlite3StrICmp(zLeft, "integrity_check")==0
1.933 + || sqlite3StrICmp(zLeft, "quick_check")==0
1.934 + ){
1.935 + int i, j, addr, mxErr;
1.936 +
1.937 + /* Code that appears at the end of the integrity check. If no error
1.938 + ** messages have been generated, output OK. Otherwise output the
1.939 + ** error message
1.940 + */
1.941 + static const VdbeOpList endCode[] = {
1.942 + { OP_AddImm, 1, 0, 0}, /* 0 */
1.943 + { OP_IfNeg, 1, 0, 0}, /* 1 */
1.944 + { OP_String8, 0, 3, 0}, /* 2 */
1.945 + { OP_ResultRow, 3, 1, 0},
1.946 + };
1.947 +
1.948 + int isQuick = (zLeft[0]=='q');
1.949 +
1.950 + /* Initialize the VDBE program */
1.951 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.952 + pParse->nMem = 6;
1.953 + sqlite3VdbeSetNumCols(v, 1);
1.954 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P4_STATIC);
1.955 +
1.956 + /* Set the maximum error count */
1.957 + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1.958 + if( zRight ){
1.959 + mxErr = atoi(zRight);
1.960 + if( mxErr<=0 ){
1.961 + mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX;
1.962 + }
1.963 + }
1.964 + sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */
1.965 +
1.966 + /* Do an integrity check on each database file */
1.967 + for(i=0; i<db->nDb; i++){
1.968 + HashElem *x;
1.969 + Hash *pTbls;
1.970 + int cnt = 0;
1.971 +
1.972 + if( OMIT_TEMPDB && i==1 ) continue;
1.973 +
1.974 + sqlite3CodeVerifySchema(pParse, i);
1.975 + addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */
1.976 + sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1.977 + sqlite3VdbeJumpHere(v, addr);
1.978 +
1.979 + /* Do an integrity check of the B-Tree
1.980 + **
1.981 + ** Begin by filling registers 2, 3, ... with the root pages numbers
1.982 + ** for all tables and indices in the database.
1.983 + */
1.984 + pTbls = &db->aDb[i].pSchema->tblHash;
1.985 + for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){
1.986 + Table *pTab = sqliteHashData(x);
1.987 + Index *pIdx;
1.988 + sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt);
1.989 + cnt++;
1.990 + for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){
1.991 + sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt);
1.992 + cnt++;
1.993 + }
1.994 + }
1.995 + if( cnt==0 ) continue;
1.996 +
1.997 + /* Make sure sufficient number of registers have been allocated */
1.998 + if( pParse->nMem < cnt+4 ){
1.999 + pParse->nMem = cnt+4;
1.1000 + }
1.1001 +
1.1002 + /* Do the b-tree integrity checks */
1.1003 + sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1);
1.1004 + sqlite3VdbeChangeP5(v, i);
1.1005 + addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2);
1.1006 + sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0,
1.1007 + sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName),
1.1008 + P4_DYNAMIC);
1.1009 + sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1);
1.1010 + sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2);
1.1011 + sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1);
1.1012 + sqlite3VdbeJumpHere(v, addr);
1.1013 +
1.1014 + /* Make sure all the indices are constructed correctly.
1.1015 + */
1.1016 + for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){
1.1017 + Table *pTab = sqliteHashData(x);
1.1018 + Index *pIdx;
1.1019 + int loopTop;
1.1020 +
1.1021 + if( pTab->pIndex==0 ) continue;
1.1022 + addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */
1.1023 + sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1.1024 + sqlite3VdbeJumpHere(v, addr);
1.1025 + sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead);
1.1026 + sqlite3VdbeAddOp2(v, OP_Integer, 0, 2); /* reg(2) will count entries */
1.1027 + loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0);
1.1028 + sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1); /* increment entry count */
1.1029 + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1.1030 + int jmp2;
1.1031 + static const VdbeOpList idxErr[] = {
1.1032 + { OP_AddImm, 1, -1, 0},
1.1033 + { OP_String8, 0, 3, 0}, /* 1 */
1.1034 + { OP_Rowid, 1, 4, 0},
1.1035 + { OP_String8, 0, 5, 0}, /* 3 */
1.1036 + { OP_String8, 0, 6, 0}, /* 4 */
1.1037 + { OP_Concat, 4, 3, 3},
1.1038 + { OP_Concat, 5, 3, 3},
1.1039 + { OP_Concat, 6, 3, 3},
1.1040 + { OP_ResultRow, 3, 1, 0},
1.1041 + { OP_IfPos, 1, 0, 0}, /* 9 */
1.1042 + { OP_Halt, 0, 0, 0},
1.1043 + };
1.1044 + sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 1);
1.1045 + jmp2 = sqlite3VdbeAddOp3(v, OP_Found, j+2, 0, 3);
1.1046 + addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr);
1.1047 + sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC);
1.1048 + sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC);
1.1049 + sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_STATIC);
1.1050 + sqlite3VdbeJumpHere(v, addr+9);
1.1051 + sqlite3VdbeJumpHere(v, jmp2);
1.1052 + }
1.1053 + sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1);
1.1054 + sqlite3VdbeJumpHere(v, loopTop);
1.1055 + for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){
1.1056 + static const VdbeOpList cntIdx[] = {
1.1057 + { OP_Integer, 0, 3, 0},
1.1058 + { OP_Rewind, 0, 0, 0}, /* 1 */
1.1059 + { OP_AddImm, 3, 1, 0},
1.1060 + { OP_Next, 0, 0, 0}, /* 3 */
1.1061 + { OP_Eq, 2, 0, 3}, /* 4 */
1.1062 + { OP_AddImm, 1, -1, 0},
1.1063 + { OP_String8, 0, 2, 0}, /* 6 */
1.1064 + { OP_String8, 0, 3, 0}, /* 7 */
1.1065 + { OP_Concat, 3, 2, 2},
1.1066 + { OP_ResultRow, 2, 1, 0},
1.1067 + };
1.1068 + if( pIdx->tnum==0 ) continue;
1.1069 + addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1);
1.1070 + sqlite3VdbeAddOp2(v, OP_Halt, 0, 0);
1.1071 + sqlite3VdbeJumpHere(v, addr);
1.1072 + addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx);
1.1073 + sqlite3VdbeChangeP1(v, addr+1, j+2);
1.1074 + sqlite3VdbeChangeP2(v, addr+1, addr+4);
1.1075 + sqlite3VdbeChangeP1(v, addr+3, j+2);
1.1076 + sqlite3VdbeChangeP2(v, addr+3, addr+2);
1.1077 + sqlite3VdbeJumpHere(v, addr+4);
1.1078 + sqlite3VdbeChangeP4(v, addr+6,
1.1079 + "wrong # of entries in index ", P4_STATIC);
1.1080 + sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_STATIC);
1.1081 + }
1.1082 + }
1.1083 + }
1.1084 + addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode);
1.1085 + sqlite3VdbeChangeP2(v, addr, -mxErr);
1.1086 + sqlite3VdbeJumpHere(v, addr+1);
1.1087 + sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
1.1088 + }else
1.1089 +#endif /* SQLITE_OMIT_INTEGRITY_CHECK */
1.1090 +
1.1091 +#ifndef SQLITE_OMIT_UTF16
1.1092 + /*
1.1093 + ** PRAGMA encoding
1.1094 + ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be"
1.1095 + **
1.1096 + ** In its first form, this pragma returns the encoding of the main
1.1097 + ** database. If the database is not initialized, it is initialized now.
1.1098 + **
1.1099 + ** The second form of this pragma is a no-op if the main database file
1.1100 + ** has not already been initialized. In this case it sets the default
1.1101 + ** encoding that will be used for the main database file if a new file
1.1102 + ** is created. If an existing main database file is opened, then the
1.1103 + ** default text encoding for the existing database is used.
1.1104 + **
1.1105 + ** In all cases new databases created using the ATTACH command are
1.1106 + ** created to use the same default text encoding as the main database. If
1.1107 + ** the main database has not been initialized and/or created when ATTACH
1.1108 + ** is executed, this is done before the ATTACH operation.
1.1109 + **
1.1110 + ** In the second form this pragma sets the text encoding to be used in
1.1111 + ** new database files created using this database handle. It is only
1.1112 + ** useful if invoked immediately after the main database i
1.1113 + */
1.1114 + if( sqlite3StrICmp(zLeft, "encoding")==0 ){
1.1115 + static const struct EncName {
1.1116 + char *zName;
1.1117 + u8 enc;
1.1118 + } encnames[] = {
1.1119 + { "UTF-8", SQLITE_UTF8 },
1.1120 + { "UTF8", SQLITE_UTF8 },
1.1121 + { "UTF-16le", SQLITE_UTF16LE },
1.1122 + { "UTF16le", SQLITE_UTF16LE },
1.1123 + { "UTF-16be", SQLITE_UTF16BE },
1.1124 + { "UTF16be", SQLITE_UTF16BE },
1.1125 + { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */
1.1126 + { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */
1.1127 + { 0, 0 }
1.1128 + };
1.1129 + const struct EncName *pEnc;
1.1130 + if( !zRight ){ /* "PRAGMA encoding" */
1.1131 + if( sqlite3ReadSchema(pParse) ) goto pragma_out;
1.1132 + sqlite3VdbeSetNumCols(v, 1);
1.1133 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P4_STATIC);
1.1134 + sqlite3VdbeAddOp2(v, OP_String8, 0, 1);
1.1135 + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
1.1136 + if( pEnc->enc==ENC(pParse->db) ){
1.1137 + sqlite3VdbeChangeP4(v, -1, pEnc->zName, P4_STATIC);
1.1138 + break;
1.1139 + }
1.1140 + }
1.1141 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1);
1.1142 + }else{ /* "PRAGMA encoding = XXX" */
1.1143 + /* Only change the value of sqlite.enc if the database handle is not
1.1144 + ** initialized. If the main database exists, the new sqlite.enc value
1.1145 + ** will be overwritten when the schema is next loaded. If it does not
1.1146 + ** already exists, it will be created to use the new encoding value.
1.1147 + */
1.1148 + if(
1.1149 + !(DbHasProperty(db, 0, DB_SchemaLoaded)) ||
1.1150 + DbHasProperty(db, 0, DB_Empty)
1.1151 + ){
1.1152 + for(pEnc=&encnames[0]; pEnc->zName; pEnc++){
1.1153 + if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){
1.1154 + ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE;
1.1155 + break;
1.1156 + }
1.1157 + }
1.1158 + if( !pEnc->zName ){
1.1159 + sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight);
1.1160 + }
1.1161 + }
1.1162 + }
1.1163 + }else
1.1164 +#endif /* SQLITE_OMIT_UTF16 */
1.1165 +
1.1166 +#ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS
1.1167 + /*
1.1168 + ** PRAGMA [database.]schema_version
1.1169 + ** PRAGMA [database.]schema_version = <integer>
1.1170 + **
1.1171 + ** PRAGMA [database.]user_version
1.1172 + ** PRAGMA [database.]user_version = <integer>
1.1173 + **
1.1174 + ** The pragma's schema_version and user_version are used to set or get
1.1175 + ** the value of the schema-version and user-version, respectively. Both
1.1176 + ** the schema-version and the user-version are 32-bit signed integers
1.1177 + ** stored in the database header.
1.1178 + **
1.1179 + ** The schema-cookie is usually only manipulated internally by SQLite. It
1.1180 + ** is incremented by SQLite whenever the database schema is modified (by
1.1181 + ** creating or dropping a table or index). The schema version is used by
1.1182 + ** SQLite each time a query is executed to ensure that the internal cache
1.1183 + ** of the schema used when compiling the SQL query matches the schema of
1.1184 + ** the database against which the compiled query is actually executed.
1.1185 + ** Subverting this mechanism by using "PRAGMA schema_version" to modify
1.1186 + ** the schema-version is potentially dangerous and may lead to program
1.1187 + ** crashes or database corruption. Use with caution!
1.1188 + **
1.1189 + ** The user-version is not used internally by SQLite. It may be used by
1.1190 + ** applications for any purpose.
1.1191 + */
1.1192 + if( sqlite3StrICmp(zLeft, "schema_version")==0
1.1193 + || sqlite3StrICmp(zLeft, "user_version")==0
1.1194 + || sqlite3StrICmp(zLeft, "freelist_count")==0
1.1195 + ){
1.1196 +
1.1197 + int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */
1.1198 + sqlite3VdbeUsesBtree(v, iDb);
1.1199 + switch( zLeft[0] ){
1.1200 + case 's': case 'S':
1.1201 + iCookie = 0;
1.1202 + break;
1.1203 + case 'f': case 'F':
1.1204 + iCookie = 1;
1.1205 + iDb = (-1*(iDb+1));
1.1206 + assert(iDb<=0);
1.1207 + break;
1.1208 + default:
1.1209 + iCookie = 5;
1.1210 + break;
1.1211 + }
1.1212 +
1.1213 + if( zRight && iDb>=0 ){
1.1214 + /* Write the specified cookie value */
1.1215 + static const VdbeOpList setCookie[] = {
1.1216 + { OP_Transaction, 0, 1, 0}, /* 0 */
1.1217 + { OP_Integer, 0, 1, 0}, /* 1 */
1.1218 + { OP_SetCookie, 0, 0, 1}, /* 2 */
1.1219 + };
1.1220 + int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie);
1.1221 + sqlite3VdbeChangeP1(v, addr, iDb);
1.1222 + sqlite3VdbeChangeP1(v, addr+1, atoi(zRight));
1.1223 + sqlite3VdbeChangeP1(v, addr+2, iDb);
1.1224 + sqlite3VdbeChangeP2(v, addr+2, iCookie);
1.1225 + }else{
1.1226 + /* Read the specified cookie value */
1.1227 + static const VdbeOpList readCookie[] = {
1.1228 + { OP_ReadCookie, 0, 1, 0}, /* 0 */
1.1229 + { OP_ResultRow, 1, 1, 0}
1.1230 + };
1.1231 + int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie);
1.1232 + sqlite3VdbeChangeP1(v, addr, iDb);
1.1233 + sqlite3VdbeChangeP3(v, addr, iCookie);
1.1234 + sqlite3VdbeSetNumCols(v, 1);
1.1235 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, P4_TRANSIENT);
1.1236 + }
1.1237 + }else
1.1238 +#endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */
1.1239 +
1.1240 +#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
1.1241 + /*
1.1242 + ** Report the current state of file logs for all databases
1.1243 + */
1.1244 + if( sqlite3StrICmp(zLeft, "lock_status")==0 ){
1.1245 + static const char *const azLockName[] = {
1.1246 + "unlocked", "shared", "reserved", "pending", "exclusive"
1.1247 + };
1.1248 + int i;
1.1249 + Vdbe *v = sqlite3GetVdbe(pParse);
1.1250 + sqlite3VdbeSetNumCols(v, 2);
1.1251 + pParse->nMem = 2;
1.1252 + sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P4_STATIC);
1.1253 + sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P4_STATIC);
1.1254 + for(i=0; i<db->nDb; i++){
1.1255 + Btree *pBt;
1.1256 + Pager *pPager;
1.1257 + const char *zState = "unknown";
1.1258 + int j;
1.1259 + if( db->aDb[i].zName==0 ) continue;
1.1260 + sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC);
1.1261 + pBt = db->aDb[i].pBt;
1.1262 + if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){
1.1263 + zState = "closed";
1.1264 + }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0,
1.1265 + SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){
1.1266 + zState = azLockName[j];
1.1267 + }
1.1268 + sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC);
1.1269 + sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2);
1.1270 + }
1.1271 + }else
1.1272 +#endif
1.1273 +
1.1274 +#ifdef SQLITE_SSE
1.1275 + /*
1.1276 + ** Check to see if the sqlite_statements table exists. Create it
1.1277 + ** if it does not.
1.1278 + */
1.1279 + if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){
1.1280 + extern int sqlite3CreateStatementsTable(Parse*);
1.1281 + sqlite3CreateStatementsTable(pParse);
1.1282 + }else
1.1283 +#endif
1.1284 +
1.1285 +#if SQLITE_HAS_CODEC
1.1286 + if( sqlite3StrICmp(zLeft, "key")==0 ){
1.1287 + sqlite3_key(db, zRight, strlen(zRight));
1.1288 + }else
1.1289 +#endif
1.1290 +#if SQLITE_HAS_CODEC || defined(SQLITE_ENABLE_CEROD)
1.1291 + if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){
1.1292 +#if SQLITE_HAS_CODEC
1.1293 + if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){
1.1294 + extern void sqlite3_activate_see(const char*);
1.1295 + sqlite3_activate_see(&zRight[4]);
1.1296 + }
1.1297 +#endif
1.1298 +#ifdef SQLITE_ENABLE_CEROD
1.1299 + if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){
1.1300 + extern void sqlite3_activate_cerod(const char*);
1.1301 + sqlite3_activate_cerod(&zRight[6]);
1.1302 + }
1.1303 +#endif
1.1304 + }
1.1305 +#endif
1.1306 +
1.1307 + {}
1.1308 +
1.1309 + if( v ){
1.1310 + /* Code an OP_Expire at the end of each PRAGMA program to cause
1.1311 + ** the VDBE implementing the pragma to expire. Most (all?) pragmas
1.1312 + ** are only valid for a single execution.
1.1313 + */
1.1314 + sqlite3VdbeAddOp2(v, OP_Expire, 1, 0);
1.1315 +
1.1316 + /*
1.1317 + ** Reset the safety level, in case the fullfsync flag or synchronous
1.1318 + ** setting changed.
1.1319 + */
1.1320 +#ifndef SQLITE_OMIT_PAGER_PRAGMAS
1.1321 + if( db->autoCommit ){
1.1322 + sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level,
1.1323 + (db->flags&SQLITE_FullFSync)!=0);
1.1324 + }
1.1325 +#endif
1.1326 + }
1.1327 +pragma_out:
1.1328 + sqlite3DbFree(db, zLeft);
1.1329 + sqlite3DbFree(db, zRight);
1.1330 +}
1.1331 +
1.1332 +#endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */