| 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 char *z; | |
| 30 if( zObj==0 ) zObj = "?"; | |
| 31 z = sqlite3_mprintf("malformed database schema (%s)", zObj); | |
| 32 if( z && zExtra ) z = sqlite3_mprintf("%z - %s", z, zExtra); | |
| 33 sqlite3DbFree(db, *pData->pzErrMsg); | |
| 34 *pData->pzErrMsg = z; | |
| 35 if( z==0 ) db->mallocFailed = 1; | |
| 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( sqlite3_strnicmp(argv[2],"create ",7)==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 || (argv[2]!=0 && argv[2][0]!=0) ){ | |
| 102 corruptSchema(pData, argv[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, 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( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) ); | |
| 398 assert( db->init.busy==0 ); | |
| 399 rc = SQLITE_OK; | |
| 400 db->init.busy = 1; | |
| 401 ENC(db) = SCHEMA_ENC(db); | |
| 402 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){ | |
| 403 if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue; | |
| 404 rc = sqlite3InitOne(db, i, pzErrMsg); | |
| 405 if( rc ){ | |
| 406 sqlite3ResetOneSchema(db, i); | |
| 407 } | |
| 408 } | |
| 409 | |
| 410 /* Once all the other databases have been initialized, load the schema | |
| 411 ** for the TEMP database. This is loaded last, as the TEMP database | |
| 412 ** schema may contain references to objects in other databases. | |
| 413 */ | |
| 414 #ifndef SQLITE_OMIT_TEMPDB | |
| 415 assert( db->nDb>1 ); | |
| 416 if( rc==SQLITE_OK && !DbHasProperty(db, 1, DB_SchemaLoaded) ){ | |
| 417 rc = sqlite3InitOne(db, 1, pzErrMsg); | |
| 418 if( rc ){ | |
| 419 sqlite3ResetOneSchema(db, 1); | |
| 420 } | |
| 421 } | |
| 422 #endif | |
| 423 | |
| 424 db->init.busy = 0; | |
| 425 if( rc==SQLITE_OK && commit_internal ){ | |
| 426 sqlite3CommitInternalChanges(db); | |
| 427 } | |
| 428 | |
| 429 return rc; | |
| 430 } | |
| 431 | |
| 432 /* | |
| 433 ** This routine is a no-op if the database schema is already initialized. | |
| 434 ** Otherwise, the schema is loaded. An error code is returned. | |
| 435 */ | |
| 436 int sqlite3ReadSchema(Parse *pParse){ | |
| 437 int rc = SQLITE_OK; | |
| 438 sqlite3 *db = pParse->db; | |
| 439 assert( sqlite3_mutex_held(db->mutex) ); | |
| 440 if( !db->init.busy ){ | |
| 441 rc = sqlite3Init(db, &pParse->zErrMsg); | |
| 442 } | |
| 443 if( rc!=SQLITE_OK ){ | |
| 444 pParse->rc = rc; | |
| 445 pParse->nErr++; | |
| 446 } | |
| 447 return rc; | |
| 448 } | |
| 449 | |
| 450 | |
| 451 /* | |
| 452 ** Check schema cookies in all databases. If any cookie is out | |
| 453 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies | |
| 454 ** make no changes to pParse->rc. | |
| 455 */ | |
| 456 static void schemaIsValid(Parse *pParse){ | |
| 457 sqlite3 *db = pParse->db; | |
| 458 int iDb; | |
| 459 int rc; | |
| 460 int cookie; | |
| 461 | |
| 462 assert( pParse->checkSchema ); | |
| 463 assert( sqlite3_mutex_held(db->mutex) ); | |
| 464 for(iDb=0; iDb<db->nDb; iDb++){ | |
| 465 int openedTransaction = 0; /* True if a transaction is opened */ | |
| 466 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */ | |
| 467 if( pBt==0 ) continue; | |
| 468 | |
| 469 /* If there is not already a read-only (or read-write) transaction opened | |
| 470 ** on the b-tree database, open one now. If a transaction is opened, it | |
| 471 ** will be closed immediately after reading the meta-value. */ | |
| 472 if( !sqlite3BtreeIsInReadTrans(pBt) ){ | |
| 473 rc = sqlite3BtreeBeginTrans(pBt, 0); | |
| 474 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ | |
| 475 db->mallocFailed = 1; | |
| 476 } | |
| 477 if( rc!=SQLITE_OK ) return; | |
| 478 openedTransaction = 1; | |
| 479 } | |
| 480 | |
| 481 /* Read the schema cookie from the database. If it does not match the | |
| 482 ** value stored as part of the in-memory schema representation, | |
| 483 ** set Parse.rc to SQLITE_SCHEMA. */ | |
| 484 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie); | |
| 485 assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); | |
| 486 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){ | |
| 487 sqlite3ResetOneSchema(db, iDb); | |
| 488 pParse->rc = SQLITE_SCHEMA; | |
| 489 } | |
| 490 | |
| 491 /* Close the transaction, if one was opened. */ | |
| 492 if( openedTransaction ){ | |
| 493 sqlite3BtreeCommit(pBt); | |
| 494 } | |
| 495 } | |
| 496 } | |
| 497 | |
| 498 /* | |
| 499 ** Convert a schema pointer into the iDb index that indicates | |
| 500 ** which database file in db->aDb[] the schema refers to. | |
| 501 ** | |
| 502 ** If the same database is attached more than once, the first | |
| 503 ** attached database is returned. | |
| 504 */ | |
| 505 int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ | |
| 506 int i = -1000000; | |
| 507 | |
| 508 /* If pSchema is NULL, then return -1000000. This happens when code in | |
| 509 ** expr.c is trying to resolve a reference to a transient table (i.e. one | |
| 510 ** created by a sub-select). In this case the return value of this | |
| 511 ** function should never be used. | |
| 512 ** | |
| 513 ** We return -1000000 instead of the more usual -1 simply because using | |
| 514 ** -1000000 as the incorrect index into db->aDb[] is much | |
| 515 ** more likely to cause a segfault than -1 (of course there are assert() | |
| 516 ** statements too, but it never hurts to play the odds). | |
| 517 */ | |
| 518 assert( sqlite3_mutex_held(db->mutex) ); | |
| 519 if( pSchema ){ | |
| 520 for(i=0; ALWAYS(i<db->nDb); i++){ | |
| 521 if( db->aDb[i].pSchema==pSchema ){ | |
| 522 break; | |
| 523 } | |
| 524 } | |
| 525 assert( i>=0 && i<db->nDb ); | |
| 526 } | |
| 527 return i; | |
| 528 } | |
| 529 | |
| 530 /* | |
| 531 ** Free all memory allocations in the pParse object | |
| 532 */ | |
| 533 void sqlite3ParserReset(Parse *pParse){ | |
| 534 if( pParse ){ | |
| 535 sqlite3 *db = pParse->db; | |
| 536 sqlite3DbFree(db, pParse->aLabel); | |
| 537 sqlite3ExprListDelete(db, pParse->pConstExpr); | |
| 538 } | |
| 539 } | |
| 540 | |
| 541 /* | |
| 542 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle. | |
| 543 */ | |
| 544 static int sqlite3Prepare( | |
| 545 sqlite3 *db, /* Database handle. */ | |
| 546 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 547 int nBytes, /* Length of zSql in bytes. */ | |
| 548 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ | |
| 549 Vdbe *pReprepare, /* VM being reprepared */ | |
| 550 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 551 const char **pzTail /* OUT: End of parsed string */ | |
| 552 ){ | |
| 553 Parse *pParse; /* Parsing context */ | |
| 554 char *zErrMsg = 0; /* Error message */ | |
| 555 int rc = SQLITE_OK; /* Result code */ | |
| 556 int i; /* Loop counter */ | |
| 557 | |
| 558 /* Allocate the parsing context */ | |
| 559 pParse = sqlite3StackAllocZero(db, sizeof(*pParse)); | |
| 560 if( pParse==0 ){ | |
| 561 rc = SQLITE_NOMEM; | |
| 562 goto end_prepare; | |
| 563 } | |
| 564 pParse->pReprepare = pReprepare; | |
| 565 assert( ppStmt && *ppStmt==0 ); | |
| 566 assert( !db->mallocFailed ); | |
| 567 assert( sqlite3_mutex_held(db->mutex) ); | |
| 568 | |
| 569 /* Check to verify that it is possible to get a read lock on all | |
| 570 ** database schemas. The inability to get a read lock indicates that | |
| 571 ** some other database connection is holding a write-lock, which in | |
| 572 ** turn means that the other connection has made uncommitted changes | |
| 573 ** to the schema. | |
| 574 ** | |
| 575 ** Were we to proceed and prepare the statement against the uncommitted | |
| 576 ** schema changes and if those schema changes are subsequently rolled | |
| 577 ** back and different changes are made in their place, then when this | |
| 578 ** prepared statement goes to run the schema cookie would fail to detect | |
| 579 ** the schema change. Disaster would follow. | |
| 580 ** | |
| 581 ** This thread is currently holding mutexes on all Btrees (because | |
| 582 ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it | |
| 583 ** is not possible for another thread to start a new schema change | |
| 584 ** while this routine is running. Hence, we do not need to hold | |
| 585 ** locks on the schema, we just need to make sure nobody else is | |
| 586 ** holding them. | |
| 587 ** | |
| 588 ** Note that setting READ_UNCOMMITTED overrides most lock detection, | |
| 589 ** but it does *not* override schema lock detection, so this all still | |
| 590 ** works even if READ_UNCOMMITTED is set. | |
| 591 */ | |
| 592 for(i=0; i<db->nDb; i++) { | |
| 593 Btree *pBt = db->aDb[i].pBt; | |
| 594 if( pBt ){ | |
| 595 assert( sqlite3BtreeHoldsMutex(pBt) ); | |
| 596 rc = sqlite3BtreeSchemaLocked(pBt); | |
| 597 if( rc ){ | |
| 598 const char *zDb = db->aDb[i].zName; | |
| 599 sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb); | |
| 600 testcase( db->flags & SQLITE_ReadUncommitted ); | |
| 601 goto end_prepare; | |
| 602 } | |
| 603 } | |
| 604 } | |
| 605 | |
| 606 sqlite3VtabUnlockList(db); | |
| 607 | |
| 608 pParse->db = db; | |
| 609 pParse->nQueryLoop = 0; /* Logarithmic, so 0 really means 1 */ | |
| 610 if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ | |
| 611 char *zSqlCopy; | |
| 612 int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; | |
| 613 testcase( nBytes==mxLen ); | |
| 614 testcase( nBytes==mxLen+1 ); | |
| 615 if( nBytes>mxLen ){ | |
| 616 sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long"); | |
| 617 rc = sqlite3ApiExit(db, SQLITE_TOOBIG); | |
| 618 goto end_prepare; | |
| 619 } | |
| 620 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); | |
| 621 if( zSqlCopy ){ | |
| 622 sqlite3RunParser(pParse, zSqlCopy, &zErrMsg); | |
| 623 sqlite3DbFree(db, zSqlCopy); | |
| 624 pParse->zTail = &zSql[pParse->zTail-zSqlCopy]; | |
| 625 }else{ | |
| 626 pParse->zTail = &zSql[nBytes]; | |
| 627 } | |
| 628 }else{ | |
| 629 sqlite3RunParser(pParse, zSql, &zErrMsg); | |
| 630 } | |
| 631 assert( 0==pParse->nQueryLoop ); | |
| 632 | |
| 633 if( db->mallocFailed ){ | |
| 634 pParse->rc = SQLITE_NOMEM; | |
| 635 } | |
| 636 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK; | |
| 637 if( pParse->checkSchema ){ | |
| 638 schemaIsValid(pParse); | |
| 639 } | |
| 640 if( db->mallocFailed ){ | |
| 641 pParse->rc = SQLITE_NOMEM; | |
| 642 } | |
| 643 if( pzTail ){ | |
| 644 *pzTail = pParse->zTail; | |
| 645 } | |
| 646 rc = pParse->rc; | |
| 647 | |
| 648 #ifndef SQLITE_OMIT_EXPLAIN | |
| 649 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){ | |
| 650 static const char * const azColName[] = { | |
| 651 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment", | |
| 652 "selectid", "order", "from", "detail" | |
| 653 }; | |
| 654 int iFirst, mx; | |
| 655 if( pParse->explain==2 ){ | |
| 656 sqlite3VdbeSetNumCols(pParse->pVdbe, 4); | |
| 657 iFirst = 8; | |
| 658 mx = 12; | |
| 659 }else{ | |
| 660 sqlite3VdbeSetNumCols(pParse->pVdbe, 8); | |
| 661 iFirst = 0; | |
| 662 mx = 8; | |
| 663 } | |
| 664 for(i=iFirst; i<mx; i++){ | |
| 665 sqlite3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME, | |
| 666 azColName[i], SQLITE_STATIC); | |
| 667 } | |
| 668 } | |
| 669 #endif | |
| 670 | |
| 671 if( db->init.busy==0 ){ | |
| 672 Vdbe *pVdbe = pParse->pVdbe; | |
| 673 sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag); | |
| 674 } | |
| 675 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){ | |
| 676 sqlite3VdbeFinalize(pParse->pVdbe); | |
| 677 assert(!(*ppStmt)); | |
| 678 }else{ | |
| 679 *ppStmt = (sqlite3_stmt*)pParse->pVdbe; | |
| 680 } | |
| 681 | |
| 682 if( zErrMsg ){ | |
| 683 sqlite3ErrorWithMsg(db, rc, "%s", zErrMsg); | |
| 684 sqlite3DbFree(db, zErrMsg); | |
| 685 }else{ | |
| 686 sqlite3Error(db, rc); | |
| 687 } | |
| 688 | |
| 689 /* Delete any TriggerPrg structures allocated while parsing this statement. */ | |
| 690 while( pParse->pTriggerPrg ){ | |
| 691 TriggerPrg *pT = pParse->pTriggerPrg; | |
| 692 pParse->pTriggerPrg = pT->pNext; | |
| 693 sqlite3DbFree(db, pT); | |
| 694 } | |
| 695 | |
| 696 end_prepare: | |
| 697 | |
| 698 sqlite3ParserReset(pParse); | |
| 699 sqlite3StackFree(db, pParse); | |
| 700 rc = sqlite3ApiExit(db, rc); | |
| 701 assert( (rc&db->errMask)==rc ); | |
| 702 return rc; | |
| 703 } | |
| 704 static int sqlite3LockAndPrepare( | |
| 705 sqlite3 *db, /* Database handle. */ | |
| 706 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 707 int nBytes, /* Length of zSql in bytes. */ | |
| 708 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */ | |
| 709 Vdbe *pOld, /* VM being reprepared */ | |
| 710 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 711 const char **pzTail /* OUT: End of parsed string */ | |
| 712 ){ | |
| 713 int rc; | |
| 714 | |
| 715 #ifdef SQLITE_ENABLE_API_ARMOR | |
| 716 if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; | |
| 717 #endif | |
| 718 *ppStmt = 0; | |
| 719 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ | |
| 720 return SQLITE_MISUSE_BKPT; | |
| 721 } | |
| 722 sqlite3_mutex_enter(db->mutex); | |
| 723 sqlite3BtreeEnterAll(db); | |
| 724 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); | |
| 725 if( rc==SQLITE_SCHEMA ){ | |
| 726 sqlite3_finalize(*ppStmt); | |
| 727 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail); | |
| 728 } | |
| 729 sqlite3BtreeLeaveAll(db); | |
| 730 sqlite3_mutex_leave(db->mutex); | |
| 731 assert( rc==SQLITE_OK || *ppStmt==0 ); | |
| 732 return rc; | |
| 733 } | |
| 734 | |
| 735 /* | |
| 736 ** Rerun the compilation of a statement after a schema change. | |
| 737 ** | |
| 738 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise, | |
| 739 ** if the statement cannot be recompiled because another connection has | |
| 740 ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error | |
| 741 ** occurs, return SQLITE_SCHEMA. | |
| 742 */ | |
| 743 int sqlite3Reprepare(Vdbe *p){ | |
| 744 int rc; | |
| 745 sqlite3_stmt *pNew; | |
| 746 const char *zSql; | |
| 747 sqlite3 *db; | |
| 748 | |
| 749 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); | |
| 750 zSql = sqlite3_sql((sqlite3_stmt *)p); | |
| 751 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */ | |
| 752 db = sqlite3VdbeDb(p); | |
| 753 assert( sqlite3_mutex_held(db->mutex) ); | |
| 754 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0); | |
| 755 if( rc ){ | |
| 756 if( rc==SQLITE_NOMEM ){ | |
| 757 db->mallocFailed = 1; | |
| 758 } | |
| 759 assert( pNew==0 ); | |
| 760 return rc; | |
| 761 }else{ | |
| 762 assert( pNew!=0 ); | |
| 763 } | |
| 764 sqlite3VdbeSwap((Vdbe*)pNew, p); | |
| 765 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p); | |
| 766 sqlite3VdbeResetStepResult((Vdbe*)pNew); | |
| 767 sqlite3VdbeFinalize((Vdbe*)pNew); | |
| 768 return SQLITE_OK; | |
| 769 } | |
| 770 | |
| 771 | |
| 772 /* | |
| 773 ** Two versions of the official API. Legacy and new use. In the legacy | |
| 774 ** version, the original SQL text is not saved in the prepared statement | |
| 775 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by | |
| 776 ** sqlite3_step(). In the new version, the original SQL text is retained | |
| 777 ** and the statement is automatically recompiled if an schema change | |
| 778 ** occurs. | |
| 779 */ | |
| 780 int sqlite3_prepare( | |
| 781 sqlite3 *db, /* Database handle. */ | |
| 782 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 783 int nBytes, /* Length of zSql in bytes. */ | |
| 784 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 785 const char **pzTail /* OUT: End of parsed string */ | |
| 786 ){ | |
| 787 int rc; | |
| 788 rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail); | |
| 789 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 790 return rc; | |
| 791 } | |
| 792 int sqlite3_prepare_v2( | |
| 793 sqlite3 *db, /* Database handle. */ | |
| 794 const char *zSql, /* UTF-8 encoded SQL statement. */ | |
| 795 int nBytes, /* Length of zSql in bytes. */ | |
| 796 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 797 const char **pzTail /* OUT: End of parsed string */ | |
| 798 ){ | |
| 799 int rc; | |
| 800 rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail); | |
| 801 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 802 return rc; | |
| 803 } | |
| 804 | |
| 805 | |
| 806 #ifndef SQLITE_OMIT_UTF16 | |
| 807 /* | |
| 808 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle. | |
| 809 */ | |
| 810 static int sqlite3Prepare16( | |
| 811 sqlite3 *db, /* Database handle. */ | |
| 812 const void *zSql, /* UTF-16 encoded SQL statement. */ | |
| 813 int nBytes, /* Length of zSql in bytes. */ | |
| 814 int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */ | |
| 815 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 816 const void **pzTail /* OUT: End of parsed string */ | |
| 817 ){ | |
| 818 /* This function currently works by first transforming the UTF-16 | |
| 819 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The | |
| 820 ** tricky bit is figuring out the pointer to return in *pzTail. | |
| 821 */ | |
| 822 char *zSql8; | |
| 823 const char *zTail8 = 0; | |
| 824 int rc = SQLITE_OK; | |
| 825 | |
| 826 #ifdef SQLITE_ENABLE_API_ARMOR | |
| 827 if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; | |
| 828 #endif | |
| 829 *ppStmt = 0; | |
| 830 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ | |
| 831 return SQLITE_MISUSE_BKPT; | |
| 832 } | |
| 833 if( nBytes>=0 ){ | |
| 834 int sz; | |
| 835 const char *z = (const char*)zSql; | |
| 836 for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){} | |
| 837 nBytes = sz; | |
| 838 } | |
| 839 sqlite3_mutex_enter(db->mutex); | |
| 840 zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); | |
| 841 if( zSql8 ){ | |
| 842 rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8); | |
| 843 } | |
| 844 | |
| 845 if( zTail8 && pzTail ){ | |
| 846 /* If sqlite3_prepare returns a tail pointer, we calculate the | |
| 847 ** equivalent pointer into the UTF-16 string by counting the unicode | |
| 848 ** characters between zSql8 and zTail8, and then returning a pointer | |
| 849 ** the same number of characters into the UTF-16 string. | |
| 850 */ | |
| 851 int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8)); | |
| 852 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); | |
| 853 } | |
| 854 sqlite3DbFree(db, zSql8); | |
| 855 rc = sqlite3ApiExit(db, rc); | |
| 856 sqlite3_mutex_leave(db->mutex); | |
| 857 return rc; | |
| 858 } | |
| 859 | |
| 860 /* | |
| 861 ** Two versions of the official API. Legacy and new use. In the legacy | |
| 862 ** version, the original SQL text is not saved in the prepared statement | |
| 863 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by | |
| 864 ** sqlite3_step(). In the new version, the original SQL text is retained | |
| 865 ** and the statement is automatically recompiled if an schema change | |
| 866 ** occurs. | |
| 867 */ | |
| 868 int sqlite3_prepare16( | |
| 869 sqlite3 *db, /* Database handle. */ | |
| 870 const void *zSql, /* UTF-16 encoded SQL statement. */ | |
| 871 int nBytes, /* Length of zSql in bytes. */ | |
| 872 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 873 const void **pzTail /* OUT: End of parsed string */ | |
| 874 ){ | |
| 875 int rc; | |
| 876 rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); | |
| 877 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 878 return rc; | |
| 879 } | |
| 880 int sqlite3_prepare16_v2( | |
| 881 sqlite3 *db, /* Database handle. */ | |
| 882 const void *zSql, /* UTF-16 encoded SQL statement. */ | |
| 883 int nBytes, /* Length of zSql in bytes. */ | |
| 884 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ | |
| 885 const void **pzTail /* OUT: End of parsed string */ | |
| 886 ){ | |
| 887 int rc; | |
| 888 rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail); | |
| 889 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ | |
| 890 return rc; | |
| 891 } | |
| 892 | |
| 893 #endif /* SQLITE_OMIT_UTF16 */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
