src/prepare.c

   1 /*
   2 ** 2005 May 25
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 ** This file contains the implementation of the sqlite3_prepare()
  13 ** interface, and routines that contribute to loading the database schema
  14 ** from disk.
  15 */
  16 #include "sqliteInt.h"
  17
  18 /*
  19 ** Fill the InitData structure with an error message that indicates
  20 ** that the database is corrupt.
  21 */
  22 static void corruptSchema(
  23   InitData *pData,     /* Initialization context */
  24   const char *zObj,    /* Object being parsed at the point of error */
  25   const char *zExtra   /* Error information */
  26 ){
  27   sqlite3 *db = pData->db;
  28   if( db->mallocFailed ){
  29     pData->rc = SQLITE_NOMEM_BKPT;
  30   }else if( pData->pzErrMsg[0]!=0 ){
  31     /* A error message has already been generated.  Do not overwrite it */
  32   }else if( pData->mInitFlags & INITFLAG_AlterTable ){
  33     *pData->pzErrMsg = sqlite3DbStrDup(db, zExtra);
  34     pData->rc = SQLITE_ERROR;
  35   }else if( db->flags & SQLITE_WriteSchema ){
  36     pData->rc = SQLITE_CORRUPT_BKPT;
  37   }else{
  38     char *z;
  39     if( zObj==0 ) zObj = "?";
  40     z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
  41     if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
  42     *pData->pzErrMsg = z;
  43     pData->rc = SQLITE_CORRUPT_BKPT;
  44   }
  45 }
  46
  47 /*
  48 ** Check to see if any sibling index (another index on the same table)
  49 ** of pIndex has the same root page number, and if it does, return true.
  50 ** This would indicate a corrupt schema.
  51 */
  52 int sqlite3IndexHasDuplicateRootPage(Index *pIndex){
  53   Index *p;
  54   for(p=pIndex->pTable->pIndex; p; p=p->pNext){
  55     if( p->tnum==pIndex->tnum && p!=pIndex ) return 1;
  56   }
  57   return 0;
  58 }
  59
  60 /* forward declaration */
  61 static int sqlite3Prepare(
  62   sqlite3 *db,              /* Database handle. */
  63   const char *zSql,         /* UTF-8 encoded SQL statement. */
  64   int nBytes,               /* Length of zSql in bytes. */
  65   u32 prepFlags,            /* Zero or more SQLITE_PREPARE_* flags */
  66   Vdbe *pReprepare,         /* VM being reprepared */
  67   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
  68   const char **pzTail       /* OUT: End of parsed string */
  69 );
  70
  71
  72 /*
  73 ** This is the callback routine for the code that initializes the
  74 ** database.  See sqlite3Init() below for additional information.
  75 ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
  76 **
  77 ** Each callback contains the following information:
  78 **
  79 **     argv[0] = type of object: "table", "index", "trigger", or "view".
  80 **     argv[1] = name of thing being created
  81 **     argv[2] = associated table if an index or trigger
  82 **     argv[3] = root page number for table or index. 0 for trigger or view.
  83 **     argv[4] = SQL text for the CREATE statement.
  84 **
  85 */
  86 int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
  87   InitData *pData = (InitData*)pInit;
  88   sqlite3 *db = pData->db;
  89   int iDb = pData->iDb;
  90
  91   assert( argc==5 );
  92   UNUSED_PARAMETER2(NotUsed, argc);
  93   assert( sqlite3_mutex_held(db->mutex) );
  94   db->mDbFlags |= DBFLAG_EncodingFixed;
  95   pData->nInitRow++;
  96   if( db->mallocFailed ){
  97     corruptSchema(pData, argv[1], 0);
  98     return 1;
  99   }
 100
 101   assert( iDb>=0 && iDb<db->nDb );
 102   if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
 103   if( argv[3]==0 ){
 104     corruptSchema(pData, argv[1], 0);
 105   }else if( sqlite3_strnicmp(argv[4],"create ",7)==0 ){
 106     /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
 107     ** But because db->init.busy is set to 1, no VDBE code is generated
 108     ** or executed.  All the parser does is build the internal data
 109     ** structures that describe the table, index, or view.
 110     */
 111     int rc;
 112     u8 saved_iDb = db->init.iDb;
 113     sqlite3_stmt *pStmt;
 114     TESTONLY(int rcp);            /* Return code from sqlite3_prepare() */
 115
 116     assert( db->init.busy );
 117     db->init.iDb = iDb;
 118     db->init.newTnum = sqlite3Atoi(argv[3]);
 119     db->init.orphanTrigger = 0;
 120     db->init.azInit = argv;
 121     pStmt = 0;
 122     TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
 123     rc = db->errCode;
 124     assert( (rc&0xFF)==(rcp&0xFF) );
 125     db->init.iDb = saved_iDb;
 126     /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */
 127     if( SQLITE_OK!=rc ){
 128       if( db->init.orphanTrigger ){
 129         assert( iDb==1 );
 130       }else{
 131         if( rc > pData->rc ) pData->rc = rc;
 132         if( rc==SQLITE_NOMEM ){
 133           sqlite3OomFault(db);
 134         }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
 135           corruptSchema(pData, argv[1], sqlite3_errmsg(db));
 136         }
 137       }
 138     }
 139     sqlite3_finalize(pStmt);
 140   }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){
 141     corruptSchema(pData, argv[1], 0);
 142   }else{
 143     /* If the SQL column is blank it means this is an index that
 144     ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
 145     ** constraint for a CREATE TABLE.  The index should have already
 146     ** been created when we processed the CREATE TABLE.  All we have
 147     ** to do here is record the root page number for that index.
 148     */
 149     Index *pIndex;
 150     pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
 151     if( pIndex==0
 152      || sqlite3GetInt32(argv[3],&pIndex->tnum)==0
 153      || pIndex->tnum<2
 154      || sqlite3IndexHasDuplicateRootPage(pIndex)
 155     ){
 156       corruptSchema(pData, argv[1], pIndex?"invalid rootpage":"orphan index");
 157     }
 158   }
 159   return 0;
 160 }
 161
 162 /*
 163 ** Attempt to read the database schema and initialize internal
 164 ** data structures for a single database file.  The index of the
 165 ** database file is given by iDb.  iDb==0 is used for the main
 166 ** database.  iDb==1 should never be used.  iDb>=2 is used for
 167 ** auxiliary databases.  Return one of the SQLITE_ error codes to
 168 ** indicate success or failure.
 169 */
 170 int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
 171   int rc;
 172   int i;
 173 #ifndef SQLITE_OMIT_DEPRECATED
 174   int size;
 175 #endif
 176   Db *pDb;
 177   char const *azArg[6];
 178   int meta[5];
 179   InitData initData;
 180   const char *zMasterName;
 181   int openedTransaction = 0;
 182   int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed);
 183
 184   assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 );
 185   assert( iDb>=0 && iDb<db->nDb );
 186   assert( db->aDb[iDb].pSchema );
 187   assert( sqlite3_mutex_held(db->mutex) );
 188   assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
 189
 190   db->init.busy = 1;
 191
 192   /* Construct the in-memory representation schema tables (sqlite_master or
 193   ** sqlite_temp_master) by invoking the parser directly.  The appropriate
 194   ** table name will be inserted automatically by the parser so we can just
 195   ** use the abbreviation "x" here.  The parser will also automatically tag
 196   ** the schema table as read-only. */
 197   azArg[0] = "table";
 198   azArg[1] = zMasterName = SCHEMA_TABLE(iDb);
 199   azArg[2] = azArg[1];
 200   azArg[3] = "1";
 201   azArg[4] = "CREATE TABLE x(type text,name text,tbl_name text,"
 202                             "rootpage int,sql text)";
 203   azArg[5] = 0;
 204   initData.db = db;
 205   initData.iDb = iDb;
 206   initData.rc = SQLITE_OK;
 207   initData.pzErrMsg = pzErrMsg;
 208   initData.mInitFlags = mFlags;
 209   initData.nInitRow = 0;
 210   sqlite3InitCallback(&initData, 5, (char **)azArg, 0);
 211   db->mDbFlags &= mask;
 212   if( initData.rc ){
 213     rc = initData.rc;
 214     goto error_out;
 215   }
 216
 217   /* Create a cursor to hold the database open
 218   */
 219   pDb = &db->aDb[iDb];
 220   if( pDb->pBt==0 ){
 221     assert( iDb==1 );
 222     DbSetProperty(db, 1, DB_SchemaLoaded);
 223     rc = SQLITE_OK;
 224     goto error_out;
 225   }
 226
 227   /* If there is not already a read-only (or read-write) transaction opened
 228   ** on the b-tree database, open one now. If a transaction is opened, it
 229   ** will be closed before this function returns.  */
 230   sqlite3BtreeEnter(pDb->pBt);
 231   if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
 232     rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0);
 233     if( rc!=SQLITE_OK ){
 234       sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc));
 235       goto initone_error_out;
 236     }
 237     openedTransaction = 1;
 238   }
 239
 240   /* Get the database meta information.
 241   **
 242   ** Meta values are as follows:
 243   **    meta[0]   Schema cookie.  Changes with each schema change.
 244   **    meta[1]   File format of schema layer.
 245   **    meta[2]   Size of the page cache.
 246   **    meta[3]   Largest rootpage (auto/incr_vacuum mode)
 247   **    meta[4]   Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
 248   **    meta[5]   User version
 249   **    meta[6]   Incremental vacuum mode
 250   **    meta[7]   unused
 251   **    meta[8]   unused
 252   **    meta[9]   unused
 253   **
 254   ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
 255   ** the possible values of meta[4].
 256   */
 257   for(i=0; i<ArraySize(meta); i++){
 258     sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
 259   }
 260   if( (db->flags & SQLITE_ResetDatabase)!=0 ){
 261     memset(meta, 0, sizeof(meta));
 262   }
 263   pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
 264
 265   /* If opening a non-empty database, check the text encoding. For the
 266   ** main database, set sqlite3.enc to the encoding of the main database.
 267   ** For an attached db, it is an error if the encoding is not the same
 268   ** as sqlite3.enc.
 269   */
 270   if( meta[BTREE_TEXT_ENCODING-1] ){  /* text encoding */
 271     if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
 272       u8 encoding;
 273 #ifndef SQLITE_OMIT_UTF16
 274       /* If opening the main database, set ENC(db). */
 275       encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
 276       if( encoding==0 ) encoding = SQLITE_UTF8;
 277 #else
 278       encoding = SQLITE_UTF8;
 279 #endif
 280       sqlite3SetTextEncoding(db, encoding);
 281     }else{
 282       /* If opening an attached database, the encoding much match ENC(db) */
 283       if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){
 284         sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
 285             " text encoding as main database");
 286         rc = SQLITE_ERROR;
 287         goto initone_error_out;
 288       }
 289     }
 290   }
 291   pDb->pSchema->enc = ENC(db);
 292
 293   if( pDb->pSchema->cache_size==0 ){
 294 #ifndef SQLITE_OMIT_DEPRECATED
 295     size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]);
 296     if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
 297     pDb->pSchema->cache_size = size;
 298 #else
 299     pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE;
 300 #endif
 301     sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
 302   }
 303
 304   /*
 305   ** file_format==1    Version 3.0.0.
 306   ** file_format==2    Version 3.1.3.  // ALTER TABLE ADD COLUMN
 307   ** file_format==3    Version 3.1.4.  // ditto but with non-NULL defaults
 308   ** file_format==4    Version 3.3.0.  // DESC indices.  Boolean constants
 309   */
 310   pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
 311   if( pDb->pSchema->file_format==0 ){
 312     pDb->pSchema->file_format = 1;
 313   }
 314   if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
 315     sqlite3SetString(pzErrMsg, db, "unsupported file format");
 316     rc = SQLITE_ERROR;
 317     goto initone_error_out;
 318   }
 319
 320   /* Ticket #2804:  When we open a database in the newer file format,
 321   ** clear the legacy_file_format pragma flag so that a VACUUM will
 322   ** not downgrade the database and thus invalidate any descending
 323   ** indices that the user might have created.
 324   */
 325   if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
 326     db->flags &= ~(u64)SQLITE_LegacyFileFmt;
 327   }
 328
 329   /* Read the schema information out of the schema tables
 330   */
 331   assert( db->init.busy );
 332   {
 333     char *zSql;
 334     zSql = sqlite3MPrintf(db,
 335         "SELECT*FROM\"%w\".%s ORDER BY rowid",
 336         db->aDb[iDb].zDbSName, zMasterName);
 337 #ifndef SQLITE_OMIT_AUTHORIZATION
 338     {
 339       sqlite3_xauth xAuth;
 340       xAuth = db->xAuth;
 341       db->xAuth = 0;
 342 #endif
 343       rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
 344 #ifndef SQLITE_OMIT_AUTHORIZATION
 345       db->xAuth = xAuth;
 346     }
 347 #endif
 348     if( rc==SQLITE_OK ) rc = initData.rc;
 349     sqlite3DbFree(db, zSql);
 350 #ifndef SQLITE_OMIT_ANALYZE
 351     if( rc==SQLITE_OK ){
 352       sqlite3AnalysisLoad(db, iDb);
 353     }
 354 #endif
 355   }
 356   if( db->mallocFailed ){
 357     rc = SQLITE_NOMEM_BKPT;
 358     sqlite3ResetAllSchemasOfConnection(db);
 359   }
 360   if( rc==SQLITE_OK || (db->flags&SQLITE_NoSchemaError)){
 361     /* Black magic: If the SQLITE_NoSchemaError flag is set, then consider
 362     ** the schema loaded, even if errors occurred. In this situation the
 363     ** current sqlite3_prepare() operation will fail, but the following one
 364     ** will attempt to compile the supplied statement against whatever subset
 365     ** of the schema was loaded before the error occurred. The primary
 366     ** purpose of this is to allow access to the sqlite_master table
 367     ** even when its contents have been corrupted.
 368     */
 369     DbSetProperty(db, iDb, DB_SchemaLoaded);
 370     rc = SQLITE_OK;
 371   }
 372
 373   /* Jump here for an error that occurs after successfully allocating
 374   ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
 375   ** before that point, jump to error_out.
 376   */
 377 initone_error_out:
 378   if( openedTransaction ){
 379     sqlite3BtreeCommit(pDb->pBt);
 380   }
 381   sqlite3BtreeLeave(pDb->pBt);
 382
 383 error_out:
 384   if( rc ){
 385     if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
 386       sqlite3OomFault(db);
 387     }
 388     sqlite3ResetOneSchema(db, iDb);
 389   }
 390   db->init.busy = 0;
 391   return rc;
 392 }
 393
 394 /*
 395 ** Initialize all database files - the main database file, the file
 396 ** used to store temporary tables, and any additional database files
 397 ** created using ATTACH statements.  Return a success code.  If an
 398 ** error occurs, write an error message into *pzErrMsg.
 399 **
 400 ** After a database is initialized, the DB_SchemaLoaded bit is set
 401 ** bit is set in the flags field of the Db structure.
 402 */
 403 int sqlite3Init(sqlite3 *db, char **pzErrMsg){
 404   int i, rc;
 405   int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange);
 406
 407   assert( sqlite3_mutex_held(db->mutex) );
 408   assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
 409   assert( db->init.busy==0 );
 410   ENC(db) = SCHEMA_ENC(db);
 411   assert( db->nDb>0 );
 412   /* Do the main schema first */
 413   if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){
 414     rc = sqlite3InitOne(db, 0, pzErrMsg, 0);
 415     if( rc ) return rc;
 416   }
 417   /* All other schemas after the main schema. The "temp" schema must be last */
 418   for(i=db->nDb-1; i>0; i--){
 419     assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
 420     if( !DbHasProperty(db, i, DB_SchemaLoaded) ){
 421       rc = sqlite3InitOne(db, i, pzErrMsg, 0);
 422       if( rc ) return rc;
 423     }
 424   }
 425   if( commit_internal ){
 426     sqlite3CommitInternalChanges(db);
 427   }
 428   return SQLITE_OK;
 429 }
 430
 431 /*
 432 ** This routine is a no-op if the database schema is already initialized.
 433 ** Otherwise, the schema is loaded. An error code is returned.
 434 */
 435 int sqlite3ReadSchema(Parse *pParse){
 436   int rc = SQLITE_OK;
 437   sqlite3 *db = pParse->db;
 438   assert( sqlite3_mutex_held(db->mutex) );
 439   if( !db->init.busy ){
 440     rc = sqlite3Init(db, &pParse->zErrMsg);
 441     if( rc!=SQLITE_OK ){
 442       pParse->rc = rc;
 443       pParse->nErr++;
 444     }else if( db->noSharedCache ){
 445       db->mDbFlags |= DBFLAG_SchemaKnownOk;
 446     }
 447   }
 448   return rc;
 449 }
 450
 451
 452 /*
 453 ** Check schema cookies in all databases.  If any cookie is out
 454 ** of date set pParse->rc to SQLITE_SCHEMA.  If all schema cookies
 455 ** make no changes to pParse->rc.
 456 */
 457 static void schemaIsValid(Parse *pParse){
 458   sqlite3 *db = pParse->db;
 459   int iDb;
 460   int rc;
 461   int cookie;
 462
 463   assert( pParse->checkSchema );
 464   assert( sqlite3_mutex_held(db->mutex) );
 465   for(iDb=0; iDb<db->nDb; iDb++){
 466     int openedTransaction = 0;         /* True if a transaction is opened */
 467     Btree *pBt = db->aDb[iDb].pBt;     /* Btree database to read cookie from */
 468     if( pBt==0 ) continue;
 469
 470     /* If there is not already a read-only (or read-write) transaction opened
 471     ** on the b-tree database, open one now. If a transaction is opened, it
 472     ** will be closed immediately after reading the meta-value. */
 473     if( !sqlite3BtreeIsInReadTrans(pBt) ){
 474       rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
 475       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
 476         sqlite3OomFault(db);
 477       }
 478       if( rc!=SQLITE_OK ) return;
 479       openedTransaction = 1;
 480     }
 481
 482     /* Read the schema cookie from the database. If it does not match the
 483     ** value stored as part of the in-memory schema representation,
 484     ** set Parse.rc to SQLITE_SCHEMA. */
 485     sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
 486     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
 487     if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
 488       sqlite3ResetOneSchema(db, iDb);
 489       pParse->rc = SQLITE_SCHEMA;
 490     }
 491
 492     /* Close the transaction, if one was opened. */
 493     if( openedTransaction ){
 494       sqlite3BtreeCommit(pBt);
 495     }
 496   }
 497 }
 498
 499 /*
 500 ** Convert a schema pointer into the iDb index that indicates
 501 ** which database file in db->aDb[] the schema refers to.
 502 **
 503 ** If the same database is attached more than once, the first
 504 ** attached database is returned.
 505 */
 506 int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
 507   int i = -1000000;
 508
 509   /* If pSchema is NULL, then return -1000000. This happens when code in
 510   ** expr.c is trying to resolve a reference to a transient table (i.e. one
 511   ** created by a sub-select). In this case the return value of this
 512   ** function should never be used.
 513   **
 514   ** We return -1000000 instead of the more usual -1 simply because using
 515   ** -1000000 as the incorrect index into db->aDb[] is much
 516   ** more likely to cause a segfault than -1 (of course there are assert()
 517   ** statements too, but it never hurts to play the odds).
 518   */
 519   assert( sqlite3_mutex_held(db->mutex) );
 520   if( pSchema ){
 521     for(i=0; 1; i++){
 522       assert( i<db->nDb );
 523       if( db->aDb[i].pSchema==pSchema ){
 524         break;
 525       }
 526     }
 527     assert( i>=0 && i<db->nDb );
 528   }
 529   return i;
 530 }
 531
 532 /*
 533 ** Free all memory allocations in the pParse object
 534 */
 535 void sqlite3ParserReset(Parse *pParse){
 536   sqlite3 *db = pParse->db;
 537   sqlite3DbFree(db, pParse->aLabel);
 538   sqlite3ExprListDelete(db, pParse->pConstExpr);
 539   if( db ){
 540     assert( db->lookaside.bDisable >= pParse->disableLookaside );
 541     db->lookaside.bDisable -= pParse->disableLookaside;
 542     db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue;
 543   }
 544   pParse->disableLookaside = 0;
 545 }
 546
 547 /*
 548 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
 549 */
 550 static int sqlite3Prepare(
 551   sqlite3 *db,              /* Database handle. */
 552   const char *zSql,         /* UTF-8 encoded SQL statement. */
 553   int nBytes,               /* Length of zSql in bytes. */
 554   u32 prepFlags,            /* Zero or more SQLITE_PREPARE_* flags */
 555   Vdbe *pReprepare,         /* VM being reprepared */
 556   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 557   const char **pzTail       /* OUT: End of parsed string */
 558 ){
 559   char *zErrMsg = 0;        /* Error message */
 560   int rc = SQLITE_OK;       /* Result code */
 561   int i;                    /* Loop counter */
 562   Parse sParse;             /* Parsing context */
 563
 564   memset(&sParse, 0, PARSE_HDR_SZ);
 565   memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ);
 566   sParse.pReprepare = pReprepare;
 567   assert( ppStmt && *ppStmt==0 );
 568   /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
 569   assert( sqlite3_mutex_held(db->mutex) );
 570
 571   /* For a long-term use prepared statement avoid the use of
 572   ** lookaside memory.
 573   */
 574   if( prepFlags & SQLITE_PREPARE_PERSISTENT ){
 575     sParse.disableLookaside++;
 576     DisableLookaside;
 577   }
 578   sParse.disableVtab = (prepFlags & SQLITE_PREPARE_NO_VTAB)!=0;
 579
 580   /* Check to verify that it is possible to get a read lock on all
 581   ** database schemas.  The inability to get a read lock indicates that
 582   ** some other database connection is holding a write-lock, which in
 583   ** turn means that the other connection has made uncommitted changes
 584   ** to the schema.
 585   **
 586   ** Were we to proceed and prepare the statement against the uncommitted
 587   ** schema changes and if those schema changes are subsequently rolled
 588   ** back and different changes are made in their place, then when this
 589   ** prepared statement goes to run the schema cookie would fail to detect
 590   ** the schema change.  Disaster would follow.
 591   **
 592   ** This thread is currently holding mutexes on all Btrees (because
 593   ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
 594   ** is not possible for another thread to start a new schema change
 595   ** while this routine is running.  Hence, we do not need to hold
 596   ** locks on the schema, we just need to make sure nobody else is
 597   ** holding them.
 598   **
 599   ** Note that setting READ_UNCOMMITTED overrides most lock detection,
 600   ** but it does *not* override schema lock detection, so this all still
 601   ** works even if READ_UNCOMMITTED is set.
 602   */
 603   if( !db->noSharedCache ){
 604     for(i=0; i<db->nDb; i++) {
 605       Btree *pBt = db->aDb[i].pBt;
 606       if( pBt ){
 607         assert( sqlite3BtreeHoldsMutex(pBt) );
 608         rc = sqlite3BtreeSchemaLocked(pBt);
 609         if( rc ){
 610           const char *zDb = db->aDb[i].zDbSName;
 611           sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb);
 612           testcase( db->flags & SQLITE_ReadUncommit );
 613           goto end_prepare;
 614         }
 615       }
 616     }
 617   }
 618
 619   sqlite3VtabUnlockList(db);
 620
 621   sParse.db = db;
 622   if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
 623     char *zSqlCopy;
 624     int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
 625     testcase( nBytes==mxLen );
 626     testcase( nBytes==mxLen+1 );
 627     if( nBytes>mxLen ){
 628       sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long");
 629       rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
 630       goto end_prepare;
 631     }
 632     zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
 633     if( zSqlCopy ){
 634       sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
 635       sParse.zTail = &zSql[sParse.zTail-zSqlCopy];
 636       sqlite3DbFree(db, zSqlCopy);
 637     }else{
 638       sParse.zTail = &zSql[nBytes];
 639     }
 640   }else{
 641     sqlite3RunParser(&sParse, zSql, &zErrMsg);
 642   }
 643   assert( 0==sParse.nQueryLoop );
 644
 645   if( sParse.rc==SQLITE_DONE ){
 646     sParse.rc = SQLITE_OK;
 647   }
 648   if( sParse.checkSchema ){
 649     schemaIsValid(&sParse);
 650   }
 651   if( pzTail ){
 652     *pzTail = sParse.zTail;
 653   }
 654
 655   if( db->init.busy==0 ){
 656     sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags);
 657   }
 658   if( db->mallocFailed ){
 659     sParse.rc = SQLITE_NOMEM_BKPT;
 660   }
 661   rc = sParse.rc;
 662   if( rc!=SQLITE_OK ){
 663     if( sParse.pVdbe ) sqlite3VdbeFinalize(sParse.pVdbe);
 664     assert(!(*ppStmt));
 665   }else{
 666     *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
 667   }
 668
 669   if( zErrMsg ){
 670     sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg);
 671     sqlite3DbFree(db, zErrMsg);
 672   }else{
 673     sqlite3Error(db, rc);
 674   }
 675
 676   /* Delete any TriggerPrg structures allocated while parsing this statement. */
 677   while( sParse.pTriggerPrg ){
 678     TriggerPrg *pT = sParse.pTriggerPrg;
 679     sParse.pTriggerPrg = pT->pNext;
 680     sqlite3DbFree(db, pT);
 681   }
 682
 683 end_prepare:
 684
 685   sqlite3ParserReset(&sParse);
 686   return rc;
 687 }
 688 static int sqlite3LockAndPrepare(
 689   sqlite3 *db,              /* Database handle. */
 690   const char *zSql,         /* UTF-8 encoded SQL statement. */
 691   int nBytes,               /* Length of zSql in bytes. */
 692   u32 prepFlags,            /* Zero or more SQLITE_PREPARE_* flags */
 693   Vdbe *pOld,               /* VM being reprepared */
 694   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 695   const char **pzTail       /* OUT: End of parsed string */
 696 ){
 697   int rc;
 698   int cnt = 0;
 699
 700 #ifdef SQLITE_ENABLE_API_ARMOR
 701   if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
 702 #endif
 703   *ppStmt = 0;
 704   if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
 705     return SQLITE_MISUSE_BKPT;
 706   }
 707   sqlite3_mutex_enter(db->mutex);
 708   sqlite3BtreeEnterAll(db);
 709   do{
 710     /* Make multiple attempts to compile the SQL, until it either succeeds
 711     ** or encounters a permanent error.  A schema problem after one schema
 712     ** reset is considered a permanent error. */
 713     rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail);
 714     assert( rc==SQLITE_OK || *ppStmt==0 );
 715   }while( rc==SQLITE_ERROR_RETRY
 716        || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) );
 717   sqlite3BtreeLeaveAll(db);
 718   rc = sqlite3ApiExit(db, rc);
 719   assert( (rc&db->errMask)==rc );
 720   sqlite3_mutex_leave(db->mutex);
 721   return rc;
 722 }
 723
 724
 725 /*
 726 ** Rerun the compilation of a statement after a schema change.
 727 **
 728 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
 729 ** if the statement cannot be recompiled because another connection has
 730 ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error
 731 ** occurs, return SQLITE_SCHEMA.
 732 */
 733 int sqlite3Reprepare(Vdbe *p){
 734   int rc;
 735   sqlite3_stmt *pNew;
 736   const char *zSql;
 737   sqlite3 *db;
 738   u8 prepFlags;
 739
 740   assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
 741   zSql = sqlite3_sql((sqlite3_stmt *)p);
 742   assert( zSql!=0 );  /* Reprepare only called for prepare_v2() statements */
 743   db = sqlite3VdbeDb(p);
 744   assert( sqlite3_mutex_held(db->mutex) );
 745   prepFlags = sqlite3VdbePrepareFlags(p);
 746   rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0);
 747   if( rc ){
 748     if( rc==SQLITE_NOMEM ){
 749       sqlite3OomFault(db);
 750     }
 751     assert( pNew==0 );
 752     return rc;
 753   }else{
 754     assert( pNew!=0 );
 755   }
 756   sqlite3VdbeSwap((Vdbe*)pNew, p);
 757   sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
 758   sqlite3VdbeResetStepResult((Vdbe*)pNew);
 759   sqlite3VdbeFinalize((Vdbe*)pNew);
 760   return SQLITE_OK;
 761 }
 762
 763
 764 /*
 765 ** Two versions of the official API.  Legacy and new use.  In the legacy
 766 ** version, the original SQL text is not saved in the prepared statement
 767 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
 768 ** sqlite3_step().  In the new version, the original SQL text is retained
 769 ** and the statement is automatically recompiled if an schema change
 770 ** occurs.
 771 */
 772 int sqlite3_prepare(
 773   sqlite3 *db,              /* Database handle. */
 774   const char *zSql,         /* UTF-8 encoded SQL statement. */
 775   int nBytes,               /* Length of zSql in bytes. */
 776   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 777   const char **pzTail       /* OUT: End of parsed string */
 778 ){
 779   int rc;
 780   rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
 781   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
 782   return rc;
 783 }
 784 int sqlite3_prepare_v2(
 785   sqlite3 *db,              /* Database handle. */
 786   const char *zSql,         /* UTF-8 encoded SQL statement. */
 787   int nBytes,               /* Length of zSql in bytes. */
 788   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 789   const char **pzTail       /* OUT: End of parsed string */
 790 ){
 791   int rc;
 792   /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works
 793   ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags
 794   ** parameter.
 795   **
 796   ** Proof in that the 5th parameter to sqlite3LockAndPrepare is 0 */
 797   rc = sqlite3LockAndPrepare(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,0,
 798                              ppStmt,pzTail);
 799   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
 800   return rc;
 801 }
 802 int sqlite3_prepare_v3(
 803   sqlite3 *db,              /* Database handle. */
 804   const char *zSql,         /* UTF-8 encoded SQL statement. */
 805   int nBytes,               /* Length of zSql in bytes. */
 806   unsigned int prepFlags,   /* Zero or more SQLITE_PREPARE_* flags */
 807   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 808   const char **pzTail       /* OUT: End of parsed string */
 809 ){
 810   int rc;
 811   /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from
 812   ** sqlite3_prepare_v2() only in having the extra prepFlags parameter,
 813   ** which is a bit array consisting of zero or more of the
 814   ** SQLITE_PREPARE_* flags.
 815   **
 816   ** Proof by comparison to the implementation of sqlite3_prepare_v2()
 817   ** directly above. */
 818   rc = sqlite3LockAndPrepare(db,zSql,nBytes,
 819                  SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK),
 820                  0,ppStmt,pzTail);
 821   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
 822   return rc;
 823 }
 824
 825
 826 #ifndef SQLITE_OMIT_UTF16
 827 /*
 828 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
 829 */
 830 static int sqlite3Prepare16(
 831   sqlite3 *db,              /* Database handle. */
 832   const void *zSql,         /* UTF-16 encoded SQL statement. */
 833   int nBytes,               /* Length of zSql in bytes. */
 834   u32 prepFlags,            /* Zero or more SQLITE_PREPARE_* flags */
 835   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 836   const void **pzTail       /* OUT: End of parsed string */
 837 ){
 838   /* This function currently works by first transforming the UTF-16
 839   ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
 840   ** tricky bit is figuring out the pointer to return in *pzTail.
 841   */
 842   char *zSql8;
 843   const char *zTail8 = 0;
 844   int rc = SQLITE_OK;
 845
 846 #ifdef SQLITE_ENABLE_API_ARMOR
 847   if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
 848 #endif
 849   *ppStmt = 0;
 850   if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
 851     return SQLITE_MISUSE_BKPT;
 852   }
 853   if( nBytes>=0 ){
 854     int sz;
 855     const char *z = (const char*)zSql;
 856     for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){}
 857     nBytes = sz;
 858   }
 859   sqlite3_mutex_enter(db->mutex);
 860   zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
 861   if( zSql8 ){
 862     rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8);
 863   }
 864
 865   if( zTail8 && pzTail ){
 866     /* If sqlite3_prepare returns a tail pointer, we calculate the
 867     ** equivalent pointer into the UTF-16 string by counting the unicode
 868     ** characters between zSql8 and zTail8, and then returning a pointer
 869     ** the same number of characters into the UTF-16 string.
 870     */
 871     int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
 872     *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
 873   }
 874   sqlite3DbFree(db, zSql8);
 875   rc = sqlite3ApiExit(db, rc);
 876   sqlite3_mutex_leave(db->mutex);
 877   return rc;
 878 }
 879
 880 /*
 881 ** Two versions of the official API.  Legacy and new use.  In the legacy
 882 ** version, the original SQL text is not saved in the prepared statement
 883 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
 884 ** sqlite3_step().  In the new version, the original SQL text is retained
 885 ** and the statement is automatically recompiled if an schema change
 886 ** occurs.
 887 */
 888 int sqlite3_prepare16(
 889   sqlite3 *db,              /* Database handle. */
 890   const void *zSql,         /* UTF-16 encoded SQL statement. */
 891   int nBytes,               /* Length of zSql in bytes. */
 892   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 893   const void **pzTail       /* OUT: End of parsed string */
 894 ){
 895   int rc;
 896   rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
 897   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
 898   return rc;
 899 }
 900 int sqlite3_prepare16_v2(
 901   sqlite3 *db,              /* Database handle. */
 902   const void *zSql,         /* UTF-16 encoded SQL statement. */
 903   int nBytes,               /* Length of zSql in bytes. */
 904   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 905   const void **pzTail       /* OUT: End of parsed string */
 906 ){
 907   int rc;
 908   rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail);
 909   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
 910   return rc;
 911 }
 912 int sqlite3_prepare16_v3(
 913   sqlite3 *db,              /* Database handle. */
 914   const void *zSql,         /* UTF-16 encoded SQL statement. */
 915   int nBytes,               /* Length of zSql in bytes. */
 916   unsigned int prepFlags,   /* Zero or more SQLITE_PREPARE_* flags */
 917   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
 918   const void **pzTail       /* OUT: End of parsed string */
 919 ){
 920   int rc;
 921   rc = sqlite3Prepare16(db,zSql,nBytes,
 922          SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK),
 923          ppStmt,pzTail);
 924   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */
 925   return rc;
 926 }
 927
 928 #endif /* SQLITE_OMIT_UTF16 */