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.c,v 1.91 2008/08/02 03:50:39 drh Exp $

    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(

    26   InitData *pData,     /* Initialization context */

    27   const char *zObj,    /* Object being parsed at the point of error */

    28   const char *zExtra   /* Error information */

    29 ){

    30   if( !pData->db->mallocFailed ){

    31     if( zObj==0 ) zObj = "?";

    32     sqlite3SetString(pData->pzErrMsg, pData->db,

    33        "malformed database schema (%s)", zObj);

    34     if( zExtra && zExtra[0] ){

    35       *pData->pzErrMsg = sqlite3MAppendf(pData->db, *pData->pzErrMsg, "%s - %s",

    36                                   *pData->pzErrMsg, zExtra);

    37     }

    38   }

    39   pData->rc = SQLITE_CORRUPT;

    40 }

    41 

    42 /*

    43 ** This is the callback routine for the code that initializes the

    44 ** database.  See sqlite3Init() below for additional information.

    45 ** This routine is also called from the OP_ParseSchema opcode of the VDBE.

    46 **

    47 ** Each callback contains the following information:

    48 **

    49 **     argv[0] = name of thing being created

    50 **     argv[1] = root page number for table or index. 0 for trigger or view.

    51 **     argv[2] = SQL text for the CREATE statement.

    52 **

    53 */

    54 int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){

    55   InitData *pData = (InitData*)pInit;

    56   sqlite3 *db = pData->db;

    57   int iDb = pData->iDb;

    58 

    59   assert( sqlite3_mutex_held(db->mutex) );

    60   pData->rc = SQLITE_OK;

    61   DbClearProperty(db, iDb, DB_Empty);

    62   if( db->mallocFailed ){

    63     corruptSchema(pData, argv[0], 0);

    64     return SQLITE_NOMEM;

    65   }

    66 

    67   assert( argc==3 );

    68   if( argv==0 ) return 0;   /* Might happen if EMPTY_RESULT_CALLBACKS are on */

    69   if( argv[1]==0 ){

    70     corruptSchema(pData, argv[0], 0);

    71     return 1;

    72   }

    73   assert( iDb>=0 && iDb<db->nDb );

    74   if( argv[2] && argv[2][0] ){

    75     /* Call the parser to process a CREATE TABLE, INDEX or VIEW.

    76     ** But because db->init.busy is set to 1, no VDBE code is generated

    77     ** or executed.  All the parser does is build the internal data

    78     ** structures that describe the table, index, or view.

    79     */

    80     char *zErr;

    81     int rc;

    82     u8 lookasideEnabled;

    83     assert( db->init.busy );

    84     db->init.iDb = iDb;

    85     db->init.newTnum = atoi(argv[1]);

    86     lookasideEnabled = db->lookaside.bEnabled;

    87     db->lookaside.bEnabled = 0;

    88     rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);

    89     db->init.iDb = 0;

    90     db->lookaside.bEnabled = lookasideEnabled;

    91     assert( rc!=SQLITE_OK || zErr==0 );

    92     if( SQLITE_OK!=rc ){

    93       pData->rc = rc;

    94       if( rc==SQLITE_NOMEM ){

    95         db->mallocFailed = 1;

    96       }else if( rc!=SQLITE_INTERRUPT ){

    97         corruptSchema(pData, argv[0], zErr);

    98       }

    99       sqlite3DbFree(db, zErr);

   100       return 1;

   101     }

   102   }else if( argv[0]==0 ){

   103     corruptSchema(pData, 0, 0);

   104   }else{

   105     /* If the SQL column is blank it means this is an index that

   106     ** was created to be the PRIMARY KEY or to fulfill a UNIQUE

   107     ** constraint for a CREATE TABLE.  The index should have already

   108     ** been created when we processed the CREATE TABLE.  All we have

   109     ** to do here is record the root page number for that index.

   110     */

   111     Index *pIndex;

   112     pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);

   113     if( pIndex==0 || pIndex->tnum!=0 ){

   114       /* This can occur if there exists an index on a TEMP table which

   115       ** has the same name as another index on a permanent index.  Since

   116       ** the permanent table is hidden by the TEMP table, we can also

   117       ** safely ignore the index on the permanent table.

   118       */

   119       /* Do Nothing */;

   120     }else{

   121       pIndex->tnum = atoi(argv[1]);

   122     }

   123   }

   124   return 0;

   125 }

   126 

   127 /*

   128 ** Attempt to read the database schema and initialize internal

   129 ** data structures for a single database file.  The index of the

   130 ** database file is given by iDb.  iDb==0 is used for the main

   131 ** database.  iDb==1 should never be used.  iDb>=2 is used for

   132 ** auxiliary databases.  Return one of the SQLITE_ error codes to

   133 ** indicate success or failure.

   134 */

   135 static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){

   136   int rc;

   137   BtCursor *curMain;

   138   int size;

   139   Table *pTab;

   140   Db *pDb;

   141   char const *azArg[4];

   142   int meta[10];

   143   InitData initData;

   144   char const *zMasterSchema;

   145   char const *zMasterName = SCHEMA_TABLE(iDb);

   146 

   147   /*

   148   ** The master database table has a structure like this

   149   */

   150   static const char master_schema[] = 

   151      "CREATE TABLE sqlite_master(\n"

   152      "  type text,\n"

   153      "  name text,\n"

   154      "  tbl_name text,\n"

   155      "  rootpage integer,\n"

   156      "  sql text\n"

   157      ")"

   158   ;

   159 #ifndef SQLITE_OMIT_TEMPDB

   160   static const char temp_master_schema[] = 

   161      "CREATE TEMP TABLE sqlite_temp_master(\n"

   162      "  type text,\n"

   163      "  name text,\n"

   164      "  tbl_name text,\n"

   165      "  rootpage integer,\n"

   166      "  sql text\n"

   167      ")"

   168   ;

   169 #else

   170   #define temp_master_schema 0

   171 #endif

   172 

   173   assert( iDb>=0 && iDb<db->nDb );

   174   assert( db->aDb[iDb].pSchema );

   175   assert( sqlite3_mutex_held(db->mutex) );

   176   assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );

   177 

   178   /* zMasterSchema and zInitScript are set to point at the master schema

   179   ** and initialisation script appropriate for the database being

   180   ** initialised. zMasterName is the name of the master table.

   181   */

   182   if( !OMIT_TEMPDB && iDb==1 ){

   183     zMasterSchema = temp_master_schema;

   184   }else{

   185     zMasterSchema = master_schema;

   186   }

   187   zMasterName = SCHEMA_TABLE(iDb);

   188 

   189   /* Construct the schema tables.  */

   190   azArg[0] = zMasterName;

   191   azArg[1] = "1";

   192   azArg[2] = zMasterSchema;

   193   azArg[3] = 0;

   194   initData.db = db;

   195   initData.iDb = iDb;

   196   initData.pzErrMsg = pzErrMsg;

   197   (void)sqlite3SafetyOff(db);

   198   rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0);

   199   (void)sqlite3SafetyOn(db);

   200   if( rc ){

   201     rc = initData.rc;

   202     goto error_out;

   203   }

   204   pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);

   205   if( pTab ){

   206     pTab->readOnly = 1;

   207   }

   208 

   209   /* Create a cursor to hold the database open

   210   */

   211   pDb = &db->aDb[iDb];

   212   if( pDb->pBt==0 ){

   213     if( !OMIT_TEMPDB && iDb==1 ){

   214       DbSetProperty(db, 1, DB_SchemaLoaded);

   215     }

   216     return SQLITE_OK;

   217   }

   218   curMain = sqlite3MallocZero(sqlite3BtreeCursorSize());

   219   if( !curMain ){

   220     rc = SQLITE_NOMEM;

   221     goto error_out;

   222   }

   223   sqlite3BtreeEnter(pDb->pBt);

   224   rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, curMain);

   225   if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){

   226     sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));

   227     goto initone_error_out;

   228   }

   229 

   230   /* Get the database meta information.

   231   **

   232   ** Meta values are as follows:

   233   **    meta[0]   Schema cookie.  Changes with each schema change.

   234   **    meta[1]   File format of schema layer.

   235   **    meta[2]   Size of the page cache.

   236   **    meta[3]   Use freelist if 0.  Autovacuum if greater than zero.

   237   **    meta[4]   Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE

   238   **    meta[5]   The user cookie. Used by the application.

   239   **    meta[6]   Incremental-vacuum flag.

   240   **    meta[7]

   241   **    meta[8]

   242   **    meta[9]

   243   **

   244   ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to

   245   ** the possible values of meta[4].

   246   */

   247   if( rc==SQLITE_OK ){

   248     int i;

   249     for(i=0; i<sizeof(meta)/sizeof(meta[0]); i++){

   250       rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);

   251       if( rc ){

   252         sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));

   253         goto initone_error_out;

   254       }

   255     }

   256   }else{

   257     memset(meta, 0, sizeof(meta));

   258   }

   259   pDb->pSchema->schema_cookie = meta[0];

   260 

   261   /* If opening a non-empty database, check the text encoding. For the

   262   ** main database, set sqlite3.enc to the encoding of the main database.

   263   ** For an attached db, it is an error if the encoding is not the same

   264   ** as sqlite3.enc.

   265   */

   266   if( meta[4] ){  /* text encoding */

   267     if( iDb==0 ){

   268       /* If opening the main database, set ENC(db). */

   269       ENC(db) = (u8)meta[4];

   270       db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);

   271     }else{

   272       /* If opening an attached database, the encoding much match ENC(db) */

   273       if( meta[4]!=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     size = meta[2];

   287     if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }

   288     if( size<0 ) size = -size;

   289     pDb->pSchema->cache_size = size;

   290     sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);

   291   }

   292 

   293   /*

   294   ** file_format==1    Version 3.0.0.

   295   ** file_format==2    Version 3.1.3.  // ALTER TABLE ADD COLUMN

   296   ** file_format==3    Version 3.1.4.  // ditto but with non-NULL defaults

   297   ** file_format==4    Version 3.3.0.  // DESC indices.  Boolean constants

   298   */

   299   pDb->pSchema->file_format = meta[1];

   300   if( pDb->pSchema->file_format==0 ){

   301     pDb->pSchema->file_format = 1;

   302   }

   303   if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){

   304     sqlite3SetString(pzErrMsg, db, "unsupported file format");

   305     rc = SQLITE_ERROR;

   306     goto initone_error_out;

   307   }

   308 

   309   /* Ticket #2804:  When we open a database in the newer file format,

   310   ** clear the legacy_file_format pragma flag so that a VACUUM will

   311   ** not downgrade the database and thus invalidate any descending

   312   ** indices that the user might have created.

   313   */

   314   if( iDb==0 && meta[1]>=4 ){

   315     db->flags &= ~SQLITE_LegacyFileFmt;

   316   }

   317 

   318   /* Read the schema information out of the schema tables

   319   */

   320   assert( db->init.busy );

   321   if( rc==SQLITE_EMPTY ){

   322     /* For an empty database, there is nothing to read */

   323     rc = SQLITE_OK;

   324   }else{

   325     char *zSql;

   326     zSql = sqlite3MPrintf(db, 

   327         "SELECT name, rootpage, sql FROM '%q'.%s",

   328         db->aDb[iDb].zName, zMasterName);

   329     (void)sqlite3SafetyOff(db);

   330 #ifndef SQLITE_OMIT_AUTHORIZATION

   331     {

   332       int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);

   333       xAuth = db->xAuth;

   334       db->xAuth = 0;

   335 #endif

   336       rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);

   337 #ifndef SQLITE_OMIT_AUTHORIZATION

   338       db->xAuth = xAuth;

   339     }

   340 #endif

   341     if( rc==SQLITE_ABORT ) rc = initData.rc;

   342     (void)sqlite3SafetyOn(db);

   343     sqlite3DbFree(db, zSql);

   344 #ifndef SQLITE_OMIT_ANALYZE

   345     if( rc==SQLITE_OK ){

   346       sqlite3AnalysisLoad(db, iDb);

   347     }

   348 #endif

   349   }

   350   if( db->mallocFailed ){

   351     rc = SQLITE_NOMEM;

   352     sqlite3ResetInternalSchema(db, 0);

   353   }

   354   if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){

   355     /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider

   356     ** the schema loaded, even if errors occured. In this situation the 

   357     ** current sqlite3_prepare() operation will fail, but the following one

   358     ** will attempt to compile the supplied statement against whatever subset

   359     ** of the schema was loaded before the error occured. The primary

   360     ** purpose of this is to allow access to the sqlite_master table

   361     ** even when its contents have been corrupted.

   362     */

   363     DbSetProperty(db, iDb, DB_SchemaLoaded);

   364     rc = SQLITE_OK;

   365   }

   366 

   367   /* Jump here for an error that occurs after successfully allocating

   368   ** curMain and calling sqlite3BtreeEnter(). For an error that occurs

   369   ** before that point, jump to error_out.

   370   */

   371 initone_error_out:

   372   sqlite3BtreeCloseCursor(curMain);

   373   sqlite3_free(curMain);

   374   sqlite3BtreeLeave(pDb->pBt);

   375 

   376 error_out:

   377   if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){

   378     db->mallocFailed = 1;

   379   }

   380   return rc;

   381 }

   382 

   383 /*

   384 ** Initialize all database files - the main database file, the file

   385 ** used to store temporary tables, and any additional database files

   386 ** created using ATTACH statements.  Return a success code.  If an

   387 ** error occurs, write an error message into *pzErrMsg.

   388 **

   389 ** After a database is initialized, the DB_SchemaLoaded bit is set

   390 ** bit is set in the flags field of the Db structure. If the database

   391 ** file was of zero-length, then the DB_Empty flag is also set.

   392 */

   393 int sqlite3Init(sqlite3 *db, char **pzErrMsg){

   394   int i, rc;

   395   int commit_internal = !(db->flags&SQLITE_InternChanges);

   396   

   397   assert( sqlite3_mutex_held(db->mutex) );

   398   if( db->init.busy ) return SQLITE_OK;

   399   rc = SQLITE_OK;

   400   db->init.busy = 1;

   401   for(i=0; rc==SQLITE_OK && i<db->nDb; i++){

   402     if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;

   403     rc = sqlite3InitOne(db, i, pzErrMsg);

   404     if( rc ){

   405       sqlite3ResetInternalSchema(db, i);

   406     }

   407   }

   408 

   409   /* Once all the other databases have been initialised, load the schema

   410   ** for the TEMP database. This is loaded last, as the TEMP database

   411   ** schema may contain references to objects in other databases.

   412   */

   413 #ifndef SQLITE_OMIT_TEMPDB

   414   if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){

   415     rc = sqlite3InitOne(db, 1, pzErrMsg);

   416     if( rc ){

   417       sqlite3ResetInternalSchema(db, 1);

   418     }

   419   }

   420 #endif

   421 

   422   db->init.busy = 0;

   423   if( rc==SQLITE_OK && commit_internal ){

   424     sqlite3CommitInternalChanges(db);

   425   }

   426 

   427   return rc; 

   428 }

   429 

   430 /*

   431 ** This routine is a no-op if the database schema is already initialised.

   432 ** Otherwise, the schema is loaded. An error code is returned.

   433 */

   434 int sqlite3ReadSchema(Parse *pParse){

   435   int rc = SQLITE_OK;

   436   sqlite3 *db = pParse->db;

   437   assert( sqlite3_mutex_held(db->mutex) );

   438   if( !db->init.busy ){

   439     rc = sqlite3Init(db, &pParse->zErrMsg);

   440   }

   441   if( rc!=SQLITE_OK ){

   442     pParse->rc = rc;

   443     pParse->nErr++;

   444   }

   445   return rc;

   446 }

   447 

   448 

   449 /*

   450 ** Check schema cookies in all databases.  If any cookie is out

   451 ** of date, return 0.  If all schema cookies are current, return 1.

   452 */

   453 static int schemaIsValid(sqlite3 *db){

   454   int iDb;

   455   int rc;

   456   BtCursor *curTemp;

   457   int cookie;

   458   int allOk = 1;

   459 

   460   curTemp = (BtCursor *)sqlite3Malloc(sqlite3BtreeCursorSize());

   461   if( curTemp ){

   462     assert( sqlite3_mutex_held(db->mutex) );

   463     for(iDb=0; allOk && iDb<db->nDb; iDb++){

   464       Btree *pBt;

   465       pBt = db->aDb[iDb].pBt;

   466       if( pBt==0 ) continue;

   467       memset(curTemp, 0, sqlite3BtreeCursorSize());

   468       rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, curTemp);

   469       if( rc==SQLITE_OK ){

   470         rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie);

   471         if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){

   472           allOk = 0;

   473         }

   474         sqlite3BtreeCloseCursor(curTemp);

   475       }

   476       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){

   477         db->mallocFailed = 1;

   478       }

   479     }

   480     sqlite3_free(curTemp);

   481   }else{

   482     allOk = 0;

   483     db->mallocFailed = 1;

   484   }

   485 

   486   return allOk;

   487 }

   488 

   489 /*

   490 ** Convert a schema pointer into the iDb index that indicates

   491 ** which database file in db->aDb[] the schema refers to.

   492 **

   493 ** If the same database is attached more than once, the first

   494 ** attached database is returned.

   495 */

   496 int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){

   497   int i = -1000000;

   498 

   499   /* If pSchema is NULL, then return -1000000. This happens when code in 

   500   ** expr.c is trying to resolve a reference to a transient table (i.e. one

   501   ** created by a sub-select). In this case the return value of this 

   502   ** function should never be used.

   503   **

   504   ** We return -1000000 instead of the more usual -1 simply because using

   505   ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much 

   506   ** more likely to cause a segfault than -1 (of course there are assert()

   507   ** statements too, but it never hurts to play the odds).

   508   */

   509   assert( sqlite3_mutex_held(db->mutex) );

   510   if( pSchema ){

   511     for(i=0; i<db->nDb; i++){

   512       if( db->aDb[i].pSchema==pSchema ){

   513         break;

   514       }

   515     }

   516     assert( i>=0 &&i>=0 &&  i<db->nDb );

   517   }

   518   return i;

   519 }

   520 

   521 /*

   522 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.

   523 */

   524 static int sqlite3Prepare(

   525   sqlite3 *db,              /* Database handle. */

   526   const char *zSql,         /* UTF-8 encoded SQL statement. */

   527   int nBytes,               /* Length of zSql in bytes. */

   528   int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */

   529   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */

   530   const char **pzTail       /* OUT: End of parsed string */

   531 ){

   532   Parse sParse;

   533   char *zErrMsg = 0;

   534   int rc = SQLITE_OK;

   535   int i;

   536 

   537   assert( ppStmt );

   538   *ppStmt = 0;

   539   if( sqlite3SafetyOn(db) ){

   540     return SQLITE_MISUSE;

   541   }

   542   assert( !db->mallocFailed );

   543   assert( sqlite3_mutex_held(db->mutex) );

   544 

   545   /* If any attached database schemas are locked, do not proceed with

   546   ** compilation. Instead return SQLITE_LOCKED immediately.

   547   */

   548   for(i=0; i<db->nDb; i++) {

   549     Btree *pBt = db->aDb[i].pBt;

   550     if( pBt ){

   551       int rc;

   552       rc = sqlite3BtreeSchemaLocked(pBt);

   553       if( rc ){

   554         const char *zDb = db->aDb[i].zName;

   555         sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);

   556         (void)sqlite3SafetyOff(db);

   557         return sqlite3ApiExit(db, SQLITE_LOCKED);

   558       }

   559     }

   560   }

   561   

   562   memset(&sParse, 0, sizeof(sParse));

   563   sParse.db = db;

   564   if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){

   565     char *zSqlCopy;

   566     int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];

   567     if( nBytes>mxLen ){

   568       sqlite3Error(db, SQLITE_TOOBIG, "statement too long");

   569       (void)sqlite3SafetyOff(db);

   570       return sqlite3ApiExit(db, SQLITE_TOOBIG);

   571     }

   572     zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);

   573     if( zSqlCopy ){

   574       sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);

   575       sqlite3DbFree(db, zSqlCopy);

   576       sParse.zTail = &zSql[sParse.zTail-zSqlCopy];

   577     }else{

   578       sParse.zTail = &zSql[nBytes];

   579     }

   580   }else{

   581     sqlite3RunParser(&sParse, zSql, &zErrMsg);

   582   }

   583 

   584   if( db->mallocFailed ){

   585     sParse.rc = SQLITE_NOMEM;

   586   }

   587   if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;

   588   if( sParse.checkSchema && !schemaIsValid(db) ){

   589     sParse.rc = SQLITE_SCHEMA;

   590   }

   591   if( sParse.rc==SQLITE_SCHEMA ){

   592     sqlite3ResetInternalSchema(db, 0);

   593   }

   594   if( db->mallocFailed ){

   595     sParse.rc = SQLITE_NOMEM;

   596   }

   597   if( pzTail ){

   598     *pzTail = sParse.zTail;

   599   }

   600   rc = sParse.rc;

   601 

   602 #ifndef SQLITE_OMIT_EXPLAIN

   603   if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){

   604     if( sParse.explain==2 ){

   605       sqlite3VdbeSetNumCols(sParse.pVdbe, 3);

   606       sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P4_STATIC);

   607       sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P4_STATIC);

   608       sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P4_STATIC);

   609     }else{

   610       sqlite3VdbeSetNumCols(sParse.pVdbe, 8);

   611       sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P4_STATIC);

   612       sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P4_STATIC);

   613       sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P4_STATIC);

   614       sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P4_STATIC);

   615       sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P4_STATIC);

   616       sqlite3VdbeSetColName(sParse.pVdbe, 5, COLNAME_NAME, "p4", P4_STATIC);

   617       sqlite3VdbeSetColName(sParse.pVdbe, 6, COLNAME_NAME, "p5", P4_STATIC);

   618       sqlite3VdbeSetColName(sParse.pVdbe, 7, COLNAME_NAME, "comment",P4_STATIC);

   619     }

   620   }

   621 #endif

   622 

   623   if( sqlite3SafetyOff(db) ){

   624     rc = SQLITE_MISUSE;

   625   }

   626 

   627   if( saveSqlFlag ){

   628     sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);

   629   }

   630   if( rc!=SQLITE_OK || db->mallocFailed ){

   631     sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);

   632     assert(!(*ppStmt));

   633   }else{

   634     *ppStmt = (sqlite3_stmt*)sParse.pVdbe;

   635   }

   636 

   637   if( zErrMsg ){

   638     sqlite3Error(db, rc, "%s", zErrMsg);

   639     sqlite3DbFree(db, zErrMsg);

   640   }else{

   641     sqlite3Error(db, rc, 0);

   642   }

   643 

   644   rc = sqlite3ApiExit(db, rc);

   645   assert( (rc&db->errMask)==rc );

   646   return rc;

   647 }

   648 static int sqlite3LockAndPrepare(

   649   sqlite3 *db,              /* Database handle. */

   650   const char *zSql,         /* UTF-8 encoded SQL statement. */

   651   int nBytes,               /* Length of zSql in bytes. */

   652   int saveSqlFlag,          /* True to copy SQL text into the sqlite3_stmt */

   653   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */

   654   const char **pzTail       /* OUT: End of parsed string */

   655 ){

   656   int rc;

   657   if( !sqlite3SafetyCheckOk(db) ){

   658     return SQLITE_MISUSE;

   659   }

   660   sqlite3_mutex_enter(db->mutex);

   661   sqlite3BtreeEnterAll(db);

   662   rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);

   663   sqlite3BtreeLeaveAll(db);

   664   sqlite3_mutex_leave(db->mutex);

   665   return rc;

   666 }

   667 

   668 /*

   669 ** Rerun the compilation of a statement after a schema change.

   670 ** Return true if the statement was recompiled successfully.

   671 ** Return false if there is an error of some kind.

   672 */

   673 int sqlite3Reprepare(Vdbe *p){

   674   int rc;

   675   sqlite3_stmt *pNew;

   676   const char *zSql;

   677   sqlite3 *db;

   678 

   679   assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );

   680   zSql = sqlite3_sql((sqlite3_stmt *)p);

   681   assert( zSql!=0 );  /* Reprepare only called for prepare_v2() statements */

   682   db = sqlite3VdbeDb(p);

   683   assert( sqlite3_mutex_held(db->mutex) );

   684   rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0);

   685   if( rc ){

   686     if( rc==SQLITE_NOMEM ){

   687       db->mallocFailed = 1;

   688     }

   689     assert( pNew==0 );

   690     return 0;

   691   }else{

   692     assert( pNew!=0 );

   693   }

   694   sqlite3VdbeSwap((Vdbe*)pNew, p);

   695   sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p);

   696   sqlite3VdbeResetStepResult((Vdbe*)pNew);

   697   sqlite3VdbeFinalize((Vdbe*)pNew);

   698   return 1;

   699 }

   700 

   701 

   702 /*

   703 ** Two versions of the official API.  Legacy and new use.  In the legacy

   704 ** version, the original SQL text is not saved in the prepared statement

   705 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by

   706 ** sqlite3_step().  In the new version, the original SQL text is retained

   707 ** and the statement is automatically recompiled if an schema change

   708 ** occurs.

   709 */

   710 int sqlite3_prepare(

   711   sqlite3 *db,              /* Database handle. */

   712   const char *zSql,         /* UTF-8 encoded SQL statement. */

   713   int nBytes,               /* Length of zSql in bytes. */

   714   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */

   715   const char **pzTail       /* OUT: End of parsed string */

   716 ){

   717   int rc;

   718   rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail);

   719   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */

   720   return rc;

   721 }

   722 int sqlite3_prepare_v2(

   723   sqlite3 *db,              /* Database handle. */

   724   const char *zSql,         /* UTF-8 encoded SQL statement. */

   725   int nBytes,               /* Length of zSql in bytes. */

   726   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */

   727   const char **pzTail       /* OUT: End of parsed string */

   728 ){

   729   int rc;

   730   rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail);

   731   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */

   732   return rc;

   733 }

   734 

   735 

   736 #ifndef SQLITE_OMIT_UTF16

   737 /*

   738 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.

   739 */

   740 static int sqlite3Prepare16(

   741   sqlite3 *db,              /* Database handle. */ 

   742   const void *zSql,         /* UTF-8 encoded SQL statement. */

   743   int nBytes,               /* Length of zSql in bytes. */

   744   int saveSqlFlag,          /* True to save SQL text into the sqlite3_stmt */

   745   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */

   746   const void **pzTail       /* OUT: End of parsed string */

   747 ){

   748   /* This function currently works by first transforming the UTF-16

   749   ** encoded string to UTF-8, then invoking sqlite3_prepare(). The

   750   ** tricky bit is figuring out the pointer to return in *pzTail.

   751   */

   752   char *zSql8;

   753   const char *zTail8 = 0;

   754   int rc = SQLITE_OK;

   755 

   756   if( !sqlite3SafetyCheckOk(db) ){

   757     return SQLITE_MISUSE;

   758   }

   759   sqlite3_mutex_enter(db->mutex);

   760   zSql8 = sqlite3Utf16to8(db, zSql, nBytes);

   761   if( zSql8 ){

   762     rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);

   763   }

   764 

   765   if( zTail8 && pzTail ){

   766     /* If sqlite3_prepare returns a tail pointer, we calculate the

   767     ** equivalent pointer into the UTF-16 string by counting the unicode

   768     ** characters between zSql8 and zTail8, and then returning a pointer

   769     ** the same number of characters into the UTF-16 string.

   770     */

   771     int chars_parsed = sqlite3Utf8CharLen(zSql8, zTail8-zSql8);

   772     *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);

   773   }

   774   sqlite3DbFree(db, zSql8); 

   775   rc = sqlite3ApiExit(db, rc);

   776   sqlite3_mutex_leave(db->mutex);

   777   return rc;

   778 }

   779 

   780 /*

   781 ** Two versions of the official API.  Legacy and new use.  In the legacy

   782 ** version, the original SQL text is not saved in the prepared statement

   783 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by

   784 ** sqlite3_step().  In the new version, the original SQL text is retained

   785 ** and the statement is automatically recompiled if an schema change

   786 ** occurs.

   787 */

   788 int sqlite3_prepare16(

   789   sqlite3 *db,              /* Database handle. */ 

   790   const void *zSql,         /* UTF-8 encoded SQL statement. */

   791   int nBytes,               /* Length of zSql in bytes. */

   792   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */

   793   const void **pzTail       /* OUT: End of parsed string */

   794 ){

   795   int rc;

   796   rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);

   797   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */

   798   return rc;

   799 }

   800 int sqlite3_prepare16_v2(

   801   sqlite3 *db,              /* Database handle. */ 

   802   const void *zSql,         /* UTF-8 encoded SQL statement. */

   803   int nBytes,               /* Length of zSql in bytes. */

   804   sqlite3_stmt **ppStmt,    /* OUT: A pointer to the prepared statement */

   805   const void **pzTail       /* OUT: End of parsed string */

   806 ){

   807   int rc;

   808   rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);

   809   assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );  /* VERIFY: F13021 */

   810   return rc;

   811 }

   812 

   813 #endif /* SQLITE_OMIT_UTF16 */