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*/
22static void corruptSchema(
23 InitData *pData, /* Initialization context */
24 char **azObj, /* Type and name of object being parsed */
25 const char *zExtra /* Error information */
26){
27 sqlite3 *db = pData->db;
28 if( db->mallocFailed ){
29 pData->rc = SQLITE_NOMEM_BKPT;
30 }else if( pData->pzErrMsg[0]!=0 ){
31 /* A error message has already been generated. Do not overwrite it */
32 }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){
33 static const char *azAlterType[] = {
34 "rename",
35 "drop column",
36 "add column"
37 };
38 *pData->pzErrMsg = sqlite3MPrintf(db,
39 "error in %s %s after %s: %s", azObj[0], azObj[1],
40 azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1],
41 zExtra
42 );
43 pData->rc = SQLITE_ERROR;
44 }else if( db->flags & SQLITE_WriteSchema ){
45 pData->rc = SQLITE_CORRUPT_BKPT;
46 }else{
47 char *z;
48 const char *zObj = azObj[1] ? azObj[1] : "?";
49 z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
50 if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
51 *pData->pzErrMsg = z;
52 pData->rc = SQLITE_CORRUPT_BKPT;
53 }
54}
55
56/*
57** Check to see if any sibling index (another index on the same table)
58** of pIndex has the same root page number, and if it does, return true.
59** This would indicate a corrupt schema.
60*/
61int sqlite3IndexHasDuplicateRootPage(Index *pIndex){
62 Index *p;
63 for(p=pIndex->pTable->pIndex; p; p=p->pNext){
64 if( p->tnum==pIndex->tnum && p!=pIndex ) return 1;
65 }
66 return 0;
67}
68
69/* forward declaration */
70static int sqlite3Prepare(
71 sqlite3 *db, /* Database handle. */
72 const char *zSql, /* UTF-8 encoded SQL statement. */
73 int nBytes, /* Length of zSql in bytes. */
74 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
75 Vdbe *pReprepare, /* VM being reprepared */
76 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
77 const char **pzTail /* OUT: End of parsed string */
78);
79
80
81/*
82** This is the callback routine for the code that initializes the
83** database. See sqlite3Init() below for additional information.
84** This routine is also called from the OP_ParseSchema opcode of the VDBE.
85**
86** Each callback contains the following information:
87**
88** argv[0] = type of object: "table", "index", "trigger", or "view".
89** argv[1] = name of thing being created
90** argv[2] = associated table if an index or trigger
91** argv[3] = root page number for table or index. 0 for trigger or view.
92** argv[4] = SQL text for the CREATE statement.
93**
94*/
95int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
96 InitData *pData = (InitData*)pInit;
97 sqlite3 *db = pData->db;
98 int iDb = pData->iDb;
99
100 assert( argc==5 );
101 UNUSED_PARAMETER2(NotUsed, argc);
102 assert( sqlite3_mutex_held(db->mutex) );
103 db->mDbFlags |= DBFLAG_EncodingFixed;
104 if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
105 pData->nInitRow++;
106 if( db->mallocFailed ){
107 corruptSchema(pData, argv, 0);
108 return 1;
109 }
110
111 assert( iDb>=0 && iDb<db->nDb );
112 if( argv[3]==0 ){
113 corruptSchema(pData, argv, 0);
114 }else if( argv[4]
115 && 'c'==sqlite3UpperToLower[(unsigned char)argv[4][0]]
116 && 'r'==sqlite3UpperToLower[(unsigned char)argv[4][1]] ){
117 /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
118 ** But because db->init.busy is set to 1, no VDBE code is generated
119 ** or executed. All the parser does is build the internal data
120 ** structures that describe the table, index, or view.
121 **
122 ** No other valid SQL statement, other than the variable CREATE statements,
123 ** can begin with the letters "C" and "R". Thus, it is not possible run
124 ** any other kind of statement while parsing the schema, even a corrupt
125 ** schema.
126 */
127 int rc;
128 u8 saved_iDb = db->init.iDb;
129 sqlite3_stmt *pStmt;
130 TESTONLY(int rcp); /* Return code from sqlite3_prepare() */
131
132 assert( db->init.busy );
133 db->init.iDb = iDb;
134 if( sqlite3GetUInt32(argv[3], &db->init.newTnum)==0
135 || (db->init.newTnum>pData->mxPage && pData->mxPage>0)
136 ){
137 if( sqlite3Config.bExtraSchemaChecks ){
138 corruptSchema(pData, argv, "invalid rootpage");
139 }
140 }
141 db->init.orphanTrigger = 0;
142 db->init.azInit = (const char**)argv;
143 pStmt = 0;
144 TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0);
145 rc = db->errCode;
146 assert( (rc&0xFF)==(rcp&0xFF) );
147 db->init.iDb = saved_iDb;
148 /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */
149 if( SQLITE_OK!=rc ){
150 if( db->init.orphanTrigger ){
151 assert( iDb==1 );
152 }else{
153 if( rc > pData->rc ) pData->rc = rc;
154 if( rc==SQLITE_NOMEM ){
155 sqlite3OomFault(db);
156 }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
157 corruptSchema(pData, argv, sqlite3_errmsg(db));
158 }
159 }
160 }
161 db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */
162 sqlite3_finalize(pStmt);
163 }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){
164 corruptSchema(pData, argv, 0);
165 }else{
166 /* If the SQL column is blank it means this is an index that
167 ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
168 ** constraint for a CREATE TABLE. The index should have already
169 ** been created when we processed the CREATE TABLE. All we have
170 ** to do here is record the root page number for that index.
171 */
172 Index *pIndex;
173 pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName);
174 if( pIndex==0 ){
175 corruptSchema(pData, argv, "orphan index");
176 }else
177 if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0
178 || pIndex->tnum<2
179 || pIndex->tnum>pData->mxPage
180 || sqlite3IndexHasDuplicateRootPage(pIndex)
181 ){
182 if( sqlite3Config.bExtraSchemaChecks ){
183 corruptSchema(pData, argv, "invalid rootpage");
184 }
185 }
186 }
187 return 0;
188}
189
190/*
191** Attempt to read the database schema and initialize internal
192** data structures for a single database file. The index of the
193** database file is given by iDb. iDb==0 is used for the main
194** database. iDb==1 should never be used. iDb>=2 is used for
195** auxiliary databases. Return one of the SQLITE_ error codes to
196** indicate success or failure.
197*/
198int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){
199 int rc;
200 int i;
201#ifndef SQLITE_OMIT_DEPRECATED
202 int size;
203#endif
204 Db *pDb;
205 char const *azArg[6];
206 int meta[5];
207 InitData initData;
208 const char *zSchemaTabName;
209 int openedTransaction = 0;
210 int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed);
211
212 assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 );
213 assert( iDb>=0 && iDb<db->nDb );
214 assert( db->aDb[iDb].pSchema );
215 assert( sqlite3_mutex_held(db->mutex) );
216 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
217
218 db->init.busy = 1;
219
220 /* Construct the in-memory representation schema tables (sqlite_schema or
221 ** sqlite_temp_schema) by invoking the parser directly. The appropriate
222 ** table name will be inserted automatically by the parser so we can just
223 ** use the abbreviation "x" here. The parser will also automatically tag
224 ** the schema table as read-only. */
225 azArg[0] = "table";
226 azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb);
227 azArg[2] = azArg[1];
228 azArg[3] = "1";
229 azArg[4] = "CREATE TABLE x(type text,name text,tbl_name text,"
230 "rootpage int,sql text)";
231 azArg[5] = 0;
232 initData.db = db;
233 initData.iDb = iDb;
234 initData.rc = SQLITE_OK;
235 initData.pzErrMsg = pzErrMsg;
236 initData.mInitFlags = mFlags;
237 initData.nInitRow = 0;
238 initData.mxPage = 0;
239 sqlite3InitCallback(&initData, 5, (char **)azArg, 0);
240 db->mDbFlags &= mask;
241 if( initData.rc ){
242 rc = initData.rc;
243 goto error_out;
244 }
245
246 /* Create a cursor to hold the database open
247 */
248 pDb = &db->aDb[iDb];
249 if( pDb->pBt==0 ){
250 assert( iDb==1 );
251 DbSetProperty(db, 1, DB_SchemaLoaded);
252 rc = SQLITE_OK;
253 goto error_out;
254 }
255
256 /* If there is not already a read-only (or read-write) transaction opened
257 ** on the b-tree database, open one now. If a transaction is opened, it
258 ** will be closed before this function returns. */
259 sqlite3BtreeEnter(pDb->pBt);
260 if( sqlite3BtreeTxnState(pDb->pBt)==SQLITE_TXN_NONE ){
261 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0);
262 if( rc!=SQLITE_OK ){
263 sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc));
264 goto initone_error_out;
265 }
266 openedTransaction = 1;
267 }
268
269 /* Get the database meta information.
270 **
271 ** Meta values are as follows:
272 ** meta[0] Schema cookie. Changes with each schema change.
273 ** meta[1] File format of schema layer.
274 ** meta[2] Size of the page cache.
275 ** meta[3] Largest rootpage (auto/incr_vacuum mode)
276 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
277 ** meta[5] User version
278 ** meta[6] Incremental vacuum mode
279 ** meta[7] unused
280 ** meta[8] unused
281 ** meta[9] unused
282 **
283 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
284 ** the possible values of meta[4].
285 */
286 for(i=0; i<ArraySize(meta); i++){
287 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
288 }
289 if( (db->flags & SQLITE_ResetDatabase)!=0 ){
290 memset(meta, 0, sizeof(meta));
291 }
292 pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
293
294 /* If opening a non-empty database, check the text encoding. For the
295 ** main database, set sqlite3.enc to the encoding of the main database.
296 ** For an attached db, it is an error if the encoding is not the same
297 ** as sqlite3.enc.
298 */
299 if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */
300 if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){
301 u8 encoding;
302#ifndef SQLITE_OMIT_UTF16
303 /* If opening the main database, set ENC(db). */
304 encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
305 if( encoding==0 ) encoding = SQLITE_UTF8;
306#else
307 encoding = SQLITE_UTF8;
308#endif
309 sqlite3SetTextEncoding(db, encoding);
310 }else{
311 /* If opening an attached database, the encoding much match ENC(db) */
312 if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){
313 sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
314 " text encoding as main database");
315 rc = SQLITE_ERROR;
316 goto initone_error_out;
317 }
318 }
319 }
320 pDb->pSchema->enc = ENC(db);
321
322 if( pDb->pSchema->cache_size==0 ){
323#ifndef SQLITE_OMIT_DEPRECATED
324 size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]);
325 if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
326 pDb->pSchema->cache_size = size;
327#else
328 pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE;
329#endif
330 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
331 }
332
333 /*
334 ** file_format==1 Version 3.0.0.
335 ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
336 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
337 ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
338 */
339 pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
340 if( pDb->pSchema->file_format==0 ){
341 pDb->pSchema->file_format = 1;
342 }
343 if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
344 sqlite3SetString(pzErrMsg, db, "unsupported file format");
345 rc = SQLITE_ERROR;
346 goto initone_error_out;
347 }
348
349 /* Ticket #2804: When we open a database in the newer file format,
350 ** clear the legacy_file_format pragma flag so that a VACUUM will
351 ** not downgrade the database and thus invalidate any descending
352 ** indices that the user might have created.
353 */
354 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
355 db->flags &= ~(u64)SQLITE_LegacyFileFmt;
356 }
357
358 /* Read the schema information out of the schema tables
359 */
360 assert( db->init.busy );
361 initData.mxPage = sqlite3BtreeLastPage(pDb->pBt);
362 {
363 char *zSql;
364 zSql = sqlite3MPrintf(db,
365 "SELECT*FROM\"%w\".%s ORDER BY rowid",
366 db->aDb[iDb].zDbSName, zSchemaTabName);
367#ifndef SQLITE_OMIT_AUTHORIZATION
368 {
369 sqlite3_xauth xAuth;
370 xAuth = db->xAuth;
371 db->xAuth = 0;
372#endif
373 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
374#ifndef SQLITE_OMIT_AUTHORIZATION
375 db->xAuth = xAuth;
376 }
377#endif
378 if( rc==SQLITE_OK ) rc = initData.rc;
379 sqlite3DbFree(db, zSql);
380#ifndef SQLITE_OMIT_ANALYZE
381 if( rc==SQLITE_OK ){
382 sqlite3AnalysisLoad(db, iDb);
383 }
384#endif
385 }
386 assert( pDb == &(db->aDb[iDb]) );
387 if( db->mallocFailed ){
388 rc = SQLITE_NOMEM_BKPT;
389 sqlite3ResetAllSchemasOfConnection(db);
390 pDb = &db->aDb[iDb];
391 }else
392 if( rc==SQLITE_OK || ((db->flags&SQLITE_NoSchemaError) && rc!=SQLITE_NOMEM)){
393 /* Hack: If the SQLITE_NoSchemaError flag is set, then consider
394 ** the schema loaded, even if errors (other than OOM) occurred. In
395 ** this situation the current sqlite3_prepare() operation will fail,
396 ** but the following one will attempt to compile the supplied statement
397 ** against whatever subset of the schema was loaded before the error
398 ** occurred.
399 **
400 ** The primary purpose of this is to allow access to the sqlite_schema
401 ** table even when its contents have been corrupted.
402 */
403 DbSetProperty(db, iDb, DB_SchemaLoaded);
404 rc = SQLITE_OK;
405 }
406
407 /* Jump here for an error that occurs after successfully allocating
408 ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
409 ** before that point, jump to error_out.
410 */
411initone_error_out:
412 if( openedTransaction ){
413 sqlite3BtreeCommit(pDb->pBt);
414 }
415 sqlite3BtreeLeave(pDb->pBt);
416
417error_out:
418 if( rc ){
419 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
420 sqlite3OomFault(db);
421 }
422 sqlite3ResetOneSchema(db, iDb);
423 }
424 db->init.busy = 0;
425 return rc;
426}
427
428/*
429** Initialize all database files - the main database file, the file
430** used to store temporary tables, and any additional database files
431** created using ATTACH statements. Return a success code. If an
432** error occurs, write an error message into *pzErrMsg.
433**
434** After a database is initialized, the DB_SchemaLoaded bit is set
435** bit is set in the flags field of the Db structure.
436*/
437int sqlite3Init(sqlite3 *db, char **pzErrMsg){
438 int i, rc;
439 int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange);
440
441 assert( sqlite3_mutex_held(db->mutex) );
442 assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) );
443 assert( db->init.busy==0 );
444 ENC(db) = SCHEMA_ENC(db);
445 assert( db->nDb>0 );
446 /* Do the main schema first */
447 if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){
448 rc = sqlite3InitOne(db, 0, pzErrMsg, 0);
449 if( rc ) return rc;
450 }
451 /* All other schemas after the main schema. The "temp" schema must be last */
452 for(i=db->nDb-1; i>0; i--){
453 assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) );
454 if( !DbHasProperty(db, i, DB_SchemaLoaded) ){
455 rc = sqlite3InitOne(db, i, pzErrMsg, 0);
456 if( rc ) return rc;
457 }
458 }
459 if( commit_internal ){
460 sqlite3CommitInternalChanges(db);
461 }
462 return SQLITE_OK;
463}
464
465/*
466** This routine is a no-op if the database schema is already initialized.
467** Otherwise, the schema is loaded. An error code is returned.
468*/
469int sqlite3ReadSchema(Parse *pParse){
470 int rc = SQLITE_OK;
471 sqlite3 *db = pParse->db;
472 assert( sqlite3_mutex_held(db->mutex) );
473 if( !db->init.busy ){
474 rc = sqlite3Init(db, &pParse->zErrMsg);
475 if( rc!=SQLITE_OK ){
476 pParse->rc = rc;
477 pParse->nErr++;
478 }else if( db->noSharedCache ){
479 db->mDbFlags |= DBFLAG_SchemaKnownOk;
480 }
481 }
482 return rc;
483}
484
485
486/*
487** Check schema cookies in all databases. If any cookie is out
488** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
489** make no changes to pParse->rc.
490*/
491static void schemaIsValid(Parse *pParse){
492 sqlite3 *db = pParse->db;
493 int iDb;
494 int rc;
495 int cookie;
496
497 assert( pParse->checkSchema );
498 assert( sqlite3_mutex_held(db->mutex) );
499 for(iDb=0; iDb<db->nDb; iDb++){
500 int openedTransaction = 0; /* True if a transaction is opened */
501 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
502 if( pBt==0 ) continue;
503
504 /* If there is not already a read-only (or read-write) transaction opened
505 ** on the b-tree database, open one now. If a transaction is opened, it
506 ** will be closed immediately after reading the meta-value. */
507 if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_NONE ){
508 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
509 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
510 sqlite3OomFault(db);
511 pParse->rc = SQLITE_NOMEM;
512 }
513 if( rc!=SQLITE_OK ) return;
514 openedTransaction = 1;
515 }
516
517 /* Read the schema cookie from the database. If it does not match the
518 ** value stored as part of the in-memory schema representation,
519 ** set Parse.rc to SQLITE_SCHEMA. */
520 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
521 assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
522 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
523 sqlite3ResetOneSchema(db, iDb);
524 pParse->rc = SQLITE_SCHEMA;
525 }
526
527 /* Close the transaction, if one was opened. */
528 if( openedTransaction ){
529 sqlite3BtreeCommit(pBt);
530 }
531 }
532}
533
534/*
535** Convert a schema pointer into the iDb index that indicates
536** which database file in db->aDb[] the schema refers to.
537**
538** If the same database is attached more than once, the first
539** attached database is returned.
540*/
541int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
542 int i = -32768;
543
544 /* If pSchema is NULL, then return -32768. This happens when code in
545 ** expr.c is trying to resolve a reference to a transient table (i.e. one
546 ** created by a sub-select). In this case the return value of this
547 ** function should never be used.
548 **
549 ** We return -32768 instead of the more usual -1 simply because using
550 ** -32768 as the incorrect index into db->aDb[] is much
551 ** more likely to cause a segfault than -1 (of course there are assert()
552 ** statements too, but it never hurts to play the odds) and
553 ** -32768 will still fit into a 16-bit signed integer.
554 */
555 assert( sqlite3_mutex_held(db->mutex) );
556 if( pSchema ){
557 for(i=0; 1; i++){
558 assert( i<db->nDb );
559 if( db->aDb[i].pSchema==pSchema ){
560 break;
561 }
562 }
563 assert( i>=0 && i<db->nDb );
564 }
565 return i;
566}
567
568/*
569** Free all memory allocations in the pParse object
570*/
571void sqlite3ParseObjectReset(Parse *pParse){
572 sqlite3 *db = pParse->db;
573 assert( db!=0 );
574 assert( db->pParse==pParse );
575 assert( pParse->nested==0 );
576#ifndef SQLITE_OMIT_SHARED_CACHE
577 if( pParse->aTableLock ) sqlite3DbNNFreeNN(db, pParse->aTableLock);
578#endif
579 while( pParse->pCleanup ){
580 ParseCleanup *pCleanup = pParse->pCleanup;
581 pParse->pCleanup = pCleanup->pNext;
582 pCleanup->xCleanup(db, pCleanup->pPtr);
583 sqlite3DbNNFreeNN(db, pCleanup);
584 }
585 if( pParse->aLabel ) sqlite3DbNNFreeNN(db, pParse->aLabel);
586 if( pParse->pConstExpr ){
587 sqlite3ExprListDelete(db, pParse->pConstExpr);
588 }
589 assert( db->lookaside.bDisable >= pParse->disableLookaside );
590 db->lookaside.bDisable -= pParse->disableLookaside;
591 db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue;
592 assert( pParse->db->pParse==pParse );
593 db->pParse = pParse->pOuterParse;
594 pParse->db = 0;
595 pParse->disableLookaside = 0;
596}
597
598/*
599** Add a new cleanup operation to a Parser. The cleanup should happen when
600** the parser object is destroyed. But, beware: the cleanup might happen
601** immediately.
602**
603** Use this mechanism for uncommon cleanups. There is a higher setup
604** cost for this mechansim (an extra malloc), so it should not be used
605** for common cleanups that happen on most calls. But for less
606** common cleanups, we save a single NULL-pointer comparison in
607** sqlite3ParseObjectReset(), which reduces the total CPU cycle count.
608**
609** If a memory allocation error occurs, then the cleanup happens immediately.
610** When either SQLITE_DEBUG or SQLITE_COVERAGE_TEST are defined, the
611** pParse->earlyCleanup flag is set in that case. Calling code show verify
612** that test cases exist for which this happens, to guard against possible
613** use-after-free errors following an OOM. The preferred way to do this is
614** to immediately follow the call to this routine with:
615**
616** testcase( pParse->earlyCleanup );
617**
618** This routine returns a copy of its pPtr input (the third parameter)
619** except if an early cleanup occurs, in which case it returns NULL. So
620** another way to check for early cleanup is to check the return value.
621** Or, stop using the pPtr parameter with this call and use only its
622** return value thereafter. Something like this:
623**
624** pObj = sqlite3ParserAddCleanup(pParse, destructor, pObj);
625*/
626void *sqlite3ParserAddCleanup(
627 Parse *pParse, /* Destroy when this Parser finishes */
628 void (*xCleanup)(sqlite3*,void*), /* The cleanup routine */
629 void *pPtr /* Pointer to object to be cleaned up */
630){
631 ParseCleanup *pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup));
632 if( pCleanup ){
633 pCleanup->pNext = pParse->pCleanup;
634 pParse->pCleanup = pCleanup;
635 pCleanup->pPtr = pPtr;
636 pCleanup->xCleanup = xCleanup;
637 }else{
638 xCleanup(pParse->db, pPtr);
639 pPtr = 0;
640#if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
641 pParse->earlyCleanup = 1;
642#endif
643 }
644 return pPtr;
645}
646
647/*
648** Turn bulk memory into a valid Parse object and link that Parse object
649** into database connection db.
650**
651** Call sqlite3ParseObjectReset() to undo this operation.
652**
653** Caution: Do not confuse this routine with sqlite3ParseObjectInit() which
654** is generated by Lemon.
655*/
656void sqlite3ParseObjectInit(Parse *pParse, sqlite3 *db){
657 memset(PARSE_HDR(pParse), 0, PARSE_HDR_SZ);
658 memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ);
659 assert( db->pParse!=pParse );
660 pParse->pOuterParse = db->pParse;
661 db->pParse = pParse;
662 pParse->db = db;
663 if( db->mallocFailed ) sqlite3ErrorMsg(pParse, "out of memory");
664}
665
666/*
667** Maximum number of times that we will try again to prepare a statement
668** that returns SQLITE_ERROR_RETRY.
669*/
670#ifndef SQLITE_MAX_PREPARE_RETRY
671# define SQLITE_MAX_PREPARE_RETRY 25
672#endif
673
674/*
675** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
676*/
677static int sqlite3Prepare(
678 sqlite3 *db, /* Database handle. */
679 const char *zSql, /* UTF-8 encoded SQL statement. */
680 int nBytes, /* Length of zSql in bytes. */
681 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
682 Vdbe *pReprepare, /* VM being reprepared */
683 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
684 const char **pzTail /* OUT: End of parsed string */
685){
686 int rc = SQLITE_OK; /* Result code */
687 int i; /* Loop counter */
688 Parse sParse; /* Parsing context */
689
690 /* sqlite3ParseObjectInit(&sParse, db); // inlined for performance */
691 memset(PARSE_HDR(&sParse), 0, PARSE_HDR_SZ);
692 memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ);
693 sParse.pOuterParse = db->pParse;
694 db->pParse = &sParse;
695 sParse.db = db;
696 sParse.pReprepare = pReprepare;
697 assert( ppStmt && *ppStmt==0 );
698 if( db->mallocFailed ) sqlite3ErrorMsg(&sParse, "out of memory");
699 assert( sqlite3_mutex_held(db->mutex) );
700
701 /* For a long-term use prepared statement avoid the use of
702 ** lookaside memory.
703 */
704 if( prepFlags & SQLITE_PREPARE_PERSISTENT ){
705 sParse.disableLookaside++;
706 DisableLookaside;
707 }
708 sParse.prepFlags = prepFlags & 0xff;
709
710 /* Check to verify that it is possible to get a read lock on all
711 ** database schemas. The inability to get a read lock indicates that
712 ** some other database connection is holding a write-lock, which in
713 ** turn means that the other connection has made uncommitted changes
714 ** to the schema.
715 **
716 ** Were we to proceed and prepare the statement against the uncommitted
717 ** schema changes and if those schema changes are subsequently rolled
718 ** back and different changes are made in their place, then when this
719 ** prepared statement goes to run the schema cookie would fail to detect
720 ** the schema change. Disaster would follow.
721 **
722 ** This thread is currently holding mutexes on all Btrees (because
723 ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
724 ** is not possible for another thread to start a new schema change
725 ** while this routine is running. Hence, we do not need to hold
726 ** locks on the schema, we just need to make sure nobody else is
727 ** holding them.
728 **
729 ** Note that setting READ_UNCOMMITTED overrides most lock detection,
730 ** but it does *not* override schema lock detection, so this all still
731 ** works even if READ_UNCOMMITTED is set.
732 */
733 if( !db->noSharedCache ){
734 for(i=0; i<db->nDb; i++) {
735 Btree *pBt = db->aDb[i].pBt;
736 if( pBt ){
737 assert( sqlite3BtreeHoldsMutex(pBt) );
738 rc = sqlite3BtreeSchemaLocked(pBt);
739 if( rc ){
740 const char *zDb = db->aDb[i].zDbSName;
741 sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s", zDb);
742 testcase( db->flags & SQLITE_ReadUncommit );
743 goto end_prepare;
744 }
745 }
746 }
747 }
748
749#ifndef SQLITE_OMIT_VIRTUALTABLE
750 if( db->pDisconnect ) sqlite3VtabUnlockList(db);
751#endif
752
753 if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
754 char *zSqlCopy;
755 int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
756 testcase( nBytes==mxLen );
757 testcase( nBytes==mxLen+1 );
758 if( nBytes>mxLen ){
759 sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long");
760 rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
761 goto end_prepare;
762 }
763 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
764 if( zSqlCopy ){
765 sqlite3RunParser(&sParse, zSqlCopy);
766 sParse.zTail = &zSql[sParse.zTail-zSqlCopy];
767 sqlite3DbFree(db, zSqlCopy);
768 }else{
769 sParse.zTail = &zSql[nBytes];
770 }
771 }else{
772 sqlite3RunParser(&sParse, zSql);
773 }
774 assert( 0==sParse.nQueryLoop );
775
776 if( pzTail ){
777 *pzTail = sParse.zTail;
778 }
779
780 if( db->init.busy==0 ){
781 sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags);
782 }
783 if( db->mallocFailed ){
784 sParse.rc = SQLITE_NOMEM_BKPT;
785 sParse.checkSchema = 0;
786 }
787 if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){
788 if( sParse.checkSchema && db->init.busy==0 ){
789 schemaIsValid(&sParse);
790 }
791 if( sParse.pVdbe ){
792 sqlite3VdbeFinalize(sParse.pVdbe);
793 }
794 assert( 0==(*ppStmt) );
795 rc = sParse.rc;
796 if( sParse.zErrMsg ){
797 sqlite3ErrorWithMsg(db, rc, "%s", sParse.zErrMsg);
798 sqlite3DbFree(db, sParse.zErrMsg);
799 }else{
800 sqlite3Error(db, rc);
801 }
802 }else{
803 assert( sParse.zErrMsg==0 );
804 *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
805 rc = SQLITE_OK;
806 sqlite3ErrorClear(db);
807 }
808
809
810 /* Delete any TriggerPrg structures allocated while parsing this statement. */
811 while( sParse.pTriggerPrg ){
812 TriggerPrg *pT = sParse.pTriggerPrg;
813 sParse.pTriggerPrg = pT->pNext;
814 sqlite3DbFree(db, pT);
815 }
816
817end_prepare:
818
819 sqlite3ParseObjectReset(&sParse);
820 return rc;
821}
822static int sqlite3LockAndPrepare(
823 sqlite3 *db, /* Database handle. */
824 const char *zSql, /* UTF-8 encoded SQL statement. */
825 int nBytes, /* Length of zSql in bytes. */
826 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
827 Vdbe *pOld, /* VM being reprepared */
828 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
829 const char **pzTail /* OUT: End of parsed string */
830){
831 int rc;
832 int cnt = 0;
833
834#ifdef SQLITE_ENABLE_API_ARMOR
835 if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
836#endif
837 *ppStmt = 0;
838 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
839 return SQLITE_MISUSE_BKPT;
840 }
841 sqlite3_mutex_enter(db->mutex);
842 sqlite3BtreeEnterAll(db);
843 do{
844 /* Make multiple attempts to compile the SQL, until it either succeeds
845 ** or encounters a permanent error. A schema problem after one schema
846 ** reset is considered a permanent error. */
847 rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail);
848 assert( rc==SQLITE_OK || *ppStmt==0 );
849 if( rc==SQLITE_OK || db->mallocFailed ) break;
850 }while( (rc==SQLITE_ERROR_RETRY && (cnt++)<SQLITE_MAX_PREPARE_RETRY)
851 || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) );
852 sqlite3BtreeLeaveAll(db);
853 rc = sqlite3ApiExit(db, rc);
854 assert( (rc&db->errMask)==rc );
855 db->busyHandler.nBusy = 0;
856 sqlite3_mutex_leave(db->mutex);
857 return rc;
858}
859
860
861/*
862** Rerun the compilation of a statement after a schema change.
863**
864** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
865** if the statement cannot be recompiled because another connection has
866** locked the sqlite3_schema table, return SQLITE_LOCKED. If any other error
867** occurs, return SQLITE_SCHEMA.
868*/
869int sqlite3Reprepare(Vdbe *p){
870 int rc;
871 sqlite3_stmt *pNew;
872 const char *zSql;
873 sqlite3 *db;
874 u8 prepFlags;
875
876 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
877 zSql = sqlite3_sql((sqlite3_stmt *)p);
878 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
879 db = sqlite3VdbeDb(p);
880 assert( sqlite3_mutex_held(db->mutex) );
881 prepFlags = sqlite3VdbePrepareFlags(p);
882 rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0);
883 if( rc ){
884 if( rc==SQLITE_NOMEM ){
885 sqlite3OomFault(db);
886 }
887 assert( pNew==0 );
888 return rc;
889 }else{
890 assert( pNew!=0 );
891 }
892 sqlite3VdbeSwap((Vdbe*)pNew, p);
893 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
894 sqlite3VdbeResetStepResult((Vdbe*)pNew);
895 sqlite3VdbeFinalize((Vdbe*)pNew);
896 return SQLITE_OK;
897}
898
899
900/*
901** Two versions of the official API. Legacy and new use. In the legacy
902** version, the original SQL text is not saved in the prepared statement
903** and so if a schema change occurs, SQLITE_SCHEMA is returned by
904** sqlite3_step(). In the new version, the original SQL text is retained
905** and the statement is automatically recompiled if an schema change
906** occurs.
907*/
908int sqlite3_prepare(
909 sqlite3 *db, /* Database handle. */
910 const char *zSql, /* UTF-8 encoded SQL statement. */
911 int nBytes, /* Length of zSql in bytes. */
912 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
913 const char **pzTail /* OUT: End of parsed string */
914){
915 int rc;
916 rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
917 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
918 return rc;
919}
920int sqlite3_prepare_v2(
921 sqlite3 *db, /* Database handle. */
922 const char *zSql, /* UTF-8 encoded SQL statement. */
923 int nBytes, /* Length of zSql in bytes. */
924 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
925 const char **pzTail /* OUT: End of parsed string */
926){
927 int rc;
928 /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works
929 ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags
930 ** parameter.
931 **
932 ** Proof in that the 5th parameter to sqlite3LockAndPrepare is 0 */
933 rc = sqlite3LockAndPrepare(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,0,
934 ppStmt,pzTail);
935 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
936 return rc;
937}
938int sqlite3_prepare_v3(
939 sqlite3 *db, /* Database handle. */
940 const char *zSql, /* UTF-8 encoded SQL statement. */
941 int nBytes, /* Length of zSql in bytes. */
942 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
943 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
944 const char **pzTail /* OUT: End of parsed string */
945){
946 int rc;
947 /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from
948 ** sqlite3_prepare_v2() only in having the extra prepFlags parameter,
949 ** which is a bit array consisting of zero or more of the
950 ** SQLITE_PREPARE_* flags.
951 **
952 ** Proof by comparison to the implementation of sqlite3_prepare_v2()
953 ** directly above. */
954 rc = sqlite3LockAndPrepare(db,zSql,nBytes,
955 SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK),
956 0,ppStmt,pzTail);
957 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 );
958 return rc;
959}
960
961
962#ifndef SQLITE_OMIT_UTF16
963/*
964** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
965*/
966static int sqlite3Prepare16(
967 sqlite3 *db, /* Database handle. */
968 const void *zSql, /* UTF-16 encoded SQL statement. */
969 int nBytes, /* Length of zSql in bytes. */
970 u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
971 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
972 const void **pzTail /* OUT: End of parsed string */
973){
974 /* This function currently works by first transforming the UTF-16
975 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
976 ** tricky bit is figuring out the pointer to return in *pzTail.
977 */
978 char *zSql8;
979 const char *zTail8 = 0;
980 int rc = SQLITE_OK;
981
982#ifdef SQLITE_ENABLE_API_ARMOR
983 if( ppStmt==0 ) return SQLITE_MISUSE_BKPT;
984#endif
985 *ppStmt = 0;
986 if( !sqlite3SafetyCheckOk(db)||zSql==0 ){
987 return SQLITE_MISUSE_BKPT;
988 }
989 if( nBytes>=0 ){
990 int sz;
991 const char *z = (const char*)zSql;
992 for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){}
993 nBytes = sz;
994 }
995 sqlite3_mutex_enter(db->mutex);
996 zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
997 if( zSql8 ){
998 rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8);
999 }
1000
1001 if( zTail8 && pzTail ){
1002 /* If sqlite3_prepare returns a tail pointer, we calculate the
1003 ** equivalent pointer into the UTF-16 string by counting the unicode
1004 ** characters between zSql8 and zTail8, and then returning a pointer
1005 ** the same number of characters into the UTF-16 string.
1006 */
1007 int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
1008 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
1009 }
1010 sqlite3DbFree(db, zSql8);
1011 rc = sqlite3ApiExit(db, rc);
1012 sqlite3_mutex_leave(db->mutex);
1013 return rc;
1014}
1015
1016/*
1017** Two versions of the official API. Legacy and new use. In the legacy
1018** version, the original SQL text is not saved in the prepared statement
1019** and so if a schema change occurs, SQLITE_SCHEMA is returned by
1020** sqlite3_step(). In the new version, the original SQL text is retained
1021** and the statement is automatically recompiled if an schema change
1022** occurs.
1023*/
1024int sqlite3_prepare16(
1025 sqlite3 *db, /* Database handle. */
1026 const void *zSql, /* UTF-16 encoded SQL statement. */
1027 int nBytes, /* Length of zSql in bytes. */
1028 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1029 const void **pzTail /* OUT: End of parsed string */
1030){
1031 int rc;
1032 rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
1033 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
1034 return rc;
1035}
1036int sqlite3_prepare16_v2(
1037 sqlite3 *db, /* Database handle. */
1038 const void *zSql, /* UTF-16 encoded SQL statement. */
1039 int nBytes, /* Length of zSql in bytes. */
1040 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1041 const void **pzTail /* OUT: End of parsed string */
1042){
1043 int rc;
1044 rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail);
1045 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
1046 return rc;
1047}
1048int sqlite3_prepare16_v3(
1049 sqlite3 *db, /* Database handle. */
1050 const void *zSql, /* UTF-16 encoded SQL statement. */
1051 int nBytes, /* Length of zSql in bytes. */
1052 unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */
1053 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
1054 const void **pzTail /* OUT: End of parsed string */
1055){
1056 int rc;
1057 rc = sqlite3Prepare16(db,zSql,nBytes,
1058 SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK),
1059 ppStmt,pzTail);
1060 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
1061 return rc;
1062}
1063
1064#endif /* SQLITE_OMIT_UTF16 */
1065