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