1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite/prepare.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,813 @@
1.4 +/*
1.5 +** 2005 May 25
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** This file contains the implementation of the sqlite3_prepare()
1.16 +** interface, and routines that contribute to loading the database schema
1.17 +** from disk.
1.18 +**
1.19 +** $Id: prepare.c,v 1.91 2008/08/02 03:50:39 drh Exp $
1.20 +*/
1.21 +#include "sqliteInt.h"
1.22 +#include <ctype.h>
1.23 +
1.24 +/*
1.25 +** Fill the InitData structure with an error message that indicates
1.26 +** that the database is corrupt.
1.27 +*/
1.28 +static void corruptSchema(
1.29 + InitData *pData, /* Initialization context */
1.30 + const char *zObj, /* Object being parsed at the point of error */
1.31 + const char *zExtra /* Error information */
1.32 +){
1.33 + if( !pData->db->mallocFailed ){
1.34 + if( zObj==0 ) zObj = "?";
1.35 + sqlite3SetString(pData->pzErrMsg, pData->db,
1.36 + "malformed database schema (%s)", zObj);
1.37 + if( zExtra && zExtra[0] ){
1.38 + *pData->pzErrMsg = sqlite3MAppendf(pData->db, *pData->pzErrMsg, "%s - %s",
1.39 + *pData->pzErrMsg, zExtra);
1.40 + }
1.41 + }
1.42 + pData->rc = SQLITE_CORRUPT;
1.43 +}
1.44 +
1.45 +/*
1.46 +** This is the callback routine for the code that initializes the
1.47 +** database. See sqlite3Init() below for additional information.
1.48 +** This routine is also called from the OP_ParseSchema opcode of the VDBE.
1.49 +**
1.50 +** Each callback contains the following information:
1.51 +**
1.52 +** argv[0] = name of thing being created
1.53 +** argv[1] = root page number for table or index. 0 for trigger or view.
1.54 +** argv[2] = SQL text for the CREATE statement.
1.55 +**
1.56 +*/
1.57 +int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){
1.58 + InitData *pData = (InitData*)pInit;
1.59 + sqlite3 *db = pData->db;
1.60 + int iDb = pData->iDb;
1.61 +
1.62 + assert( sqlite3_mutex_held(db->mutex) );
1.63 + pData->rc = SQLITE_OK;
1.64 + DbClearProperty(db, iDb, DB_Empty);
1.65 + if( db->mallocFailed ){
1.66 + corruptSchema(pData, argv[0], 0);
1.67 + return SQLITE_NOMEM;
1.68 + }
1.69 +
1.70 + assert( argc==3 );
1.71 + if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
1.72 + if( argv[1]==0 ){
1.73 + corruptSchema(pData, argv[0], 0);
1.74 + return 1;
1.75 + }
1.76 + assert( iDb>=0 && iDb<db->nDb );
1.77 + if( argv[2] && argv[2][0] ){
1.78 + /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
1.79 + ** But because db->init.busy is set to 1, no VDBE code is generated
1.80 + ** or executed. All the parser does is build the internal data
1.81 + ** structures that describe the table, index, or view.
1.82 + */
1.83 + char *zErr;
1.84 + int rc;
1.85 + u8 lookasideEnabled;
1.86 + assert( db->init.busy );
1.87 + db->init.iDb = iDb;
1.88 + db->init.newTnum = atoi(argv[1]);
1.89 + lookasideEnabled = db->lookaside.bEnabled;
1.90 + db->lookaside.bEnabled = 0;
1.91 + rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
1.92 + db->init.iDb = 0;
1.93 + db->lookaside.bEnabled = lookasideEnabled;
1.94 + assert( rc!=SQLITE_OK || zErr==0 );
1.95 + if( SQLITE_OK!=rc ){
1.96 + pData->rc = rc;
1.97 + if( rc==SQLITE_NOMEM ){
1.98 + db->mallocFailed = 1;
1.99 + }else if( rc!=SQLITE_INTERRUPT ){
1.100 + corruptSchema(pData, argv[0], zErr);
1.101 + }
1.102 + sqlite3DbFree(db, zErr);
1.103 + return 1;
1.104 + }
1.105 + }else if( argv[0]==0 ){
1.106 + corruptSchema(pData, 0, 0);
1.107 + }else{
1.108 + /* If the SQL column is blank it means this is an index that
1.109 + ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
1.110 + ** constraint for a CREATE TABLE. The index should have already
1.111 + ** been created when we processed the CREATE TABLE. All we have
1.112 + ** to do here is record the root page number for that index.
1.113 + */
1.114 + Index *pIndex;
1.115 + pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
1.116 + if( pIndex==0 || pIndex->tnum!=0 ){
1.117 + /* This can occur if there exists an index on a TEMP table which
1.118 + ** has the same name as another index on a permanent index. Since
1.119 + ** the permanent table is hidden by the TEMP table, we can also
1.120 + ** safely ignore the index on the permanent table.
1.121 + */
1.122 + /* Do Nothing */;
1.123 + }else{
1.124 + pIndex->tnum = atoi(argv[1]);
1.125 + }
1.126 + }
1.127 + return 0;
1.128 +}
1.129 +
1.130 +/*
1.131 +** Attempt to read the database schema and initialize internal
1.132 +** data structures for a single database file. The index of the
1.133 +** database file is given by iDb. iDb==0 is used for the main
1.134 +** database. iDb==1 should never be used. iDb>=2 is used for
1.135 +** auxiliary databases. Return one of the SQLITE_ error codes to
1.136 +** indicate success or failure.
1.137 +*/
1.138 +static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
1.139 + int rc;
1.140 + BtCursor *curMain;
1.141 + int size;
1.142 + Table *pTab;
1.143 + Db *pDb;
1.144 + char const *azArg[4];
1.145 + int meta[10];
1.146 + InitData initData;
1.147 + char const *zMasterSchema;
1.148 + char const *zMasterName = SCHEMA_TABLE(iDb);
1.149 +
1.150 + /*
1.151 + ** The master database table has a structure like this
1.152 + */
1.153 + static const char master_schema[] =
1.154 + "CREATE TABLE sqlite_master(\n"
1.155 + " type text,\n"
1.156 + " name text,\n"
1.157 + " tbl_name text,\n"
1.158 + " rootpage integer,\n"
1.159 + " sql text\n"
1.160 + ")"
1.161 + ;
1.162 +#ifndef SQLITE_OMIT_TEMPDB
1.163 + static const char temp_master_schema[] =
1.164 + "CREATE TEMP TABLE sqlite_temp_master(\n"
1.165 + " type text,\n"
1.166 + " name text,\n"
1.167 + " tbl_name text,\n"
1.168 + " rootpage integer,\n"
1.169 + " sql text\n"
1.170 + ")"
1.171 + ;
1.172 +#else
1.173 + #define temp_master_schema 0
1.174 +#endif
1.175 +
1.176 + assert( iDb>=0 && iDb<db->nDb );
1.177 + assert( db->aDb[iDb].pSchema );
1.178 + assert( sqlite3_mutex_held(db->mutex) );
1.179 + assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
1.180 +
1.181 + /* zMasterSchema and zInitScript are set to point at the master schema
1.182 + ** and initialisation script appropriate for the database being
1.183 + ** initialised. zMasterName is the name of the master table.
1.184 + */
1.185 + if( !OMIT_TEMPDB && iDb==1 ){
1.186 + zMasterSchema = temp_master_schema;
1.187 + }else{
1.188 + zMasterSchema = master_schema;
1.189 + }
1.190 + zMasterName = SCHEMA_TABLE(iDb);
1.191 +
1.192 + /* Construct the schema tables. */
1.193 + azArg[0] = zMasterName;
1.194 + azArg[1] = "1";
1.195 + azArg[2] = zMasterSchema;
1.196 + azArg[3] = 0;
1.197 + initData.db = db;
1.198 + initData.iDb = iDb;
1.199 + initData.pzErrMsg = pzErrMsg;
1.200 + (void)sqlite3SafetyOff(db);
1.201 + rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
1.202 + (void)sqlite3SafetyOn(db);
1.203 + if( rc ){
1.204 + rc = initData.rc;
1.205 + goto error_out;
1.206 + }
1.207 + pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
1.208 + if( pTab ){
1.209 + pTab->readOnly = 1;
1.210 + }
1.211 +
1.212 + /* Create a cursor to hold the database open
1.213 + */
1.214 + pDb = &db->aDb[iDb];
1.215 + if( pDb->pBt==0 ){
1.216 + if( !OMIT_TEMPDB && iDb==1 ){
1.217 + DbSetProperty(db, 1, DB_SchemaLoaded);
1.218 + }
1.219 + return SQLITE_OK;
1.220 + }
1.221 + curMain = sqlite3MallocZero(sqlite3BtreeCursorSize());
1.222 + if( !curMain ){
1.223 + rc = SQLITE_NOMEM;
1.224 + goto error_out;
1.225 + }
1.226 + sqlite3BtreeEnter(pDb->pBt);
1.227 + rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, curMain);
1.228 + if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){
1.229 + sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));
1.230 + goto initone_error_out;
1.231 + }
1.232 +
1.233 + /* Get the database meta information.
1.234 + **
1.235 + ** Meta values are as follows:
1.236 + ** meta[0] Schema cookie. Changes with each schema change.
1.237 + ** meta[1] File format of schema layer.
1.238 + ** meta[2] Size of the page cache.
1.239 + ** meta[3] Use freelist if 0. Autovacuum if greater than zero.
1.240 + ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
1.241 + ** meta[5] The user cookie. Used by the application.
1.242 + ** meta[6] Incremental-vacuum flag.
1.243 + ** meta[7]
1.244 + ** meta[8]
1.245 + ** meta[9]
1.246 + **
1.247 + ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
1.248 + ** the possible values of meta[4].
1.249 + */
1.250 + if( rc==SQLITE_OK ){
1.251 + int i;
1.252 + for(i=0; i<sizeof(meta)/sizeof(meta[0]); i++){
1.253 + rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
1.254 + if( rc ){
1.255 + sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));
1.256 + goto initone_error_out;
1.257 + }
1.258 + }
1.259 + }else{
1.260 + memset(meta, 0, sizeof(meta));
1.261 + }
1.262 + pDb->pSchema->schema_cookie = meta[0];
1.263 +
1.264 + /* If opening a non-empty database, check the text encoding. For the
1.265 + ** main database, set sqlite3.enc to the encoding of the main database.
1.266 + ** For an attached db, it is an error if the encoding is not the same
1.267 + ** as sqlite3.enc.
1.268 + */
1.269 + if( meta[4] ){ /* text encoding */
1.270 + if( iDb==0 ){
1.271 + /* If opening the main database, set ENC(db). */
1.272 + ENC(db) = (u8)meta[4];
1.273 + db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
1.274 + }else{
1.275 + /* If opening an attached database, the encoding much match ENC(db) */
1.276 + if( meta[4]!=ENC(db) ){
1.277 + sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
1.278 + " text encoding as main database");
1.279 + rc = SQLITE_ERROR;
1.280 + goto initone_error_out;
1.281 + }
1.282 + }
1.283 + }else{
1.284 + DbSetProperty(db, iDb, DB_Empty);
1.285 + }
1.286 + pDb->pSchema->enc = ENC(db);
1.287 +
1.288 + if( pDb->pSchema->cache_size==0 ){
1.289 + size = meta[2];
1.290 + if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
1.291 + if( size<0 ) size = -size;
1.292 + pDb->pSchema->cache_size = size;
1.293 + sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
1.294 + }
1.295 +
1.296 + /*
1.297 + ** file_format==1 Version 3.0.0.
1.298 + ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
1.299 + ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
1.300 + ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
1.301 + */
1.302 + pDb->pSchema->file_format = meta[1];
1.303 + if( pDb->pSchema->file_format==0 ){
1.304 + pDb->pSchema->file_format = 1;
1.305 + }
1.306 + if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
1.307 + sqlite3SetString(pzErrMsg, db, "unsupported file format");
1.308 + rc = SQLITE_ERROR;
1.309 + goto initone_error_out;
1.310 + }
1.311 +
1.312 + /* Ticket #2804: When we open a database in the newer file format,
1.313 + ** clear the legacy_file_format pragma flag so that a VACUUM will
1.314 + ** not downgrade the database and thus invalidate any descending
1.315 + ** indices that the user might have created.
1.316 + */
1.317 + if( iDb==0 && meta[1]>=4 ){
1.318 + db->flags &= ~SQLITE_LegacyFileFmt;
1.319 + }
1.320 +
1.321 + /* Read the schema information out of the schema tables
1.322 + */
1.323 + assert( db->init.busy );
1.324 + if( rc==SQLITE_EMPTY ){
1.325 + /* For an empty database, there is nothing to read */
1.326 + rc = SQLITE_OK;
1.327 + }else{
1.328 + char *zSql;
1.329 + zSql = sqlite3MPrintf(db,
1.330 + "SELECT name, rootpage, sql FROM '%q'.%s",
1.331 + db->aDb[iDb].zName, zMasterName);
1.332 + (void)sqlite3SafetyOff(db);
1.333 +#ifndef SQLITE_OMIT_AUTHORIZATION
1.334 + {
1.335 + int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
1.336 + xAuth = db->xAuth;
1.337 + db->xAuth = 0;
1.338 +#endif
1.339 + rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
1.340 +#ifndef SQLITE_OMIT_AUTHORIZATION
1.341 + db->xAuth = xAuth;
1.342 + }
1.343 +#endif
1.344 + if( rc==SQLITE_ABORT ) rc = initData.rc;
1.345 + (void)sqlite3SafetyOn(db);
1.346 + sqlite3DbFree(db, zSql);
1.347 +#ifndef SQLITE_OMIT_ANALYZE
1.348 + if( rc==SQLITE_OK ){
1.349 + sqlite3AnalysisLoad(db, iDb);
1.350 + }
1.351 +#endif
1.352 + }
1.353 + if( db->mallocFailed ){
1.354 + rc = SQLITE_NOMEM;
1.355 + sqlite3ResetInternalSchema(db, 0);
1.356 + }
1.357 + if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
1.358 + /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
1.359 + ** the schema loaded, even if errors occured. In this situation the
1.360 + ** current sqlite3_prepare() operation will fail, but the following one
1.361 + ** will attempt to compile the supplied statement against whatever subset
1.362 + ** of the schema was loaded before the error occured. The primary
1.363 + ** purpose of this is to allow access to the sqlite_master table
1.364 + ** even when its contents have been corrupted.
1.365 + */
1.366 + DbSetProperty(db, iDb, DB_SchemaLoaded);
1.367 + rc = SQLITE_OK;
1.368 + }
1.369 +
1.370 + /* Jump here for an error that occurs after successfully allocating
1.371 + ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
1.372 + ** before that point, jump to error_out.
1.373 + */
1.374 +initone_error_out:
1.375 + sqlite3BtreeCloseCursor(curMain);
1.376 + sqlite3_free(curMain);
1.377 + sqlite3BtreeLeave(pDb->pBt);
1.378 +
1.379 +error_out:
1.380 + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
1.381 + db->mallocFailed = 1;
1.382 + }
1.383 + return rc;
1.384 +}
1.385 +
1.386 +/*
1.387 +** Initialize all database files - the main database file, the file
1.388 +** used to store temporary tables, and any additional database files
1.389 +** created using ATTACH statements. Return a success code. If an
1.390 +** error occurs, write an error message into *pzErrMsg.
1.391 +**
1.392 +** After a database is initialized, the DB_SchemaLoaded bit is set
1.393 +** bit is set in the flags field of the Db structure. If the database
1.394 +** file was of zero-length, then the DB_Empty flag is also set.
1.395 +*/
1.396 +int sqlite3Init(sqlite3 *db, char **pzErrMsg){
1.397 + int i, rc;
1.398 + int commit_internal = !(db->flags&SQLITE_InternChanges);
1.399 +
1.400 + assert( sqlite3_mutex_held(db->mutex) );
1.401 + if( db->init.busy ) return SQLITE_OK;
1.402 + rc = SQLITE_OK;
1.403 + db->init.busy = 1;
1.404 + for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
1.405 + if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
1.406 + rc = sqlite3InitOne(db, i, pzErrMsg);
1.407 + if( rc ){
1.408 + sqlite3ResetInternalSchema(db, i);
1.409 + }
1.410 + }
1.411 +
1.412 + /* Once all the other databases have been initialised, load the schema
1.413 + ** for the TEMP database. This is loaded last, as the TEMP database
1.414 + ** schema may contain references to objects in other databases.
1.415 + */
1.416 +#ifndef SQLITE_OMIT_TEMPDB
1.417 + if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
1.418 + rc = sqlite3InitOne(db, 1, pzErrMsg);
1.419 + if( rc ){
1.420 + sqlite3ResetInternalSchema(db, 1);
1.421 + }
1.422 + }
1.423 +#endif
1.424 +
1.425 + db->init.busy = 0;
1.426 + if( rc==SQLITE_OK && commit_internal ){
1.427 + sqlite3CommitInternalChanges(db);
1.428 + }
1.429 +
1.430 + return rc;
1.431 +}
1.432 +
1.433 +/*
1.434 +** This routine is a no-op if the database schema is already initialised.
1.435 +** Otherwise, the schema is loaded. An error code is returned.
1.436 +*/
1.437 +int sqlite3ReadSchema(Parse *pParse){
1.438 + int rc = SQLITE_OK;
1.439 + sqlite3 *db = pParse->db;
1.440 + assert( sqlite3_mutex_held(db->mutex) );
1.441 + if( !db->init.busy ){
1.442 + rc = sqlite3Init(db, &pParse->zErrMsg);
1.443 + }
1.444 + if( rc!=SQLITE_OK ){
1.445 + pParse->rc = rc;
1.446 + pParse->nErr++;
1.447 + }
1.448 + return rc;
1.449 +}
1.450 +
1.451 +
1.452 +/*
1.453 +** Check schema cookies in all databases. If any cookie is out
1.454 +** of date, return 0. If all schema cookies are current, return 1.
1.455 +*/
1.456 +static int schemaIsValid(sqlite3 *db){
1.457 + int iDb;
1.458 + int rc;
1.459 + BtCursor *curTemp;
1.460 + int cookie;
1.461 + int allOk = 1;
1.462 +
1.463 + curTemp = (BtCursor *)sqlite3Malloc(sqlite3BtreeCursorSize());
1.464 + if( curTemp ){
1.465 + assert( sqlite3_mutex_held(db->mutex) );
1.466 + for(iDb=0; allOk && iDb<db->nDb; iDb++){
1.467 + Btree *pBt;
1.468 + pBt = db->aDb[iDb].pBt;
1.469 + if( pBt==0 ) continue;
1.470 + memset(curTemp, 0, sqlite3BtreeCursorSize());
1.471 + rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, curTemp);
1.472 + if( rc==SQLITE_OK ){
1.473 + rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie);
1.474 + if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){
1.475 + allOk = 0;
1.476 + }
1.477 + sqlite3BtreeCloseCursor(curTemp);
1.478 + }
1.479 + if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
1.480 + db->mallocFailed = 1;
1.481 + }
1.482 + }
1.483 + sqlite3_free(curTemp);
1.484 + }else{
1.485 + allOk = 0;
1.486 + db->mallocFailed = 1;
1.487 + }
1.488 +
1.489 + return allOk;
1.490 +}
1.491 +
1.492 +/*
1.493 +** Convert a schema pointer into the iDb index that indicates
1.494 +** which database file in db->aDb[] the schema refers to.
1.495 +**
1.496 +** If the same database is attached more than once, the first
1.497 +** attached database is returned.
1.498 +*/
1.499 +int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
1.500 + int i = -1000000;
1.501 +
1.502 + /* If pSchema is NULL, then return -1000000. This happens when code in
1.503 + ** expr.c is trying to resolve a reference to a transient table (i.e. one
1.504 + ** created by a sub-select). In this case the return value of this
1.505 + ** function should never be used.
1.506 + **
1.507 + ** We return -1000000 instead of the more usual -1 simply because using
1.508 + ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much
1.509 + ** more likely to cause a segfault than -1 (of course there are assert()
1.510 + ** statements too, but it never hurts to play the odds).
1.511 + */
1.512 + assert( sqlite3_mutex_held(db->mutex) );
1.513 + if( pSchema ){
1.514 + for(i=0; i<db->nDb; i++){
1.515 + if( db->aDb[i].pSchema==pSchema ){
1.516 + break;
1.517 + }
1.518 + }
1.519 + assert( i>=0 &&i>=0 && i<db->nDb );
1.520 + }
1.521 + return i;
1.522 +}
1.523 +
1.524 +/*
1.525 +** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
1.526 +*/
1.527 +static int sqlite3Prepare(
1.528 + sqlite3 *db, /* Database handle. */
1.529 + const char *zSql, /* UTF-8 encoded SQL statement. */
1.530 + int nBytes, /* Length of zSql in bytes. */
1.531 + int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
1.532 + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1.533 + const char **pzTail /* OUT: End of parsed string */
1.534 +){
1.535 + Parse sParse;
1.536 + char *zErrMsg = 0;
1.537 + int rc = SQLITE_OK;
1.538 + int i;
1.539 +
1.540 + assert( ppStmt );
1.541 + *ppStmt = 0;
1.542 + if( sqlite3SafetyOn(db) ){
1.543 + return SQLITE_MISUSE;
1.544 + }
1.545 + assert( !db->mallocFailed );
1.546 + assert( sqlite3_mutex_held(db->mutex) );
1.547 +
1.548 + /* If any attached database schemas are locked, do not proceed with
1.549 + ** compilation. Instead return SQLITE_LOCKED immediately.
1.550 + */
1.551 + for(i=0; i<db->nDb; i++) {
1.552 + Btree *pBt = db->aDb[i].pBt;
1.553 + if( pBt ){
1.554 + int rc;
1.555 + rc = sqlite3BtreeSchemaLocked(pBt);
1.556 + if( rc ){
1.557 + const char *zDb = db->aDb[i].zName;
1.558 + sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);
1.559 + (void)sqlite3SafetyOff(db);
1.560 + return sqlite3ApiExit(db, SQLITE_LOCKED);
1.561 + }
1.562 + }
1.563 + }
1.564 +
1.565 + memset(&sParse, 0, sizeof(sParse));
1.566 + sParse.db = db;
1.567 + if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
1.568 + char *zSqlCopy;
1.569 + int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
1.570 + if( nBytes>mxLen ){
1.571 + sqlite3Error(db, SQLITE_TOOBIG, "statement too long");
1.572 + (void)sqlite3SafetyOff(db);
1.573 + return sqlite3ApiExit(db, SQLITE_TOOBIG);
1.574 + }
1.575 + zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
1.576 + if( zSqlCopy ){
1.577 + sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
1.578 + sqlite3DbFree(db, zSqlCopy);
1.579 + sParse.zTail = &zSql[sParse.zTail-zSqlCopy];
1.580 + }else{
1.581 + sParse.zTail = &zSql[nBytes];
1.582 + }
1.583 + }else{
1.584 + sqlite3RunParser(&sParse, zSql, &zErrMsg);
1.585 + }
1.586 +
1.587 + if( db->mallocFailed ){
1.588 + sParse.rc = SQLITE_NOMEM;
1.589 + }
1.590 + if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
1.591 + if( sParse.checkSchema && !schemaIsValid(db) ){
1.592 + sParse.rc = SQLITE_SCHEMA;
1.593 + }
1.594 + if( sParse.rc==SQLITE_SCHEMA ){
1.595 + sqlite3ResetInternalSchema(db, 0);
1.596 + }
1.597 + if( db->mallocFailed ){
1.598 + sParse.rc = SQLITE_NOMEM;
1.599 + }
1.600 + if( pzTail ){
1.601 + *pzTail = sParse.zTail;
1.602 + }
1.603 + rc = sParse.rc;
1.604 +
1.605 +#ifndef SQLITE_OMIT_EXPLAIN
1.606 + if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){
1.607 + if( sParse.explain==2 ){
1.608 + sqlite3VdbeSetNumCols(sParse.pVdbe, 3);
1.609 + sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P4_STATIC);
1.610 + sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P4_STATIC);
1.611 + sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P4_STATIC);
1.612 + }else{
1.613 + sqlite3VdbeSetNumCols(sParse.pVdbe, 8);
1.614 + sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P4_STATIC);
1.615 + sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P4_STATIC);
1.616 + sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P4_STATIC);
1.617 + sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P4_STATIC);
1.618 + sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P4_STATIC);
1.619 + sqlite3VdbeSetColName(sParse.pVdbe, 5, COLNAME_NAME, "p4", P4_STATIC);
1.620 + sqlite3VdbeSetColName(sParse.pVdbe, 6, COLNAME_NAME, "p5", P4_STATIC);
1.621 + sqlite3VdbeSetColName(sParse.pVdbe, 7, COLNAME_NAME, "comment",P4_STATIC);
1.622 + }
1.623 + }
1.624 +#endif
1.625 +
1.626 + if( sqlite3SafetyOff(db) ){
1.627 + rc = SQLITE_MISUSE;
1.628 + }
1.629 +
1.630 + if( saveSqlFlag ){
1.631 + sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);
1.632 + }
1.633 + if( rc!=SQLITE_OK || db->mallocFailed ){
1.634 + sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
1.635 + assert(!(*ppStmt));
1.636 + }else{
1.637 + *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
1.638 + }
1.639 +
1.640 + if( zErrMsg ){
1.641 + sqlite3Error(db, rc, "%s", zErrMsg);
1.642 + sqlite3DbFree(db, zErrMsg);
1.643 + }else{
1.644 + sqlite3Error(db, rc, 0);
1.645 + }
1.646 +
1.647 + rc = sqlite3ApiExit(db, rc);
1.648 + assert( (rc&db->errMask)==rc );
1.649 + return rc;
1.650 +}
1.651 +static int sqlite3LockAndPrepare(
1.652 + sqlite3 *db, /* Database handle. */
1.653 + const char *zSql, /* UTF-8 encoded SQL statement. */
1.654 + int nBytes, /* Length of zSql in bytes. */
1.655 + int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
1.656 + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1.657 + const char **pzTail /* OUT: End of parsed string */
1.658 +){
1.659 + int rc;
1.660 + if( !sqlite3SafetyCheckOk(db) ){
1.661 + return SQLITE_MISUSE;
1.662 + }
1.663 + sqlite3_mutex_enter(db->mutex);
1.664 + sqlite3BtreeEnterAll(db);
1.665 + rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);
1.666 + sqlite3BtreeLeaveAll(db);
1.667 + sqlite3_mutex_leave(db->mutex);
1.668 + return rc;
1.669 +}
1.670 +
1.671 +/*
1.672 +** Rerun the compilation of a statement after a schema change.
1.673 +** Return true if the statement was recompiled successfully.
1.674 +** Return false if there is an error of some kind.
1.675 +*/
1.676 +int sqlite3Reprepare(Vdbe *p){
1.677 + int rc;
1.678 + sqlite3_stmt *pNew;
1.679 + const char *zSql;
1.680 + sqlite3 *db;
1.681 +
1.682 + assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
1.683 + zSql = sqlite3_sql((sqlite3_stmt *)p);
1.684 + assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
1.685 + db = sqlite3VdbeDb(p);
1.686 + assert( sqlite3_mutex_held(db->mutex) );
1.687 + rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0);
1.688 + if( rc ){
1.689 + if( rc==SQLITE_NOMEM ){
1.690 + db->mallocFailed = 1;
1.691 + }
1.692 + assert( pNew==0 );
1.693 + return 0;
1.694 + }else{
1.695 + assert( pNew!=0 );
1.696 + }
1.697 + sqlite3VdbeSwap((Vdbe*)pNew, p);
1.698 + sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p);
1.699 + sqlite3VdbeResetStepResult((Vdbe*)pNew);
1.700 + sqlite3VdbeFinalize((Vdbe*)pNew);
1.701 + return 1;
1.702 +}
1.703 +
1.704 +
1.705 +/*
1.706 +** Two versions of the official API. Legacy and new use. In the legacy
1.707 +** version, the original SQL text is not saved in the prepared statement
1.708 +** and so if a schema change occurs, SQLITE_SCHEMA is returned by
1.709 +** sqlite3_step(). In the new version, the original SQL text is retained
1.710 +** and the statement is automatically recompiled if an schema change
1.711 +** occurs.
1.712 +*/
1.713 +int sqlite3_prepare(
1.714 + sqlite3 *db, /* Database handle. */
1.715 + const char *zSql, /* UTF-8 encoded SQL statement. */
1.716 + int nBytes, /* Length of zSql in bytes. */
1.717 + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1.718 + const char **pzTail /* OUT: End of parsed string */
1.719 +){
1.720 + int rc;
1.721 + rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail);
1.722 + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
1.723 + return rc;
1.724 +}
1.725 +int sqlite3_prepare_v2(
1.726 + sqlite3 *db, /* Database handle. */
1.727 + const char *zSql, /* UTF-8 encoded SQL statement. */
1.728 + int nBytes, /* Length of zSql in bytes. */
1.729 + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1.730 + const char **pzTail /* OUT: End of parsed string */
1.731 +){
1.732 + int rc;
1.733 + rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail);
1.734 + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
1.735 + return rc;
1.736 +}
1.737 +
1.738 +
1.739 +#ifndef SQLITE_OMIT_UTF16
1.740 +/*
1.741 +** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
1.742 +*/
1.743 +static int sqlite3Prepare16(
1.744 + sqlite3 *db, /* Database handle. */
1.745 + const void *zSql, /* UTF-8 encoded SQL statement. */
1.746 + int nBytes, /* Length of zSql in bytes. */
1.747 + int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
1.748 + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1.749 + const void **pzTail /* OUT: End of parsed string */
1.750 +){
1.751 + /* This function currently works by first transforming the UTF-16
1.752 + ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
1.753 + ** tricky bit is figuring out the pointer to return in *pzTail.
1.754 + */
1.755 + char *zSql8;
1.756 + const char *zTail8 = 0;
1.757 + int rc = SQLITE_OK;
1.758 +
1.759 + if( !sqlite3SafetyCheckOk(db) ){
1.760 + return SQLITE_MISUSE;
1.761 + }
1.762 + sqlite3_mutex_enter(db->mutex);
1.763 + zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
1.764 + if( zSql8 ){
1.765 + rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
1.766 + }
1.767 +
1.768 + if( zTail8 && pzTail ){
1.769 + /* If sqlite3_prepare returns a tail pointer, we calculate the
1.770 + ** equivalent pointer into the UTF-16 string by counting the unicode
1.771 + ** characters between zSql8 and zTail8, and then returning a pointer
1.772 + ** the same number of characters into the UTF-16 string.
1.773 + */
1.774 + int chars_parsed = sqlite3Utf8CharLen(zSql8, zTail8-zSql8);
1.775 + *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
1.776 + }
1.777 + sqlite3DbFree(db, zSql8);
1.778 + rc = sqlite3ApiExit(db, rc);
1.779 + sqlite3_mutex_leave(db->mutex);
1.780 + return rc;
1.781 +}
1.782 +
1.783 +/*
1.784 +** Two versions of the official API. Legacy and new use. In the legacy
1.785 +** version, the original SQL text is not saved in the prepared statement
1.786 +** and so if a schema change occurs, SQLITE_SCHEMA is returned by
1.787 +** sqlite3_step(). In the new version, the original SQL text is retained
1.788 +** and the statement is automatically recompiled if an schema change
1.789 +** occurs.
1.790 +*/
1.791 +int sqlite3_prepare16(
1.792 + sqlite3 *db, /* Database handle. */
1.793 + const void *zSql, /* UTF-8 encoded SQL statement. */
1.794 + int nBytes, /* Length of zSql in bytes. */
1.795 + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1.796 + const void **pzTail /* OUT: End of parsed string */
1.797 +){
1.798 + int rc;
1.799 + rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
1.800 + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
1.801 + return rc;
1.802 +}
1.803 +int sqlite3_prepare16_v2(
1.804 + sqlite3 *db, /* Database handle. */
1.805 + const void *zSql, /* UTF-8 encoded SQL statement. */
1.806 + int nBytes, /* Length of zSql in bytes. */
1.807 + sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1.808 + const void **pzTail /* OUT: End of parsed string */
1.809 +){
1.810 + int rc;
1.811 + rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
1.812 + assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
1.813 + return rc;
1.814 +}
1.815 +
1.816 +#endif /* SQLITE_OMIT_UTF16 */