| OLD | NEW |
|---|
| (Empty) |
| 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 #ifndef SQLITE_OMIT_DEPRECATED | |
| 138 int size; | |
| 139 #endif | |
| 140 Table *pTab; | |
| 141 Db *pDb; | |
| 142 char const *azArg[4]; | |
| 143 int meta[5]; | |
| 144 InitData initData; | |
| 145 char const *zMasterSchema; | |
| 146 char const *zMasterName; | |
| 147 int openedTransaction = 0; | |
| 148 | |
| 149 /* | |
| 150 ** The master database table has a structure like this | |
| 151 */ | |
| 152 static const char master_schema[] = | |
| 153 "CREATE TABLE sqlite_master(\n" | |
| 154 " type text,\n" | |
| 155 " name text,\n" | |
| 156 " tbl_name text,\n" | |
| 157 " rootpage integer,\n" | |
| 158 " sql text\n" | |
| 159 ")" | |
| 160 ; | |
| 161 #ifndef SQLITE_OMIT_TEMPDB | |
| 162 static const char temp_master_schema[] = | |
| 163 "CREATE TEMP TABLE sqlite_temp_master(\n" | |
| 164 " type text,\n" | |
| 165 " name text,\n" | |
| 166 " tbl_name text,\n" | |
| 167 " rootpage integer,\n" | |
| 168 " sql text\n" | |
| 169 ")" | |
| 170 ; | |
| 171 #else | |
| 172 #define temp_master_schema 0 | |
| 173 #endif | |
| 174 | |
| 175 assert( iDb>=0 && iDb<db->nDb ); | |
| 176 assert( db->aDb[iDb].pSchema ); | |
| 177 assert( sqlite3_mutex_held(db->mutex) ); | |
| 178 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); | |
| 179 | |
| 180 /* zMasterSchema and zInitScript are set to point at the master schema | |
| 181 ** and initialisation script appropriate for the database being | |
| 182 ** initialized. zMasterName is the name of the master table. | |
| 183 */ | |
| 184 if( !OMIT_TEMPDB && iDb==1 ){ | |
| 185 zMasterSchema = temp_master_schema; | |
| 186 }else{ | |
| 187 zMasterSchema = master_schema; | |
| 188 } | |
| 189 zMasterName = SCHEMA_TABLE(iDb); | |
| 190 | |
| 191 /* Construct the schema tables. */ | |
| 192 azArg[0] = zMasterName; | |
| 193 azArg[1] = "1"; | |
| 194 azArg[2] = zMasterSchema; | |
| 195 azArg[3] = 0; | |
| 196 initData.db = db; | |
| 197 initData.iDb = iDb; | |
| 198 initData.rc = SQLITE_OK; | |
| 199 initData.pzErrMsg = pzErrMsg; | |
| 200 sqlite3InitCallback(&initData, 3, (char **)azArg, 0); | |
| 201 if( initData.rc ){ | |
| 202 rc = initData.rc; | |
| 203 goto error_out; | |
| 204 } | |
| 205 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName); | |
| 206 if( ALWAYS(pTab) ){ | |
| 207 pTab->tabFlags |= TF_Readonly; | |
| 208 } | |
| 209 | |
| 210 /* Create a cursor to hold the database open | |
| 211 */ | |
| 212 pDb = &db->aDb[iDb]; | |
| 213 if( pDb->pBt==0 ){ | |
| 214 if( !OMIT_TEMPDB && ALWAYS(iDb==1) ){ | |
| 215 DbSetProperty(db, 1, DB_SchemaLoaded); | |
| 216 } | |
| 217 return SQLITE_OK; | |
| 218 } | |
| 219 | |
| 220 /* If there is not already a read-only (or read-write) transaction opened | |
| 221 ** on the b-tree database, open one now. If a transaction is opened, it | |
| 222 ** will be closed before this function returns. */ | |
| 223 sqlite3BtreeEnter(pDb->pBt); | |
| 224 if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){ | |
| 225 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0); | |
| 226 if( rc!=SQLITE_OK ){ | |
| 227 sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc)); | |
| 228 goto initone_error_out; | |
| 229 } | |
| 230 openedTransaction = 1; | |
| 231 } | |
| 232 | |
| 233 /* Get the database meta information. | |
| 234 ** | |
| 235 ** Meta values are as follows: | |
| 236 ** meta[0] Schema cookie. Changes with each schema change. | |
| 237 ** meta[1] File format of schema layer. | |
| 238 ** meta[2] Size of the page cache. | |
| 239 ** meta[3] Largest rootpage (auto/incr_vacuum mode) | |
| 240 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE | |
| 241 ** meta[5] User version | |
| 242 ** meta[6] Incremental vacuum mode | |
| 243 ** meta[7] unused | |
| 244 ** meta[8] unused | |
| 245 ** meta[9] unused | |
| 246 ** | |
| 247 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to | |
| 248 ** the possible values of meta[4]. | |
| 249 */ | |
| 250 for(i=0; i<ArraySize(meta); i++){ | |
| 251 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]); | |
| 252 } | |
| 253 pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1]; | |
| 254 | |
| 255 /* If opening a non-empty database, check the text encoding. For the | |
| 256 ** main database, set sqlite3.enc to the encoding of the main database. | |
| 257 ** For an attached db, it is an error if the encoding is not the same | |
| 258 ** as sqlite3.enc. | |
| 259 */ | |
| 260 if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */ | |
| 261 if( iDb==0 ){ | |
| 262 #ifndef SQLITE_OMIT_UTF16 | |
| 263 u8 encoding; | |
| 264 /* If opening the main database, set ENC(db). */ | |
| 265 encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3; | |
| 266 if( encoding==0 ) encoding = SQLITE_UTF8; | |
| 267 ENC(db) = encoding; | |
| 268 #else | |
| 269 ENC(db) = SQLITE_UTF8; | |
| 270 #endif | |
| 271 }else{ | |
| 272 /* If opening an attached database, the encoding much match ENC(db) */ | |
| 273 if( meta[BTREE_TEXT_ENCODING-1]!=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 #ifndef SQLITE_OMIT_DEPRECATED | |
| 287 size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]); | |
| 288 if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } | |
| 289 pDb->pSchema->cache_size = size; | |
| 290 #else | |
| 291 pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE; | |
| 292 #endif | |
| 293 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); | |
| 294 } | |
| 295 | |
| 296 /* | |
| 297 ** file_format==1 Version 3.0.0. | |
| 298 ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN | |
| 299 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults | |
| 300 ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants | |
| 301 */ | |
| 302 pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1]; | |
| 303 if( pDb->pSchema->file_format==0 ){ | |
| 304 pDb->pSchema->file_format = 1; | |
| 305 } | |
| 306 if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ | |
| 307 sqlite3SetString(pzErrMsg, db, "unsupported file format"); | |
| 308 rc = SQLITE_ERROR; | |
| 309 goto initone_error_out; | |
| 310 } | |
| 311 | |
| 312 /* Ticket #2804: When we open a database in the newer file format, | |
| 313 ** clear the legacy_file_format pragma flag so that a VACUUM will | |
| 314 ** not downgrade the database and thus invalidate any descending | |
| 315 ** indices that the user might have created. | |
| 316 */ | |
| 317 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){ | |
| 318 db->flags &= ~SQLITE_LegacyFileFmt; | |
| 319 } | |
| 320 | |
| 321 /* Read the schema information out of the schema tables | |
| 322 */ | |
| 323 assert( db->init.busy ); | |
| 324 { | |
| 325 char *zSql; | |
| 326 zSql = sqlite3MPrintf(db, | |
| 327 "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid", | |
| 328 db->aDb[iDb].zName, zMasterName); | |
| 329 #ifndef SQLITE_OMIT_AUTHORIZATION | |
| 330 { | |
| 331 sqlite3_xauth xAuth; | |
| 332 xAuth = db->xAuth; | |
| 333 db->xAuth = 0; | |
| 334 #endif | |
| 335 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); | |
| 336 #ifndef SQLITE_OMIT_AUTHORIZATION | |
| 337 db->xAuth = xAuth; | |
| 338 } | |
| 339 #endif | |
| 340 if( rc==SQLITE_OK ) rc = initData.rc; | |
| 341 sqlite3DbFree(db, zSql); | |
| 342 #ifndef SQLITE_OMIT_ANALYZE | |
| 343 if( rc==SQLITE_OK ){ | |
| 344 sqlite3AnalysisLoad(db, iDb); | |
| 345 } | |
| 346 #endif | |
| 347 } | |
| 348 if( db->mallocFailed ){ | |
| 349 rc = SQLITE_NOMEM; | |
| 350 sqlite3ResetAllSchemasOfConnection(db); | |
| 351 } | |
| 352 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){ | |
| 353 /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider | |
| 354 ** the schema loaded, even if errors occurred. In this situation the | |
| 355 ** current sqlite3_prepare() operation will fail, but the following one | |
| 356 ** will attempt to compile the supplied statement against whatever subset | |
| 357 ** of the schema was loaded before the error occurred. The primary | |
| 358 ** purpose of this is to allow access to the sqlite_master table | |
| 359 ** even when its contents have been corrupted. | |
| 360 */ | |
| 361 DbSetProperty(db, iDb, DB_SchemaLoaded); | |
| 362 rc = SQLITE_OK; | |
| 363 } | |
| 364 | |
| 365 /* Jump here for an error that occurs after successfully allocating | |
| 366 ** curMain and calling sqlite3BtreeEnter(). For an error that occurs | |
| 367 ** before that point, jump to error_out. | |
| 368 */ | |
| 369 initone_error_out: | |
| 370 if( openedTransaction ){ | |
| 371 sqlite3BtreeCommit(pDb->pBt); | |
| 372 } | |
| 373 sqlite3BtreeLeave(pDb->pBt); | |
| 374 | |
| 375 error_out: | |
| 376 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ | |
| 377 db->mallocFailed = 1; | |
| 378 } | |
| 379 return rc; | |
| 380 } | |
| 381 | |
| 382 /* | |
| 383 ** Initialize all database files - the main database file, the file | |
| 384 ** used to store temporary tables, and any additional database files | |
| 385 ** created using ATTACH statements. Return a success code. If an | |
| 386 ** error occurs, write an error message into *pzErrMsg. | |
| 387 ** | |
| 388 ** After a database is initialized, the DB_SchemaLoaded bit is set | |
| 389 ** bit is set in the flags field of the Db structure. If the database | |
| 390 ** file was of zero-length, then the DB_Empty flag is also set. | |
| 391 */ | |
| 392 int sqlite3Init(sqlite3 *db, char **pzErrMsg){ | |
| 393 int i, rc; | |
| 394 int commit_internal = !(db->flags&SQLITE_InternChanges); | |
| 395 | |
| 396 assert( sqlite3_mutex_held(db->mutex) ); | |
| 397 assert( db->init.busy==0 ); | |
| 398 rc = SQLITE_OK; | |
| 399 db->init.busy = 1; | |
| 400 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ | |
| 401 if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue; | |
| 402 rc = sqlite3InitOne(db, i, pzErrMsg); | |
| 403 if( rc ){ | |
| 404 sqlite3ResetOneSchema(db, i); | |
| 405 } | |
| 406 } | |
| 407 | |
| 408 /* Once all the other databases have been initialized, load the schema | |
| 409 ** for the TEMP database. This is loaded last, as the TEMP database | |
| 410 ** schema may contain references to objects in other databases. | |
| 411 */ | |
| 412 #ifndef SQLITE_OMIT_TEMPDB | |
| 413 assert( db->nDb>1 ); | |
| 414 if( rc==SQLITE_OK && !DbHasProperty(db, 1, DB_SchemaLoaded) ){ | |
| 415 rc = sqlite3InitOne(db, 1, pzErrMsg); | |
| 416 if( rc ){ | |
| 417 sqlite3ResetOneSchema(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 initialized. | |
| 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 set pParse->rc to SQLITE_SCHEMA. If all schema cookies | |
| 452 ** make no changes to pParse->rc. | |
| 453 */ | |
| 454 static void schemaIsValid(Parse *pParse){ | |
| 455 sqlite3 *db = pParse->db; | |
| 456 int iDb; | |
| 457 int rc; | |
| 458 int cookie; | |
| 459 | |
| 460 assert( pParse->checkSchema ); | |
| 461 assert( sqlite3_mutex_held(db->mutex) ); | |
| 462 for(iDb=0; iDb<db->nDb; iDb++){ | |
| 463 int openedTransaction = 0; /* True if a transaction is opened */ | |
| 464 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */ | |
| 465 if( pBt==0 ) continue; | |
| 466 | |
| 467 /* If there is not already a read-only (or read-write) transaction opened | |
| 468 ** on the b-tree database, open one now. If a transaction is opened, it | |
| 469 ** will be closed immediately after reading the meta-value. */ | |
| 470 if( !sqlite3BtreeIsInReadTrans(pBt) ){ | |
| 471 rc = sqlite3BtreeBeginTrans(pBt, 0); | |
| 472 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ | |
| 473 db->mallocFailed = 1; | |
| 474 } | |
| 475 if( rc!=SQLITE_OK ) return; | |
| 476 openedTransaction = 1; | |
| 477 } | |
| 478 | |
| 479 /* Read the schema cookie from the database. If it does not match the | |
| 480 ** value stored as part of the in-memory schema representation, | |
| 481 ** set Parse.rc to SQLITE_SCHEMA. */ | |
| 482 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie); | |
| 483 assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); | |
| 484 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){ | |
| 485 sqlite3ResetOneSchema(db, iDb); | |
| 486 pParse->rc = SQLITE_SCHEMA; | |
| 487 } | |
| 488 | |
| 489 /* Close the transaction, if one was opened. */ | |
| 490 if( openedTransaction ){ | |
| 491 sqlite3BtreeCommit(pBt); | |
| 492 } | |
| 493 } | |
| 494 } | |
| 495 | |
| 496 /* | |
| 497 ** Convert a schema pointer into the iDb index that indicates | |
| 498 ** which database file in db->aDb[] the schema refers to. | |
| 499 ** | |
| 500 ** If the same database is attached more than once, the first | |
| 501 ** attached database is returned. | |
| 502 */ | |
| 503 int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ | |
| 504 int i = -1000000; | |
| 505 | |
| 506 /* If pSchema is NULL, then return -1000000. This happens when code in | |
| 507 ** expr.c is trying to resolve a reference to a transient table (i.e. one | |
| 508 ** created by a sub-select). In this case the return value of this | |
| 509 ** function should never be used. | |
| 510 ** | |
| 511 ** We return -1000000 instead of the more usual -1 simply because using | |
| 512 ** -1000000 as the incorrect index into db->aDb[] is much | |
| 513 ** more likely to cause a segfault than -1 (of course there are assert() | |
| 514 ** statements too, but it never hurts to play the odds). | |
| 515 */ | |
| 516 assert( sqlite3_mutex_held(db->mutex) ); | |
| 517 if( pSchema ){ | |
| 518 for(i=0; ALWAYS(i<db->nDb); i++){ | |
| 519 if( db->aDb[i].pSchema==pSchema ){ | |
| 520 break; | |
| 521 } | |
| 522 } | |
| 523 assert( i>=0 && i<db->nDb ); | |
| 524 } | |
| 525 return i; | |
| 526 } | |
| 527 | |
| 528 /* | |
| 529 ** Free all memory allocations in the pParse object | |
| 530 */ | |
| 531 void sqlite3ParserReset(Parse *pParse){ | |
| 532 if( pParse ){ | |
| 533 sqlite3 *db = pParse->db; | |
| 534 sqlite3DbFree(db, pParse->aLabel); | |
| 535 sqlite3ExprListDelete(db, pParse->pConstExpr); | |
| 536 } | |
| 537 } | |
| 538 | |
| 539 /* | |
| 540 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle. | |
| 541 */ | |
| 542 static int sqlite3Prepare( | |
| 543 sqlite3 *db, /* Database handle. */ | |
| 544 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 545 int nBytes, /* Length of zSql in bytes. */ | |
| 546 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ | |
| 547 Vdbe *pReprepare, /* VM being reprepared */ | |
| 548 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 549 const char **pzTail /* OUT: End of parsed string */ | |
| 550 ){ | |
| 551 Parse *pParse; /* Parsing context */ | |
| 552 char *zErrMsg = 0; /* Error message */ | |
| 553 int rc = SQLITE_OK; /* Result code */ | |
| 554 int i; /* Loop counter */ | |
| 555 | |
| 556 /* Allocate the parsing context */ | |
| 557 pParse = sqlite3StackAllocZero(db, sizeof(*pParse)); | |
| 558 if( pParse==0 ){ | |
| 559 rc = SQLITE_NOMEM; | |
| 560 goto end_prepare; | |
| 561 } | |
| 562 pParse->pReprepare = pReprepare; | |
| 563 assert( ppStmt && *ppStmt==0 ); | |
| 564 assert( !db->mallocFailed ); | |
| 565 assert( sqlite3_mutex_held(db->mutex) ); | |
| 566 | |
| 567 /* Check to verify that it is possible to get a read lock on all | |
| 568 ** database schemas. The inability to get a read lock indicates that | |
| 569 ** some other database connection is holding a write-lock, which in | |
| 570 ** turn means that the other connection has made uncommitted changes | |
| 571 ** to the schema. | |
| 572 ** | |
| 573 ** Were we to proceed and prepare the statement against the uncommitted | |
| 574 ** schema changes and if those schema changes are subsequently rolled | |
| 575 ** back and different changes are made in their place, then when this | |
| 576 ** prepared statement goes to run the schema cookie would fail to detect | |
| 577 ** the schema change. Disaster would follow. | |
| 578 ** | |
| 579 ** This thread is currently holding mutexes on all Btrees (because | |
| 580 ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it | |
| 581 ** is not possible for another thread to start a new schema change | |
| 582 ** while this routine is running. Hence, we do not need to hold | |
| 583 ** locks on the schema, we just need to make sure nobody else is | |
| 584 ** holding them. | |
| 585 ** | |
| 586 ** Note that setting READ_UNCOMMITTED overrides most lock detection, | |
| 587 ** but it does *not* override schema lock detection, so this all still | |
| 588 ** works even if READ_UNCOMMITTED is set. | |
| 589 */ | |
| 590 for(i=0; i<db->nDb; i++) { | |
| 591 Btree *pBt = db->aDb[i].pBt; | |
| 592 if( pBt ){ | |
| 593 assert( sqlite3BtreeHoldsMutex(pBt) ); | |
| 594 rc = sqlite3BtreeSchemaLocked(pBt); | |
| 595 if( rc ){ | |
| 596 const char *zDb = db->aDb[i].zName; | |
| 597 sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb); | |
| 598 testcase( db->flags & SQLITE_ReadUncommitted ); | |
| 599 goto end_prepare; | |
| 600 } | |
| 601 } | |
| 602 } | |
| 603 | |
| 604 sqlite3VtabUnlockList(db); | |
| 605 | |
| 606 pParse->db = db; | |
| 607 pParse->nQueryLoop = 0; /* Logarithmic, so 0 really means 1 */ | |
| 608 if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ | |
| 609 char *zSqlCopy; | |
| 610 int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; | |
| 611 testcase( nBytes==mxLen ); | |
| 612 testcase( nBytes==mxLen+1 ); | |
| 613 if( nBytes>mxLen ){ | |
| 614 sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long"); | |
| 615 rc = sqlite3ApiExit(db, SQLITE_TOOBIG); | |
| 616 goto end_prepare; | |
| 617 } | |
| 618 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); | |
| 619 if( zSqlCopy ){ | |
| 620 sqlite3RunParser(pParse, zSqlCopy, &zErrMsg); | |
| 621 sqlite3DbFree(db, zSqlCopy); | |
| 622 pParse->zTail = &zSql[pParse->zTail-zSqlCopy]; | |
| 623 }else{ | |
| 624 pParse->zTail = &zSql[nBytes]; | |
| 625 } | |
| 626 }else{ | |
| 627 sqlite3RunParser(pParse, zSql, &zErrMsg); | |
| 628 } | |
| 629 assert( 0==pParse->nQueryLoop ); | |
| 630 | |
| 631 if( db->mallocFailed ){ | |
| 632 pParse->rc = SQLITE_NOMEM; | |
| 633 } | |
| 634 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK; | |
| 635 if( pParse->checkSchema ){ | |
| 636 schemaIsValid(pParse); | |
| 637 } | |
| 638 if( db->mallocFailed ){ | |
| 639 pParse->rc = SQLITE_NOMEM; | |
| 640 } | |
| 641 if( pzTail ){ | |
| 642 *pzTail = pParse->zTail; | |
| 643 } | |
| 644 rc = pParse->rc; | |
| 645 | |
| 646 #ifndef SQLITE_OMIT_EXPLAIN | |
| 647 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){ | |
| 648 static const char * const azColName[] = { | |
| 649 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment", | |
| 650 "selectid", "order", "from", "detail" | |
| 651 }; | |
| 652 int iFirst, mx; | |
| 653 if( pParse->explain==2 ){ | |
| 654 sqlite3VdbeSetNumCols(pParse->pVdbe, 4); | |
| 655 iFirst = 8; | |
| 656 mx = 12; | |
| 657 }else{ | |
| 658 sqlite3VdbeSetNumCols(pParse->pVdbe, 8); | |
| 659 iFirst = 0; | |
| 660 mx = 8; | |
| 661 } | |
| 662 for(i=iFirst; i<mx; i++){ | |
| 663 sqlite3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME, | |
| 664 azColName[i], SQLITE_STATIC); | |
| 665 } | |
| 666 } | |
| 667 #endif | |
| 668 | |
| 669 if( db->init.busy==0 ){ | |
| 670 Vdbe *pVdbe = pParse->pVdbe; | |
| 671 sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag); | |
| 672 } | |
| 673 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){ | |
| 674 sqlite3VdbeFinalize(pParse->pVdbe); | |
| 675 assert(!(*ppStmt)); | |
| 676 }else{ | |
| 677 *ppStmt = (sqlite3_stmt*)pParse->pVdbe; | |
| 678 } | |
| 679 | |
| 680 if( zErrMsg ){ | |
| 681 sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); | |
| 682 sqlite3DbFree(db, zErrMsg); | |
| 683 }else{ | |
| 684 sqlite3Error(db, rc); | |
| 685 } | |
| 686 | |
| 687 /* Delete any TriggerPrg structures allocated while parsing this statement. */ | |
| 688 while( pParse->pTriggerPrg ){ | |
| 689 TriggerPrg *pT = pParse->pTriggerPrg; | |
| 690 pParse->pTriggerPrg = pT->pNext; | |
| 691 sqlite3DbFree(db, pT); | |
| 692 } | |
| 693 | |
| 694 end_prepare: | |
| 695 | |
| 696 sqlite3ParserReset(pParse); | |
| 697 sqlite3StackFree(db, pParse); | |
| 698 rc = sqlite3ApiExit(db, rc); | |
| 699 assert( (rc&db->errMask)==rc ); | |
| 700 return rc; | |
| 701 } | |
| 702 static int sqlite3LockAndPrepare( | |
| 703 sqlite3 *db, /* Database handle. */ | |
| 704 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 705 int nBytes, /* Length of zSql in bytes. */ | |
| 706 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ | |
| 707 Vdbe *pOld, /* VM being reprepared */ | |
| 708 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 709 const char **pzTail /* OUT: End of parsed string */ | |
| 710 ){ | |
| 711 int rc; | |
| 712 assert( ppStmt!=0 ); | |
| 713 *ppStmt = 0; | |
| 714 if( !sqlite3SafetyCheckOk(db) ){ | |
| 715 return SQLITE_MISUSE_BKPT; | |
| 716 } | |
| 717 sqlite3_mutex_enter(db->mutex); | |
| 718 sqlite3BtreeEnterAll(db); | |
| 719 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); | |
| 720 if( rc==SQLITE_SCHEMA ){ | |
| 721 sqlite3_finalize(*ppStmt); | |
| 722 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); | |
| 723 } | |
| 724 sqlite3BtreeLeaveAll(db); | |
| 725 sqlite3_mutex_leave(db->mutex); | |
| 726 assert( rc==SQLITE_OK || *ppStmt==0 ); | |
| 727 return rc; | |
| 728 } | |
| 729 | |
| 730 /* | |
| 731 ** Rerun the compilation of a statement after a schema change. | |
| 732 ** | |
| 733 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise, | |
| 734 ** if the statement cannot be recompiled because another connection has | |
| 735 ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error | |
| 736 ** occurs, return SQLITE_SCHEMA. | |
| 737 */ | |
| 738 int sqlite3Reprepare(Vdbe *p){ | |
| 739 int rc; | |
| 740 sqlite3_stmt *pNew; | |
| 741 const char *zSql; | |
| 742 sqlite3 *db; | |
| 743 | |
| 744 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); | |
| 745 zSql = sqlite3_sql((sqlite3_stmt *)p); | |
| 746 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */ | |
| 747 db = sqlite3VdbeDb(p); | |
| 748 assert( sqlite3_mutex_held(db->mutex) ); | |
| 749 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0); | |
| 750 if( rc ){ | |
| 751 if( rc==SQLITE_NOMEM ){ | |
| 752 db->mallocFailed = 1; | |
| 753 } | |
| 754 assert( pNew==0 ); | |
| 755 return rc; | |
| 756 }else{ | |
| 757 assert( pNew!=0 ); | |
| 758 } | |
| 759 sqlite3VdbeSwap((Vdbe*)pNew, p); | |
| 760 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p); | |
| 761 sqlite3VdbeResetStepResult((Vdbe*)pNew); | |
| 762 sqlite3VdbeFinalize((Vdbe*)pNew); | |
| 763 return SQLITE_OK; | |
| 764 } | |
| 765 | |
| 766 | |
| 767 /* | |
| 768 ** Two versions of the official API. Legacy and new use. In the legacy | |
| 769 ** version, the original SQL text is not saved in the prepared statement | |
| 770 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by | |
| 771 ** sqlite3_step(). In the new version, the original SQL text is retained | |
| 772 ** and the statement is automatically recompiled if an schema change | |
| 773 ** occurs. | |
| 774 */ | |
| 775 int sqlite3_prepare( | |
| 776 sqlite3 *db, /* Database handle. */ | |
| 777 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 778 int nBytes, /* Length of zSql in bytes. */ | |
| 779 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 780 const char **pzTail /* OUT: End of parsed string */ | |
| 781 ){ | |
| 782 int rc; | |
| 783 rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail); | |
| 784 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 785 return rc; | |
| 786 } | |
| 787 int sqlite3_prepare_v2( | |
| 788 sqlite3 *db, /* Database handle. */ | |
| 789 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 790 int nBytes, /* Length of zSql in bytes. */ | |
| 791 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 792 const char **pzTail /* OUT: End of parsed string */ | |
| 793 ){ | |
| 794 int rc; | |
| 795 rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail); | |
| 796 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 797 return rc; | |
| 798 } | |
| 799 | |
| 800 | |
| 801 #ifndef SQLITE_OMIT_UTF16 | |
| 802 /* | |
| 803 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle. | |
| 804 */ | |
| 805 static int sqlite3Prepare16( | |
| 806 sqlite3 *db, /* Database handle. */ | |
| 807 const void *zSql, /* UTF-16 encoded SQL statement. */ | |
| 808 int nBytes, /* Length of zSql in bytes. */ | |
| 809 int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */ | |
| 810 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 811 const void **pzTail /* OUT: End of parsed string */ | |
| 812 ){ | |
| 813 /* This function currently works by first transforming the UTF-16 | |
| 814 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The | |
| 815 ** tricky bit is figuring out the pointer to return in *pzTail. | |
| 816 */ | |
| 817 char *zSql8; | |
| 818 const char *zTail8 = 0; | |
| 819 int rc = SQLITE_OK; | |
| 820 | |
| 821 assert( ppStmt ); | |
| 822 *ppStmt = 0; | |
| 823 if( !sqlite3SafetyCheckOk(db) ){ | |
| 824 return SQLITE_MISUSE_BKPT; | |
| 825 } | |
| 826 if( nBytes>=0 ){ | |
| 827 int sz; | |
| 828 const char *z = (const char*)zSql; | |
| 829 for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){} | |
| 830 nBytes = sz; | |
| 831 } | |
| 832 sqlite3_mutex_enter(db->mutex); | |
| 833 zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); | |
| 834 if( zSql8 ){ | |
| 835 rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8); | |
| 836 } | |
| 837 | |
| 838 if( zTail8 && pzTail ){ | |
| 839 /* If sqlite3_prepare returns a tail pointer, we calculate the | |
| 840 ** equivalent pointer into the UTF-16 string by counting the unicode | |
| 841 ** characters between zSql8 and zTail8, and then returning a pointer | |
| 842 ** the same number of characters into the UTF-16 string. | |
| 843 */ | |
| 844 int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8)); | |
| 845 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); | |
| 846 } | |
| 847 sqlite3DbFree(db, zSql8); | |
| 848 rc = sqlite3ApiExit(db, rc); | |
| 849 sqlite3_mutex_leave(db->mutex); | |
| 850 return rc; | |
| 851 } | |
| 852 | |
| 853 /* | |
| 854 ** Two versions of the official API. Legacy and new use. In the legacy | |
| 855 ** version, the original SQL text is not saved in the prepared statement | |
| 856 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by | |
| 857 ** sqlite3_step(). In the new version, the original SQL text is retained | |
| 858 ** and the statement is automatically recompiled if an schema change | |
| 859 ** occurs. | |
| 860 */ | |
| 861 int sqlite3_prepare16( | |
| 862 sqlite3 *db, /* Database handle. */ | |
| 863 const void *zSql, /* UTF-16 encoded SQL statement. */ | |
| 864 int nBytes, /* Length of zSql in bytes. */ | |
| 865 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 866 const void **pzTail /* OUT: End of parsed string */ | |
| 867 ){ | |
| 868 int rc; | |
| 869 rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); | |
| 870 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 871 return rc; | |
| 872 } | |
| 873 int sqlite3_prepare16_v2( | |
| 874 sqlite3 *db, /* Database handle. */ | |
| 875 const void *zSql, /* UTF-16 encoded SQL statement. */ | |
| 876 int nBytes, /* Length of zSql in bytes. */ | |
| 877 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 878 const void **pzTail /* OUT: End of parsed string */ | |
| 879 ){ | |
| 880 int rc; | |
| 881 rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail); | |
| 882 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 883 return rc; | |
| 884 } | |
| 885 | |
| 886 #endif /* SQLITE_OMIT_UTF16 */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2363173002:
[sqlite] Remove obsolete reference version 3.8.7.4. (Closed)
