4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
11 *************************************************************************
12 ** This file contains the implementation of the sqlite3_prepare()
13 ** interface, and routines that contribute to loading the database schema
16 #include "sqliteInt.h"
19 ** Fill the InitData structure with an error message that indicates
20 ** that the database is corrupt.
22 static void corruptSchema(
23 InitData
*pData
, /* Initialization context */
24 char **azObj
, /* Type and name of object being parsed */
25 const char *zExtra
/* Error information */
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
[] = {
38 *pData
->pzErrMsg
= sqlite3MPrintf(db
,
39 "error in %s %s after %s: %s", azObj
[0], azObj
[1],
40 azAlterType
[(pData
->mInitFlags
&INITFLAG_AlterMask
)-1],
43 pData
->rc
= SQLITE_ERROR
;
44 }else if( db
->flags
& SQLITE_WriteSchema
){
45 pData
->rc
= SQLITE_CORRUPT_BKPT
;
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
);
52 pData
->rc
= SQLITE_CORRUPT_BKPT
;
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.
61 int sqlite3IndexHasDuplicateRootPage(Index
*pIndex
){
63 for(p
=pIndex
->pTable
->pIndex
; p
; p
=p
->pNext
){
64 if( p
->tnum
==pIndex
->tnum
&& p
!=pIndex
) return 1;
69 /* forward declaration */
70 static 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 */
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.
86 ** Each callback contains the following information:
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.
95 int sqlite3InitCallback(void *pInit
, int argc
, char **argv
, char **NotUsed
){
96 InitData
*pData
= (InitData
*)pInit
;
97 sqlite3
*db
= pData
->db
;
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 */
106 if( db
->mallocFailed
){
107 corruptSchema(pData
, argv
, 0);
111 assert( iDb
>=0 && iDb
<db
->nDb
);
113 corruptSchema(pData
, argv
, 0);
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.
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
128 u8 saved_iDb
= db
->init
.iDb
;
130 TESTONLY(int rcp
); /* Return code from sqlite3_prepare() */
132 assert( db
->init
.busy
);
134 if( sqlite3GetUInt32(argv
[3], &db
->init
.newTnum
)==0
135 || (db
->init
.newTnum
>pData
->mxPage
&& pData
->mxPage
>0)
137 if( sqlite3Config
.bExtraSchemaChecks
){
138 corruptSchema(pData
, argv
, "invalid rootpage");
141 db
->init
.orphanTrigger
= 0;
142 db
->init
.azInit
= (const char**)argv
;
144 TESTONLY(rcp
= ) sqlite3Prepare(db
, argv
[4], -1, 0, 0, &pStmt
, 0);
146 assert( (rc
&0xFF)==(rcp
&0xFF) );
147 db
->init
.iDb
= saved_iDb
;
148 /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */
150 if( db
->init
.orphanTrigger
){
153 if( rc
> pData
->rc
) pData
->rc
= rc
;
154 if( rc
==SQLITE_NOMEM
){
156 }else if( rc
!=SQLITE_INTERRUPT
&& (rc
&0xFF)!=SQLITE_LOCKED
){
157 corruptSchema(pData
, argv
, sqlite3_errmsg(db
));
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);
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.
173 pIndex
= sqlite3FindIndex(db
, argv
[1], db
->aDb
[iDb
].zDbSName
);
175 corruptSchema(pData
, argv
, "orphan index");
177 if( sqlite3GetUInt32(argv
[3],&pIndex
->tnum
)==0
179 || pIndex
->tnum
>pData
->mxPage
180 || sqlite3IndexHasDuplicateRootPage(pIndex
)
182 if( sqlite3Config
.bExtraSchemaChecks
){
183 corruptSchema(pData
, argv
, "invalid rootpage");
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.
198 int sqlite3InitOne(sqlite3
*db
, int iDb
, char **pzErrMsg
, u32 mFlags
){
201 #ifndef SQLITE_OMIT_DEPRECATED
205 char const *azArg
[6];
208 const char *zSchemaTabName
;
209 int openedTransaction
= 0;
210 int mask
= ((db
->mDbFlags
& DBFLAG_EncodingFixed
) | ~DBFLAG_EncodingFixed
);
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
) );
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. */
226 azArg
[1] = zSchemaTabName
= SCHEMA_TABLE(iDb
);
229 azArg
[4] = "CREATE TABLE x(type text,name text,tbl_name text,"
230 "rootpage int,sql text)";
234 initData
.rc
= SQLITE_OK
;
235 initData
.pzErrMsg
= pzErrMsg
;
236 initData
.mInitFlags
= mFlags
;
237 initData
.nInitRow
= 0;
239 sqlite3InitCallback(&initData
, 5, (char **)azArg
, 0);
240 db
->mDbFlags
&= mask
;
246 /* Create a cursor to hold the database open
251 DbSetProperty(db
, 1, DB_SchemaLoaded
);
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);
263 sqlite3SetString(pzErrMsg
, db
, sqlite3ErrStr(rc
));
264 goto initone_error_out
;
266 openedTransaction
= 1;
269 /* Get the database meta information.
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
283 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
284 ** the possible values of meta[4].
286 for(i
=0; i
<ArraySize(meta
); i
++){
287 sqlite3BtreeGetMeta(pDb
->pBt
, i
+1, (u32
*)&meta
[i
]);
289 if( (db
->flags
& SQLITE_ResetDatabase
)!=0 ){
290 memset(meta
, 0, sizeof(meta
));
292 pDb
->pSchema
->schema_cookie
= meta
[BTREE_SCHEMA_VERSION
-1];
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
299 if( meta
[BTREE_TEXT_ENCODING
-1] ){ /* text encoding */
300 if( iDb
==0 && (db
->mDbFlags
& DBFLAG_EncodingFixed
)==0 ){
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
;
307 encoding
= SQLITE_UTF8
;
309 sqlite3SetTextEncoding(db
, encoding
);
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");
316 goto initone_error_out
;
320 pDb
->pSchema
->enc
= ENC(db
);
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
;
328 pDb
->pSchema
->cache_size
= SQLITE_DEFAULT_CACHE_SIZE
;
330 sqlite3BtreeSetCacheSize(pDb
->pBt
, pDb
->pSchema
->cache_size
);
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
339 pDb
->pSchema
->file_format
= (u8
)meta
[BTREE_FILE_FORMAT
-1];
340 if( pDb
->pSchema
->file_format
==0 ){
341 pDb
->pSchema
->file_format
= 1;
343 if( pDb
->pSchema
->file_format
>SQLITE_MAX_FILE_FORMAT
){
344 sqlite3SetString(pzErrMsg
, db
, "unsupported file format");
346 goto initone_error_out
;
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.
354 if( iDb
==0 && meta
[BTREE_FILE_FORMAT
-1]>=4 ){
355 db
->flags
&= ~(u64
)SQLITE_LegacyFileFmt
;
358 /* Read the schema information out of the schema tables
360 assert( db
->init
.busy
);
361 initData
.mxPage
= sqlite3BtreeLastPage(pDb
->pBt
);
364 zSql
= sqlite3MPrintf(db
,
365 "SELECT*FROM\"%w\".%s ORDER BY rowid",
366 db
->aDb
[iDb
].zDbSName
, zSchemaTabName
);
367 #ifndef SQLITE_OMIT_AUTHORIZATION
373 rc
= sqlite3_exec(db
, zSql
, sqlite3InitCallback
, &initData
, 0);
374 #ifndef SQLITE_OMIT_AUTHORIZATION
378 if( rc
==SQLITE_OK
) rc
= initData
.rc
;
379 sqlite3DbFree(db
, zSql
);
380 #ifndef SQLITE_OMIT_ANALYZE
382 sqlite3AnalysisLoad(db
, iDb
);
386 assert( pDb
== &(db
->aDb
[iDb
]) );
387 if( db
->mallocFailed
){
388 rc
= SQLITE_NOMEM_BKPT
;
389 sqlite3ResetAllSchemasOfConnection(db
);
392 if( rc
==SQLITE_OK
|| (db
->flags
&SQLITE_NoSchemaError
)){
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
400 ** The primary purpose of this is to allow access to the sqlite_schema
401 ** table even when its contents have been corrupted.
403 DbSetProperty(db
, iDb
, DB_SchemaLoaded
);
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.
412 if( openedTransaction
){
413 sqlite3BtreeCommit(pDb
->pBt
);
415 sqlite3BtreeLeave(pDb
->pBt
);
419 if( rc
==SQLITE_NOMEM
|| rc
==SQLITE_IOERR_NOMEM
){
422 sqlite3ResetOneSchema(db
, iDb
);
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.
434 ** After a database is initialized, the DB_SchemaLoaded bit is set
435 ** bit is set in the flags field of the Db structure.
437 int sqlite3Init(sqlite3
*db
, char **pzErrMsg
){
439 int commit_internal
= !(db
->mDbFlags
&DBFLAG_SchemaChange
);
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
);
446 /* Do the main schema first */
447 if( !DbHasProperty(db
, 0, DB_SchemaLoaded
) ){
448 rc
= sqlite3InitOne(db
, 0, pzErrMsg
, 0);
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);
459 if( commit_internal
){
460 sqlite3CommitInternalChanges(db
);
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.
469 int sqlite3ReadSchema(Parse
*pParse
){
471 sqlite3
*db
= pParse
->db
;
472 assert( sqlite3_mutex_held(db
->mutex
) );
473 if( !db
->init
.busy
){
474 rc
= sqlite3Init(db
, &pParse
->zErrMsg
);
478 }else if( db
->noSharedCache
){
479 db
->mDbFlags
|= DBFLAG_SchemaKnownOk
;
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.
491 static void schemaIsValid(Parse
*pParse
){
492 sqlite3
*db
= pParse
->db
;
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;
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
){
511 pParse
->rc
= SQLITE_NOMEM
;
513 if( rc
!=SQLITE_OK
) return;
514 openedTransaction
= 1;
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
;
527 /* Close the transaction, if one was opened. */
528 if( openedTransaction
){
529 sqlite3BtreeCommit(pBt
);
535 ** Convert a schema pointer into the iDb index that indicates
536 ** which database file in db->aDb[] the schema refers to.
538 ** If the same database is attached more than once, the first
539 ** attached database is returned.
541 int sqlite3SchemaToIndex(sqlite3
*db
, Schema
*pSchema
){
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.
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.
555 assert( sqlite3_mutex_held(db
->mutex
) );
559 if( db
->aDb
[i
].pSchema
==pSchema
){
563 assert( i
>=0 && i
<db
->nDb
);
569 ** Free all memory allocations in the pParse object
571 void sqlite3ParserReset(Parse
*pParse
){
572 sqlite3
*db
= pParse
->db
;
573 while( pParse
->pCleanup
){
574 ParseCleanup
*pCleanup
= pParse
->pCleanup
;
575 pParse
->pCleanup
= pCleanup
->pNext
;
576 pCleanup
->xCleanup(db
, pCleanup
->pPtr
);
577 sqlite3DbFreeNN(db
, pCleanup
);
579 sqlite3DbFree(db
, pParse
->aLabel
);
580 if( pParse
->pConstExpr
){
581 sqlite3ExprListDelete(db
, pParse
->pConstExpr
);
584 assert( db
->lookaside
.bDisable
>= pParse
->disableLookaside
);
585 db
->lookaside
.bDisable
-= pParse
->disableLookaside
;
586 db
->lookaside
.sz
= db
->lookaside
.bDisable
? 0 : db
->lookaside
.szTrue
;
588 pParse
->disableLookaside
= 0;
592 ** Add a new cleanup operation to a Parser. The cleanup should happen when
593 ** the parser object is destroyed. But, beware: the cleanup might happen
596 ** Use this mechanism for uncommon cleanups. There is a higher setup
597 ** cost for this mechansim (an extra malloc), so it should not be used
598 ** for common cleanups that happen on most calls. But for less
599 ** common cleanups, we save a single NULL-pointer comparison in
600 ** sqlite3ParserReset(), which reduces the total CPU cycle count.
602 ** If a memory allocation error occurs, then the cleanup happens immediately.
603 ** When either SQLITE_DEBUG or SQLITE_COVERAGE_TEST are defined, the
604 ** pParse->earlyCleanup flag is set in that case. Calling code show verify
605 ** that test cases exist for which this happens, to guard against possible
606 ** use-after-free errors following an OOM. The preferred way to do this is
607 ** to immediately follow the call to this routine with:
609 ** testcase( pParse->earlyCleanup );
611 ** This routine returns a copy of its pPtr input (the third parameter)
612 ** except if an early cleanup occurs, in which case it returns NULL. So
613 ** another way to check for early cleanup is to check the return value.
614 ** Or, stop using the pPtr parameter with this call and use only its
615 ** return value thereafter. Something like this:
617 ** pObj = sqlite3ParserAddCleanup(pParse, destructor, pObj);
619 void *sqlite3ParserAddCleanup(
620 Parse
*pParse
, /* Destroy when this Parser finishes */
621 void (*xCleanup
)(sqlite3
*,void*), /* The cleanup routine */
622 void *pPtr
/* Pointer to object to be cleaned up */
624 ParseCleanup
*pCleanup
= sqlite3DbMallocRaw(pParse
->db
, sizeof(*pCleanup
));
626 pCleanup
->pNext
= pParse
->pCleanup
;
627 pParse
->pCleanup
= pCleanup
;
628 pCleanup
->pPtr
= pPtr
;
629 pCleanup
->xCleanup
= xCleanup
;
631 xCleanup(pParse
->db
, pPtr
);
633 #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST)
634 pParse
->earlyCleanup
= 1;
641 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
643 static int sqlite3Prepare(
644 sqlite3
*db
, /* Database handle. */
645 const char *zSql
, /* UTF-8 encoded SQL statement. */
646 int nBytes
, /* Length of zSql in bytes. */
647 u32 prepFlags
, /* Zero or more SQLITE_PREPARE_* flags */
648 Vdbe
*pReprepare
, /* VM being reprepared */
649 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
650 const char **pzTail
/* OUT: End of parsed string */
652 char *zErrMsg
= 0; /* Error message */
653 int rc
= SQLITE_OK
; /* Result code */
654 int i
; /* Loop counter */
655 Parse sParse
; /* Parsing context */
657 memset(&sParse
, 0, PARSE_HDR_SZ
);
658 memset(PARSE_TAIL(&sParse
), 0, PARSE_TAIL_SZ
);
659 sParse
.pReprepare
= pReprepare
;
660 assert( ppStmt
&& *ppStmt
==0 );
661 /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
662 assert( sqlite3_mutex_held(db
->mutex
) );
664 /* For a long-term use prepared statement avoid the use of
667 if( prepFlags
& SQLITE_PREPARE_PERSISTENT
){
668 sParse
.disableLookaside
++;
671 sParse
.disableVtab
= (prepFlags
& SQLITE_PREPARE_NO_VTAB
)!=0;
673 /* Check to verify that it is possible to get a read lock on all
674 ** database schemas. The inability to get a read lock indicates that
675 ** some other database connection is holding a write-lock, which in
676 ** turn means that the other connection has made uncommitted changes
679 ** Were we to proceed and prepare the statement against the uncommitted
680 ** schema changes and if those schema changes are subsequently rolled
681 ** back and different changes are made in their place, then when this
682 ** prepared statement goes to run the schema cookie would fail to detect
683 ** the schema change. Disaster would follow.
685 ** This thread is currently holding mutexes on all Btrees (because
686 ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
687 ** is not possible for another thread to start a new schema change
688 ** while this routine is running. Hence, we do not need to hold
689 ** locks on the schema, we just need to make sure nobody else is
692 ** Note that setting READ_UNCOMMITTED overrides most lock detection,
693 ** but it does *not* override schema lock detection, so this all still
694 ** works even if READ_UNCOMMITTED is set.
696 if( !db
->noSharedCache
){
697 for(i
=0; i
<db
->nDb
; i
++) {
698 Btree
*pBt
= db
->aDb
[i
].pBt
;
700 assert( sqlite3BtreeHoldsMutex(pBt
) );
701 rc
= sqlite3BtreeSchemaLocked(pBt
);
703 const char *zDb
= db
->aDb
[i
].zDbSName
;
704 sqlite3ErrorWithMsg(db
, rc
, "database schema is locked: %s", zDb
);
705 testcase( db
->flags
& SQLITE_ReadUncommit
);
712 sqlite3VtabUnlockList(db
);
715 if( nBytes
>=0 && (nBytes
==0 || zSql
[nBytes
-1]!=0) ){
717 int mxLen
= db
->aLimit
[SQLITE_LIMIT_SQL_LENGTH
];
718 testcase( nBytes
==mxLen
);
719 testcase( nBytes
==mxLen
+1 );
721 sqlite3ErrorWithMsg(db
, SQLITE_TOOBIG
, "statement too long");
722 rc
= sqlite3ApiExit(db
, SQLITE_TOOBIG
);
725 zSqlCopy
= sqlite3DbStrNDup(db
, zSql
, nBytes
);
727 sqlite3RunParser(&sParse
, zSqlCopy
, &zErrMsg
);
728 sParse
.zTail
= &zSql
[sParse
.zTail
-zSqlCopy
];
729 sqlite3DbFree(db
, zSqlCopy
);
731 sParse
.zTail
= &zSql
[nBytes
];
734 sqlite3RunParser(&sParse
, zSql
, &zErrMsg
);
736 assert( 0==sParse
.nQueryLoop
);
739 *pzTail
= sParse
.zTail
;
742 if( db
->init
.busy
==0 ){
743 sqlite3VdbeSetSql(sParse
.pVdbe
, zSql
, (int)(sParse
.zTail
-zSql
), prepFlags
);
745 if( db
->mallocFailed
){
746 sParse
.rc
= SQLITE_NOMEM_BKPT
;
747 sParse
.checkSchema
= 0;
749 if( sParse
.rc
!=SQLITE_OK
&& sParse
.rc
!=SQLITE_DONE
){
750 if( sParse
.checkSchema
&& db
->init
.busy
==0 ){
751 schemaIsValid(&sParse
);
754 sqlite3VdbeFinalize(sParse
.pVdbe
);
756 assert( 0==(*ppStmt
) );
759 sqlite3ErrorWithMsg(db
, rc
, "%s", zErrMsg
);
760 sqlite3DbFree(db
, zErrMsg
);
762 sqlite3Error(db
, rc
);
765 assert( zErrMsg
==0 );
766 *ppStmt
= (sqlite3_stmt
*)sParse
.pVdbe
;
768 sqlite3ErrorClear(db
);
772 /* Delete any TriggerPrg structures allocated while parsing this statement. */
773 while( sParse
.pTriggerPrg
){
774 TriggerPrg
*pT
= sParse
.pTriggerPrg
;
775 sParse
.pTriggerPrg
= pT
->pNext
;
776 sqlite3DbFree(db
, pT
);
781 sqlite3ParserReset(&sParse
);
784 static int sqlite3LockAndPrepare(
785 sqlite3
*db
, /* Database handle. */
786 const char *zSql
, /* UTF-8 encoded SQL statement. */
787 int nBytes
, /* Length of zSql in bytes. */
788 u32 prepFlags
, /* Zero or more SQLITE_PREPARE_* flags */
789 Vdbe
*pOld
, /* VM being reprepared */
790 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
791 const char **pzTail
/* OUT: End of parsed string */
796 #ifdef SQLITE_ENABLE_API_ARMOR
797 if( ppStmt
==0 ) return SQLITE_MISUSE_BKPT
;
800 if( !sqlite3SafetyCheckOk(db
)||zSql
==0 ){
801 return SQLITE_MISUSE_BKPT
;
803 sqlite3_mutex_enter(db
->mutex
);
804 sqlite3BtreeEnterAll(db
);
806 /* Make multiple attempts to compile the SQL, until it either succeeds
807 ** or encounters a permanent error. A schema problem after one schema
808 ** reset is considered a permanent error. */
809 rc
= sqlite3Prepare(db
, zSql
, nBytes
, prepFlags
, pOld
, ppStmt
, pzTail
);
810 assert( rc
==SQLITE_OK
|| *ppStmt
==0 );
811 if( rc
==SQLITE_OK
|| db
->mallocFailed
) break;
812 }while( rc
==SQLITE_ERROR_RETRY
813 || (rc
==SQLITE_SCHEMA
&& (sqlite3ResetOneSchema(db
,-1), cnt
++)==0) );
814 sqlite3BtreeLeaveAll(db
);
815 rc
= sqlite3ApiExit(db
, rc
);
816 assert( (rc
&db
->errMask
)==rc
);
817 db
->busyHandler
.nBusy
= 0;
818 sqlite3_mutex_leave(db
->mutex
);
824 ** Rerun the compilation of a statement after a schema change.
826 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
827 ** if the statement cannot be recompiled because another connection has
828 ** locked the sqlite3_schema table, return SQLITE_LOCKED. If any other error
829 ** occurs, return SQLITE_SCHEMA.
831 int sqlite3Reprepare(Vdbe
*p
){
838 assert( sqlite3_mutex_held(sqlite3VdbeDb(p
)->mutex
) );
839 zSql
= sqlite3_sql((sqlite3_stmt
*)p
);
840 assert( zSql
!=0 ); /* Reprepare only called for prepare_v2() statements */
841 db
= sqlite3VdbeDb(p
);
842 assert( sqlite3_mutex_held(db
->mutex
) );
843 prepFlags
= sqlite3VdbePrepareFlags(p
);
844 rc
= sqlite3LockAndPrepare(db
, zSql
, -1, prepFlags
, p
, &pNew
, 0);
846 if( rc
==SQLITE_NOMEM
){
854 sqlite3VdbeSwap((Vdbe
*)pNew
, p
);
855 sqlite3TransferBindings(pNew
, (sqlite3_stmt
*)p
);
856 sqlite3VdbeResetStepResult((Vdbe
*)pNew
);
857 sqlite3VdbeFinalize((Vdbe
*)pNew
);
863 ** Two versions of the official API. Legacy and new use. In the legacy
864 ** version, the original SQL text is not saved in the prepared statement
865 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
866 ** sqlite3_step(). In the new version, the original SQL text is retained
867 ** and the statement is automatically recompiled if an schema change
871 sqlite3
*db
, /* Database handle. */
872 const char *zSql
, /* UTF-8 encoded SQL statement. */
873 int nBytes
, /* Length of zSql in bytes. */
874 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
875 const char **pzTail
/* OUT: End of parsed string */
878 rc
= sqlite3LockAndPrepare(db
,zSql
,nBytes
,0,0,ppStmt
,pzTail
);
879 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
882 int sqlite3_prepare_v2(
883 sqlite3
*db
, /* Database handle. */
884 const char *zSql
, /* UTF-8 encoded SQL statement. */
885 int nBytes
, /* Length of zSql in bytes. */
886 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
887 const char **pzTail
/* OUT: End of parsed string */
890 /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works
891 ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags
894 ** Proof in that the 5th parameter to sqlite3LockAndPrepare is 0 */
895 rc
= sqlite3LockAndPrepare(db
,zSql
,nBytes
,SQLITE_PREPARE_SAVESQL
,0,
897 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 );
900 int sqlite3_prepare_v3(
901 sqlite3
*db
, /* Database handle. */
902 const char *zSql
, /* UTF-8 encoded SQL statement. */
903 int nBytes
, /* Length of zSql in bytes. */
904 unsigned int prepFlags
, /* Zero or more SQLITE_PREPARE_* flags */
905 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
906 const char **pzTail
/* OUT: End of parsed string */
909 /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from
910 ** sqlite3_prepare_v2() only in having the extra prepFlags parameter,
911 ** which is a bit array consisting of zero or more of the
912 ** SQLITE_PREPARE_* flags.
914 ** Proof by comparison to the implementation of sqlite3_prepare_v2()
915 ** directly above. */
916 rc
= sqlite3LockAndPrepare(db
,zSql
,nBytes
,
917 SQLITE_PREPARE_SAVESQL
|(prepFlags
&SQLITE_PREPARE_MASK
),
919 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 );
924 #ifndef SQLITE_OMIT_UTF16
926 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
928 static int sqlite3Prepare16(
929 sqlite3
*db
, /* Database handle. */
930 const void *zSql
, /* UTF-16 encoded SQL statement. */
931 int nBytes
, /* Length of zSql in bytes. */
932 u32 prepFlags
, /* Zero or more SQLITE_PREPARE_* flags */
933 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
934 const void **pzTail
/* OUT: End of parsed string */
936 /* This function currently works by first transforming the UTF-16
937 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
938 ** tricky bit is figuring out the pointer to return in *pzTail.
941 const char *zTail8
= 0;
944 #ifdef SQLITE_ENABLE_API_ARMOR
945 if( ppStmt
==0 ) return SQLITE_MISUSE_BKPT
;
948 if( !sqlite3SafetyCheckOk(db
)||zSql
==0 ){
949 return SQLITE_MISUSE_BKPT
;
953 const char *z
= (const char*)zSql
;
954 for(sz
=0; sz
<nBytes
&& (z
[sz
]!=0 || z
[sz
+1]!=0); sz
+= 2){}
957 sqlite3_mutex_enter(db
->mutex
);
958 zSql8
= sqlite3Utf16to8(db
, zSql
, nBytes
, SQLITE_UTF16NATIVE
);
960 rc
= sqlite3LockAndPrepare(db
, zSql8
, -1, prepFlags
, 0, ppStmt
, &zTail8
);
963 if( zTail8
&& pzTail
){
964 /* If sqlite3_prepare returns a tail pointer, we calculate the
965 ** equivalent pointer into the UTF-16 string by counting the unicode
966 ** characters between zSql8 and zTail8, and then returning a pointer
967 ** the same number of characters into the UTF-16 string.
969 int chars_parsed
= sqlite3Utf8CharLen(zSql8
, (int)(zTail8
-zSql8
));
970 *pzTail
= (u8
*)zSql
+ sqlite3Utf16ByteLen(zSql
, chars_parsed
);
972 sqlite3DbFree(db
, zSql8
);
973 rc
= sqlite3ApiExit(db
, rc
);
974 sqlite3_mutex_leave(db
->mutex
);
979 ** Two versions of the official API. Legacy and new use. In the legacy
980 ** version, the original SQL text is not saved in the prepared statement
981 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
982 ** sqlite3_step(). In the new version, the original SQL text is retained
983 ** and the statement is automatically recompiled if an schema change
986 int sqlite3_prepare16(
987 sqlite3
*db
, /* Database handle. */
988 const void *zSql
, /* UTF-16 encoded SQL statement. */
989 int nBytes
, /* Length of zSql in bytes. */
990 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
991 const void **pzTail
/* OUT: End of parsed string */
994 rc
= sqlite3Prepare16(db
,zSql
,nBytes
,0,ppStmt
,pzTail
);
995 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
998 int sqlite3_prepare16_v2(
999 sqlite3
*db
, /* Database handle. */
1000 const void *zSql
, /* UTF-16 encoded SQL statement. */
1001 int nBytes
, /* Length of zSql in bytes. */
1002 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
1003 const void **pzTail
/* OUT: End of parsed string */
1006 rc
= sqlite3Prepare16(db
,zSql
,nBytes
,SQLITE_PREPARE_SAVESQL
,ppStmt
,pzTail
);
1007 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
1010 int sqlite3_prepare16_v3(
1011 sqlite3
*db
, /* Database handle. */
1012 const void *zSql
, /* UTF-16 encoded SQL statement. */
1013 int nBytes
, /* Length of zSql in bytes. */
1014 unsigned int prepFlags
, /* Zero or more SQLITE_PREPARE_* flags */
1015 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
1016 const void **pzTail
/* OUT: End of parsed string */
1019 rc
= sqlite3Prepare16(db
,zSql
,nBytes
,
1020 SQLITE_PREPARE_SAVESQL
|(prepFlags
&SQLITE_PREPARE_MASK
),
1022 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
1026 #endif /* SQLITE_OMIT_UTF16 */