engine/sqlite/src/prepare.cpp
changeset 2 29cda98b007e
equal deleted inserted replaced
1:5f8e5adbbed9 2:29cda98b007e
       
     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 ** $Id: prepare.cpp 1282 2008-11-13 09:31:33Z LarsPson $
       
    17 */
       
    18 #include "sqliteInt.h"
       
    19 #include <ctype.h>
       
    20 
       
    21 /*
       
    22 ** Fill the InitData structure with an error message that indicates
       
    23 ** that the database is corrupt.
       
    24 */
       
    25 static void corruptSchema(InitData *pData, const char *zExtra){
       
    26   if( !pData->db->mallocFailed ){
       
    27     sqlite3SetString(pData->pzErrMsg, "malformed database schema",
       
    28        zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0);
       
    29   }
       
    30   pData->rc = SQLITE_CORRUPT;
       
    31 }
       
    32 
       
    33 /*
       
    34 ** This is the callback routine for the code that initializes the
       
    35 ** database.  See sqlite3Init() below for additional information.
       
    36 ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
       
    37 **
       
    38 ** Each callback contains the following information:
       
    39 **
       
    40 **     argv[0] = name of thing being created
       
    41 **     argv[1] = root page number for table or index. 0 for trigger or view.
       
    42 **     argv[2] = SQL text for the CREATE statement.
       
    43 **
       
    44 */
       
    45 int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){
       
    46   InitData *pData = (InitData*)pInit;
       
    47   sqlite3 *db = pData->db;
       
    48   int iDb = pData->iDb;
       
    49 
       
    50   assert( sqlite3_mutex_held(db->mutex) );
       
    51   pData->rc = SQLITE_OK;
       
    52   DbClearProperty(db, iDb, DB_Empty);
       
    53   if( db->mallocFailed ){
       
    54     corruptSchema(pData, 0);
       
    55     return SQLITE_NOMEM;
       
    56   }
       
    57 
       
    58   assert( argc==3 );
       
    59   if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */
       
    60   if( argv[1]==0 ){
       
    61     corruptSchema(pData, 0);
       
    62     return 1;
       
    63   }
       
    64   assert( iDb>=0 && iDb<db->nDb );
       
    65   if( argv[2] && argv[2][0] ){
       
    66     /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
       
    67     ** But because db->init.busy is set to 1, no VDBE code is generated
       
    68     ** or executed.  All the parser does is build the internal data
       
    69     ** structures that describe the table, index, or view.
       
    70     */
       
    71     char *zErr;
       
    72     int rc;
       
    73     assert( db->init.busy );
       
    74     db->init.iDb = iDb;
       
    75     db->init.newTnum = atoi(argv[1]);
       
    76     rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
       
    77     db->init.iDb = 0;
       
    78     assert( rc!=SQLITE_OK || zErr==0 );
       
    79     if( SQLITE_OK!=rc ){
       
    80       pData->rc = rc;
       
    81       if( rc==SQLITE_NOMEM ){
       
    82         db->mallocFailed = 1;
       
    83       }else if( rc!=SQLITE_INTERRUPT ){
       
    84         corruptSchema(pData, zErr);
       
    85       }
       
    86       sqlite3_free(zErr);
       
    87       return 1;
       
    88     }
       
    89   }else{
       
    90     /* If the SQL column is blank it means this is an index that
       
    91     ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
       
    92     ** constraint for a CREATE TABLE.  The index should have already
       
    93     ** been created when we processed the CREATE TABLE.  All we have
       
    94     ** to do here is record the root page number for that index.
       
    95     */
       
    96     Index *pIndex;
       
    97     pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
       
    98     if( pIndex==0 || pIndex->tnum!=0 ){
       
    99       /* This can occur if there exists an index on a TEMP table which
       
   100       ** has the same name as another index on a permanent index.  Since
       
   101       ** the permanent table is hidden by the TEMP table, we can also
       
   102       ** safely ignore the index on the permanent table.
       
   103       */
       
   104       /* Do Nothing */;
       
   105     }else{
       
   106       pIndex->tnum = atoi(argv[1]);
       
   107     }
       
   108   }
       
   109   return 0;
       
   110 }
       
   111 
       
   112 /*
       
   113 ** Attempt to read the database schema and initialize internal
       
   114 ** data structures for a single database file.  The index of the
       
   115 ** database file is given by iDb.  iDb==0 is used for the main
       
   116 ** database.  iDb==1 should never be used.  iDb>=2 is used for
       
   117 ** auxiliary databases.  Return one of the SQLITE_ error codes to
       
   118 ** indicate success or failure.
       
   119 */
       
   120 static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
       
   121   int rc;
       
   122   BtCursor *curMain;
       
   123   int size;
       
   124   Table *pTab;
       
   125   Db *pDb;
       
   126   char const *azArg[4];
       
   127   int meta[10];
       
   128   InitData initData;
       
   129   char const *zMasterSchema;
       
   130   char const *zMasterName = SCHEMA_TABLE(iDb);
       
   131 
       
   132   /*
       
   133   ** The master database table has a structure like this
       
   134   */
       
   135   static const char master_schema[] = 
       
   136      "CREATE TABLE sqlite_master(\n"
       
   137      "  type text,\n"
       
   138      "  name text,\n"
       
   139      "  tbl_name text,\n"
       
   140      "  rootpage integer,\n"
       
   141      "  sql text\n"
       
   142      ")"
       
   143   ;
       
   144 #ifndef SQLITE_OMIT_TEMPDB
       
   145   static const char temp_master_schema[] = 
       
   146      "CREATE TEMP TABLE sqlite_temp_master(\n"
       
   147      "  type text,\n"
       
   148      "  name text,\n"
       
   149      "  tbl_name text,\n"
       
   150      "  rootpage integer,\n"
       
   151      "  sql text\n"
       
   152      ")"
       
   153   ;
       
   154 #else
       
   155   #define temp_master_schema 0
       
   156 #endif
       
   157 
       
   158   assert( iDb>=0 && iDb<db->nDb );
       
   159   assert( db->aDb[iDb].pSchema );
       
   160   assert( sqlite3_mutex_held(db->mutex) );
       
   161 
       
   162   /* zMasterSchema and zInitScript are set to point at the master schema
       
   163   ** and initialisation script appropriate for the database being
       
   164   ** initialised. zMasterName is the name of the master table.
       
   165   */
       
   166   if( !OMIT_TEMPDB && iDb==1 ){
       
   167     zMasterSchema = temp_master_schema;
       
   168   }else{
       
   169     zMasterSchema = master_schema;
       
   170   }
       
   171   zMasterName = SCHEMA_TABLE(iDb);
       
   172 
       
   173   /* Construct the schema tables.  */
       
   174   sqlite3SafetyOff(db);
       
   175   azArg[0] = zMasterName;
       
   176   azArg[1] = "1";
       
   177   azArg[2] = zMasterSchema;
       
   178   azArg[3] = 0;
       
   179   initData.db = db;
       
   180   initData.iDb = iDb;
       
   181   initData.pzErrMsg = pzErrMsg;
       
   182   rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
       
   183   if( rc ){
       
   184     sqlite3SafetyOn(db);
       
   185     rc = initData.rc;
       
   186     goto error_out;
       
   187   }
       
   188   pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
       
   189   if( pTab ){
       
   190     pTab->readOnly = 1;
       
   191   }
       
   192   sqlite3SafetyOn(db);
       
   193 
       
   194   /* Create a cursor to hold the database open
       
   195   */
       
   196   pDb = &db->aDb[iDb];
       
   197   if( pDb->pBt==0 ){
       
   198     if( !OMIT_TEMPDB && iDb==1 ){
       
   199       DbSetProperty(db, 1, DB_SchemaLoaded);
       
   200     }
       
   201     return SQLITE_OK;
       
   202   }
       
   203   sqlite3BtreeEnter(pDb->pBt);
       
   204   rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain);
       
   205   if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){
       
   206     sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
       
   207     sqlite3BtreeLeave(pDb->pBt);
       
   208     goto error_out;
       
   209   }
       
   210 
       
   211   /* Get the database meta information.
       
   212   **
       
   213   ** Meta values are as follows:
       
   214   **    meta[0]   Schema cookie.  Changes with each schema change.
       
   215   **    meta[1]   File format of schema layer.
       
   216   **    meta[2]   Size of the page cache.
       
   217   **    meta[3]   Use freelist if 0.  Autovacuum if greater than zero.
       
   218   **    meta[4]   Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
       
   219   **    meta[5]   The user cookie. Used by the application.
       
   220   **    meta[6]   Incremental-vacuum flag.
       
   221   **    meta[7]
       
   222   **    meta[8]
       
   223   **    meta[9]
       
   224   **
       
   225   ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
       
   226   ** the possible values of meta[4].
       
   227   */
       
   228   if( rc==SQLITE_OK ){
       
   229     int i;
       
   230     for(i=0; rc==SQLITE_OK && i<sizeof(meta)/sizeof(meta[0]); i++){
       
   231       rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
       
   232     }
       
   233     if( rc ){
       
   234       sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
       
   235       sqlite3BtreeCloseCursor(curMain);
       
   236       sqlite3BtreeLeave(pDb->pBt);
       
   237       goto error_out;
       
   238     }
       
   239   }else{
       
   240     memset(meta, 0, sizeof(meta));
       
   241   }
       
   242   pDb->pSchema->schema_cookie = meta[0];
       
   243 
       
   244   /* If opening a non-empty database, check the text encoding. For the
       
   245   ** main database, set sqlite3.enc to the encoding of the main database.
       
   246   ** For an attached db, it is an error if the encoding is not the same
       
   247   ** as sqlite3.enc.
       
   248   */
       
   249   if( meta[4] ){  /* text encoding */
       
   250     if( iDb==0 ){
       
   251       /* If opening the main database, set ENC(db). */
       
   252       ENC(db) = (u8)meta[4];
       
   253       db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
       
   254     }else{
       
   255       /* If opening an attached database, the encoding much match ENC(db) */
       
   256       if( meta[4]!=ENC(db) ){
       
   257         sqlite3BtreeCloseCursor(curMain);
       
   258         sqlite3SetString(pzErrMsg, "attached databases must use the same"
       
   259             " text encoding as main database", (char*)0);
       
   260         sqlite3BtreeLeave(pDb->pBt);
       
   261         return SQLITE_ERROR;
       
   262       }
       
   263     }
       
   264   }else{
       
   265     DbSetProperty(db, iDb, DB_Empty);
       
   266   }
       
   267   pDb->pSchema->enc = ENC(db);
       
   268 
       
   269   size = meta[2];
       
   270   if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
       
   271   pDb->pSchema->cache_size = size;
       
   272   sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
       
   273 
       
   274   /*
       
   275   ** file_format==1    Version 3.0.0.
       
   276   ** file_format==2    Version 3.1.3.  // ALTER TABLE ADD COLUMN
       
   277   ** file_format==3    Version 3.1.4.  // ditto but with non-NULL defaults
       
   278   ** file_format==4    Version 3.3.0.  // DESC indices.  Boolean constants
       
   279   */
       
   280   pDb->pSchema->file_format = meta[1];
       
   281   if( pDb->pSchema->file_format==0 ){
       
   282     pDb->pSchema->file_format = 1;
       
   283   }
       
   284   if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
       
   285     sqlite3BtreeCloseCursor(curMain);
       
   286     sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);
       
   287     sqlite3BtreeLeave(pDb->pBt);
       
   288     return SQLITE_ERROR;
       
   289   }
       
   290 
       
   291   /* Ticket #2804:  When we open a database in the newer file format,
       
   292   ** clear the legacy_file_format pragma flag so that a VACUUM will
       
   293   ** not downgrade the database and thus invalidate any descending
       
   294   ** indices that the user might have created.
       
   295   */
       
   296   if( iDb==0 && meta[1]>=4 ){
       
   297     db->flags &= ~SQLITE_LegacyFileFmt;
       
   298   }
       
   299 
       
   300   /* Read the schema information out of the schema tables
       
   301   */
       
   302   assert( db->init.busy );
       
   303   if( rc==SQLITE_EMPTY ){
       
   304     /* For an empty database, there is nothing to read */
       
   305     rc = SQLITE_OK;
       
   306   }else{
       
   307     char *zSql;
       
   308     zSql = sqlite3MPrintf(db, 
       
   309         "SELECT name, rootpage, sql FROM '%q'.%s",
       
   310         db->aDb[iDb].zName, zMasterName);
       
   311     sqlite3SafetyOff(db);
       
   312 #ifndef SQLITE_OMIT_AUTHORIZATION
       
   313     {
       
   314       int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
       
   315       xAuth = db->xAuth;
       
   316       db->xAuth = 0;
       
   317 #endif
       
   318       rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
       
   319 #ifndef SQLITE_OMIT_AUTHORIZATION
       
   320       db->xAuth = xAuth;
       
   321     }
       
   322 #endif
       
   323     if( rc==SQLITE_ABORT ) rc = initData.rc;
       
   324     sqlite3SafetyOn(db);
       
   325     sqlite3_free(zSql);
       
   326 #ifndef SQLITE_OMIT_ANALYZE
       
   327     if( rc==SQLITE_OK ){
       
   328       sqlite3AnalysisLoad(db, iDb);
       
   329     }
       
   330 #endif
       
   331     sqlite3BtreeCloseCursor(curMain);
       
   332   }
       
   333   if( db->mallocFailed ){
       
   334     /* sqlite3SetString(pzErrMsg, "out of memory", (char*)0); */
       
   335     rc = SQLITE_NOMEM;
       
   336     sqlite3ResetInternalSchema(db, 0);
       
   337   }
       
   338   if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
       
   339     /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
       
   340     ** the schema loaded, even if errors occured. In this situation the 
       
   341     ** current sqlite3_prepare() operation will fail, but the following one
       
   342     ** will attempt to compile the supplied statement against whatever subset
       
   343     ** of the schema was loaded before the error occured. The primary
       
   344     ** purpose of this is to allow access to the sqlite_master table
       
   345     ** even when its contents have been corrupted.
       
   346     */
       
   347     DbSetProperty(db, iDb, DB_SchemaLoaded);
       
   348     rc = SQLITE_OK;
       
   349   }
       
   350   sqlite3BtreeLeave(pDb->pBt);
       
   351 
       
   352 error_out:
       
   353   if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
       
   354     db->mallocFailed = 1;
       
   355   }
       
   356   return rc;
       
   357 }
       
   358 
       
   359 /*
       
   360 ** Initialize all database files - the main database file, the file
       
   361 ** used to store temporary tables, and any additional database files
       
   362 ** created using ATTACH statements.  Return a success code.  If an
       
   363 ** error occurs, write an error message into *pzErrMsg.
       
   364 **
       
   365 ** After a database is initialized, the DB_SchemaLoaded bit is set
       
   366 ** bit is set in the flags field of the Db structure. If the database
       
   367 ** file was of zero-length, then the DB_Empty flag is also set.
       
   368 */
       
   369 int sqlite3Init(sqlite3 *db, char **pzErrMsg){
       
   370   int i, rc;
       
   371   int commit_internal = !(db->flags&SQLITE_InternChanges);
       
   372   
       
   373   assert( sqlite3_mutex_held(db->mutex) );
       
   374   if( db->init.busy ) return SQLITE_OK;
       
   375   rc = SQLITE_OK;
       
   376   db->init.busy = 1;
       
   377   for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
       
   378     if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
       
   379     rc = sqlite3InitOne(db, i, pzErrMsg);
       
   380     if( rc ){
       
   381       sqlite3ResetInternalSchema(db, i);
       
   382     }
       
   383   }
       
   384 
       
   385   /* Once all the other databases have been initialised, load the schema
       
   386   ** for the TEMP database. This is loaded last, as the TEMP database
       
   387   ** schema may contain references to objects in other databases.
       
   388   */
       
   389 #ifndef SQLITE_OMIT_TEMPDB
       
   390   if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
       
   391     rc = sqlite3InitOne(db, 1, pzErrMsg);
       
   392     if( rc ){
       
   393       sqlite3ResetInternalSchema(db, 1);
       
   394     }
       
   395   }
       
   396 #endif
       
   397 
       
   398   db->init.busy = 0;
       
   399   if( rc==SQLITE_OK && commit_internal ){
       
   400     sqlite3CommitInternalChanges(db);
       
   401   }
       
   402 
       
   403   return rc; 
       
   404 }
       
   405 
       
   406 /*
       
   407 ** This routine is a no-op if the database schema is already initialised.
       
   408 ** Otherwise, the schema is loaded. An error code is returned.
       
   409 */
       
   410 int sqlite3ReadSchema(Parse *pParse){
       
   411   int rc = SQLITE_OK;
       
   412   sqlite3 *db = pParse->db;
       
   413   assert( sqlite3_mutex_held(db->mutex) );
       
   414   if( !db->init.busy ){
       
   415     rc = sqlite3Init(db, &pParse->zErrMsg);
       
   416   }
       
   417   if( rc!=SQLITE_OK ){
       
   418     pParse->rc = rc;
       
   419     pParse->nErr++;
       
   420   }
       
   421   return rc;
       
   422 }
       
   423 
       
   424 
       
   425 /*
       
   426 ** Check schema cookies in all databases.  If any cookie is out
       
   427 ** of date, return 0.  If all schema cookies are current, return 1.
       
   428 */
       
   429 static int schemaIsValid(sqlite3 *db){
       
   430   int iDb;
       
   431   int rc;
       
   432   BtCursor *curTemp;
       
   433   int cookie;
       
   434   int allOk = 1;
       
   435 
       
   436   assert( sqlite3_mutex_held(db->mutex) );
       
   437   for(iDb=0; allOk && iDb<db->nDb; iDb++){
       
   438     Btree *pBt;
       
   439     pBt = db->aDb[iDb].pBt;
       
   440     if( pBt==0 ) continue;
       
   441     rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, 0, &curTemp);
       
   442     if( rc==SQLITE_OK ){
       
   443       rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie);
       
   444       if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){
       
   445         allOk = 0;
       
   446       }
       
   447       sqlite3BtreeCloseCursor(curTemp);
       
   448     }
       
   449     if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
       
   450       db->mallocFailed = 1;
       
   451     }
       
   452   }
       
   453   return allOk;
       
   454 }
       
   455 
       
   456 /*
       
   457 ** Convert a schema pointer into the iDb index that indicates
       
   458 ** which database file in db->aDb[] the schema refers to.
       
   459 **
       
   460 ** If the same database is attached more than once, the first
       
   461 ** attached database is returned.
       
   462 */
       
   463 int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
       
   464   int i = -1000000;
       
   465 
       
   466   /* If pSchema is NULL, then return -1000000. This happens when code in 
       
   467   ** expr.c is trying to resolve a reference to a transient table (i.e. one
       
   468   ** created by a sub-select). In this case the return value of this 
       
   469   ** function should never be used.
       
   470   **
       
   471   ** We return -1000000 instead of the more usual -1 simply because using
       
   472   ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much 
       
   473   ** more likely to cause a segfault than -1 (of course there are assert()
       
   474   ** statements too, but it never hurts to play the odds).
       
   475   */
       
   476   assert( sqlite3_mutex_held(db->mutex) );
       
   477   if( pSchema ){
       
   478     for(i=0; i<db->nDb; i++){
       
   479       if( db->aDb[i].pSchema==pSchema ){
       
   480         break;
       
   481       }
       
   482     }
       
   483     assert( i>=0 &&i>=0 &&  i<db->nDb );
       
   484   }
       
   485   return i;
       
   486 }
       
   487 
       
   488 /*
       
   489 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
       
   490 */
       
   491 int sqlite3Prepare(
       
   492   sqlite3 *db,              /* Database handle. */
       
   493   const char *zSql,         /* UTF-8 encoded SQL statement. */
       
   494   int nBytes,               /* Length of zSql in bytes. */
       
   495   int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */
       
   496   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
       
   497   const char **pzTail       /* OUT: End of parsed string */
       
   498 ){
       
   499   Parse sParse;
       
   500   char *zErrMsg = 0;
       
   501   int rc = SQLITE_OK;
       
   502   int i;
       
   503 
       
   504   assert( ppStmt );
       
   505   *ppStmt = 0;
       
   506   if( sqlite3SafetyOn(db) ){
       
   507     return SQLITE_MISUSE;
       
   508   }
       
   509   assert( !db->mallocFailed );
       
   510   assert( sqlite3_mutex_held(db->mutex) );
       
   511 
       
   512   /* If any attached database schemas are locked, do not proceed with
       
   513   ** compilation. Instead return SQLITE_LOCKED immediately.
       
   514   */
       
   515   for(i=0; i<db->nDb; i++) {
       
   516     Btree *pBt = db->aDb[i].pBt;
       
   517     if( pBt ){
       
   518       int rc;
       
   519       rc = sqlite3BtreeSchemaLocked(pBt);
       
   520       if( rc ){
       
   521         const char *zDb = db->aDb[i].zName;
       
   522         sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);
       
   523         sqlite3SafetyOff(db);
       
   524         return SQLITE_LOCKED;
       
   525       }
       
   526     }
       
   527   }
       
   528   
       
   529   memset(&sParse, 0, sizeof(sParse));
       
   530   sParse.db = db;
       
   531   if( nBytes>=0 && zSql[nBytes]!=0 ){
       
   532     char *zSqlCopy;
       
   533     if( nBytes>SQLITE_MAX_SQL_LENGTH ){
       
   534       return SQLITE_TOOBIG;
       
   535     }
       
   536     zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
       
   537     if( zSqlCopy ){
       
   538       sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
       
   539       sqlite3_free(zSqlCopy);
       
   540     }
       
   541     sParse.zTail = &zSql[nBytes];
       
   542   }else{
       
   543     sqlite3RunParser(&sParse, zSql, &zErrMsg);
       
   544   }
       
   545 
       
   546   if( db->mallocFailed ){
       
   547     sParse.rc = SQLITE_NOMEM;
       
   548   }
       
   549   if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
       
   550   if( sParse.checkSchema && !schemaIsValid(db) ){
       
   551     sParse.rc = SQLITE_SCHEMA;
       
   552   }
       
   553   if( sParse.rc==SQLITE_SCHEMA ){
       
   554     sqlite3ResetInternalSchema(db, 0);
       
   555   }
       
   556   if( db->mallocFailed ){
       
   557     sParse.rc = SQLITE_NOMEM;
       
   558   }
       
   559   if( pzTail ){
       
   560     *pzTail = sParse.zTail;
       
   561   }
       
   562   rc = sParse.rc;
       
   563 
       
   564 #ifndef SQLITE_OMIT_EXPLAIN
       
   565   if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){
       
   566     if( sParse.explain==2 ){
       
   567       sqlite3VdbeSetNumCols(sParse.pVdbe, 3);
       
   568       sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P3_STATIC);
       
   569       sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P3_STATIC);
       
   570       sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P3_STATIC);
       
   571     }else{
       
   572       sqlite3VdbeSetNumCols(sParse.pVdbe, 5);
       
   573       sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P3_STATIC);
       
   574       sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P3_STATIC);
       
   575       sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P3_STATIC);
       
   576       sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P3_STATIC);
       
   577       sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P3_STATIC);
       
   578     }
       
   579   }
       
   580 #endif
       
   581 
       
   582   if( sqlite3SafetyOff(db) ){
       
   583     rc = SQLITE_MISUSE;
       
   584   }
       
   585 
       
   586   if( saveSqlFlag ){
       
   587     sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);
       
   588   }
       
   589   if( rc!=SQLITE_OK || db->mallocFailed ){
       
   590     sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
       
   591     assert(!(*ppStmt));
       
   592   }else{
       
   593     *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
       
   594   }
       
   595 
       
   596   if( zErrMsg ){
       
   597     sqlite3Error(db, rc, "%s", zErrMsg);
       
   598     sqlite3_free(zErrMsg);
       
   599   }else{
       
   600     sqlite3Error(db, rc, 0);
       
   601   }
       
   602 
       
   603   rc = sqlite3ApiExit(db, rc);
       
   604   /* sqlite3ReleaseThreadData(); */
       
   605   assert( (rc&db->errMask)==rc );
       
   606   return rc;
       
   607 }
       
   608 static int sqlite3LockAndPrepare(
       
   609   sqlite3 *db,              /* Database handle. */
       
   610   const char *zSql,         /* UTF-8 encoded SQL statement. */
       
   611   int nBytes,               /* Length of zSql in bytes. */
       
   612   int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */
       
   613   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
       
   614   const char **pzTail       /* OUT: End of parsed string */
       
   615 ){
       
   616   int rc;
       
   617   if( sqlite3SafetyCheck(db) ){
       
   618     return SQLITE_MISUSE;
       
   619   }
       
   620   sqlite3_mutex_enter(db->mutex);
       
   621   sqlite3BtreeEnterAll(db);
       
   622   rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);
       
   623   sqlite3BtreeLeaveAll(db);
       
   624   sqlite3_mutex_leave(db->mutex);
       
   625   return rc;
       
   626 }
       
   627 
       
   628 /*
       
   629 ** Rerun the compilation of a statement after a schema change.
       
   630 ** Return true if the statement was recompiled successfully.
       
   631 ** Return false if there is an error of some kind.
       
   632 */
       
   633 int sqlite3Reprepare(Vdbe *p){
       
   634   int rc;
       
   635   sqlite3_stmt *pNew;
       
   636   const char *zSql;
       
   637   sqlite3 *db;
       
   638 
       
   639   assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
       
   640   zSql = sqlite3_sql((sqlite3_stmt *)p);
       
   641   if( zSql==0 ){
       
   642     return 0;
       
   643   }
       
   644   db = sqlite3VdbeDb(p);
       
   645   assert( sqlite3_mutex_held(db->mutex) );
       
   646   rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0);
       
   647   if( rc ){
       
   648     if( rc==SQLITE_NOMEM ){
       
   649       db->mallocFailed = 1;
       
   650     }
       
   651     assert( pNew==0 );
       
   652     return 0;
       
   653   }else{
       
   654     assert( pNew!=0 );
       
   655   }
       
   656   sqlite3VdbeSwap((Vdbe*)pNew, p);
       
   657   sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p);
       
   658   sqlite3VdbeResetStepResult((Vdbe*)pNew);
       
   659   sqlite3VdbeFinalize((Vdbe*)pNew);
       
   660   return 1;
       
   661 }
       
   662 
       
   663 
       
   664 /*
       
   665 ** Two versions of the official API.  Legacy and new use.  In the legacy
       
   666 ** version, the original SQL text is not saved in the prepared statement
       
   667 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
       
   668 ** sqlite3_step().  In the new version, the original SQL text is retained
       
   669 ** and the statement is automatically recompiled if an schema change
       
   670 ** occurs.
       
   671 */
       
   672 EXPORT_C int sqlite3_prepare(
       
   673   sqlite3 *db,              /* Database handle. */
       
   674   const char *zSql,         /* UTF-8 encoded SQL statement. */
       
   675   int nBytes,               /* Length of zSql in bytes. */
       
   676   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
       
   677   const char **pzTail       /* OUT: End of parsed string */
       
   678 ){
       
   679   return sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail);
       
   680 }
       
   681 EXPORT_C int sqlite3_prepare_v2(
       
   682   sqlite3 *db,              /* Database handle. */
       
   683   const char *zSql,         /* UTF-8 encoded SQL statement. */
       
   684   int nBytes,               /* Length of zSql in bytes. */
       
   685   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
       
   686   const char **pzTail       /* OUT: End of parsed string */
       
   687 ){
       
   688   return sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail);
       
   689 }
       
   690 
       
   691 
       
   692 #ifndef SQLITE_OMIT_UTF16
       
   693 /*
       
   694 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
       
   695 */
       
   696 static int sqlite3Prepare16(
       
   697   sqlite3 *db,              /* Database handle. */ 
       
   698   const void *zSql,         /* UTF-8 encoded SQL statement. */
       
   699   int nBytes,               /* Length of zSql in bytes. */
       
   700   int saveSqlFlag,          /* True to save SQL text into the sqlite3_stmt */
       
   701   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
       
   702   const void **pzTail       /* OUT: End of parsed string */
       
   703 ){
       
   704   /* This function currently works by first transforming the UTF-16
       
   705   ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
       
   706   ** tricky bit is figuring out the pointer to return in *pzTail.
       
   707   */
       
   708   char *zSql8;
       
   709   const char *zTail8 = 0;
       
   710   int rc = SQLITE_OK;
       
   711 
       
   712   if( sqlite3SafetyCheck(db) ){
       
   713     return SQLITE_MISUSE;
       
   714   }
       
   715   sqlite3_mutex_enter(db->mutex);
       
   716   zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
       
   717   if( zSql8 ){
       
   718     rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
       
   719   }
       
   720 
       
   721   if( zTail8 && pzTail ){
       
   722     /* If sqlite3_prepare returns a tail pointer, we calculate the
       
   723     ** equivalent pointer into the UTF-16 string by counting the unicode
       
   724     ** characters between zSql8 and zTail8, and then returning a pointer
       
   725     ** the same number of characters into the UTF-16 string.
       
   726     */
       
   727     int chars_parsed = sqlite3Utf8CharLen(zSql8, zTail8-zSql8);
       
   728     *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
       
   729   }
       
   730   sqlite3_free(zSql8); 
       
   731   rc = sqlite3ApiExit(db, rc);
       
   732   sqlite3_mutex_leave(db->mutex);
       
   733   return rc;
       
   734 }
       
   735 
       
   736 /*
       
   737 ** Two versions of the official API.  Legacy and new use.  In the legacy
       
   738 ** version, the original SQL text is not saved in the prepared statement
       
   739 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
       
   740 ** sqlite3_step().  In the new version, the original SQL text is retained
       
   741 ** and the statement is automatically recompiled if an schema change
       
   742 ** occurs.
       
   743 */
       
   744 EXPORT_C int sqlite3_prepare16(
       
   745   sqlite3 *db,              /* Database handle. */ 
       
   746   const void *zSql,         /* UTF-8 encoded SQL statement. */
       
   747   int nBytes,               /* Length of zSql in bytes. */
       
   748   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
       
   749   const void **pzTail       /* OUT: End of parsed string */
       
   750 ){
       
   751   return sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
       
   752 }
       
   753 EXPORT_C int sqlite3_prepare16_v2(
       
   754   sqlite3 *db,              /* Database handle. */ 
       
   755   const void *zSql,         /* UTF-8 encoded SQL statement. */
       
   756   int nBytes,               /* Length of zSql in bytes. */
       
   757   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */
       
   758   const void **pzTail       /* OUT: End of parsed string */
       
   759 ){
       
   760   return sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
       
   761 }
       
   762 
       
   763 #endif /* SQLITE_OMIT_UTF16 */