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