000001 /* 000002 ** 2005 May 25 000003 ** 000004 ** The author disclaims copyright to this source code. In place of 000005 ** a legal notice, here is a blessing: 000006 ** 000007 ** May you do good and not evil. 000008 ** May you find forgiveness for yourself and forgive others. 000009 ** May you share freely, never taking more than you give. 000010 ** 000011 ************************************************************************* 000012 ** This file contains the implementation of the sqlite3_prepare() 000013 ** interface, and routines that contribute to loading the database schema 000014 ** from disk. 000015 */ 000016 #include "sqliteInt.h" 000017 000018 /* 000019 ** Fill the InitData structure with an error message that indicates 000020 ** that the database is corrupt. 000021 */ 000022 static void corruptSchema( 000023 InitData *pData, /* Initialization context */ 000024 const char *zObj, /* Object being parsed at the point of error */ 000025 const char *zExtra /* Error information */ 000026 ){ 000027 sqlite3 *db = pData->db; 000028 if( db->mallocFailed ){ 000029 pData->rc = SQLITE_NOMEM_BKPT; 000030 }else if( pData->pzErrMsg[0]!=0 ){ 000031 /* A error message has already been generated. Do not overwrite it */ 000032 }else if( pData->mInitFlags & INITFLAG_AlterTable ){ 000033 *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra); 000034 pData->rc = SQLITE_ERROR; 000035 }else if( db->flags & SQLITE_WriteSchema ){ 000036 pData->rc = SQLITE_CORRUPT_BKPT; 000037 }else{ 000038 char *z; 000039 if( zObj==0 ) zObj = "?"; 000040 z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj); 000041 if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra); 000042 *pData->pzErrMsg = z; 000043 pData->rc = SQLITE_CORRUPT_BKPT; 000044 } 000045 } 000046 000047 /* 000048 ** Check to see if any sibling index (another index on the same table) 000049 ** of pIndex has the same root page number, and if it does, return true. 000050 ** This would indicate a corrupt schema. 000051 */ 000052 int sqlite3IndexHasDuplicateRootPage(Index *pIndex){ 000053 Index *p; 000054 for(p=pIndex->pTable->pIndex; p; p=p->pNext){ 000055 if( p->tnum==pIndex->tnum && p!=pIndex ) return 1; 000056 } 000057 return 0; 000058 } 000059 000060 /* forward declaration */ 000061 static int sqlite3Prepare( 000062 sqlite3 *db, /* Database handle. */ 000063 const char *zSql, /* UTF-8 encoded SQL statement. */ 000064 int nBytes, /* Length of zSql in bytes. */ 000065 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ 000066 Vdbe *pReprepare, /* VM being reprepared */ 000067 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000068 const char **pzTail /* OUT: End of parsed string */ 000069 ); 000070 000071 000072 /* 000073 ** This is the callback routine for the code that initializes the 000074 ** database. See sqlite3Init() below for additional information. 000075 ** This routine is also called from the OP_ParseSchema opcode of the VDBE. 000076 ** 000077 ** Each callback contains the following information: 000078 ** 000079 ** argv[0] = type of object: "table", "index", "trigger", or "view". 000080 ** argv[1] = name of thing being created 000081 ** argv[2] = associated table if an index or trigger 000082 ** argv[3] = root page number for table or index. 0 for trigger or view. 000083 ** argv[4] = SQL text for the CREATE statement. 000084 ** 000085 */ 000086 int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){ 000087 InitData *pData = (InitData*)pInit; 000088 sqlite3 *db = pData->db; 000089 int iDb = pData->iDb; 000090 000091 assert( argc==5 ); 000092 UNUSED_PARAMETER2(NotUsed, argc); 000093 assert( sqlite3_mutex_held(db->mutex) ); 000094 DbClearProperty(db, iDb, DB_Empty); 000095 pData->nInitRow++; 000096 if( db->mallocFailed ){ 000097 corruptSchema(pData, argv[1], 0); 000098 return 1; 000099 } 000100 000101 assert( iDb>=0 && iDb<db->nDb ); 000102 if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ 000103 if( argv[3]==0 ){ 000104 corruptSchema(pData, argv[1], 0); 000105 }else if( sqlite3_strnicmp(argv[4],"create ",7)==0 ){ 000106 /* Call the parser to process a CREATE TABLE, INDEX or VIEW. 000107 ** But because db->init.busy is set to 1, no VDBE code is generated 000108 ** or executed. All the parser does is build the internal data 000109 ** structures that describe the table, index, or view. 000110 */ 000111 int rc; 000112 u8 saved_iDb = db->init.iDb; 000113 sqlite3_stmt *pStmt; 000114 TESTONLY(int rcp); /* Return code from sqlite3_prepare() */ 000115 000116 assert( db->init.busy ); 000117 db->init.iDb = iDb; 000118 db->init.newTnum = sqlite3Atoi(argv[3]); 000119 db->init.orphanTrigger = 0; 000120 db->init.azInit = argv; 000121 pStmt = 0; 000122 TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0); 000123 rc = db->errCode; 000124 assert( (rc&0xFF)==(rcp&0xFF) ); 000125 db->init.iDb = saved_iDb; 000126 /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */ 000127 if( SQLITE_OK!=rc ){ 000128 if( db->init.orphanTrigger ){ 000129 assert( iDb==1 ); 000130 }else{ 000131 if( rc > pData->rc ) pData->rc = rc; 000132 if( rc==SQLITE_NOMEM ){ 000133 sqlite3OomFault(db); 000134 }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){ 000135 corruptSchema(pData, argv[1], sqlite3_errmsg(db)); 000136 } 000137 } 000138 } 000139 sqlite3_finalize(pStmt); 000140 }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){ 000141 corruptSchema(pData, argv[1], 0); 000142 }else{ 000143 /* If the SQL column is blank it means this is an index that 000144 ** was created to be the PRIMARY KEY or to fulfill a UNIQUE 000145 ** constraint for a CREATE TABLE. The index should have already 000146 ** been created when we processed the CREATE TABLE. All we have 000147 ** to do here is record the root page number for that index. 000148 */ 000149 Index *pIndex; 000150 pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName); 000151 if( pIndex==0 000152 || sqlite3GetInt32(argv[3],&pIndex->tnum)==0 000153 || pIndex->tnum<2 000154 || sqlite3IndexHasDuplicateRootPage(pIndex) 000155 ){ 000156 corruptSchema(pData, argv[1], pIndex?"invalid rootpage":"orphan index"); 000157 } 000158 } 000159 return 0; 000160 } 000161 000162 /* 000163 ** Attempt to read the database schema and initialize internal 000164 ** data structures for a single database file. The index of the 000165 ** database file is given by iDb. iDb==0 is used for the main 000166 ** database. iDb==1 should never be used. iDb>=2 is used for 000167 ** auxiliary databases. Return one of the SQLITE_ error codes to 000168 ** indicate success or failure. 000169 */ 000170 int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){ 000171 int rc; 000172 int i; 000173 #ifndef SQLITE_OMIT_DEPRECATED 000174 int size; 000175 #endif 000176 Db *pDb; 000177 char const *azArg[6]; 000178 int meta[5]; 000179 InitData initData; 000180 const char *zMasterName; 000181 int openedTransaction = 0; 000182 000183 assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ); 000184 assert( iDb>=0 && iDb<db->nDb ); 000185 assert( db->aDb[iDb].pSchema ); 000186 assert( sqlite3_mutex_held(db->mutex) ); 000187 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); 000188 000189 db->init.busy = 1; 000190 000191 /* Construct the in-memory representation schema tables (sqlite_master or 000192 ** sqlite_temp_master) by invoking the parser directly. The appropriate 000193 ** table name will be inserted automatically by the parser so we can just 000194 ** use the abbreviation "x" here. The parser will also automatically tag 000195 ** the schema table as read-only. */ 000196 azArg[0] = "table"; 000197 azArg[1] = zMasterName = SCHEMA_TABLE(iDb); 000198 azArg[2] = azArg[1]; 000199 azArg[3] = "1"; 000200 azArg[4] = "CREATE TABLE x(type text,name text,tbl_name text," 000201 "rootpage int,sql text)"; 000202 azArg[5] = 0; 000203 initData.db = db; 000204 initData.iDb = iDb; 000205 initData.rc = SQLITE_OK; 000206 initData.pzErrMsg = pzErrMsg; 000207 initData.mInitFlags = mFlags; 000208 initData.nInitRow = 0; 000209 sqlite3InitCallback(&initData, 5, (char **)azArg, 0); 000210 if( initData.rc ){ 000211 rc = initData.rc; 000212 goto error_out; 000213 } 000214 000215 /* Create a cursor to hold the database open 000216 */ 000217 pDb = &db->aDb[iDb]; 000218 if( pDb->pBt==0 ){ 000219 assert( iDb==1 ); 000220 DbSetProperty(db, 1, DB_SchemaLoaded); 000221 rc = SQLITE_OK; 000222 goto error_out; 000223 } 000224 000225 /* If there is not already a read-only (or read-write) transaction opened 000226 ** on the b-tree database, open one now. If a transaction is opened, it 000227 ** will be closed before this function returns. */ 000228 sqlite3BtreeEnter(pDb->pBt); 000229 if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){ 000230 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0); 000231 if( rc!=SQLITE_OK ){ 000232 sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc)); 000233 goto initone_error_out; 000234 } 000235 openedTransaction = 1; 000236 } 000237 000238 /* Get the database meta information. 000239 ** 000240 ** Meta values are as follows: 000241 ** meta[0] Schema cookie. Changes with each schema change. 000242 ** meta[1] File format of schema layer. 000243 ** meta[2] Size of the page cache. 000244 ** meta[3] Largest rootpage (auto/incr_vacuum mode) 000245 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE 000246 ** meta[5] User version 000247 ** meta[6] Incremental vacuum mode 000248 ** meta[7] unused 000249 ** meta[8] unused 000250 ** meta[9] unused 000251 ** 000252 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to 000253 ** the possible values of meta[4]. 000254 */ 000255 for(i=0; i<ArraySize(meta); i++){ 000256 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]); 000257 } 000258 if( (db->flags & SQLITE_ResetDatabase)!=0 ){ 000259 memset(meta, 0, sizeof(meta)); 000260 } 000261 pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1]; 000262 000263 /* If opening a non-empty database, check the text encoding. For the 000264 ** main database, set sqlite3.enc to the encoding of the main database. 000265 ** For an attached db, it is an error if the encoding is not the same 000266 ** as sqlite3.enc. 000267 */ 000268 if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */ 000269 if( iDb==0 ){ 000270 #ifndef SQLITE_OMIT_UTF16 000271 u8 encoding; 000272 /* If opening the main database, set ENC(db). */ 000273 encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3; 000274 if( encoding==0 ) encoding = SQLITE_UTF8; 000275 ENC(db) = encoding; 000276 #else 000277 ENC(db) = SQLITE_UTF8; 000278 #endif 000279 }else{ 000280 /* If opening an attached database, the encoding much match ENC(db) */ 000281 if( meta[BTREE_TEXT_ENCODING-1]!=ENC(db) ){ 000282 sqlite3SetString(pzErrMsg, db, "attached databases must use the same" 000283 " text encoding as main database"); 000284 rc = SQLITE_ERROR; 000285 goto initone_error_out; 000286 } 000287 } 000288 }else{ 000289 DbSetProperty(db, iDb, DB_Empty); 000290 } 000291 pDb->pSchema->enc = ENC(db); 000292 000293 if( pDb->pSchema->cache_size==0 ){ 000294 #ifndef SQLITE_OMIT_DEPRECATED 000295 size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]); 000296 if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } 000297 pDb->pSchema->cache_size = size; 000298 #else 000299 pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE; 000300 #endif 000301 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); 000302 } 000303 000304 /* 000305 ** file_format==1 Version 3.0.0. 000306 ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN 000307 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults 000308 ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants 000309 */ 000310 pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1]; 000311 if( pDb->pSchema->file_format==0 ){ 000312 pDb->pSchema->file_format = 1; 000313 } 000314 if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ 000315 sqlite3SetString(pzErrMsg, db, "unsupported file format"); 000316 rc = SQLITE_ERROR; 000317 goto initone_error_out; 000318 } 000319 000320 /* Ticket #2804: When we open a database in the newer file format, 000321 ** clear the legacy_file_format pragma flag so that a VACUUM will 000322 ** not downgrade the database and thus invalidate any descending 000323 ** indices that the user might have created. 000324 */ 000325 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){ 000326 db->flags &= ~(u64)SQLITE_LegacyFileFmt; 000327 } 000328 000329 /* Read the schema information out of the schema tables 000330 */ 000331 assert( db->init.busy ); 000332 { 000333 char *zSql; 000334 zSql = sqlite3MPrintf(db, 000335 "SELECT*FROM\"%w\".%s ORDER BY rowid", 000336 db->aDb[iDb].zDbSName, zMasterName); 000337 #ifndef SQLITE_OMIT_AUTHORIZATION 000338 { 000339 sqlite3_xauth xAuth; 000340 xAuth = db->xAuth; 000341 db->xAuth = 0; 000342 #endif 000343 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); 000344 #ifndef SQLITE_OMIT_AUTHORIZATION 000345 db->xAuth = xAuth; 000346 } 000347 #endif 000348 if( rc==SQLITE_OK ) rc = initData.rc; 000349 sqlite3DbFree(db, zSql); 000350 #ifndef SQLITE_OMIT_ANALYZE 000351 if( rc==SQLITE_OK ){ 000352 sqlite3AnalysisLoad(db, iDb); 000353 } 000354 #endif 000355 } 000356 if( db->mallocFailed ){ 000357 rc = SQLITE_NOMEM_BKPT; 000358 sqlite3ResetAllSchemasOfConnection(db); 000359 } 000360 if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){ 000361 /* Black magic: If the SQLITE_NoSchemaError flag is set, then consider 000362 ** the schema loaded, even if errors occurred. In this situation the 000363 ** current sqlite3_prepare() operation will fail, but the following one 000364 ** will attempt to compile the supplied statement against whatever subset 000365 ** of the schema was loaded before the error occurred. The primary 000366 ** purpose of this is to allow access to the sqlite_master table 000367 ** even when its contents have been corrupted. 000368 */ 000369 DbSetProperty(db, iDb, DB_SchemaLoaded); 000370 rc = SQLITE_OK; 000371 } 000372 000373 /* Jump here for an error that occurs after successfully allocating 000374 ** curMain and calling sqlite3BtreeEnter(). For an error that occurs 000375 ** before that point, jump to error_out. 000376 */ 000377 initone_error_out: 000378 if( openedTransaction ){ 000379 sqlite3BtreeCommit(pDb->pBt); 000380 } 000381 sqlite3BtreeLeave(pDb->pBt); 000382 000383 error_out: 000384 if( rc ){ 000385 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ 000386 sqlite3OomFault(db); 000387 } 000388 sqlite3ResetOneSchema(db, iDb); 000389 } 000390 db->init.busy = 0; 000391 return rc; 000392 } 000393 000394 /* 000395 ** Initialize all database files - the main database file, the file 000396 ** used to store temporary tables, and any additional database files 000397 ** created using ATTACH statements. Return a success code. If an 000398 ** error occurs, write an error message into *pzErrMsg. 000399 ** 000400 ** After a database is initialized, the DB_SchemaLoaded bit is set 000401 ** bit is set in the flags field of the Db structure. If the database 000402 ** file was of zero-length, then the DB_Empty flag is also set. 000403 */ 000404 int sqlite3Init(sqlite3 *db, char **pzErrMsg){ 000405 int i, rc; 000406 int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange); 000407 000408 assert( sqlite3_mutex_held(db->mutex) ); 000409 assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) ); 000410 assert( db->init.busy==0 ); 000411 ENC(db) = SCHEMA_ENC(db); 000412 assert( db->nDb>0 ); 000413 /* Do the main schema first */ 000414 if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){ 000415 rc = sqlite3InitOne(db, 0, pzErrMsg, 0); 000416 if( rc ) return rc; 000417 } 000418 /* All other schemas after the main schema. The "temp" schema must be last */ 000419 for(i=db->nDb-1; i>0; i--){ 000420 assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) ); 000421 if( !DbHasProperty(db, i, DB_SchemaLoaded) ){ 000422 rc = sqlite3InitOne(db, i, pzErrMsg, 0); 000423 if( rc ) return rc; 000424 } 000425 } 000426 if( commit_internal ){ 000427 sqlite3CommitInternalChanges(db); 000428 } 000429 return SQLITE_OK; 000430 } 000431 000432 /* 000433 ** This routine is a no-op if the database schema is already initialized. 000434 ** Otherwise, the schema is loaded. An error code is returned. 000435 */ 000436 int sqlite3ReadSchema(Parse *pParse){ 000437 int rc = SQLITE_OK; 000438 sqlite3 *db = pParse->db; 000439 assert( sqlite3_mutex_held(db->mutex) ); 000440 if( !db->init.busy ){ 000441 rc = sqlite3Init(db, &pParse->zErrMsg); 000442 if( rc!=SQLITE_OK ){ 000443 pParse->rc = rc; 000444 pParse->nErr++; 000445 }else if( db->noSharedCache ){ 000446 db->mDbFlags |= DBFLAG_SchemaKnownOk; 000447 } 000448 } 000449 return rc; 000450 } 000451 000452 000453 /* 000454 ** Check schema cookies in all databases. If any cookie is out 000455 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies 000456 ** make no changes to pParse->rc. 000457 */ 000458 static void schemaIsValid(Parse *pParse){ 000459 sqlite3 *db = pParse->db; 000460 int iDb; 000461 int rc; 000462 int cookie; 000463 000464 assert( pParse->checkSchema ); 000465 assert( sqlite3_mutex_held(db->mutex) ); 000466 for(iDb=0; iDb<db->nDb; iDb++){ 000467 int openedTransaction = 0; /* True if a transaction is opened */ 000468 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */ 000469 if( pBt==0 ) continue; 000470 000471 /* If there is not already a read-only (or read-write) transaction opened 000472 ** on the b-tree database, open one now. If a transaction is opened, it 000473 ** will be closed immediately after reading the meta-value. */ 000474 if( !sqlite3BtreeIsInReadTrans(pBt) ){ 000475 rc = sqlite3BtreeBeginTrans(pBt, 0, 0); 000476 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ 000477 sqlite3OomFault(db); 000478 } 000479 if( rc!=SQLITE_OK ) return; 000480 openedTransaction = 1; 000481 } 000482 000483 /* Read the schema cookie from the database. If it does not match the 000484 ** value stored as part of the in-memory schema representation, 000485 ** set Parse.rc to SQLITE_SCHEMA. */ 000486 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie); 000487 assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); 000488 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){ 000489 sqlite3ResetOneSchema(db, iDb); 000490 pParse->rc = SQLITE_SCHEMA; 000491 } 000492 000493 /* Close the transaction, if one was opened. */ 000494 if( openedTransaction ){ 000495 sqlite3BtreeCommit(pBt); 000496 } 000497 } 000498 } 000499 000500 /* 000501 ** Convert a schema pointer into the iDb index that indicates 000502 ** which database file in db->aDb[] the schema refers to. 000503 ** 000504 ** If the same database is attached more than once, the first 000505 ** attached database is returned. 000506 */ 000507 int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ 000508 int i = -1000000; 000509 000510 /* If pSchema is NULL, then return -1000000. This happens when code in 000511 ** expr.c is trying to resolve a reference to a transient table (i.e. one 000512 ** created by a sub-select). In this case the return value of this 000513 ** function should never be used. 000514 ** 000515 ** We return -1000000 instead of the more usual -1 simply because using 000516 ** -1000000 as the incorrect index into db->aDb[] is much 000517 ** more likely to cause a segfault than -1 (of course there are assert() 000518 ** statements too, but it never hurts to play the odds). 000519 */ 000520 assert( sqlite3_mutex_held(db->mutex) ); 000521 if( pSchema ){ 000522 for(i=0; 1; i++){ 000523 assert( i<db->nDb ); 000524 if( db->aDb[i].pSchema==pSchema ){ 000525 break; 000526 } 000527 } 000528 assert( i>=0 && i<db->nDb ); 000529 } 000530 return i; 000531 } 000532 000533 /* 000534 ** Free all memory allocations in the pParse object 000535 */ 000536 void sqlite3ParserReset(Parse *pParse){ 000537 sqlite3 *db = pParse->db; 000538 sqlite3DbFree(db, pParse->aLabel); 000539 sqlite3ExprListDelete(db, pParse->pConstExpr); 000540 if( db ){ 000541 assert( db->lookaside.bDisable >= pParse->disableLookaside ); 000542 db->lookaside.bDisable -= pParse->disableLookaside; 000543 db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue; 000544 } 000545 pParse->disableLookaside = 0; 000546 } 000547 000548 /* 000549 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle. 000550 */ 000551 static int sqlite3Prepare( 000552 sqlite3 *db, /* Database handle. */ 000553 const char *zSql, /* UTF-8 encoded SQL statement. */ 000554 int nBytes, /* Length of zSql in bytes. */ 000555 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ 000556 Vdbe *pReprepare, /* VM being reprepared */ 000557 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000558 const char **pzTail /* OUT: End of parsed string */ 000559 ){ 000560 char *zErrMsg = 0; /* Error message */ 000561 int rc = SQLITE_OK; /* Result code */ 000562 int i; /* Loop counter */ 000563 Parse sParse; /* Parsing context */ 000564 000565 memset(&sParse, 0, PARSE_HDR_SZ); 000566 memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ); 000567 sParse.pReprepare = pReprepare; 000568 assert( ppStmt && *ppStmt==0 ); 000569 /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */ 000570 assert( sqlite3_mutex_held(db->mutex) ); 000571 000572 /* For a long-term use prepared statement avoid the use of 000573 ** lookaside memory. 000574 */ 000575 if( prepFlags & SQLITE_PREPARE_PERSISTENT ){ 000576 sParse.disableLookaside++; 000577 DisableLookaside; 000578 } 000579 sParse.disableVtab = (prepFlags & SQLITE_PREPARE_NO_VTAB)!=0; 000580 000581 /* Check to verify that it is possible to get a read lock on all 000582 ** database schemas. The inability to get a read lock indicates that 000583 ** some other database connection is holding a write-lock, which in 000584 ** turn means that the other connection has made uncommitted changes 000585 ** to the schema. 000586 ** 000587 ** Were we to proceed and prepare the statement against the uncommitted 000588 ** schema changes and if those schema changes are subsequently rolled 000589 ** back and different changes are made in their place, then when this 000590 ** prepared statement goes to run the schema cookie would fail to detect 000591 ** the schema change. Disaster would follow. 000592 ** 000593 ** This thread is currently holding mutexes on all Btrees (because 000594 ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it 000595 ** is not possible for another thread to start a new schema change 000596 ** while this routine is running. Hence, we do not need to hold 000597 ** locks on the schema, we just need to make sure nobody else is 000598 ** holding them. 000599 ** 000600 ** Note that setting READ_UNCOMMITTED overrides most lock detection, 000601 ** but it does *not* override schema lock detection, so this all still 000602 ** works even if READ_UNCOMMITTED is set. 000603 */ 000604 if( !db->noSharedCache ){ 000605 for(i=0; i<db->nDb; i++) { 000606 Btree *pBt = db->aDb[i].pBt; 000607 if( pBt ){ 000608 assert( sqlite3BtreeHoldsMutex(pBt) ); 000609 rc = sqlite3BtreeSchemaLocked(pBt); 000610 if( rc ){ 000611 const char *zDb = db->aDb[i].zDbSName; 000612 sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb); 000613 testcase( db->flags & SQLITE_ReadUncommit ); 000614 goto end_prepare; 000615 } 000616 } 000617 } 000618 } 000619 000620 sqlite3VtabUnlockList(db); 000621 000622 sParse.db = db; 000623 if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ 000624 char *zSqlCopy; 000625 int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; 000626 testcase( nBytes==mxLen ); 000627 testcase( nBytes==mxLen+1 ); 000628 if( nBytes>mxLen ){ 000629 sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long"); 000630 rc = sqlite3ApiExit(db, SQLITE_TOOBIG); 000631 goto end_prepare; 000632 } 000633 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); 000634 if( zSqlCopy ){ 000635 sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg); 000636 sParse.zTail = &zSql[sParse.zTail-zSqlCopy]; 000637 sqlite3DbFree(db, zSqlCopy); 000638 }else{ 000639 sParse.zTail = &zSql[nBytes]; 000640 } 000641 }else{ 000642 sqlite3RunParser(&sParse, zSql, &zErrMsg); 000643 } 000644 assert( 0==sParse.nQueryLoop ); 000645 000646 if( sParse.rc==SQLITE_DONE ){ 000647 sParse.rc = SQLITE_OK; 000648 } 000649 if( sParse.checkSchema ){ 000650 schemaIsValid(&sParse); 000651 } 000652 if( pzTail ){ 000653 *pzTail = sParse.zTail; 000654 } 000655 000656 if( db->init.busy==0 ){ 000657 sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags); 000658 } 000659 if( db->mallocFailed ){ 000660 sParse.rc = SQLITE_NOMEM_BKPT; 000661 } 000662 rc = sParse.rc; 000663 if( rc!=SQLITE_OK ){ 000664 if( sParse.pVdbe ) sqlite3VdbeFinalize(sParse.pVdbe); 000665 assert(!(*ppStmt)); 000666 }else{ 000667 *ppStmt = (sqlite3_stmt*)sParse.pVdbe; 000668 } 000669 000670 if( zErrMsg ){ 000671 sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); 000672 sqlite3DbFree(db, zErrMsg); 000673 }else{ 000674 sqlite3Error(db, rc); 000675 } 000676 000677 /* Delete any TriggerPrg structures allocated while parsing this statement. */ 000678 while( sParse.pTriggerPrg ){ 000679 TriggerPrg *pT = sParse.pTriggerPrg; 000680 sParse.pTriggerPrg = pT->pNext; 000681 sqlite3DbFree(db, pT); 000682 } 000683 000684 end_prepare: 000685 000686 sqlite3ParserReset(&sParse); 000687 return rc; 000688 } 000689 static int sqlite3LockAndPrepare( 000690 sqlite3 *db, /* Database handle. */ 000691 const char *zSql, /* UTF-8 encoded SQL statement. */ 000692 int nBytes, /* Length of zSql in bytes. */ 000693 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ 000694 Vdbe *pOld, /* VM being reprepared */ 000695 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000696 const char **pzTail /* OUT: End of parsed string */ 000697 ){ 000698 int rc; 000699 int cnt = 0; 000700 000701 #ifdef SQLITE_ENABLE_API_ARMOR 000702 if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; 000703 #endif 000704 *ppStmt = 0; 000705 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ 000706 return SQLITE_MISUSE_BKPT; 000707 } 000708 sqlite3_mutex_enter(db->mutex); 000709 sqlite3BtreeEnterAll(db); 000710 do{ 000711 /* Make multiple attempts to compile the SQL, until it either succeeds 000712 ** or encounters a permanent error. A schema problem after one schema 000713 ** reset is considered a permanent error. */ 000714 rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail); 000715 assert( rc==SQLITE_OK || *ppStmt==0 ); 000716 }while( rc==SQLITE_ERROR_RETRY 000717 || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) ); 000718 sqlite3BtreeLeaveAll(db); 000719 rc = sqlite3ApiExit(db, rc); 000720 assert( (rc&db->errMask)==rc ); 000721 sqlite3_mutex_leave(db->mutex); 000722 return rc; 000723 } 000724 000725 000726 /* 000727 ** Rerun the compilation of a statement after a schema change. 000728 ** 000729 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise, 000730 ** if the statement cannot be recompiled because another connection has 000731 ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error 000732 ** occurs, return SQLITE_SCHEMA. 000733 */ 000734 int sqlite3Reprepare(Vdbe *p){ 000735 int rc; 000736 sqlite3_stmt *pNew; 000737 const char *zSql; 000738 sqlite3 *db; 000739 u8 prepFlags; 000740 000741 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); 000742 zSql = sqlite3_sql((sqlite3_stmt *)p); 000743 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */ 000744 db = sqlite3VdbeDb(p); 000745 assert( sqlite3_mutex_held(db->mutex) ); 000746 prepFlags = sqlite3VdbePrepareFlags(p); 000747 rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0); 000748 if( rc ){ 000749 if( rc==SQLITE_NOMEM ){ 000750 sqlite3OomFault(db); 000751 } 000752 assert( pNew==0 ); 000753 return rc; 000754 }else{ 000755 assert( pNew!=0 ); 000756 } 000757 sqlite3VdbeSwap((Vdbe*)pNew, p); 000758 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p); 000759 sqlite3VdbeResetStepResult((Vdbe*)pNew); 000760 sqlite3VdbeFinalize((Vdbe*)pNew); 000761 return SQLITE_OK; 000762 } 000763 000764 000765 /* 000766 ** Two versions of the official API. Legacy and new use. In the legacy 000767 ** version, the original SQL text is not saved in the prepared statement 000768 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by 000769 ** sqlite3_step(). In the new version, the original SQL text is retained 000770 ** and the statement is automatically recompiled if an schema change 000771 ** occurs. 000772 */ 000773 int sqlite3_prepare( 000774 sqlite3 *db, /* Database handle. */ 000775 const char *zSql, /* UTF-8 encoded SQL statement. */ 000776 int nBytes, /* Length of zSql in bytes. */ 000777 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000778 const char **pzTail /* OUT: End of parsed string */ 000779 ){ 000780 int rc; 000781 rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail); 000782 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ 000783 return rc; 000784 } 000785 int sqlite3_prepare_v2( 000786 sqlite3 *db, /* Database handle. */ 000787 const char *zSql, /* UTF-8 encoded SQL statement. */ 000788 int nBytes, /* Length of zSql in bytes. */ 000789 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000790 const char **pzTail /* OUT: End of parsed string */ 000791 ){ 000792 int rc; 000793 /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works 000794 ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags 000795 ** parameter. 000796 ** 000797 ** Proof in that the 5th parameter to sqlite3LockAndPrepare is 0 */ 000798 rc = sqlite3LockAndPrepare(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,0, 000799 ppStmt,pzTail); 000800 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); 000801 return rc; 000802 } 000803 int sqlite3_prepare_v3( 000804 sqlite3 *db, /* Database handle. */ 000805 const char *zSql, /* UTF-8 encoded SQL statement. */ 000806 int nBytes, /* Length of zSql in bytes. */ 000807 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ 000808 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000809 const char **pzTail /* OUT: End of parsed string */ 000810 ){ 000811 int rc; 000812 /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from 000813 ** sqlite3_prepare_v2() only in having the extra prepFlags parameter, 000814 ** which is a bit array consisting of zero or more of the 000815 ** SQLITE_PREPARE_* flags. 000816 ** 000817 ** Proof by comparison to the implementation of sqlite3_prepare_v2() 000818 ** directly above. */ 000819 rc = sqlite3LockAndPrepare(db,zSql,nBytes, 000820 SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), 000821 0,ppStmt,pzTail); 000822 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); 000823 return rc; 000824 } 000825 000826 000827 #ifndef SQLITE_OMIT_UTF16 000828 /* 000829 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle. 000830 */ 000831 static int sqlite3Prepare16( 000832 sqlite3 *db, /* Database handle. */ 000833 const void *zSql, /* UTF-16 encoded SQL statement. */ 000834 int nBytes, /* Length of zSql in bytes. */ 000835 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ 000836 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000837 const void **pzTail /* OUT: End of parsed string */ 000838 ){ 000839 /* This function currently works by first transforming the UTF-16 000840 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The 000841 ** tricky bit is figuring out the pointer to return in *pzTail. 000842 */ 000843 char *zSql8; 000844 const char *zTail8 = 0; 000845 int rc = SQLITE_OK; 000846 000847 #ifdef SQLITE_ENABLE_API_ARMOR 000848 if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; 000849 #endif 000850 *ppStmt = 0; 000851 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ 000852 return SQLITE_MISUSE_BKPT; 000853 } 000854 if( nBytes>=0 ){ 000855 int sz; 000856 const char *z = (const char*)zSql; 000857 for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){} 000858 nBytes = sz; 000859 } 000860 sqlite3_mutex_enter(db->mutex); 000861 zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); 000862 if( zSql8 ){ 000863 rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8); 000864 } 000865 000866 if( zTail8 && pzTail ){ 000867 /* If sqlite3_prepare returns a tail pointer, we calculate the 000868 ** equivalent pointer into the UTF-16 string by counting the unicode 000869 ** characters between zSql8 and zTail8, and then returning a pointer 000870 ** the same number of characters into the UTF-16 string. 000871 */ 000872 int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8)); 000873 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); 000874 } 000875 sqlite3DbFree(db, zSql8); 000876 rc = sqlite3ApiExit(db, rc); 000877 sqlite3_mutex_leave(db->mutex); 000878 return rc; 000879 } 000880 000881 /* 000882 ** Two versions of the official API. Legacy and new use. In the legacy 000883 ** version, the original SQL text is not saved in the prepared statement 000884 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by 000885 ** sqlite3_step(). In the new version, the original SQL text is retained 000886 ** and the statement is automatically recompiled if an schema change 000887 ** occurs. 000888 */ 000889 int sqlite3_prepare16( 000890 sqlite3 *db, /* Database handle. */ 000891 const void *zSql, /* UTF-16 encoded SQL statement. */ 000892 int nBytes, /* Length of zSql in bytes. */ 000893 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000894 const void **pzTail /* OUT: End of parsed string */ 000895 ){ 000896 int rc; 000897 rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); 000898 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ 000899 return rc; 000900 } 000901 int sqlite3_prepare16_v2( 000902 sqlite3 *db, /* Database handle. */ 000903 const void *zSql, /* UTF-16 encoded SQL statement. */ 000904 int nBytes, /* Length of zSql in bytes. */ 000905 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000906 const void **pzTail /* OUT: End of parsed string */ 000907 ){ 000908 int rc; 000909 rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail); 000910 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ 000911 return rc; 000912 } 000913 int sqlite3_prepare16_v3( 000914 sqlite3 *db, /* Database handle. */ 000915 const void *zSql, /* UTF-16 encoded SQL statement. */ 000916 int nBytes, /* Length of zSql in bytes. */ 000917 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ 000918 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ 000919 const void **pzTail /* OUT: End of parsed string */ 000920 ){ 000921 int rc; 000922 rc = sqlite3Prepare16(db,zSql,nBytes, 000923 SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), 000924 ppStmt,pzTail); 000925 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ 000926 return rc; 000927 } 000928 000929 #endif /* SQLITE_OMIT_UTF16 */