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 : ** $Id: prepare.c 235759 2007-05-16 21:04:46Z iliaa $
17 : */
18 : #include "sqliteInt.h"
19 : #include "os.h"
20 : #include <ctype.h>
21 :
22 : /*
23 : ** Fill the InitData structure with an error message that indicates
24 : ** that the database is corrupt.
25 : */
26 0 : static void corruptSchema(InitData *pData, const char *zExtra){
27 0 : if( !sqlite3MallocFailed() ){
28 0 : sqlite3SetString(pData->pzErrMsg, "malformed database schema",
29 : zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0);
30 : }
31 0 : pData->rc = SQLITE_CORRUPT;
32 0 : }
33 :
34 : /*
35 : ** This is the callback routine for the code that initializes the
36 : ** database. See sqlite3Init() below for additional information.
37 : ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
38 : **
39 : ** Each callback contains the following information:
40 : **
41 : ** argv[0] = name of thing being created
42 : ** argv[1] = root page number for table or index. 0 for trigger or view.
43 : ** argv[2] = SQL text for the CREATE statement.
44 : **
45 : */
46 312 : int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){
47 312 : InitData *pData = (InitData*)pInit;
48 312 : sqlite3 *db = pData->db;
49 312 : int iDb = pData->iDb;
50 :
51 312 : pData->rc = SQLITE_OK;
52 312 : DbClearProperty(db, iDb, DB_Empty);
53 312 : if( sqlite3MallocFailed() ){
54 0 : corruptSchema(pData, 0);
55 0 : return SQLITE_NOMEM;
56 : }
57 :
58 : assert( argc==3 );
59 312 : if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
60 312 : if( argv[1]==0 ){
61 0 : corruptSchema(pData, 0);
62 0 : return 1;
63 : }
64 : assert( iDb>=0 && iDb<db->nDb );
65 585 : if( argv[2] && argv[2][0] ){
66 : /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
67 : ** But because db->init.busy is set to 1, no VDBE code is generated
68 : ** or executed. All the parser does is build the internal data
69 : ** structures that describe the table, index, or view.
70 : */
71 : char *zErr;
72 : int rc;
73 : assert( db->init.busy );
74 273 : db->init.iDb = iDb;
75 273 : db->init.newTnum = atoi(argv[1]);
76 273 : rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
77 273 : db->init.iDb = 0;
78 : assert( rc!=SQLITE_OK || zErr==0 );
79 273 : if( SQLITE_OK!=rc ){
80 0 : pData->rc = rc;
81 0 : if( rc==SQLITE_NOMEM ){
82 0 : sqlite3FailedMalloc();
83 0 : }else if( rc!=SQLITE_INTERRUPT ){
84 0 : corruptSchema(pData, zErr);
85 : }
86 0 : sqlite3_free(zErr);
87 0 : return 1;
88 : }
89 : }else{
90 : /* If the SQL column is blank it means this is an index that
91 : ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
92 : ** constraint for a CREATE TABLE. The index should have already
93 : ** been created when we processed the CREATE TABLE. All we have
94 : ** to do here is record the root page number for that index.
95 : */
96 : Index *pIndex;
97 39 : pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
98 39 : if( pIndex==0 || pIndex->tnum!=0 ){
99 : /* This can occur if there exists an index on a TEMP table which
100 : ** has the same name as another index on a permanent index. Since
101 : ** the permanent table is hidden by the TEMP table, we can also
102 : ** safely ignore the index on the permanent table.
103 : */
104 : /* Do Nothing */;
105 : }else{
106 39 : pIndex->tnum = atoi(argv[1]);
107 : }
108 : }
109 312 : return 0;
110 : }
111 :
112 : /*
113 : ** Attempt to read the database schema and initialize internal
114 : ** data structures for a single database file. The index of the
115 : ** database file is given by iDb. iDb==0 is used for the main
116 : ** database. iDb==1 should never be used. iDb>=2 is used for
117 : ** auxiliary databases. Return one of the SQLITE_ error codes to
118 : ** indicate success or failure.
119 : */
120 216 : static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
121 : int rc;
122 : BtCursor *curMain;
123 : int size;
124 : Table *pTab;
125 : Db *pDb;
126 : char const *azArg[4];
127 : int meta[10];
128 : InitData initData;
129 : char const *zMasterSchema;
130 216 : char const *zMasterName = SCHEMA_TABLE(iDb);
131 :
132 : /*
133 : ** The master database table has a structure like this
134 : */
135 : static const char master_schema[] =
136 : "CREATE TABLE sqlite_master(\n"
137 : " type text,\n"
138 : " name text,\n"
139 : " tbl_name text,\n"
140 : " rootpage integer,\n"
141 : " sql text\n"
142 : ")"
143 : ;
144 : #ifndef SQLITE_OMIT_TEMPDB
145 : static const char temp_master_schema[] =
146 : "CREATE TEMP TABLE sqlite_temp_master(\n"
147 : " type text,\n"
148 : " name text,\n"
149 : " tbl_name text,\n"
150 : " rootpage integer,\n"
151 : " sql text\n"
152 : ")"
153 : ;
154 : #else
155 : #define temp_master_schema 0
156 : #endif
157 :
158 : assert( iDb>=0 && iDb<db->nDb );
159 : assert( db->aDb[iDb].pSchema );
160 :
161 : /* zMasterSchema and zInitScript are set to point at the master schema
162 : ** and initialisation script appropriate for the database being
163 : ** initialised. zMasterName is the name of the master table.
164 : */
165 216 : if( !OMIT_TEMPDB && iDb==1 ){
166 108 : zMasterSchema = temp_master_schema;
167 : }else{
168 108 : zMasterSchema = master_schema;
169 : }
170 216 : zMasterName = SCHEMA_TABLE(iDb);
171 :
172 : /* Construct the schema tables. */
173 216 : sqlite3SafetyOff(db);
174 216 : azArg[0] = zMasterName;
175 216 : azArg[1] = "1";
176 216 : azArg[2] = zMasterSchema;
177 216 : azArg[3] = 0;
178 216 : initData.db = db;
179 216 : initData.iDb = iDb;
180 216 : initData.pzErrMsg = pzErrMsg;
181 216 : rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
182 216 : if( rc ){
183 0 : sqlite3SafetyOn(db);
184 0 : return initData.rc;
185 : }
186 216 : pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
187 216 : if( pTab ){
188 216 : pTab->readOnly = 1;
189 : }
190 216 : sqlite3SafetyOn(db);
191 :
192 : /* Create a cursor to hold the database open
193 : */
194 216 : pDb = &db->aDb[iDb];
195 216 : if( pDb->pBt==0 ){
196 108 : if( !OMIT_TEMPDB && iDb==1 ){
197 108 : DbSetProperty(db, 1, DB_SchemaLoaded);
198 : }
199 108 : return SQLITE_OK;
200 : }
201 108 : rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain);
202 108 : if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){
203 0 : sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
204 0 : return rc;
205 : }
206 :
207 : /* Get the database meta information.
208 : **
209 : ** Meta values are as follows:
210 : ** meta[0] Schema cookie. Changes with each schema change.
211 : ** meta[1] File format of schema layer.
212 : ** meta[2] Size of the page cache.
213 : ** meta[3] Use freelist if 0. Autovacuum if greater than zero.
214 : ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
215 : ** meta[5] The user cookie. Used by the application.
216 : ** meta[6]
217 : ** meta[7]
218 : ** meta[8]
219 : ** meta[9]
220 : **
221 : ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
222 : ** the possible values of meta[4].
223 : */
224 108 : if( rc==SQLITE_OK ){
225 : int i;
226 44 : for(i=0; rc==SQLITE_OK && i<sizeof(meta)/sizeof(meta[0]); i++){
227 40 : rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
228 : }
229 4 : if( rc ){
230 0 : sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
231 0 : sqlite3BtreeCloseCursor(curMain);
232 0 : return rc;
233 : }
234 : }else{
235 104 : memset(meta, 0, sizeof(meta));
236 : }
237 108 : pDb->pSchema->schema_cookie = meta[0];
238 :
239 : /* If opening a non-empty database, check the text encoding. For the
240 : ** main database, set sqlite3.enc to the encoding of the main database.
241 : ** For an attached db, it is an error if the encoding is not the same
242 : ** as sqlite3.enc.
243 : */
244 108 : if( meta[4] ){ /* text encoding */
245 4 : if( iDb==0 ){
246 : /* If opening the main database, set ENC(db). */
247 4 : ENC(db) = (u8)meta[4];
248 4 : db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
249 : }else{
250 : /* If opening an attached database, the encoding much match ENC(db) */
251 0 : if( meta[4]!=ENC(db) ){
252 0 : sqlite3BtreeCloseCursor(curMain);
253 0 : sqlite3SetString(pzErrMsg, "attached databases must use the same"
254 : " text encoding as main database", (char*)0);
255 0 : return SQLITE_ERROR;
256 : }
257 : }
258 : }else{
259 104 : DbSetProperty(db, iDb, DB_Empty);
260 : }
261 108 : pDb->pSchema->enc = ENC(db);
262 :
263 108 : size = meta[2];
264 108 : if( size==0 ){ size = MAX_PAGES; }
265 108 : pDb->pSchema->cache_size = size;
266 108 : sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
267 :
268 : /*
269 : ** file_format==1 Version 3.0.0.
270 : ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
271 : ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
272 : ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
273 : */
274 108 : pDb->pSchema->file_format = meta[1];
275 108 : if( pDb->pSchema->file_format==0 ){
276 104 : pDb->pSchema->file_format = 1;
277 : }
278 108 : if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
279 0 : sqlite3BtreeCloseCursor(curMain);
280 0 : sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);
281 0 : return SQLITE_ERROR;
282 : }
283 :
284 :
285 : /* Read the schema information out of the schema tables
286 : */
287 : assert( db->init.busy );
288 108 : if( rc==SQLITE_EMPTY ){
289 : /* For an empty database, there is nothing to read */
290 104 : rc = SQLITE_OK;
291 : }else{
292 : char *zSql;
293 4 : zSql = sqlite3MPrintf(
294 : "SELECT name, rootpage, sql FROM '%q'.%s",
295 : db->aDb[iDb].zName, zMasterName);
296 4 : sqlite3SafetyOff(db);
297 4 : rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
298 4 : if( rc==SQLITE_ABORT ) rc = initData.rc;
299 4 : sqlite3SafetyOn(db);
300 4 : sqliteFree(zSql);
301 : #ifndef SQLITE_OMIT_ANALYZE
302 4 : if( rc==SQLITE_OK ){
303 4 : sqlite3AnalysisLoad(db, iDb);
304 : }
305 : #endif
306 4 : sqlite3BtreeCloseCursor(curMain);
307 : }
308 108 : if( sqlite3MallocFailed() ){
309 : /* sqlite3SetString(pzErrMsg, "out of memory", (char*)0); */
310 0 : rc = SQLITE_NOMEM;
311 0 : sqlite3ResetInternalSchema(db, 0);
312 : }
313 108 : if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
314 : /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
315 : ** the schema loaded, even if errors occured. In this situation the
316 : ** current sqlite3_prepare() operation will fail, but the following one
317 : ** will attempt to compile the supplied statement against whatever subset
318 : ** of the schema was loaded before the error occured. The primary
319 : ** purpose of this is to allow access to the sqlite_master table
320 : ** even when it's contents have been corrupted.
321 : */
322 108 : DbSetProperty(db, iDb, DB_SchemaLoaded);
323 108 : rc = SQLITE_OK;
324 : }
325 108 : return rc;
326 : }
327 :
328 : /*
329 : ** Initialize all database files - the main database file, the file
330 : ** used to store temporary tables, and any additional database files
331 : ** created using ATTACH statements. Return a success code. If an
332 : ** error occurs, write an error message into *pzErrMsg.
333 : **
334 : ** After a database is initialized, the DB_SchemaLoaded bit is set
335 : ** bit is set in the flags field of the Db structure. If the database
336 : ** file was of zero-length, then the DB_Empty flag is also set.
337 : */
338 687 : int sqlite3Init(sqlite3 *db, char **pzErrMsg){
339 : int i, rc;
340 687 : int called_initone = 0;
341 :
342 687 : if( db->init.busy ) return SQLITE_OK;
343 687 : rc = SQLITE_OK;
344 687 : db->init.busy = 1;
345 2061 : for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
346 1374 : if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
347 108 : rc = sqlite3InitOne(db, i, pzErrMsg);
348 108 : if( rc ){
349 0 : sqlite3ResetInternalSchema(db, i);
350 : }
351 108 : called_initone = 1;
352 : }
353 :
354 : /* Once all the other databases have been initialised, load the schema
355 : ** for the TEMP database. This is loaded last, as the TEMP database
356 : ** schema may contain references to objects in other databases.
357 : */
358 : #ifndef SQLITE_OMIT_TEMPDB
359 687 : if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
360 108 : rc = sqlite3InitOne(db, 1, pzErrMsg);
361 108 : if( rc ){
362 0 : sqlite3ResetInternalSchema(db, 1);
363 : }
364 108 : called_initone = 1;
365 : }
366 : #endif
367 :
368 687 : db->init.busy = 0;
369 687 : if( rc==SQLITE_OK && called_initone ){
370 108 : sqlite3CommitInternalChanges(db);
371 : }
372 :
373 687 : return rc;
374 : }
375 :
376 : /*
377 : ** This routine is a no-op if the database schema is already initialised.
378 : ** Otherwise, the schema is loaded. An error code is returned.
379 : */
380 1021 : int sqlite3ReadSchema(Parse *pParse){
381 1021 : int rc = SQLITE_OK;
382 1021 : sqlite3 *db = pParse->db;
383 1021 : if( !db->init.busy ){
384 687 : rc = sqlite3Init(db, &pParse->zErrMsg);
385 : }
386 1021 : if( rc!=SQLITE_OK ){
387 0 : pParse->rc = rc;
388 0 : pParse->nErr++;
389 : }
390 1021 : return rc;
391 : }
392 :
393 :
394 : /*
395 : ** Check schema cookies in all databases. If any cookie is out
396 : ** of date, return 0. If all schema cookies are current, return 1.
397 : */
398 309 : static int schemaIsValid(sqlite3 *db){
399 : int iDb;
400 : int rc;
401 : BtCursor *curTemp;
402 : int cookie;
403 309 : int allOk = 1;
404 :
405 927 : for(iDb=0; allOk && iDb<db->nDb; iDb++){
406 : Btree *pBt;
407 618 : pBt = db->aDb[iDb].pBt;
408 618 : if( pBt==0 ) continue;
409 309 : rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, 0, &curTemp);
410 309 : if( rc==SQLITE_OK ){
411 0 : rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie);
412 0 : if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){
413 0 : allOk = 0;
414 : }
415 0 : sqlite3BtreeCloseCursor(curTemp);
416 : }
417 : }
418 309 : return allOk;
419 : }
420 :
421 : /*
422 : ** Convert a schema pointer into the iDb index that indicates
423 : ** which database file in db->aDb[] the schema refers to.
424 : **
425 : ** If the same database is attached more than once, the first
426 : ** attached database is returned.
427 : */
428 1857 : int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
429 1857 : int i = -1000000;
430 :
431 : /* If pSchema is NULL, then return -1000000. This happens when code in
432 : ** expr.c is trying to resolve a reference to a transient table (i.e. one
433 : ** created by a sub-select). In this case the return value of this
434 : ** function should never be used.
435 : **
436 : ** We return -1000000 instead of the more usual -1 simply because using
437 : ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much
438 : ** more likely to cause a segfault than -1 (of course there are assert()
439 : ** statements too, but it never hurts to play the odds).
440 : */
441 1857 : if( pSchema ){
442 1965 : for(i=0; i<db->nDb; i++){
443 1965 : if( db->aDb[i].pSchema==pSchema ){
444 1857 : break;
445 : }
446 : }
447 : assert( i>=0 &&i>=0 && i<db->nDb );
448 : }
449 1857 : return i;
450 : }
451 :
452 : /*
453 : ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
454 : */
455 : int sqlite3Prepare(
456 : sqlite3 *db, /* Database handle. */
457 : const char *zSql, /* UTF-8 encoded SQL statement. */
458 : int nBytes, /* Length of zSql in bytes. */
459 : int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
460 : sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
461 : const char **pzTail /* OUT: End of parsed string */
462 930 : ){
463 : Parse sParse;
464 930 : char *zErrMsg = 0;
465 930 : int rc = SQLITE_OK;
466 : int i;
467 :
468 : /* Assert that malloc() has not failed */
469 : assert( !sqlite3MallocFailed() );
470 :
471 : assert( ppStmt );
472 930 : *ppStmt = 0;
473 930 : if( sqlite3SafetyOn(db) ){
474 0 : return SQLITE_MISUSE;
475 : }
476 :
477 : /* If any attached database schemas are locked, do not proceed with
478 : ** compilation. Instead return SQLITE_LOCKED immediately.
479 : */
480 2790 : for(i=0; i<db->nDb; i++) {
481 1860 : Btree *pBt = db->aDb[i].pBt;
482 1860 : if( pBt && sqlite3BtreeSchemaLocked(pBt) ){
483 0 : const char *zDb = db->aDb[i].zName;
484 0 : sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);
485 0 : sqlite3SafetyOff(db);
486 0 : return SQLITE_LOCKED;
487 : }
488 : }
489 :
490 930 : memset(&sParse, 0, sizeof(sParse));
491 930 : sParse.db = db;
492 930 : if( nBytes>=0 && zSql[nBytes]!=0 ){
493 0 : char *zSqlCopy = sqlite3StrNDup(zSql, nBytes);
494 0 : sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
495 0 : sParse.zTail += zSql - zSqlCopy;
496 0 : sqliteFree(zSqlCopy);
497 : }else{
498 930 : sqlite3RunParser(&sParse, zSql, &zErrMsg);
499 : }
500 :
501 930 : if( sqlite3MallocFailed() ){
502 0 : sParse.rc = SQLITE_NOMEM;
503 : }
504 930 : if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
505 930 : if( sParse.checkSchema && !schemaIsValid(db) ){
506 0 : sParse.rc = SQLITE_SCHEMA;
507 : }
508 930 : if( sParse.rc==SQLITE_SCHEMA ){
509 0 : sqlite3ResetInternalSchema(db, 0);
510 : }
511 930 : if( sqlite3MallocFailed() ){
512 0 : sParse.rc = SQLITE_NOMEM;
513 : }
514 930 : if( pzTail ){
515 930 : *pzTail = sParse.zTail;
516 : }
517 930 : rc = sParse.rc;
518 :
519 : #ifndef SQLITE_OMIT_EXPLAIN
520 930 : if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){
521 0 : if( sParse.explain==2 ){
522 0 : sqlite3VdbeSetNumCols(sParse.pVdbe, 3);
523 0 : sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P3_STATIC);
524 0 : sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P3_STATIC);
525 0 : sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P3_STATIC);
526 : }else{
527 0 : sqlite3VdbeSetNumCols(sParse.pVdbe, 5);
528 0 : sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P3_STATIC);
529 0 : sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P3_STATIC);
530 0 : sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P3_STATIC);
531 0 : sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P3_STATIC);
532 0 : sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P3_STATIC);
533 : }
534 : }
535 : #endif
536 :
537 930 : if( sqlite3SafetyOff(db) ){
538 0 : rc = SQLITE_MISUSE;
539 : }
540 :
541 930 : if( saveSqlFlag ){
542 0 : sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);
543 : }
544 1240 : if( rc!=SQLITE_OK || sqlite3MallocFailed() ){
545 310 : sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
546 : assert(!(*ppStmt));
547 : }else{
548 620 : *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
549 : }
550 :
551 930 : if( zErrMsg ){
552 310 : sqlite3Error(db, rc, "%s", zErrMsg);
553 310 : sqliteFree(zErrMsg);
554 : }else{
555 620 : sqlite3Error(db, rc, 0);
556 : }
557 :
558 930 : rc = sqlite3ApiExit(db, rc);
559 930 : sqlite3ReleaseThreadData();
560 : assert( (rc&db->errMask)==rc );
561 930 : return rc;
562 : }
563 :
564 : /*
565 : ** Rerun the compilation of a statement after a schema change.
566 : ** Return true if the statement was recompiled successfully.
567 : ** Return false if there is an error of some kind.
568 : */
569 0 : int sqlite3Reprepare(Vdbe *p){
570 : int rc;
571 : sqlite3_stmt *pNew;
572 : const char *zSql;
573 : sqlite3 *db;
574 :
575 0 : zSql = sqlite3VdbeGetSql(p);
576 0 : if( zSql==0 ){
577 0 : return 0;
578 : }
579 0 : db = sqlite3VdbeDb(p);
580 0 : rc = sqlite3Prepare(db, zSql, -1, 0, &pNew, 0);
581 0 : if( rc ){
582 : assert( pNew==0 );
583 0 : return 0;
584 : }else{
585 : assert( pNew!=0 );
586 : }
587 0 : sqlite3VdbeSwap((Vdbe*)pNew, p);
588 0 : sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p);
589 0 : sqlite3VdbeResetStepResult((Vdbe*)pNew);
590 0 : sqlite3VdbeFinalize((Vdbe*)pNew);
591 0 : return 1;
592 : }
593 :
594 :
595 : /*
596 : ** Two versions of the official API. Legacy and new use. In the legacy
597 : ** version, the original SQL text is not saved in the prepared statement
598 : ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
599 : ** sqlite3_step(). In the new version, the original SQL text is retained
600 : ** and the statement is automatically recompiled if an schema change
601 : ** occurs.
602 : */
603 : int sqlite3_prepare(
604 : sqlite3 *db, /* Database handle. */
605 : const char *zSql, /* UTF-8 encoded SQL statement. */
606 : int nBytes, /* Length of zSql in bytes. */
607 : sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
608 : const char **pzTail /* OUT: End of parsed string */
609 930 : ){
610 930 : return sqlite3Prepare(db,zSql,nBytes,0,ppStmt,pzTail);
611 : }
612 : int sqlite3_prepare_v2(
613 : sqlite3 *db, /* Database handle. */
614 : const char *zSql, /* UTF-8 encoded SQL statement. */
615 : int nBytes, /* Length of zSql in bytes. */
616 : sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
617 : const char **pzTail /* OUT: End of parsed string */
618 0 : ){
619 0 : return sqlite3Prepare(db,zSql,nBytes,1,ppStmt,pzTail);
620 : }
621 :
622 :
623 : #ifndef SQLITE_OMIT_UTF16
624 : /*
625 : ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
626 : */
627 : static int sqlite3Prepare16(
628 : sqlite3 *db, /* Database handle. */
629 : const void *zSql, /* UTF-8 encoded SQL statement. */
630 : int nBytes, /* Length of zSql in bytes. */
631 : int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
632 : sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
633 : const void **pzTail /* OUT: End of parsed string */
634 0 : ){
635 : /* This function currently works by first transforming the UTF-16
636 : ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
637 : ** tricky bit is figuring out the pointer to return in *pzTail.
638 : */
639 : char *zSql8;
640 0 : const char *zTail8 = 0;
641 0 : int rc = SQLITE_OK;
642 :
643 0 : if( sqlite3SafetyCheck(db) ){
644 0 : return SQLITE_MISUSE;
645 : }
646 0 : zSql8 = sqlite3utf16to8(zSql, nBytes);
647 0 : if( zSql8 ){
648 0 : rc = sqlite3Prepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
649 : }
650 :
651 0 : if( zTail8 && pzTail ){
652 : /* If sqlite3_prepare returns a tail pointer, we calculate the
653 : ** equivalent pointer into the UTF-16 string by counting the unicode
654 : ** characters between zSql8 and zTail8, and then returning a pointer
655 : ** the same number of characters into the UTF-16 string.
656 : */
657 0 : int chars_parsed = sqlite3utf8CharLen(zSql8, zTail8-zSql8);
658 0 : *pzTail = (u8 *)zSql + sqlite3utf16ByteLen(zSql, chars_parsed);
659 : }
660 0 : sqliteFree(zSql8);
661 0 : return sqlite3ApiExit(db, rc);
662 : }
663 :
664 : /*
665 : ** Two versions of the official API. Legacy and new use. In the legacy
666 : ** version, the original SQL text is not saved in the prepared statement
667 : ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
668 : ** sqlite3_step(). In the new version, the original SQL text is retained
669 : ** and the statement is automatically recompiled if an schema change
670 : ** occurs.
671 : */
672 : int sqlite3_prepare16(
673 : sqlite3 *db, /* Database handle. */
674 : const void *zSql, /* UTF-8 encoded SQL statement. */
675 : int nBytes, /* Length of zSql in bytes. */
676 : sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
677 : const void **pzTail /* OUT: End of parsed string */
678 0 : ){
679 0 : return sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
680 : }
681 : int sqlite3_prepare16_v2(
682 : sqlite3 *db, /* Database handle. */
683 : const void *zSql, /* UTF-8 encoded SQL statement. */
684 : int nBytes, /* Length of zSql in bytes. */
685 : sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
686 : const void **pzTail /* OUT: End of parsed string */
687 0 : ){
688 0 : return sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
689 : }
690 :
691 : #endif /* SQLITE_OMIT_UTF16 */
|
