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 const char *zObj
, /* Object being parsed at the point of error */
25 const char *zExtra
/* Error information */
27 sqlite3
*db
= pData
->db
;
28 if( !db
->mallocFailed
&& (db
->flags
& SQLITE_RecoveryMode
)==0 ){
30 if( zObj
==0 ) zObj
= "?";
31 z
= sqlite3MPrintf(db
, "malformed database schema (%s)", zObj
);
32 if( zExtra
) z
= sqlite3MPrintf(db
, "%z - %s", z
, zExtra
);
33 sqlite3DbFree(db
, *pData
->pzErrMsg
);
36 pData
->rc
= db
->mallocFailed
? SQLITE_NOMEM_BKPT
: SQLITE_CORRUPT_BKPT
;
40 ** This is the callback routine for the code that initializes the
41 ** database. See sqlite3Init() below for additional information.
42 ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
44 ** Each callback contains the following information:
46 ** argv[0] = name of thing being created
47 ** argv[1] = root page number for table or index. 0 for trigger or view.
48 ** argv[2] = SQL text for the CREATE statement.
51 int sqlite3InitCallback(void *pInit
, int argc
, char **argv
, char **NotUsed
){
52 InitData
*pData
= (InitData
*)pInit
;
53 sqlite3
*db
= pData
->db
;
57 UNUSED_PARAMETER2(NotUsed
, argc
);
58 assert( sqlite3_mutex_held(db
->mutex
) );
59 DbClearProperty(db
, iDb
, DB_Empty
);
60 if( db
->mallocFailed
){
61 corruptSchema(pData
, argv
[0], 0);
65 assert( iDb
>=0 && iDb
<db
->nDb
);
66 if( argv
==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
68 corruptSchema(pData
, argv
[0], 0);
69 }else if( sqlite3_strnicmp(argv
[2],"create ",7)==0 ){
70 /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
71 ** But because db->init.busy is set to 1, no VDBE code is generated
72 ** or executed. All the parser does is build the internal data
73 ** structures that describe the table, index, or view.
76 u8 saved_iDb
= db
->init
.iDb
;
78 TESTONLY(int rcp
); /* Return code from sqlite3_prepare() */
80 assert( db
->init
.busy
);
82 db
->init
.newTnum
= sqlite3Atoi(argv
[1]);
83 db
->init
.orphanTrigger
= 0;
84 TESTONLY(rcp
= ) sqlite3_prepare(db
, argv
[2], -1, &pStmt
, 0);
86 assert( (rc
&0xFF)==(rcp
&0xFF) );
87 db
->init
.iDb
= saved_iDb
;
88 assert( saved_iDb
==0 || (db
->flags
& SQLITE_Vacuum
)!=0 );
90 if( db
->init
.orphanTrigger
){
94 if( rc
==SQLITE_NOMEM
){
96 }else if( rc
!=SQLITE_INTERRUPT
&& (rc
&0xFF)!=SQLITE_LOCKED
){
97 corruptSchema(pData
, argv
[0], sqlite3_errmsg(db
));
101 sqlite3_finalize(pStmt
);
102 }else if( argv
[0]==0 || (argv
[2]!=0 && argv
[2][0]!=0) ){
103 corruptSchema(pData
, argv
[0], 0);
105 /* If the SQL column is blank it means this is an index that
106 ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
107 ** constraint for a CREATE TABLE. The index should have already
108 ** been created when we processed the CREATE TABLE. All we have
109 ** to do here is record the root page number for that index.
112 pIndex
= sqlite3FindIndex(db
, argv
[0], db
->aDb
[iDb
].zDbSName
);
114 /* This can occur if there exists an index on a TEMP table which
115 ** has the same name as another index on a permanent index. Since
116 ** the permanent table is hidden by the TEMP table, we can also
117 ** safely ignore the index on the permanent table.
120 }else if( sqlite3GetInt32(argv
[1], &pIndex
->tnum
)==0 ){
121 corruptSchema(pData
, argv
[0], "invalid rootpage");
128 ** Attempt to read the database schema and initialize internal
129 ** data structures for a single database file. The index of the
130 ** database file is given by iDb. iDb==0 is used for the main
131 ** database. iDb==1 should never be used. iDb>=2 is used for
132 ** auxiliary databases. Return one of the SQLITE_ error codes to
133 ** indicate success or failure.
135 static int sqlite3InitOne(sqlite3
*db
, int iDb
, char **pzErrMsg
){
138 #ifndef SQLITE_OMIT_DEPRECATED
142 char const *azArg
[4];
145 const char *zMasterName
;
146 int openedTransaction
= 0;
148 assert( iDb
>=0 && iDb
<db
->nDb
);
149 assert( db
->aDb
[iDb
].pSchema
);
150 assert( sqlite3_mutex_held(db
->mutex
) );
151 assert( iDb
==1 || sqlite3BtreeHoldsMutex(db
->aDb
[iDb
].pBt
) );
153 /* Construct the in-memory representation schema tables (sqlite_master or
154 ** sqlite_temp_master) by invoking the parser directly. The appropriate
155 ** table name will be inserted automatically by the parser so we can just
156 ** use the abbreviation "x" here. The parser will also automatically tag
157 ** the schema table as read-only. */
158 azArg
[0] = zMasterName
= SCHEMA_TABLE(iDb
);
160 azArg
[2] = "CREATE TABLE x(type text,name text,tbl_name text,"
161 "rootpage integer,sql text)";
165 initData
.rc
= SQLITE_OK
;
166 initData
.pzErrMsg
= pzErrMsg
;
167 sqlite3InitCallback(&initData
, 3, (char **)azArg
, 0);
173 /* Create a cursor to hold the database open
177 if( !OMIT_TEMPDB
&& ALWAYS(iDb
==1) ){
178 DbSetProperty(db
, 1, DB_SchemaLoaded
);
183 /* If there is not already a read-only (or read-write) transaction opened
184 ** on the b-tree database, open one now. If a transaction is opened, it
185 ** will be closed before this function returns. */
186 sqlite3BtreeEnter(pDb
->pBt
);
187 if( !sqlite3BtreeIsInReadTrans(pDb
->pBt
) ){
188 rc
= sqlite3BtreeBeginTrans(pDb
->pBt
, 0);
190 sqlite3SetString(pzErrMsg
, db
, sqlite3ErrStr(rc
));
191 goto initone_error_out
;
193 openedTransaction
= 1;
196 /* Get the database meta information.
198 ** Meta values are as follows:
199 ** meta[0] Schema cookie. Changes with each schema change.
200 ** meta[1] File format of schema layer.
201 ** meta[2] Size of the page cache.
202 ** meta[3] Largest rootpage (auto/incr_vacuum mode)
203 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
204 ** meta[5] User version
205 ** meta[6] Incremental vacuum mode
210 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
211 ** the possible values of meta[4].
213 for(i
=0; i
<ArraySize(meta
); i
++){
214 sqlite3BtreeGetMeta(pDb
->pBt
, i
+1, (u32
*)&meta
[i
]);
216 pDb
->pSchema
->schema_cookie
= meta
[BTREE_SCHEMA_VERSION
-1];
218 /* If opening a non-empty database, check the text encoding. For the
219 ** main database, set sqlite3.enc to the encoding of the main database.
220 ** For an attached db, it is an error if the encoding is not the same
223 if( meta
[BTREE_TEXT_ENCODING
-1] ){ /* text encoding */
225 #ifndef SQLITE_OMIT_UTF16
227 /* If opening the main database, set ENC(db). */
228 encoding
= (u8
)meta
[BTREE_TEXT_ENCODING
-1] & 3;
229 if( encoding
==0 ) encoding
= SQLITE_UTF8
;
232 ENC(db
) = SQLITE_UTF8
;
235 /* If opening an attached database, the encoding much match ENC(db) */
236 if( meta
[BTREE_TEXT_ENCODING
-1]!=ENC(db
) ){
237 sqlite3SetString(pzErrMsg
, db
, "attached databases must use the same"
238 " text encoding as main database");
240 goto initone_error_out
;
244 DbSetProperty(db
, iDb
, DB_Empty
);
246 pDb
->pSchema
->enc
= ENC(db
);
248 if( pDb
->pSchema
->cache_size
==0 ){
249 #ifndef SQLITE_OMIT_DEPRECATED
250 size
= sqlite3AbsInt32(meta
[BTREE_DEFAULT_CACHE_SIZE
-1]);
251 if( size
==0 ){ size
= SQLITE_DEFAULT_CACHE_SIZE
; }
252 pDb
->pSchema
->cache_size
= size
;
254 pDb
->pSchema
->cache_size
= SQLITE_DEFAULT_CACHE_SIZE
;
256 sqlite3BtreeSetCacheSize(pDb
->pBt
, pDb
->pSchema
->cache_size
);
260 ** file_format==1 Version 3.0.0.
261 ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
262 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
263 ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
265 pDb
->pSchema
->file_format
= (u8
)meta
[BTREE_FILE_FORMAT
-1];
266 if( pDb
->pSchema
->file_format
==0 ){
267 pDb
->pSchema
->file_format
= 1;
269 if( pDb
->pSchema
->file_format
>SQLITE_MAX_FILE_FORMAT
){
270 sqlite3SetString(pzErrMsg
, db
, "unsupported file format");
272 goto initone_error_out
;
275 /* Ticket #2804: When we open a database in the newer file format,
276 ** clear the legacy_file_format pragma flag so that a VACUUM will
277 ** not downgrade the database and thus invalidate any descending
278 ** indices that the user might have created.
280 if( iDb
==0 && meta
[BTREE_FILE_FORMAT
-1]>=4 ){
281 db
->flags
&= ~SQLITE_LegacyFileFmt
;
284 /* Read the schema information out of the schema tables
286 assert( db
->init
.busy
);
289 zSql
= sqlite3MPrintf(db
,
290 "SELECT name, rootpage, sql FROM \"%w\".%s ORDER BY rowid",
291 db
->aDb
[iDb
].zDbSName
, zMasterName
);
292 #ifndef SQLITE_OMIT_AUTHORIZATION
298 rc
= sqlite3_exec(db
, zSql
, sqlite3InitCallback
, &initData
, 0);
299 #ifndef SQLITE_OMIT_AUTHORIZATION
303 if( rc
==SQLITE_OK
) rc
= initData
.rc
;
304 sqlite3DbFree(db
, zSql
);
305 #ifndef SQLITE_OMIT_ANALYZE
307 sqlite3AnalysisLoad(db
, iDb
);
311 if( db
->mallocFailed
){
312 rc
= SQLITE_NOMEM_BKPT
;
313 sqlite3ResetAllSchemasOfConnection(db
);
315 if( rc
==SQLITE_OK
|| (db
->flags
&SQLITE_RecoveryMode
)){
316 /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
317 ** the schema loaded, even if errors occurred. In this situation the
318 ** current sqlite3_prepare() operation will fail, but the following one
319 ** will attempt to compile the supplied statement against whatever subset
320 ** of the schema was loaded before the error occurred. The primary
321 ** purpose of this is to allow access to the sqlite_master table
322 ** even when its contents have been corrupted.
324 DbSetProperty(db
, iDb
, DB_SchemaLoaded
);
328 /* Jump here for an error that occurs after successfully allocating
329 ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
330 ** before that point, jump to error_out.
333 if( openedTransaction
){
334 sqlite3BtreeCommit(pDb
->pBt
);
336 sqlite3BtreeLeave(pDb
->pBt
);
339 if( rc
==SQLITE_NOMEM
|| rc
==SQLITE_IOERR_NOMEM
){
346 ** Initialize all database files - the main database file, the file
347 ** used to store temporary tables, and any additional database files
348 ** created using ATTACH statements. Return a success code. If an
349 ** error occurs, write an error message into *pzErrMsg.
351 ** After a database is initialized, the DB_SchemaLoaded bit is set
352 ** bit is set in the flags field of the Db structure. If the database
353 ** file was of zero-length, then the DB_Empty flag is also set.
355 int sqlite3Init(sqlite3
*db
, char **pzErrMsg
){
357 int commit_internal
= !(db
->flags
&SQLITE_InternChanges
);
359 assert( sqlite3_mutex_held(db
->mutex
) );
360 assert( sqlite3BtreeHoldsMutex(db
->aDb
[0].pBt
) );
361 assert( db
->init
.busy
==0 );
364 ENC(db
) = SCHEMA_ENC(db
);
365 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
366 if( DbHasProperty(db
, i
, DB_SchemaLoaded
) || i
==1 ) continue;
367 rc
= sqlite3InitOne(db
, i
, pzErrMsg
);
369 sqlite3ResetOneSchema(db
, i
);
373 /* Once all the other databases have been initialized, load the schema
374 ** for the TEMP database. This is loaded last, as the TEMP database
375 ** schema may contain references to objects in other databases.
377 #ifndef SQLITE_OMIT_TEMPDB
379 if( rc
==SQLITE_OK
&& !DbHasProperty(db
, 1, DB_SchemaLoaded
) ){
380 rc
= sqlite3InitOne(db
, 1, pzErrMsg
);
382 sqlite3ResetOneSchema(db
, 1);
388 if( rc
==SQLITE_OK
&& commit_internal
){
389 sqlite3CommitInternalChanges(db
);
396 ** This routine is a no-op if the database schema is already initialized.
397 ** Otherwise, the schema is loaded. An error code is returned.
399 int sqlite3ReadSchema(Parse
*pParse
){
401 sqlite3
*db
= pParse
->db
;
402 assert( sqlite3_mutex_held(db
->mutex
) );
403 if( !db
->init
.busy
){
404 rc
= sqlite3Init(db
, &pParse
->zErrMsg
);
415 ** Check schema cookies in all databases. If any cookie is out
416 ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
417 ** make no changes to pParse->rc.
419 static void schemaIsValid(Parse
*pParse
){
420 sqlite3
*db
= pParse
->db
;
425 assert( pParse
->checkSchema
);
426 assert( sqlite3_mutex_held(db
->mutex
) );
427 for(iDb
=0; iDb
<db
->nDb
; iDb
++){
428 int openedTransaction
= 0; /* True if a transaction is opened */
429 Btree
*pBt
= db
->aDb
[iDb
].pBt
; /* Btree database to read cookie from */
430 if( pBt
==0 ) continue;
432 /* If there is not already a read-only (or read-write) transaction opened
433 ** on the b-tree database, open one now. If a transaction is opened, it
434 ** will be closed immediately after reading the meta-value. */
435 if( !sqlite3BtreeIsInReadTrans(pBt
) ){
436 rc
= sqlite3BtreeBeginTrans(pBt
, 0);
437 if( rc
==SQLITE_NOMEM
|| rc
==SQLITE_IOERR_NOMEM
){
440 if( rc
!=SQLITE_OK
) return;
441 openedTransaction
= 1;
444 /* Read the schema cookie from the database. If it does not match the
445 ** value stored as part of the in-memory schema representation,
446 ** set Parse.rc to SQLITE_SCHEMA. */
447 sqlite3BtreeGetMeta(pBt
, BTREE_SCHEMA_VERSION
, (u32
*)&cookie
);
448 assert( sqlite3SchemaMutexHeld(db
, iDb
, 0) );
449 if( cookie
!=db
->aDb
[iDb
].pSchema
->schema_cookie
){
450 sqlite3ResetOneSchema(db
, iDb
);
451 pParse
->rc
= SQLITE_SCHEMA
;
454 /* Close the transaction, if one was opened. */
455 if( openedTransaction
){
456 sqlite3BtreeCommit(pBt
);
462 ** Convert a schema pointer into the iDb index that indicates
463 ** which database file in db->aDb[] the schema refers to.
465 ** If the same database is attached more than once, the first
466 ** attached database is returned.
468 int sqlite3SchemaToIndex(sqlite3
*db
, Schema
*pSchema
){
471 /* If pSchema is NULL, then return -1000000. This happens when code in
472 ** expr.c is trying to resolve a reference to a transient table (i.e. one
473 ** created by a sub-select). In this case the return value of this
474 ** function should never be used.
476 ** We return -1000000 instead of the more usual -1 simply because using
477 ** -1000000 as the incorrect index into db->aDb[] is much
478 ** more likely to cause a segfault than -1 (of course there are assert()
479 ** statements too, but it never hurts to play the odds).
481 assert( sqlite3_mutex_held(db
->mutex
) );
483 for(i
=0; ALWAYS(i
<db
->nDb
); i
++){
484 if( db
->aDb
[i
].pSchema
==pSchema
){
488 assert( i
>=0 && i
<db
->nDb
);
494 ** Free all memory allocations in the pParse object
496 void sqlite3ParserReset(Parse
*pParse
){
498 sqlite3
*db
= pParse
->db
;
499 sqlite3DbFree(db
, pParse
->aLabel
);
500 sqlite3ExprListDelete(db
, pParse
->pConstExpr
);
502 assert( db
->lookaside
.bDisable
>= pParse
->disableLookaside
);
503 db
->lookaside
.bDisable
-= pParse
->disableLookaside
;
505 pParse
->disableLookaside
= 0;
510 ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
512 static int sqlite3Prepare(
513 sqlite3
*db
, /* Database handle. */
514 const char *zSql
, /* UTF-8 encoded SQL statement. */
515 int nBytes
, /* Length of zSql in bytes. */
516 int saveSqlFlag
, /* True to copy SQL text into the sqlite3_stmt */
517 Vdbe
*pReprepare
, /* VM being reprepared */
518 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
519 const char **pzTail
/* OUT: End of parsed string */
521 char *zErrMsg
= 0; /* Error message */
522 int rc
= SQLITE_OK
; /* Result code */
523 int i
; /* Loop counter */
524 Parse sParse
; /* Parsing context */
526 memset(&sParse
, 0, PARSE_HDR_SZ
);
527 memset(PARSE_TAIL(&sParse
), 0, PARSE_TAIL_SZ
);
528 sParse
.pReprepare
= pReprepare
;
529 assert( ppStmt
&& *ppStmt
==0 );
530 /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
531 assert( sqlite3_mutex_held(db
->mutex
) );
533 /* Check to verify that it is possible to get a read lock on all
534 ** database schemas. The inability to get a read lock indicates that
535 ** some other database connection is holding a write-lock, which in
536 ** turn means that the other connection has made uncommitted changes
539 ** Were we to proceed and prepare the statement against the uncommitted
540 ** schema changes and if those schema changes are subsequently rolled
541 ** back and different changes are made in their place, then when this
542 ** prepared statement goes to run the schema cookie would fail to detect
543 ** the schema change. Disaster would follow.
545 ** This thread is currently holding mutexes on all Btrees (because
546 ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
547 ** is not possible for another thread to start a new schema change
548 ** while this routine is running. Hence, we do not need to hold
549 ** locks on the schema, we just need to make sure nobody else is
552 ** Note that setting READ_UNCOMMITTED overrides most lock detection,
553 ** but it does *not* override schema lock detection, so this all still
554 ** works even if READ_UNCOMMITTED is set.
556 for(i
=0; i
<db
->nDb
; i
++) {
557 Btree
*pBt
= db
->aDb
[i
].pBt
;
559 assert( sqlite3BtreeHoldsMutex(pBt
) );
560 rc
= sqlite3BtreeSchemaLocked(pBt
);
562 const char *zDb
= db
->aDb
[i
].zDbSName
;
563 sqlite3ErrorWithMsg(db
, rc
, "database schema is locked: %s", zDb
);
564 testcase( db
->flags
& SQLITE_ReadUncommitted
);
570 sqlite3VtabUnlockList(db
);
573 if( nBytes
>=0 && (nBytes
==0 || zSql
[nBytes
-1]!=0) ){
575 int mxLen
= db
->aLimit
[SQLITE_LIMIT_SQL_LENGTH
];
576 testcase( nBytes
==mxLen
);
577 testcase( nBytes
==mxLen
+1 );
579 sqlite3ErrorWithMsg(db
, SQLITE_TOOBIG
, "statement too long");
580 rc
= sqlite3ApiExit(db
, SQLITE_TOOBIG
);
583 zSqlCopy
= sqlite3DbStrNDup(db
, zSql
, nBytes
);
585 sqlite3RunParser(&sParse
, zSqlCopy
, &zErrMsg
);
586 sParse
.zTail
= &zSql
[sParse
.zTail
-zSqlCopy
];
587 sqlite3DbFree(db
, zSqlCopy
);
589 sParse
.zTail
= &zSql
[nBytes
];
592 sqlite3RunParser(&sParse
, zSql
, &zErrMsg
);
594 assert( 0==sParse
.nQueryLoop
);
596 if( sParse
.rc
==SQLITE_DONE
) sParse
.rc
= SQLITE_OK
;
597 if( sParse
.checkSchema
){
598 schemaIsValid(&sParse
);
600 if( db
->mallocFailed
){
601 sParse
.rc
= SQLITE_NOMEM_BKPT
;
604 *pzTail
= sParse
.zTail
;
608 #ifndef SQLITE_OMIT_EXPLAIN
609 if( rc
==SQLITE_OK
&& sParse
.pVdbe
&& sParse
.explain
){
610 static const char * const azColName
[] = {
611 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
612 "selectid", "order", "from", "detail"
615 if( sParse
.explain
==2 ){
616 sqlite3VdbeSetNumCols(sParse
.pVdbe
, 4);
620 sqlite3VdbeSetNumCols(sParse
.pVdbe
, 8);
624 for(i
=iFirst
; i
<mx
; i
++){
625 sqlite3VdbeSetColName(sParse
.pVdbe
, i
-iFirst
, COLNAME_NAME
,
626 azColName
[i
], SQLITE_STATIC
);
631 if( db
->init
.busy
==0 ){
632 Vdbe
*pVdbe
= sParse
.pVdbe
;
633 sqlite3VdbeSetSql(pVdbe
, zSql
, (int)(sParse
.zTail
-zSql
), saveSqlFlag
);
635 if( sParse
.pVdbe
&& (rc
!=SQLITE_OK
|| db
->mallocFailed
) ){
636 sqlite3VdbeFinalize(sParse
.pVdbe
);
639 *ppStmt
= (sqlite3_stmt
*)sParse
.pVdbe
;
643 sqlite3ErrorWithMsg(db
, rc
, "%s", zErrMsg
);
644 sqlite3DbFree(db
, zErrMsg
);
646 sqlite3Error(db
, rc
);
649 /* Delete any TriggerPrg structures allocated while parsing this statement. */
650 while( sParse
.pTriggerPrg
){
651 TriggerPrg
*pT
= sParse
.pTriggerPrg
;
652 sParse
.pTriggerPrg
= pT
->pNext
;
653 sqlite3DbFree(db
, pT
);
658 sqlite3ParserReset(&sParse
);
659 rc
= sqlite3ApiExit(db
, rc
);
660 assert( (rc
&db
->errMask
)==rc
);
663 static int sqlite3LockAndPrepare(
664 sqlite3
*db
, /* Database handle. */
665 const char *zSql
, /* UTF-8 encoded SQL statement. */
666 int nBytes
, /* Length of zSql in bytes. */
667 int saveSqlFlag
, /* True to copy SQL text into the sqlite3_stmt */
668 Vdbe
*pOld
, /* VM being reprepared */
669 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
670 const char **pzTail
/* OUT: End of parsed string */
674 #ifdef SQLITE_ENABLE_API_ARMOR
675 if( ppStmt
==0 ) return SQLITE_MISUSE_BKPT
;
678 if( !sqlite3SafetyCheckOk(db
)||zSql
==0 ){
679 return SQLITE_MISUSE_BKPT
;
681 sqlite3_mutex_enter(db
->mutex
);
682 sqlite3BtreeEnterAll(db
);
683 rc
= sqlite3Prepare(db
, zSql
, nBytes
, saveSqlFlag
, pOld
, ppStmt
, pzTail
);
684 if( rc
==SQLITE_SCHEMA
){
685 sqlite3_finalize(*ppStmt
);
686 rc
= sqlite3Prepare(db
, zSql
, nBytes
, saveSqlFlag
, pOld
, ppStmt
, pzTail
);
688 sqlite3BtreeLeaveAll(db
);
689 sqlite3_mutex_leave(db
->mutex
);
690 assert( rc
==SQLITE_OK
|| *ppStmt
==0 );
695 ** Rerun the compilation of a statement after a schema change.
697 ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
698 ** if the statement cannot be recompiled because another connection has
699 ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error
700 ** occurs, return SQLITE_SCHEMA.
702 int sqlite3Reprepare(Vdbe
*p
){
708 assert( sqlite3_mutex_held(sqlite3VdbeDb(p
)->mutex
) );
709 zSql
= sqlite3_sql((sqlite3_stmt
*)p
);
710 assert( zSql
!=0 ); /* Reprepare only called for prepare_v2() statements */
711 db
= sqlite3VdbeDb(p
);
712 assert( sqlite3_mutex_held(db
->mutex
) );
713 rc
= sqlite3LockAndPrepare(db
, zSql
, -1, 0, p
, &pNew
, 0);
715 if( rc
==SQLITE_NOMEM
){
723 sqlite3VdbeSwap((Vdbe
*)pNew
, p
);
724 sqlite3TransferBindings(pNew
, (sqlite3_stmt
*)p
);
725 sqlite3VdbeResetStepResult((Vdbe
*)pNew
);
726 sqlite3VdbeFinalize((Vdbe
*)pNew
);
732 ** Two versions of the official API. Legacy and new use. In the legacy
733 ** version, the original SQL text is not saved in the prepared statement
734 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
735 ** sqlite3_step(). In the new version, the original SQL text is retained
736 ** and the statement is automatically recompiled if an schema change
740 sqlite3
*db
, /* Database handle. */
741 const char *zSql
, /* UTF-8 encoded SQL statement. */
742 int nBytes
, /* Length of zSql in bytes. */
743 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
744 const char **pzTail
/* OUT: End of parsed string */
747 rc
= sqlite3LockAndPrepare(db
,zSql
,nBytes
,0,0,ppStmt
,pzTail
);
748 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
751 int sqlite3_prepare_v2(
752 sqlite3
*db
, /* Database handle. */
753 const char *zSql
, /* UTF-8 encoded SQL statement. */
754 int nBytes
, /* Length of zSql in bytes. */
755 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
756 const char **pzTail
/* OUT: End of parsed string */
759 rc
= sqlite3LockAndPrepare(db
,zSql
,nBytes
,1,0,ppStmt
,pzTail
);
760 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
765 #ifndef SQLITE_OMIT_UTF16
767 ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
769 static int sqlite3Prepare16(
770 sqlite3
*db
, /* Database handle. */
771 const void *zSql
, /* UTF-16 encoded SQL statement. */
772 int nBytes
, /* Length of zSql in bytes. */
773 int saveSqlFlag
, /* True to save SQL text into the sqlite3_stmt */
774 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
775 const void **pzTail
/* OUT: End of parsed string */
777 /* This function currently works by first transforming the UTF-16
778 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
779 ** tricky bit is figuring out the pointer to return in *pzTail.
782 const char *zTail8
= 0;
785 #ifdef SQLITE_ENABLE_API_ARMOR
786 if( ppStmt
==0 ) return SQLITE_MISUSE_BKPT
;
789 if( !sqlite3SafetyCheckOk(db
)||zSql
==0 ){
790 return SQLITE_MISUSE_BKPT
;
794 const char *z
= (const char*)zSql
;
795 for(sz
=0; sz
<nBytes
&& (z
[sz
]!=0 || z
[sz
+1]!=0); sz
+= 2){}
798 sqlite3_mutex_enter(db
->mutex
);
799 zSql8
= sqlite3Utf16to8(db
, zSql
, nBytes
, SQLITE_UTF16NATIVE
);
801 rc
= sqlite3LockAndPrepare(db
, zSql8
, -1, saveSqlFlag
, 0, ppStmt
, &zTail8
);
804 if( zTail8
&& pzTail
){
805 /* If sqlite3_prepare returns a tail pointer, we calculate the
806 ** equivalent pointer into the UTF-16 string by counting the unicode
807 ** characters between zSql8 and zTail8, and then returning a pointer
808 ** the same number of characters into the UTF-16 string.
810 int chars_parsed
= sqlite3Utf8CharLen(zSql8
, (int)(zTail8
-zSql8
));
811 *pzTail
= (u8
*)zSql
+ sqlite3Utf16ByteLen(zSql
, chars_parsed
);
813 sqlite3DbFree(db
, zSql8
);
814 rc
= sqlite3ApiExit(db
, rc
);
815 sqlite3_mutex_leave(db
->mutex
);
820 ** Two versions of the official API. Legacy and new use. In the legacy
821 ** version, the original SQL text is not saved in the prepared statement
822 ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
823 ** sqlite3_step(). In the new version, the original SQL text is retained
824 ** and the statement is automatically recompiled if an schema change
827 int sqlite3_prepare16(
828 sqlite3
*db
, /* Database handle. */
829 const void *zSql
, /* UTF-16 encoded SQL statement. */
830 int nBytes
, /* Length of zSql in bytes. */
831 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
832 const void **pzTail
/* OUT: End of parsed string */
835 rc
= sqlite3Prepare16(db
,zSql
,nBytes
,0,ppStmt
,pzTail
);
836 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
839 int sqlite3_prepare16_v2(
840 sqlite3
*db
, /* Database handle. */
841 const void *zSql
, /* UTF-16 encoded SQL statement. */
842 int nBytes
, /* Length of zSql in bytes. */
843 sqlite3_stmt
**ppStmt
, /* OUT: A pointer to the prepared statement */
844 const void **pzTail
/* OUT: End of parsed string */
847 rc
= sqlite3Prepare16(db
,zSql
,nBytes
,1,ppStmt
,pzTail
);
848 assert( rc
==SQLITE_OK
|| ppStmt
==0 || *ppStmt
==0 ); /* VERIFY: F13021 */
852 #endif /* SQLITE_OMIT_UTF16 */