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