sl@0: /* sl@0: ** 2003 April 6 sl@0: ** sl@0: ** The author disclaims copyright to this source code. In place of sl@0: ** a legal notice, here is a blessing: sl@0: ** sl@0: ** May you do good and not evil. sl@0: ** May you find forgiveness for yourself and forgive others. sl@0: ** May you share freely, never taking more than you give. sl@0: ** sl@0: ************************************************************************* sl@0: ** This file contains code used to implement the PRAGMA command. sl@0: ** sl@0: ** $Id: pragma.c,v 1.183 2008/07/28 19:34:53 drh Exp $ sl@0: */ sl@0: #include "sqliteInt.h" sl@0: #include sl@0: sl@0: /* Ignore this whole file if pragmas are disabled sl@0: */ sl@0: #if !defined(SQLITE_OMIT_PRAGMA) && !defined(SQLITE_OMIT_PARSER) sl@0: sl@0: /* sl@0: ** Interpret the given string as a safety level. Return 0 for OFF, sl@0: ** 1 for ON or NORMAL and 2 for FULL. Return 1 for an empty or sl@0: ** unrecognized string argument. sl@0: ** sl@0: ** Note that the values returned are one less that the values that sl@0: ** should be passed into sqlite3BtreeSetSafetyLevel(). The is done sl@0: ** to support legacy SQL code. The safety level used to be boolean sl@0: ** and older scripts may have used numbers 0 for OFF and 1 for ON. sl@0: */ sl@0: static int getSafetyLevel(const char *z){ sl@0: /* 123456789 123456789 */ sl@0: static const char zText[] = "onoffalseyestruefull"; sl@0: static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16}; sl@0: static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4}; sl@0: static const u8 iValue[] = {1, 0, 0, 0, 1, 1, 2}; sl@0: int i, n; sl@0: if( isdigit(*z) ){ sl@0: return atoi(z); sl@0: } sl@0: n = strlen(z); sl@0: for(i=0; i=0&&i<=2)?i:0); sl@0: } sl@0: #endif /* ifndef SQLITE_OMIT_AUTOVACUUM */ sl@0: sl@0: #ifndef SQLITE_OMIT_PAGER_PRAGMAS sl@0: /* sl@0: ** Interpret the given string as a temp db location. Return 1 for file sl@0: ** backed temporary databases, 2 for the Red-Black tree in memory database sl@0: ** and 0 to use the compile-time default. sl@0: */ sl@0: static int getTempStore(const char *z){ sl@0: if( z[0]>='0' && z[0]<='2' ){ sl@0: return z[0] - '0'; sl@0: }else if( sqlite3StrICmp(z, "file")==0 ){ sl@0: return 1; sl@0: }else if( sqlite3StrICmp(z, "memory")==0 ){ sl@0: return 2; sl@0: }else{ sl@0: return 0; sl@0: } sl@0: } sl@0: #endif /* SQLITE_PAGER_PRAGMAS */ sl@0: sl@0: #ifndef SQLITE_OMIT_PAGER_PRAGMAS sl@0: /* sl@0: ** Invalidate temp storage, either when the temp storage is changed sl@0: ** from default, or when 'file' and the temp_store_directory has changed sl@0: */ sl@0: static int invalidateTempStorage(Parse *pParse){ sl@0: sqlite3 *db = pParse->db; sl@0: if( db->aDb[1].pBt!=0 ){ sl@0: if( !db->autoCommit || sqlite3BtreeIsInReadTrans(db->aDb[1].pBt) ){ sl@0: sqlite3ErrorMsg(pParse, "temporary storage cannot be changed " sl@0: "from within a transaction"); sl@0: return SQLITE_ERROR; sl@0: } sl@0: sqlite3BtreeClose(db->aDb[1].pBt); sl@0: db->aDb[1].pBt = 0; sl@0: sqlite3ResetInternalSchema(db, 0); sl@0: } sl@0: return SQLITE_OK; sl@0: } sl@0: #endif /* SQLITE_PAGER_PRAGMAS */ sl@0: sl@0: #ifndef SQLITE_OMIT_PAGER_PRAGMAS sl@0: /* sl@0: ** If the TEMP database is open, close it and mark the database schema sl@0: ** as needing reloading. This must be done when using the SQLITE_TEMP_STORE sl@0: ** or DEFAULT_TEMP_STORE pragmas. sl@0: */ sl@0: static int changeTempStorage(Parse *pParse, const char *zStorageType){ sl@0: int ts = getTempStore(zStorageType); sl@0: sqlite3 *db = pParse->db; sl@0: if( db->temp_store==ts ) return SQLITE_OK; sl@0: if( invalidateTempStorage( pParse ) != SQLITE_OK ){ sl@0: return SQLITE_ERROR; sl@0: } sl@0: db->temp_store = ts; sl@0: return SQLITE_OK; sl@0: } sl@0: #endif /* SQLITE_PAGER_PRAGMAS */ sl@0: sl@0: /* sl@0: ** Generate code to return a single integer value. sl@0: */ sl@0: static void returnSingleInt(Parse *pParse, const char *zLabel, int value){ sl@0: Vdbe *v = sqlite3GetVdbe(pParse); sl@0: int mem = ++pParse->nMem; sl@0: sqlite3VdbeAddOp2(v, OP_Integer, value, mem); sl@0: if( pParse->explain==0 ){ sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLabel, P4_STATIC); sl@0: } sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, mem, 1); sl@0: } sl@0: sl@0: #ifndef SQLITE_OMIT_FLAG_PRAGMAS sl@0: /* sl@0: ** Check to see if zRight and zLeft refer to a pragma that queries sl@0: ** or changes one of the flags in db->flags. Return 1 if so and 0 if not. sl@0: ** Also, implement the pragma. sl@0: */ sl@0: static int flagPragma(Parse *pParse, const char *zLeft, const char *zRight){ sl@0: static const struct sPragmaType { sl@0: const char *zName; /* Name of the pragma */ sl@0: int mask; /* Mask for the db->flags value */ sl@0: } aPragma[] = { sl@0: { "full_column_names", SQLITE_FullColNames }, sl@0: { "short_column_names", SQLITE_ShortColNames }, sl@0: { "count_changes", SQLITE_CountRows }, sl@0: { "empty_result_callbacks", SQLITE_NullCallback }, sl@0: { "legacy_file_format", SQLITE_LegacyFileFmt }, sl@0: { "fullfsync", SQLITE_FullFSync }, sl@0: #ifdef SQLITE_DEBUG sl@0: { "sql_trace", SQLITE_SqlTrace }, sl@0: { "vdbe_listing", SQLITE_VdbeListing }, sl@0: { "vdbe_trace", SQLITE_VdbeTrace }, sl@0: #endif sl@0: #ifndef SQLITE_OMIT_CHECK sl@0: { "ignore_check_constraints", SQLITE_IgnoreChecks }, sl@0: #endif sl@0: /* The following is VERY experimental */ sl@0: { "writable_schema", SQLITE_WriteSchema|SQLITE_RecoveryMode }, sl@0: { "omit_readlock", SQLITE_NoReadlock }, sl@0: sl@0: /* TODO: Maybe it shouldn't be possible to change the ReadUncommitted sl@0: ** flag if there are any active statements. */ sl@0: { "read_uncommitted", SQLITE_ReadUncommitted }, sl@0: }; sl@0: int i; sl@0: const struct sPragmaType *p; sl@0: for(i=0, p=aPragma; izName)==0 ){ sl@0: sqlite3 *db = pParse->db; sl@0: Vdbe *v; sl@0: v = sqlite3GetVdbe(pParse); sl@0: if( v ){ sl@0: if( zRight==0 ){ sl@0: returnSingleInt(pParse, p->zName, (db->flags & p->mask)!=0 ); sl@0: }else{ sl@0: if( getBoolean(zRight) ){ sl@0: db->flags |= p->mask; sl@0: }else{ sl@0: db->flags &= ~p->mask; sl@0: } sl@0: sl@0: /* Many of the flag-pragmas modify the code generated by the SQL sl@0: ** compiler (eg. count_changes). So add an opcode to expire all sl@0: ** compiled SQL statements after modifying a pragma value. sl@0: */ sl@0: sqlite3VdbeAddOp2(v, OP_Expire, 0, 0); sl@0: } sl@0: } sl@0: sl@0: return 1; sl@0: } sl@0: } sl@0: return 0; sl@0: } sl@0: #endif /* SQLITE_OMIT_FLAG_PRAGMAS */ sl@0: sl@0: /* sl@0: ** Process a pragma statement. sl@0: ** sl@0: ** Pragmas are of this form: sl@0: ** sl@0: ** PRAGMA [database.]id [= value] sl@0: ** sl@0: ** The identifier might also be a string. The value is a string, and sl@0: ** identifier, or a number. If minusFlag is true, then the value is sl@0: ** a number that was preceded by a minus sign. sl@0: ** sl@0: ** If the left side is "database.id" then pId1 is the database name sl@0: ** and pId2 is the id. If the left side is just "id" then pId1 is the sl@0: ** id and pId2 is any empty string. sl@0: */ sl@0: void sqlite3Pragma( sl@0: Parse *pParse, sl@0: Token *pId1, /* First part of [database.]id field */ sl@0: Token *pId2, /* Second part of [database.]id field, or NULL */ sl@0: Token *pValue, /* Token for , or NULL */ sl@0: int minusFlag /* True if a '-' sign preceded */ sl@0: ){ sl@0: char *zLeft = 0; /* Nul-terminated UTF-8 string */ sl@0: char *zRight = 0; /* Nul-terminated UTF-8 string , or NULL */ sl@0: const char *zDb = 0; /* The database name */ sl@0: Token *pId; /* Pointer to token */ sl@0: int iDb; /* Database index for */ sl@0: sqlite3 *db = pParse->db; sl@0: Db *pDb; sl@0: Vdbe *v = pParse->pVdbe = sqlite3VdbeCreate(db); sl@0: if( v==0 ) return; sl@0: pParse->nMem = 2; sl@0: sl@0: /* Interpret the [database.] part of the pragma statement. iDb is the sl@0: ** index of the database this pragma is being applied to in db.aDb[]. */ sl@0: iDb = sqlite3TwoPartName(pParse, pId1, pId2, &pId); sl@0: if( iDb<0 ) return; sl@0: pDb = &db->aDb[iDb]; sl@0: sl@0: /* If the temp database has been explicitly named as part of the sl@0: ** pragma, make sure it is open. sl@0: */ sl@0: if( iDb==1 && sqlite3OpenTempDatabase(pParse) ){ sl@0: return; sl@0: } sl@0: sl@0: zLeft = sqlite3NameFromToken(db, pId); sl@0: if( !zLeft ) return; sl@0: if( minusFlag ){ sl@0: zRight = sqlite3MPrintf(db, "-%T", pValue); sl@0: }else{ sl@0: zRight = sqlite3NameFromToken(db, pValue); sl@0: } sl@0: sl@0: zDb = ((iDb>0)?pDb->zName:0); sl@0: if( sqlite3AuthCheck(pParse, SQLITE_PRAGMA, zLeft, zRight, zDb) ){ sl@0: goto pragma_out; sl@0: } sl@0: sl@0: #ifndef SQLITE_OMIT_PAGER_PRAGMAS sl@0: /* sl@0: ** PRAGMA [database.]default_cache_size sl@0: ** PRAGMA [database.]default_cache_size=N sl@0: ** sl@0: ** The first form reports the current persistent setting for the sl@0: ** page cache size. The value returned is the maximum number of sl@0: ** pages in the page cache. The second form sets both the current sl@0: ** page cache size value and the persistent page cache size value sl@0: ** stored in the database file. sl@0: ** sl@0: ** The default cache size is stored in meta-value 2 of page 1 of the sl@0: ** database file. The cache size is actually the absolute value of sl@0: ** this memory location. The sign of meta-value 2 determines the sl@0: ** synchronous setting. A negative value means synchronous is off sl@0: ** and a positive value means synchronous is on. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"default_cache_size")==0 ){ sl@0: static const VdbeOpList getCacheSize[] = { sl@0: { OP_ReadCookie, 0, 1, 2}, /* 0 */ sl@0: { OP_IfPos, 1, 6, 0}, sl@0: { OP_Integer, 0, 2, 0}, sl@0: { OP_Subtract, 1, 2, 1}, sl@0: { OP_IfPos, 1, 6, 0}, sl@0: { OP_Integer, 0, 1, 0}, /* 5 */ sl@0: { OP_ResultRow, 1, 1, 0}, sl@0: }; sl@0: int addr; sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: sqlite3VdbeUsesBtree(v, iDb); sl@0: if( !zRight ){ sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cache_size", P4_STATIC); sl@0: pParse->nMem += 2; sl@0: addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize); sl@0: sqlite3VdbeChangeP1(v, addr, iDb); sl@0: sqlite3VdbeChangeP1(v, addr+5, SQLITE_DEFAULT_CACHE_SIZE); sl@0: }else{ sl@0: int size = atoi(zRight); sl@0: if( size<0 ) size = -size; sl@0: sqlite3BeginWriteOperation(pParse, 0, iDb); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, size, 1); sl@0: sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, 2, 2); sl@0: addr = sqlite3VdbeAddOp2(v, OP_IfPos, 2, 0); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, -size, 1); sl@0: sqlite3VdbeJumpHere(v, addr); sl@0: sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, 2, 1); sl@0: pDb->pSchema->cache_size = size; sl@0: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); sl@0: } sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA [database.]page_size sl@0: ** PRAGMA [database.]page_size=N sl@0: ** sl@0: ** The first form reports the current setting for the sl@0: ** database page size in bytes. The second form sets the sl@0: ** database page size value. The value can only be set if sl@0: ** the database has not yet been created. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"page_size")==0 ){ sl@0: Btree *pBt = pDb->pBt; sl@0: if( !zRight ){ sl@0: int size = pBt ? sqlite3BtreeGetPageSize(pBt) : 0; sl@0: returnSingleInt(pParse, "page_size", size); sl@0: }else{ sl@0: /* Malloc may fail when setting the page-size, as there is an internal sl@0: ** buffer that the pager module resizes using sqlite3_realloc(). sl@0: */ sl@0: db->nextPagesize = atoi(zRight); sl@0: if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1) ){ sl@0: db->mallocFailed = 1; sl@0: } sl@0: } sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA [database.]max_page_count sl@0: ** PRAGMA [database.]max_page_count=N sl@0: ** sl@0: ** The first form reports the current setting for the sl@0: ** maximum number of pages in the database file. The sl@0: ** second form attempts to change this setting. Both sl@0: ** forms return the current setting. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"max_page_count")==0 ){ sl@0: Btree *pBt = pDb->pBt; sl@0: int newMax = 0; sl@0: if( zRight ){ sl@0: newMax = atoi(zRight); sl@0: } sl@0: if( pBt ){ sl@0: newMax = sqlite3BtreeMaxPageCount(pBt, newMax); sl@0: } sl@0: returnSingleInt(pParse, "max_page_count", newMax); sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA [database.]page_count sl@0: ** sl@0: ** Return the number of pages in the specified database. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"page_count")==0 ){ sl@0: Vdbe *v; sl@0: int iReg; sl@0: v = sqlite3GetVdbe(pParse); sl@0: if( !v || sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: sqlite3CodeVerifySchema(pParse, iDb); sl@0: iReg = ++pParse->nMem; sl@0: sqlite3VdbeAddOp2(v, OP_Pagecount, iDb, iReg); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, iReg, 1); sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "page_count", P4_STATIC); sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA [database.]locking_mode sl@0: ** PRAGMA [database.]locking_mode = (normal|exclusive) sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"locking_mode")==0 ){ sl@0: const char *zRet = "normal"; sl@0: int eMode = getLockingMode(zRight); sl@0: sl@0: if( pId2->n==0 && eMode==PAGER_LOCKINGMODE_QUERY ){ sl@0: /* Simple "PRAGMA locking_mode;" statement. This is a query for sl@0: ** the current default locking mode (which may be different to sl@0: ** the locking-mode of the main database). sl@0: */ sl@0: eMode = db->dfltLockMode; sl@0: }else{ sl@0: Pager *pPager; sl@0: if( pId2->n==0 ){ sl@0: /* This indicates that no database name was specified as part sl@0: ** of the PRAGMA command. In this case the locking-mode must be sl@0: ** set on all attached databases, as well as the main db file. sl@0: ** sl@0: ** Also, the sqlite3.dfltLockMode variable is set so that sl@0: ** any subsequently attached databases also use the specified sl@0: ** locking mode. sl@0: */ sl@0: int ii; sl@0: assert(pDb==&db->aDb[0]); sl@0: for(ii=2; iinDb; ii++){ sl@0: pPager = sqlite3BtreePager(db->aDb[ii].pBt); sl@0: sqlite3PagerLockingMode(pPager, eMode); sl@0: } sl@0: db->dfltLockMode = eMode; sl@0: } sl@0: pPager = sqlite3BtreePager(pDb->pBt); sl@0: eMode = sqlite3PagerLockingMode(pPager, eMode); sl@0: } sl@0: sl@0: assert(eMode==PAGER_LOCKINGMODE_NORMAL||eMode==PAGER_LOCKINGMODE_EXCLUSIVE); sl@0: if( eMode==PAGER_LOCKINGMODE_EXCLUSIVE ){ sl@0: zRet = "exclusive"; sl@0: } sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "locking_mode", P4_STATIC); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, zRet, 0); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA [database.]journal_mode sl@0: ** PRAGMA [database.]journal_mode = (delete|persist|off) sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"journal_mode")==0 ){ sl@0: int eMode; sl@0: static const char *azModeName[] = {"delete", "persist", "off"}; sl@0: sl@0: if( zRight==0 ){ sl@0: eMode = PAGER_JOURNALMODE_QUERY; sl@0: }else{ sl@0: int n = strlen(zRight); sl@0: eMode = 2; sl@0: while( eMode>=0 && sqlite3StrNICmp(zRight, azModeName[eMode], n)!=0 ){ sl@0: eMode--; sl@0: } sl@0: } sl@0: if( pId2->n==0 && eMode==PAGER_JOURNALMODE_QUERY ){ sl@0: /* Simple "PRAGMA journal_mode;" statement. This is a query for sl@0: ** the current default journal mode (which may be different to sl@0: ** the journal-mode of the main database). sl@0: */ sl@0: eMode = db->dfltJournalMode; sl@0: }else{ sl@0: Pager *pPager; sl@0: if( pId2->n==0 ){ sl@0: /* This indicates that no database name was specified as part sl@0: ** of the PRAGMA command. In this case the journal-mode must be sl@0: ** set on all attached databases, as well as the main db file. sl@0: ** sl@0: ** Also, the sqlite3.dfltJournalMode variable is set so that sl@0: ** any subsequently attached databases also use the specified sl@0: ** journal mode. sl@0: */ sl@0: int ii; sl@0: assert(pDb==&db->aDb[0]); sl@0: for(ii=1; iinDb; ii++){ sl@0: if( db->aDb[ii].pBt ){ sl@0: pPager = sqlite3BtreePager(db->aDb[ii].pBt); sl@0: sqlite3PagerJournalMode(pPager, eMode); sl@0: } sl@0: } sl@0: db->dfltJournalMode = eMode; sl@0: } sl@0: pPager = sqlite3BtreePager(pDb->pBt); sl@0: eMode = sqlite3PagerJournalMode(pPager, eMode); sl@0: } sl@0: assert( eMode==PAGER_JOURNALMODE_DELETE sl@0: || eMode==PAGER_JOURNALMODE_PERSIST sl@0: || eMode==PAGER_JOURNALMODE_OFF ); sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "journal_mode", P4_STATIC); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sl@0: azModeName[eMode], P4_STATIC); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA [database.]journal_size_limit sl@0: ** PRAGMA [database.]journal_size_limit=N sl@0: ** sl@0: ** Get or set the (boolean) value of the database 'auto-vacuum' parameter. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"journal_size_limit")==0 ){ sl@0: Pager *pPager = sqlite3BtreePager(pDb->pBt); sl@0: i64 iLimit = -2; sl@0: if( zRight ){ sl@0: int iLimit32 = atoi(zRight); sl@0: if( iLimit32<-1 ){ sl@0: iLimit32 = -1; sl@0: } sl@0: iLimit = iLimit32; sl@0: } sl@0: iLimit = sqlite3PagerJournalSizeLimit(pPager, iLimit); sl@0: returnSingleInt(pParse, "journal_size_limit", (int)iLimit); sl@0: }else sl@0: sl@0: #endif /* SQLITE_OMIT_PAGER_PRAGMAS */ sl@0: sl@0: /* sl@0: ** PRAGMA [database.]auto_vacuum sl@0: ** PRAGMA [database.]auto_vacuum=N sl@0: ** sl@0: ** Get or set the (boolean) value of the database 'auto-vacuum' parameter. sl@0: */ sl@0: #ifndef SQLITE_OMIT_AUTOVACUUM sl@0: if( sqlite3StrICmp(zLeft,"auto_vacuum")==0 ){ sl@0: Btree *pBt = pDb->pBt; sl@0: if( sqlite3ReadSchema(pParse) ){ sl@0: goto pragma_out; sl@0: } sl@0: if( !zRight ){ sl@0: int auto_vacuum = sl@0: pBt ? sqlite3BtreeGetAutoVacuum(pBt) : SQLITE_DEFAULT_AUTOVACUUM; sl@0: returnSingleInt(pParse, "auto_vacuum", auto_vacuum); sl@0: }else{ sl@0: int eAuto = getAutoVacuum(zRight); sl@0: db->nextAutovac = eAuto; sl@0: if( eAuto>=0 ){ sl@0: /* Call SetAutoVacuum() to set initialize the internal auto and sl@0: ** incr-vacuum flags. This is required in case this connection sl@0: ** creates the database file. It is important that it is created sl@0: ** as an auto-vacuum capable db. sl@0: */ sl@0: int rc = sqlite3BtreeSetAutoVacuum(pBt, eAuto); sl@0: if( rc==SQLITE_OK && (eAuto==1 || eAuto==2) ){ sl@0: /* When setting the auto_vacuum mode to either "full" or sl@0: ** "incremental", write the value of meta[6] in the database sl@0: ** file. Before writing to meta[6], check that meta[3] indicates sl@0: ** that this really is an auto-vacuum capable database. sl@0: */ sl@0: static const VdbeOpList setMeta6[] = { sl@0: { OP_Transaction, 0, 1, 0}, /* 0 */ sl@0: { OP_ReadCookie, 0, 1, 3}, /* 1 */ sl@0: { OP_If, 1, 0, 0}, /* 2 */ sl@0: { OP_Halt, SQLITE_OK, OE_Abort, 0}, /* 3 */ sl@0: { OP_Integer, 0, 1, 0}, /* 4 */ sl@0: { OP_SetCookie, 0, 6, 1}, /* 5 */ sl@0: }; sl@0: int iAddr; sl@0: iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6); sl@0: sqlite3VdbeChangeP1(v, iAddr, iDb); sl@0: sqlite3VdbeChangeP1(v, iAddr+1, iDb); sl@0: sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4); sl@0: sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1); sl@0: sqlite3VdbeChangeP1(v, iAddr+5, iDb); sl@0: sqlite3VdbeUsesBtree(v, iDb); sl@0: } sl@0: } sl@0: } sl@0: }else sl@0: #endif sl@0: sl@0: /* sl@0: ** PRAGMA [database.]incremental_vacuum(N) sl@0: ** sl@0: ** Do N steps of incremental vacuuming on a database. sl@0: */ sl@0: #ifndef SQLITE_OMIT_AUTOVACUUM sl@0: if( sqlite3StrICmp(zLeft,"incremental_vacuum")==0 ){ sl@0: int iLimit, addr; sl@0: if( sqlite3ReadSchema(pParse) ){ sl@0: goto pragma_out; sl@0: } sl@0: if( zRight==0 || !sqlite3GetInt32(zRight, &iLimit) || iLimit<=0 ){ sl@0: iLimit = 0x7fffffff; sl@0: } sl@0: sqlite3BeginWriteOperation(pParse, 0, iDb); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, iLimit, 1); sl@0: addr = sqlite3VdbeAddOp1(v, OP_IncrVacuum, iDb); sl@0: sqlite3VdbeAddOp1(v, OP_ResultRow, 1); sl@0: sqlite3VdbeAddOp2(v, OP_AddImm, 1, -1); sl@0: sqlite3VdbeAddOp2(v, OP_IfPos, 1, addr); sl@0: sqlite3VdbeJumpHere(v, addr); sl@0: }else sl@0: #endif sl@0: sl@0: #ifndef SQLITE_OMIT_PAGER_PRAGMAS sl@0: /* sl@0: ** PRAGMA [database.]cache_size sl@0: ** PRAGMA [database.]cache_size=N sl@0: ** sl@0: ** The first form reports the current local setting for the sl@0: ** page cache size. The local setting can be different from sl@0: ** the persistent cache size value that is stored in the database sl@0: ** file itself. The value returned is the maximum number of sl@0: ** pages in the page cache. The second form sets the local sl@0: ** page cache size value. It does not change the persistent sl@0: ** cache size stored on the disk so the cache size will revert sl@0: ** to its default value when the database is closed and reopened. sl@0: ** N should be a positive integer. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"cache_size")==0 ){ sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: if( !zRight ){ sl@0: returnSingleInt(pParse, "cache_size", pDb->pSchema->cache_size); sl@0: }else{ sl@0: int size = atoi(zRight); sl@0: if( size<0 ) size = -size; sl@0: pDb->pSchema->cache_size = size; sl@0: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); sl@0: } sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA temp_store sl@0: ** PRAGMA temp_store = "default"|"memory"|"file" sl@0: ** sl@0: ** Return or set the local value of the temp_store flag. Changing sl@0: ** the local value does not make changes to the disk file and the default sl@0: ** value will be restored the next time the database is opened. sl@0: ** sl@0: ** Note that it is possible for the library compile-time options to sl@0: ** override this setting sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "temp_store")==0 ){ sl@0: if( !zRight ){ sl@0: returnSingleInt(pParse, "temp_store", db->temp_store); sl@0: }else{ sl@0: changeTempStorage(pParse, zRight); sl@0: } sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA temp_store_directory sl@0: ** PRAGMA temp_store_directory = ""|"directory_name" sl@0: ** sl@0: ** Return or set the local value of the temp_store_directory flag. Changing sl@0: ** the value sets a specific directory to be used for temporary files. sl@0: ** Setting to a null string reverts to the default temporary directory search. sl@0: ** If temporary directory is changed, then invalidateTempStorage. sl@0: ** sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "temp_store_directory")==0 ){ sl@0: if( !zRight ){ sl@0: if( sqlite3_temp_directory ){ sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, sl@0: "temp_store_directory", P4_STATIC); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, sqlite3_temp_directory, 0); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); sl@0: } sl@0: }else{ sl@0: if( zRight[0] ){ sl@0: int res; sl@0: sqlite3OsAccess(db->pVfs, zRight, SQLITE_ACCESS_READWRITE, &res); sl@0: if( res==0 ){ sl@0: sqlite3ErrorMsg(pParse, "not a writable directory"); sl@0: goto pragma_out; sl@0: } sl@0: } sl@0: if( SQLITE_TEMP_STORE==0 sl@0: || (SQLITE_TEMP_STORE==1 && db->temp_store<=1) sl@0: || (SQLITE_TEMP_STORE==2 && db->temp_store==1) sl@0: ){ sl@0: invalidateTempStorage(pParse); sl@0: } sl@0: sqlite3_free(sqlite3_temp_directory); sl@0: if( zRight[0] ){ sl@0: sqlite3_temp_directory = sqlite3DbStrDup(0, zRight); sl@0: }else{ sl@0: sqlite3_temp_directory = 0; sl@0: } sl@0: } sl@0: }else sl@0: sl@0: /* sl@0: ** PRAGMA [database.]synchronous sl@0: ** PRAGMA [database.]synchronous=OFF|ON|NORMAL|FULL sl@0: ** sl@0: ** Return or set the local value of the synchronous flag. Changing sl@0: ** the local value does not make changes to the disk file and the sl@0: ** default value will be restored the next time the database is sl@0: ** opened. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft,"synchronous")==0 ){ sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: if( !zRight ){ sl@0: returnSingleInt(pParse, "synchronous", pDb->safety_level-1); sl@0: }else{ sl@0: if( !db->autoCommit ){ sl@0: sqlite3ErrorMsg(pParse, sl@0: "Safety level may not be changed inside a transaction"); sl@0: }else{ sl@0: pDb->safety_level = getSafetyLevel(zRight)+1; sl@0: } sl@0: } sl@0: }else sl@0: #endif /* SQLITE_OMIT_PAGER_PRAGMAS */ sl@0: sl@0: #ifndef SQLITE_OMIT_FLAG_PRAGMAS sl@0: if( flagPragma(pParse, zLeft, zRight) ){ sl@0: /* The flagPragma() subroutine also generates any necessary code sl@0: ** there is nothing more to do here */ sl@0: }else sl@0: #endif /* SQLITE_OMIT_FLAG_PRAGMAS */ sl@0: sl@0: #ifndef SQLITE_OMIT_SCHEMA_PRAGMAS sl@0: /* sl@0: ** PRAGMA table_info() sl@0: ** sl@0: ** Return a single row for each column of the named table. The columns of sl@0: ** the returned data set are: sl@0: ** sl@0: ** cid: Column id (numbered from left to right, starting at 0) sl@0: ** name: Column name sl@0: ** type: Column declaration type. sl@0: ** notnull: True if 'NOT NULL' is part of column declaration sl@0: ** dflt_value: The default value for the column, if any. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "table_info")==0 && zRight ){ sl@0: Table *pTab; sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: pTab = sqlite3FindTable(db, zRight, zDb); sl@0: if( pTab ){ sl@0: int i; sl@0: int nHidden = 0; sl@0: Column *pCol; sl@0: sqlite3VdbeSetNumCols(v, 6); sl@0: pParse->nMem = 6; sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "cid", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "type", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "notnull", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "dflt_value", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 5, COLNAME_NAME, "pk", P4_STATIC); sl@0: sqlite3ViewGetColumnNames(pParse, pTab); sl@0: for(i=0, pCol=pTab->aCol; inCol; i++, pCol++){ sl@0: const Token *pDflt; sl@0: if( IsHiddenColumn(pCol) ){ sl@0: nHidden++; sl@0: continue; sl@0: } sl@0: sqlite3VdbeAddOp2(v, OP_Integer, i-nHidden, 1); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pCol->zName, 0); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, sl@0: pCol->zType ? pCol->zType : "", 0); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, pCol->notNull, 4); sl@0: if( pCol->pDflt && (pDflt = &pCol->pDflt->span)->z ){ sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 5, 0, (char*)pDflt->z, pDflt->n); sl@0: }else{ sl@0: sqlite3VdbeAddOp2(v, OP_Null, 0, 5); sl@0: } sl@0: sqlite3VdbeAddOp2(v, OP_Integer, pCol->isPrimKey, 6); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 6); sl@0: } sl@0: } sl@0: }else sl@0: sl@0: if( sqlite3StrICmp(zLeft, "index_info")==0 && zRight ){ sl@0: Index *pIdx; sl@0: Table *pTab; sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: pIdx = sqlite3FindIndex(db, zRight, zDb); sl@0: if( pIdx ){ sl@0: int i; sl@0: pTab = pIdx->pTable; sl@0: sqlite3VdbeSetNumCols(v, 3); sl@0: pParse->nMem = 3; sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seqno", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "cid", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "name", P4_STATIC); sl@0: for(i=0; inColumn; i++){ sl@0: int cnum = pIdx->aiColumn[i]; sl@0: sqlite3VdbeAddOp2(v, OP_Integer, i, 1); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, cnum, 2); sl@0: assert( pTab->nCol>cnum ); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pTab->aCol[cnum].zName, 0); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3); sl@0: } sl@0: } sl@0: }else sl@0: sl@0: if( sqlite3StrICmp(zLeft, "index_list")==0 && zRight ){ sl@0: Index *pIdx; sl@0: Table *pTab; sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: pTab = sqlite3FindTable(db, zRight, zDb); sl@0: if( pTab ){ sl@0: v = sqlite3GetVdbe(pParse); sl@0: pIdx = pTab->pIndex; sl@0: if( pIdx ){ sl@0: int i = 0; sl@0: sqlite3VdbeSetNumCols(v, 3); sl@0: pParse->nMem = 3; sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "unique", P4_STATIC); sl@0: while(pIdx){ sl@0: sqlite3VdbeAddOp2(v, OP_Integer, i, 1); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pIdx->zName, 0); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, pIdx->onError!=OE_None, 3); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3); sl@0: ++i; sl@0: pIdx = pIdx->pNext; sl@0: } sl@0: } sl@0: } sl@0: }else sl@0: sl@0: if( sqlite3StrICmp(zLeft, "database_list")==0 ){ sl@0: int i; sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: sqlite3VdbeSetNumCols(v, 3); sl@0: pParse->nMem = 3; sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "file", P4_STATIC); sl@0: for(i=0; inDb; i++){ sl@0: if( db->aDb[i].pBt==0 ) continue; sl@0: assert( db->aDb[i].zName!=0 ); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, i, 1); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, db->aDb[i].zName, 0); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, sl@0: sqlite3BtreeGetFilename(db->aDb[i].pBt), 0); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 3); sl@0: } sl@0: }else sl@0: sl@0: if( sqlite3StrICmp(zLeft, "collation_list")==0 ){ sl@0: int i = 0; sl@0: HashElem *p; sl@0: sqlite3VdbeSetNumCols(v, 2); sl@0: pParse->nMem = 2; sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "seq", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "name", P4_STATIC); sl@0: for(p=sqliteHashFirst(&db->aCollSeq); p; p=sqliteHashNext(p)){ sl@0: CollSeq *pColl = (CollSeq *)sqliteHashData(p); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, i++, 1); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, pColl->zName, 0); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2); sl@0: } sl@0: }else sl@0: #endif /* SQLITE_OMIT_SCHEMA_PRAGMAS */ sl@0: sl@0: #ifndef SQLITE_OMIT_FOREIGN_KEY sl@0: if( sqlite3StrICmp(zLeft, "foreign_key_list")==0 && zRight ){ sl@0: FKey *pFK; sl@0: Table *pTab; sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: pTab = sqlite3FindTable(db, zRight, zDb); sl@0: if( pTab ){ sl@0: v = sqlite3GetVdbe(pParse); sl@0: pFK = pTab->pFKey; sl@0: if( pFK ){ sl@0: int i = 0; sl@0: sqlite3VdbeSetNumCols(v, 5); sl@0: pParse->nMem = 5; sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "id", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "seq", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 2, COLNAME_NAME, "table", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 3, COLNAME_NAME, "from", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 4, COLNAME_NAME, "to", P4_STATIC); sl@0: while(pFK){ sl@0: int j; sl@0: for(j=0; jnCol; j++){ sl@0: char *zCol = pFK->aCol[j].zCol; sl@0: sqlite3VdbeAddOp2(v, OP_Integer, i, 1); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, j, 2); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, pFK->zTo, 0); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 4, 0, sl@0: pTab->aCol[pFK->aCol[j].iFrom].zName, 0); sl@0: sqlite3VdbeAddOp4(v, zCol ? OP_String8 : OP_Null, 0, 5, 0, zCol, 0); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 5); sl@0: } sl@0: ++i; sl@0: pFK = pFK->pNextFrom; sl@0: } sl@0: } sl@0: } sl@0: }else sl@0: #endif /* !defined(SQLITE_OMIT_FOREIGN_KEY) */ sl@0: sl@0: #ifndef NDEBUG sl@0: if( sqlite3StrICmp(zLeft, "parser_trace")==0 ){ sl@0: if( zRight ){ sl@0: if( getBoolean(zRight) ){ sl@0: sqlite3ParserTrace(stderr, "parser: "); sl@0: }else{ sl@0: sqlite3ParserTrace(0, 0); sl@0: } sl@0: } sl@0: }else sl@0: #endif sl@0: sl@0: /* Reinstall the LIKE and GLOB functions. The variant of LIKE sl@0: ** used will be case sensitive or not depending on the RHS. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "case_sensitive_like")==0 ){ sl@0: if( zRight ){ sl@0: sqlite3RegisterLikeFunctions(db, getBoolean(zRight)); sl@0: } sl@0: }else sl@0: sl@0: #ifndef SQLITE_INTEGRITY_CHECK_ERROR_MAX sl@0: # define SQLITE_INTEGRITY_CHECK_ERROR_MAX 100 sl@0: #endif sl@0: sl@0: #ifndef SQLITE_OMIT_INTEGRITY_CHECK sl@0: /* Pragma "quick_check" is an experimental reduced version of sl@0: ** integrity_check designed to detect most database corruption sl@0: ** without most of the overhead of a full integrity-check. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "integrity_check")==0 sl@0: || sqlite3StrICmp(zLeft, "quick_check")==0 sl@0: ){ sl@0: int i, j, addr, mxErr; sl@0: sl@0: /* Code that appears at the end of the integrity check. If no error sl@0: ** messages have been generated, output OK. Otherwise output the sl@0: ** error message sl@0: */ sl@0: static const VdbeOpList endCode[] = { sl@0: { OP_AddImm, 1, 0, 0}, /* 0 */ sl@0: { OP_IfNeg, 1, 0, 0}, /* 1 */ sl@0: { OP_String8, 0, 3, 0}, /* 2 */ sl@0: { OP_ResultRow, 3, 1, 0}, sl@0: }; sl@0: sl@0: int isQuick = (zLeft[0]=='q'); sl@0: sl@0: /* Initialize the VDBE program */ sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: pParse->nMem = 6; sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "integrity_check", P4_STATIC); sl@0: sl@0: /* Set the maximum error count */ sl@0: mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; sl@0: if( zRight ){ sl@0: mxErr = atoi(zRight); sl@0: if( mxErr<=0 ){ sl@0: mxErr = SQLITE_INTEGRITY_CHECK_ERROR_MAX; sl@0: } sl@0: } sl@0: sqlite3VdbeAddOp2(v, OP_Integer, mxErr, 1); /* reg[1] holds errors left */ sl@0: sl@0: /* Do an integrity check on each database file */ sl@0: for(i=0; inDb; i++){ sl@0: HashElem *x; sl@0: Hash *pTbls; sl@0: int cnt = 0; sl@0: sl@0: if( OMIT_TEMPDB && i==1 ) continue; sl@0: sl@0: sqlite3CodeVerifySchema(pParse, i); sl@0: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Halt if out of errors */ sl@0: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0); sl@0: sqlite3VdbeJumpHere(v, addr); sl@0: sl@0: /* Do an integrity check of the B-Tree sl@0: ** sl@0: ** Begin by filling registers 2, 3, ... with the root pages numbers sl@0: ** for all tables and indices in the database. sl@0: */ sl@0: pTbls = &db->aDb[i].pSchema->tblHash; sl@0: for(x=sqliteHashFirst(pTbls); x; x=sqliteHashNext(x)){ sl@0: Table *pTab = sqliteHashData(x); sl@0: Index *pIdx; sl@0: sqlite3VdbeAddOp2(v, OP_Integer, pTab->tnum, 2+cnt); sl@0: cnt++; sl@0: for(pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext){ sl@0: sqlite3VdbeAddOp2(v, OP_Integer, pIdx->tnum, 2+cnt); sl@0: cnt++; sl@0: } sl@0: } sl@0: if( cnt==0 ) continue; sl@0: sl@0: /* Make sure sufficient number of registers have been allocated */ sl@0: if( pParse->nMem < cnt+4 ){ sl@0: pParse->nMem = cnt+4; sl@0: } sl@0: sl@0: /* Do the b-tree integrity checks */ sl@0: sqlite3VdbeAddOp3(v, OP_IntegrityCk, 2, cnt, 1); sl@0: sqlite3VdbeChangeP5(v, i); sl@0: addr = sqlite3VdbeAddOp1(v, OP_IsNull, 2); sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 3, 0, sl@0: sqlite3MPrintf(db, "*** in database %s ***\n", db->aDb[i].zName), sl@0: P4_DYNAMIC); sl@0: sqlite3VdbeAddOp3(v, OP_Move, 2, 4, 1); sl@0: sqlite3VdbeAddOp3(v, OP_Concat, 4, 3, 2); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 2, 1); sl@0: sqlite3VdbeJumpHere(v, addr); sl@0: sl@0: /* Make sure all the indices are constructed correctly. sl@0: */ sl@0: for(x=sqliteHashFirst(pTbls); x && !isQuick; x=sqliteHashNext(x)){ sl@0: Table *pTab = sqliteHashData(x); sl@0: Index *pIdx; sl@0: int loopTop; sl@0: sl@0: if( pTab->pIndex==0 ) continue; sl@0: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); /* Stop if out of errors */ sl@0: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0); sl@0: sqlite3VdbeJumpHere(v, addr); sl@0: sqlite3OpenTableAndIndices(pParse, pTab, 1, OP_OpenRead); sl@0: sqlite3VdbeAddOp2(v, OP_Integer, 0, 2); /* reg(2) will count entries */ sl@0: loopTop = sqlite3VdbeAddOp2(v, OP_Rewind, 1, 0); sl@0: sqlite3VdbeAddOp2(v, OP_AddImm, 2, 1); /* increment entry count */ sl@0: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ sl@0: int jmp2; sl@0: static const VdbeOpList idxErr[] = { sl@0: { OP_AddImm, 1, -1, 0}, sl@0: { OP_String8, 0, 3, 0}, /* 1 */ sl@0: { OP_Rowid, 1, 4, 0}, sl@0: { OP_String8, 0, 5, 0}, /* 3 */ sl@0: { OP_String8, 0, 6, 0}, /* 4 */ sl@0: { OP_Concat, 4, 3, 3}, sl@0: { OP_Concat, 5, 3, 3}, sl@0: { OP_Concat, 6, 3, 3}, sl@0: { OP_ResultRow, 3, 1, 0}, sl@0: { OP_IfPos, 1, 0, 0}, /* 9 */ sl@0: { OP_Halt, 0, 0, 0}, sl@0: }; sl@0: sqlite3GenerateIndexKey(pParse, pIdx, 1, 3, 1); sl@0: jmp2 = sqlite3VdbeAddOp3(v, OP_Found, j+2, 0, 3); sl@0: addr = sqlite3VdbeAddOpList(v, ArraySize(idxErr), idxErr); sl@0: sqlite3VdbeChangeP4(v, addr+1, "rowid ", P4_STATIC); sl@0: sqlite3VdbeChangeP4(v, addr+3, " missing from index ", P4_STATIC); sl@0: sqlite3VdbeChangeP4(v, addr+4, pIdx->zName, P4_STATIC); sl@0: sqlite3VdbeJumpHere(v, addr+9); sl@0: sqlite3VdbeJumpHere(v, jmp2); sl@0: } sl@0: sqlite3VdbeAddOp2(v, OP_Next, 1, loopTop+1); sl@0: sqlite3VdbeJumpHere(v, loopTop); sl@0: for(j=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, j++){ sl@0: static const VdbeOpList cntIdx[] = { sl@0: { OP_Integer, 0, 3, 0}, sl@0: { OP_Rewind, 0, 0, 0}, /* 1 */ sl@0: { OP_AddImm, 3, 1, 0}, sl@0: { OP_Next, 0, 0, 0}, /* 3 */ sl@0: { OP_Eq, 2, 0, 3}, /* 4 */ sl@0: { OP_AddImm, 1, -1, 0}, sl@0: { OP_String8, 0, 2, 0}, /* 6 */ sl@0: { OP_String8, 0, 3, 0}, /* 7 */ sl@0: { OP_Concat, 3, 2, 2}, sl@0: { OP_ResultRow, 2, 1, 0}, sl@0: }; sl@0: if( pIdx->tnum==0 ) continue; sl@0: addr = sqlite3VdbeAddOp1(v, OP_IfPos, 1); sl@0: sqlite3VdbeAddOp2(v, OP_Halt, 0, 0); sl@0: sqlite3VdbeJumpHere(v, addr); sl@0: addr = sqlite3VdbeAddOpList(v, ArraySize(cntIdx), cntIdx); sl@0: sqlite3VdbeChangeP1(v, addr+1, j+2); sl@0: sqlite3VdbeChangeP2(v, addr+1, addr+4); sl@0: sqlite3VdbeChangeP1(v, addr+3, j+2); sl@0: sqlite3VdbeChangeP2(v, addr+3, addr+2); sl@0: sqlite3VdbeJumpHere(v, addr+4); sl@0: sqlite3VdbeChangeP4(v, addr+6, sl@0: "wrong # of entries in index ", P4_STATIC); sl@0: sqlite3VdbeChangeP4(v, addr+7, pIdx->zName, P4_STATIC); sl@0: } sl@0: } sl@0: } sl@0: addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode); sl@0: sqlite3VdbeChangeP2(v, addr, -mxErr); sl@0: sqlite3VdbeJumpHere(v, addr+1); sl@0: sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC); sl@0: }else sl@0: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ sl@0: sl@0: #ifndef SQLITE_OMIT_UTF16 sl@0: /* sl@0: ** PRAGMA encoding sl@0: ** PRAGMA encoding = "utf-8"|"utf-16"|"utf-16le"|"utf-16be" sl@0: ** sl@0: ** In its first form, this pragma returns the encoding of the main sl@0: ** database. If the database is not initialized, it is initialized now. sl@0: ** sl@0: ** The second form of this pragma is a no-op if the main database file sl@0: ** has not already been initialized. In this case it sets the default sl@0: ** encoding that will be used for the main database file if a new file sl@0: ** is created. If an existing main database file is opened, then the sl@0: ** default text encoding for the existing database is used. sl@0: ** sl@0: ** In all cases new databases created using the ATTACH command are sl@0: ** created to use the same default text encoding as the main database. If sl@0: ** the main database has not been initialized and/or created when ATTACH sl@0: ** is executed, this is done before the ATTACH operation. sl@0: ** sl@0: ** In the second form this pragma sets the text encoding to be used in sl@0: ** new database files created using this database handle. It is only sl@0: ** useful if invoked immediately after the main database i sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "encoding")==0 ){ sl@0: static const struct EncName { sl@0: char *zName; sl@0: u8 enc; sl@0: } encnames[] = { sl@0: { "UTF-8", SQLITE_UTF8 }, sl@0: { "UTF8", SQLITE_UTF8 }, sl@0: { "UTF-16le", SQLITE_UTF16LE }, sl@0: { "UTF16le", SQLITE_UTF16LE }, sl@0: { "UTF-16be", SQLITE_UTF16BE }, sl@0: { "UTF16be", SQLITE_UTF16BE }, sl@0: { "UTF-16", 0 }, /* SQLITE_UTF16NATIVE */ sl@0: { "UTF16", 0 }, /* SQLITE_UTF16NATIVE */ sl@0: { 0, 0 } sl@0: }; sl@0: const struct EncName *pEnc; sl@0: if( !zRight ){ /* "PRAGMA encoding" */ sl@0: if( sqlite3ReadSchema(pParse) ) goto pragma_out; sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "encoding", P4_STATIC); sl@0: sqlite3VdbeAddOp2(v, OP_String8, 0, 1); sl@0: for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ sl@0: if( pEnc->enc==ENC(pParse->db) ){ sl@0: sqlite3VdbeChangeP4(v, -1, pEnc->zName, P4_STATIC); sl@0: break; sl@0: } sl@0: } sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 1); sl@0: }else{ /* "PRAGMA encoding = XXX" */ sl@0: /* Only change the value of sqlite.enc if the database handle is not sl@0: ** initialized. If the main database exists, the new sqlite.enc value sl@0: ** will be overwritten when the schema is next loaded. If it does not sl@0: ** already exists, it will be created to use the new encoding value. sl@0: */ sl@0: if( sl@0: !(DbHasProperty(db, 0, DB_SchemaLoaded)) || sl@0: DbHasProperty(db, 0, DB_Empty) sl@0: ){ sl@0: for(pEnc=&encnames[0]; pEnc->zName; pEnc++){ sl@0: if( 0==sqlite3StrICmp(zRight, pEnc->zName) ){ sl@0: ENC(pParse->db) = pEnc->enc ? pEnc->enc : SQLITE_UTF16NATIVE; sl@0: break; sl@0: } sl@0: } sl@0: if( !pEnc->zName ){ sl@0: sqlite3ErrorMsg(pParse, "unsupported encoding: %s", zRight); sl@0: } sl@0: } sl@0: } sl@0: }else sl@0: #endif /* SQLITE_OMIT_UTF16 */ sl@0: sl@0: #ifndef SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS sl@0: /* sl@0: ** PRAGMA [database.]schema_version sl@0: ** PRAGMA [database.]schema_version = sl@0: ** sl@0: ** PRAGMA [database.]user_version sl@0: ** PRAGMA [database.]user_version = sl@0: ** sl@0: ** The pragma's schema_version and user_version are used to set or get sl@0: ** the value of the schema-version and user-version, respectively. Both sl@0: ** the schema-version and the user-version are 32-bit signed integers sl@0: ** stored in the database header. sl@0: ** sl@0: ** The schema-cookie is usually only manipulated internally by SQLite. It sl@0: ** is incremented by SQLite whenever the database schema is modified (by sl@0: ** creating or dropping a table or index). The schema version is used by sl@0: ** SQLite each time a query is executed to ensure that the internal cache sl@0: ** of the schema used when compiling the SQL query matches the schema of sl@0: ** the database against which the compiled query is actually executed. sl@0: ** Subverting this mechanism by using "PRAGMA schema_version" to modify sl@0: ** the schema-version is potentially dangerous and may lead to program sl@0: ** crashes or database corruption. Use with caution! sl@0: ** sl@0: ** The user-version is not used internally by SQLite. It may be used by sl@0: ** applications for any purpose. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "schema_version")==0 sl@0: || sqlite3StrICmp(zLeft, "user_version")==0 sl@0: || sqlite3StrICmp(zLeft, "freelist_count")==0 sl@0: ){ sl@0: sl@0: int iCookie; /* Cookie index. 0 for schema-cookie, 6 for user-cookie. */ sl@0: sqlite3VdbeUsesBtree(v, iDb); sl@0: switch( zLeft[0] ){ sl@0: case 's': case 'S': sl@0: iCookie = 0; sl@0: break; sl@0: case 'f': case 'F': sl@0: iCookie = 1; sl@0: iDb = (-1*(iDb+1)); sl@0: assert(iDb<=0); sl@0: break; sl@0: default: sl@0: iCookie = 5; sl@0: break; sl@0: } sl@0: sl@0: if( zRight && iDb>=0 ){ sl@0: /* Write the specified cookie value */ sl@0: static const VdbeOpList setCookie[] = { sl@0: { OP_Transaction, 0, 1, 0}, /* 0 */ sl@0: { OP_Integer, 0, 1, 0}, /* 1 */ sl@0: { OP_SetCookie, 0, 0, 1}, /* 2 */ sl@0: }; sl@0: int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie); sl@0: sqlite3VdbeChangeP1(v, addr, iDb); sl@0: sqlite3VdbeChangeP1(v, addr+1, atoi(zRight)); sl@0: sqlite3VdbeChangeP1(v, addr+2, iDb); sl@0: sqlite3VdbeChangeP2(v, addr+2, iCookie); sl@0: }else{ sl@0: /* Read the specified cookie value */ sl@0: static const VdbeOpList readCookie[] = { sl@0: { OP_ReadCookie, 0, 1, 0}, /* 0 */ sl@0: { OP_ResultRow, 1, 1, 0} sl@0: }; sl@0: int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie); sl@0: sqlite3VdbeChangeP1(v, addr, iDb); sl@0: sqlite3VdbeChangeP3(v, addr, iCookie); sl@0: sqlite3VdbeSetNumCols(v, 1); sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, P4_TRANSIENT); sl@0: } sl@0: }else sl@0: #endif /* SQLITE_OMIT_SCHEMA_VERSION_PRAGMAS */ sl@0: sl@0: #if defined(SQLITE_DEBUG) || defined(SQLITE_TEST) sl@0: /* sl@0: ** Report the current state of file logs for all databases sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "lock_status")==0 ){ sl@0: static const char *const azLockName[] = { sl@0: "unlocked", "shared", "reserved", "pending", "exclusive" sl@0: }; sl@0: int i; sl@0: Vdbe *v = sqlite3GetVdbe(pParse); sl@0: sqlite3VdbeSetNumCols(v, 2); sl@0: pParse->nMem = 2; sl@0: sqlite3VdbeSetColName(v, 0, COLNAME_NAME, "database", P4_STATIC); sl@0: sqlite3VdbeSetColName(v, 1, COLNAME_NAME, "status", P4_STATIC); sl@0: for(i=0; inDb; i++){ sl@0: Btree *pBt; sl@0: Pager *pPager; sl@0: const char *zState = "unknown"; sl@0: int j; sl@0: if( db->aDb[i].zName==0 ) continue; sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 1, 0, db->aDb[i].zName, P4_STATIC); sl@0: pBt = db->aDb[i].pBt; sl@0: if( pBt==0 || (pPager = sqlite3BtreePager(pBt))==0 ){ sl@0: zState = "closed"; sl@0: }else if( sqlite3_file_control(db, i ? db->aDb[i].zName : 0, sl@0: SQLITE_FCNTL_LOCKSTATE, &j)==SQLITE_OK ){ sl@0: zState = azLockName[j]; sl@0: } sl@0: sqlite3VdbeAddOp4(v, OP_String8, 0, 2, 0, zState, P4_STATIC); sl@0: sqlite3VdbeAddOp2(v, OP_ResultRow, 1, 2); sl@0: } sl@0: }else sl@0: #endif sl@0: sl@0: #ifdef SQLITE_SSE sl@0: /* sl@0: ** Check to see if the sqlite_statements table exists. Create it sl@0: ** if it does not. sl@0: */ sl@0: if( sqlite3StrICmp(zLeft, "create_sqlite_statement_table")==0 ){ sl@0: extern int sqlite3CreateStatementsTable(Parse*); sl@0: sqlite3CreateStatementsTable(pParse); sl@0: }else sl@0: #endif sl@0: sl@0: #if SQLITE_HAS_CODEC sl@0: if( sqlite3StrICmp(zLeft, "key")==0 ){ sl@0: sqlite3_key(db, zRight, strlen(zRight)); sl@0: }else sl@0: #endif sl@0: #if SQLITE_HAS_CODEC || defined(SQLITE_ENABLE_CEROD) sl@0: if( sqlite3StrICmp(zLeft, "activate_extensions")==0 ){ sl@0: #if SQLITE_HAS_CODEC sl@0: if( sqlite3StrNICmp(zRight, "see-", 4)==0 ){ sl@0: extern void sqlite3_activate_see(const char*); sl@0: sqlite3_activate_see(&zRight[4]); sl@0: } sl@0: #endif sl@0: #ifdef SQLITE_ENABLE_CEROD sl@0: if( sqlite3StrNICmp(zRight, "cerod-", 6)==0 ){ sl@0: extern void sqlite3_activate_cerod(const char*); sl@0: sqlite3_activate_cerod(&zRight[6]); sl@0: } sl@0: #endif sl@0: } sl@0: #endif sl@0: sl@0: {} sl@0: sl@0: if( v ){ sl@0: /* Code an OP_Expire at the end of each PRAGMA program to cause sl@0: ** the VDBE implementing the pragma to expire. Most (all?) pragmas sl@0: ** are only valid for a single execution. sl@0: */ sl@0: sqlite3VdbeAddOp2(v, OP_Expire, 1, 0); sl@0: sl@0: /* sl@0: ** Reset the safety level, in case the fullfsync flag or synchronous sl@0: ** setting changed. sl@0: */ sl@0: #ifndef SQLITE_OMIT_PAGER_PRAGMAS sl@0: if( db->autoCommit ){ sl@0: sqlite3BtreeSetSafetyLevel(pDb->pBt, pDb->safety_level, sl@0: (db->flags&SQLITE_FullFSync)!=0); sl@0: } sl@0: #endif sl@0: } sl@0: pragma_out: sl@0: sqlite3DbFree(db, zLeft); sl@0: sqlite3DbFree(db, zRight); sl@0: } sl@0: sl@0: #endif /* SQLITE_OMIT_PRAGMA || SQLITE_OMIT_PARSER */