Annotation of embedaddon/sqlite3/src/prepare.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2005 May 25
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** This file contains the implementation of the sqlite3_prepare()
13: ** interface, and routines that contribute to loading the database schema
14: ** from disk.
15: */
16: #include "sqliteInt.h"
17:
18: /*
19: ** Fill the InitData structure with an error message that indicates
20: ** that the database is corrupt.
21: */
22: static void corruptSchema(
23: InitData *pData, /* Initialization context */
24: const char *zObj, /* Object being parsed at the point of error */
25: const char *zExtra /* Error information */
26: ){
27: sqlite3 *db = pData->db;
28: if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
29: if( zObj==0 ) zObj = "?";
30: sqlite3SetString(pData->pzErrMsg, db,
31: "malformed database schema (%s)", zObj);
32: if( zExtra ){
33: *pData->pzErrMsg = sqlite3MAppendf(db, *pData->pzErrMsg,
34: "%s - %s", *pData->pzErrMsg, zExtra);
35: }
36: }
37: pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT;
38: }
39:
40: /*
41: ** This is the callback routine for the code that initializes the
42: ** database. See sqlite3Init() below for additional information.
43: ** This routine is also called from the OP_ParseSchema opcode of the VDBE.
44: **
45: ** Each callback contains the following information:
46: **
47: ** argv[0] = name of thing being created
48: ** argv[1] = root page number for table or index. 0 for trigger or view.
49: ** argv[2] = SQL text for the CREATE statement.
50: **
51: */
52: int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
53: InitData *pData = (InitData*)pInit;
54: sqlite3 *db = pData->db;
55: int iDb = pData->iDb;
56:
57: assert( argc==3 );
58: UNUSED_PARAMETER2(NotUsed, argc);
59: assert( sqlite3_mutex_held(db->mutex) );
60: DbClearProperty(db, iDb, DB_Empty);
61: if( db->mallocFailed ){
62: corruptSchema(pData, argv[0], 0);
63: return 1;
64: }
65:
66: assert( iDb>=0 && iDb<db->nDb );
67: if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
68: if( argv[1]==0 ){
69: corruptSchema(pData, argv[0], 0);
70: }else if( argv[2] && argv[2][0] ){
71: /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
72: ** But because db->init.busy is set to 1, no VDBE code is generated
73: ** or executed. All the parser does is build the internal data
74: ** structures that describe the table, index, or view.
75: */
76: int rc;
77: sqlite3_stmt *pStmt;
78: TESTONLY(int rcp); /* Return code from sqlite3_prepare() */
79:
80: assert( db->init.busy );
81: db->init.iDb = iDb;
82: db->init.newTnum = sqlite3Atoi(argv[1]);
83: db->init.orphanTrigger = 0;
84: TESTONLY(rcp = ) sqlite3_prepare(db, argv[2], -1, &pStmt, 0);
85: rc = db->errCode;
86: assert( (rc&0xFF)==(rcp&0xFF) );
87: db->init.iDb = 0;
88: if( SQLITE_OK!=rc ){
89: if( db->init.orphanTrigger ){
90: assert( iDb==1 );
91: }else{
92: pData->rc = rc;
93: if( rc==SQLITE_NOMEM ){
94: db->mallocFailed = 1;
95: }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
96: corruptSchema(pData, argv[0], sqlite3_errmsg(db));
97: }
98: }
99: }
100: sqlite3_finalize(pStmt);
101: }else if( argv[0]==0 ){
102: corruptSchema(pData, 0, 0);
103: }else{
104: /* If the SQL column is blank it means this is an index that
105: ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
106: ** constraint for a CREATE TABLE. The index should have already
107: ** been created when we processed the CREATE TABLE. All we have
108: ** to do here is record the root page number for that index.
109: */
110: Index *pIndex;
111: pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
112: if( pIndex==0 ){
113: /* This can occur if there exists an index on a TEMP table which
114: ** has the same name as another index on a permanent index. Since
115: ** the permanent table is hidden by the TEMP table, we can also
116: ** safely ignore the index on the permanent table.
117: */
118: /* Do Nothing */;
119: }else if( sqlite3GetInt32(argv[1], &pIndex->tnum)==0 ){
120: corruptSchema(pData, argv[0], "invalid rootpage");
121: }
122: }
123: return 0;
124: }
125:
126: /*
127: ** Attempt to read the database schema and initialize internal
128: ** data structures for a single database file. The index of the
129: ** database file is given by iDb. iDb==0 is used for the main
130: ** database. iDb==1 should never be used. iDb>=2 is used for
131: ** auxiliary databases. Return one of the SQLITE_ error codes to
132: ** indicate success or failure.
133: */
134: static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
135: int rc;
136: int i;
137: int size;
138: Table *pTab;
139: Db *pDb;
140: char const *azArg[4];
141: int meta[5];
142: InitData initData;
143: char const *zMasterSchema;
144: char const *zMasterName;
145: int openedTransaction = 0;
146:
147: /*
148: ** The master database table has a structure like this
149: */
150: static const char master_schema[] =
151: "CREATE TABLE sqlite_master(\n"
152: " type text,\n"
153: " name text,\n"
154: " tbl_name text,\n"
155: " rootpage integer,\n"
156: " sql text\n"
157: ")"
158: ;
159: #ifndef SQLITE_OMIT_TEMPDB
160: static const char temp_master_schema[] =
161: "CREATE TEMP TABLE sqlite_temp_master(\n"
162: " type text,\n"
163: " name text,\n"
164: " tbl_name text,\n"
165: " rootpage integer,\n"
166: " sql text\n"
167: ")"
168: ;
169: #else
170: #define temp_master_schema 0
171: #endif
172:
173: assert( iDb>=0 && iDb<db->nDb );
174: assert( db->aDb[iDb].pSchema );
175: assert( sqlite3_mutex_held(db->mutex) );
176: assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
177:
178: /* zMasterSchema and zInitScript are set to point at the master schema
179: ** and initialisation script appropriate for the database being
180: ** initialised. zMasterName is the name of the master table.
181: */
182: if( !OMIT_TEMPDB && iDb==1 ){
183: zMasterSchema = temp_master_schema;
184: }else{
185: zMasterSchema = master_schema;
186: }
187: zMasterName = SCHEMA_TABLE(iDb);
188:
189: /* Construct the schema tables. */
190: azArg[0] = zMasterName;
191: azArg[1] = "1";
192: azArg[2] = zMasterSchema;
193: azArg[3] = 0;
194: initData.db = db;
195: initData.iDb = iDb;
196: initData.rc = SQLITE_OK;
197: initData.pzErrMsg = pzErrMsg;
198: sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
199: if( initData.rc ){
200: rc = initData.rc;
201: goto error_out;
202: }
203: pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
204: if( ALWAYS(pTab) ){
205: pTab->tabFlags |= TF_Readonly;
206: }
207:
208: /* Create a cursor to hold the database open
209: */
210: pDb = &db->aDb[iDb];
211: if( pDb->pBt==0 ){
212: if( !OMIT_TEMPDB && ALWAYS(iDb==1) ){
213: DbSetProperty(db, 1, DB_SchemaLoaded);
214: }
215: return SQLITE_OK;
216: }
217:
218: /* If there is not already a read-only (or read-write) transaction opened
219: ** on the b-tree database, open one now. If a transaction is opened, it
220: ** will be closed before this function returns. */
221: sqlite3BtreeEnter(pDb->pBt);
222: if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
223: rc = sqlite3BtreeBeginTrans(pDb->pBt, 0);
224: if( rc!=SQLITE_OK ){
225: sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));
226: goto initone_error_out;
227: }
228: openedTransaction = 1;
229: }
230:
231: /* Get the database meta information.
232: **
233: ** Meta values are as follows:
234: ** meta[0] Schema cookie. Changes with each schema change.
235: ** meta[1] File format of schema layer.
236: ** meta[2] Size of the page cache.
237: ** meta[3] Largest rootpage (auto/incr_vacuum mode)
238: ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
239: ** meta[5] User version
240: ** meta[6] Incremental vacuum mode
241: ** meta[7] unused
242: ** meta[8] unused
243: ** meta[9] unused
244: **
245: ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
246: ** the possible values of meta[4].
247: */
248: for(i=0; i<ArraySize(meta); i++){
249: sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
250: }
251: pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
252:
253: /* If opening a non-empty database, check the text encoding. For the
254: ** main database, set sqlite3.enc to the encoding of the main database.
255: ** For an attached db, it is an error if the encoding is not the same
256: ** as sqlite3.enc.
257: */
258: if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */
259: if( iDb==0 ){
260: u8 encoding;
261: /* If opening the main database, set ENC(db). */
262: encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
263: if( encoding==0 ) encoding = SQLITE_UTF8;
264: ENC(db) = encoding;
265: db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);
266: }else{
267: /* If opening an attached database, the encoding much match ENC(db) */
268: if( meta[BTREE_TEXT_ENCODING-1]!=ENC(db) ){
269: sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
270: " text encoding as main database");
271: rc = SQLITE_ERROR;
272: goto initone_error_out;
273: }
274: }
275: }else{
276: DbSetProperty(db, iDb, DB_Empty);
277: }
278: pDb->pSchema->enc = ENC(db);
279:
280: if( pDb->pSchema->cache_size==0 ){
281: #ifndef SQLITE_OMIT_DEPRECATED
282: size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]);
283: if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
284: pDb->pSchema->cache_size = size;
285: #else
286: pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE;
287: #endif
288: sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
289: }
290:
291: /*
292: ** file_format==1 Version 3.0.0.
293: ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
294: ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
295: ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
296: */
297: pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
298: if( pDb->pSchema->file_format==0 ){
299: pDb->pSchema->file_format = 1;
300: }
301: if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
302: sqlite3SetString(pzErrMsg, db, "unsupported file format");
303: rc = SQLITE_ERROR;
304: goto initone_error_out;
305: }
306:
307: /* Ticket #2804: When we open a database in the newer file format,
308: ** clear the legacy_file_format pragma flag so that a VACUUM will
309: ** not downgrade the database and thus invalidate any descending
310: ** indices that the user might have created.
311: */
312: if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
313: db->flags &= ~SQLITE_LegacyFileFmt;
314: }
315:
316: /* Read the schema information out of the schema tables
317: */
318: assert( db->init.busy );
319: {
320: char *zSql;
321: zSql = sqlite3MPrintf(db,
322: "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid",
323: db->aDb[iDb].zName, zMasterName);
324: #ifndef SQLITE_OMIT_AUTHORIZATION
325: {
326: int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
327: xAuth = db->xAuth;
328: db->xAuth = 0;
329: #endif
330: rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
331: #ifndef SQLITE_OMIT_AUTHORIZATION
332: db->xAuth = xAuth;
333: }
334: #endif
335: if( rc==SQLITE_OK ) rc = initData.rc;
336: sqlite3DbFree(db, zSql);
337: #ifndef SQLITE_OMIT_ANALYZE
338: if( rc==SQLITE_OK ){
339: sqlite3AnalysisLoad(db, iDb);
340: }
341: #endif
342: }
343: if( db->mallocFailed ){
344: rc = SQLITE_NOMEM;
345: sqlite3ResetInternalSchema(db, -1);
346: }
347: if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
348: /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
349: ** the schema loaded, even if errors occurred. In this situation the
350: ** current sqlite3_prepare() operation will fail, but the following one
351: ** will attempt to compile the supplied statement against whatever subset
352: ** of the schema was loaded before the error occurred. The primary
353: ** purpose of this is to allow access to the sqlite_master table
354: ** even when its contents have been corrupted.
355: */
356: DbSetProperty(db, iDb, DB_SchemaLoaded);
357: rc = SQLITE_OK;
358: }
359:
360: /* Jump here for an error that occurs after successfully allocating
361: ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
362: ** before that point, jump to error_out.
363: */
364: initone_error_out:
365: if( openedTransaction ){
366: sqlite3BtreeCommit(pDb->pBt);
367: }
368: sqlite3BtreeLeave(pDb->pBt);
369:
370: error_out:
371: if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
372: db->mallocFailed = 1;
373: }
374: return rc;
375: }
376:
377: /*
378: ** Initialize all database files - the main database file, the file
379: ** used to store temporary tables, and any additional database files
380: ** created using ATTACH statements. Return a success code. If an
381: ** error occurs, write an error message into *pzErrMsg.
382: **
383: ** After a database is initialized, the DB_SchemaLoaded bit is set
384: ** bit is set in the flags field of the Db structure. If the database
385: ** file was of zero-length, then the DB_Empty flag is also set.
386: */
387: int sqlite3Init(sqlite3 *db, char **pzErrMsg){
388: int i, rc;
389: int commit_internal = !(db->flags&SQLITE_InternChanges);
390:
391: assert( sqlite3_mutex_held(db->mutex) );
392: rc = SQLITE_OK;
393: db->init.busy = 1;
394: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
395: if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
396: rc = sqlite3InitOne(db, i, pzErrMsg);
397: if( rc ){
398: sqlite3ResetInternalSchema(db, i);
399: }
400: }
401:
402: /* Once all the other databases have been initialised, load the schema
403: ** for the TEMP database. This is loaded last, as the TEMP database
404: ** schema may contain references to objects in other databases.
405: */
406: #ifndef SQLITE_OMIT_TEMPDB
407: if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
408: && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
409: rc = sqlite3InitOne(db, 1, pzErrMsg);
410: if( rc ){
411: sqlite3ResetInternalSchema(db, 1);
412: }
413: }
414: #endif
415:
416: db->init.busy = 0;
417: if( rc==SQLITE_OK && commit_internal ){
418: sqlite3CommitInternalChanges(db);
419: }
420:
421: return rc;
422: }
423:
424: /*
425: ** This routine is a no-op if the database schema is already initialised.
426: ** Otherwise, the schema is loaded. An error code is returned.
427: */
428: int sqlite3ReadSchema(Parse *pParse){
429: int rc = SQLITE_OK;
430: sqlite3 *db = pParse->db;
431: assert( sqlite3_mutex_held(db->mutex) );
432: if( !db->init.busy ){
433: rc = sqlite3Init(db, &pParse->zErrMsg);
434: }
435: if( rc!=SQLITE_OK ){
436: pParse->rc = rc;
437: pParse->nErr++;
438: }
439: return rc;
440: }
441:
442:
443: /*
444: ** Check schema cookies in all databases. If any cookie is out
445: ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies
446: ** make no changes to pParse->rc.
447: */
448: static void schemaIsValid(Parse *pParse){
449: sqlite3 *db = pParse->db;
450: int iDb;
451: int rc;
452: int cookie;
453:
454: assert( pParse->checkSchema );
455: assert( sqlite3_mutex_held(db->mutex) );
456: for(iDb=0; iDb<db->nDb; iDb++){
457: int openedTransaction = 0; /* True if a transaction is opened */
458: Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
459: if( pBt==0 ) continue;
460:
461: /* If there is not already a read-only (or read-write) transaction opened
462: ** on the b-tree database, open one now. If a transaction is opened, it
463: ** will be closed immediately after reading the meta-value. */
464: if( !sqlite3BtreeIsInReadTrans(pBt) ){
465: rc = sqlite3BtreeBeginTrans(pBt, 0);
466: if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
467: db->mallocFailed = 1;
468: }
469: if( rc!=SQLITE_OK ) return;
470: openedTransaction = 1;
471: }
472:
473: /* Read the schema cookie from the database. If it does not match the
474: ** value stored as part of the in-memory schema representation,
475: ** set Parse.rc to SQLITE_SCHEMA. */
476: sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
477: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
478: if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
479: sqlite3ResetInternalSchema(db, iDb);
480: pParse->rc = SQLITE_SCHEMA;
481: }
482:
483: /* Close the transaction, if one was opened. */
484: if( openedTransaction ){
485: sqlite3BtreeCommit(pBt);
486: }
487: }
488: }
489:
490: /*
491: ** Convert a schema pointer into the iDb index that indicates
492: ** which database file in db->aDb[] the schema refers to.
493: **
494: ** If the same database is attached more than once, the first
495: ** attached database is returned.
496: */
497: int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
498: int i = -1000000;
499:
500: /* If pSchema is NULL, then return -1000000. This happens when code in
501: ** expr.c is trying to resolve a reference to a transient table (i.e. one
502: ** created by a sub-select). In this case the return value of this
503: ** function should never be used.
504: **
505: ** We return -1000000 instead of the more usual -1 simply because using
506: ** -1000000 as the incorrect index into db->aDb[] is much
507: ** more likely to cause a segfault than -1 (of course there are assert()
508: ** statements too, but it never hurts to play the odds).
509: */
510: assert( sqlite3_mutex_held(db->mutex) );
511: if( pSchema ){
512: for(i=0; ALWAYS(i<db->nDb); i++){
513: if( db->aDb[i].pSchema==pSchema ){
514: break;
515: }
516: }
517: assert( i>=0 && i<db->nDb );
518: }
519: return i;
520: }
521:
522: /*
523: ** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
524: */
525: static int sqlite3Prepare(
526: sqlite3 *db, /* Database handle. */
527: const char *zSql, /* UTF-8 encoded SQL statement. */
528: int nBytes, /* Length of zSql in bytes. */
529: int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
530: Vdbe *pReprepare, /* VM being reprepared */
531: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
532: const char **pzTail /* OUT: End of parsed string */
533: ){
534: Parse *pParse; /* Parsing context */
535: char *zErrMsg = 0; /* Error message */
536: int rc = SQLITE_OK; /* Result code */
537: int i; /* Loop counter */
538:
539: /* Allocate the parsing context */
540: pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
541: if( pParse==0 ){
542: rc = SQLITE_NOMEM;
543: goto end_prepare;
544: }
545: pParse->pReprepare = pReprepare;
546: assert( ppStmt && *ppStmt==0 );
547: assert( !db->mallocFailed );
548: assert( sqlite3_mutex_held(db->mutex) );
549:
550: /* Check to verify that it is possible to get a read lock on all
551: ** database schemas. The inability to get a read lock indicates that
552: ** some other database connection is holding a write-lock, which in
553: ** turn means that the other connection has made uncommitted changes
554: ** to the schema.
555: **
556: ** Were we to proceed and prepare the statement against the uncommitted
557: ** schema changes and if those schema changes are subsequently rolled
558: ** back and different changes are made in their place, then when this
559: ** prepared statement goes to run the schema cookie would fail to detect
560: ** the schema change. Disaster would follow.
561: **
562: ** This thread is currently holding mutexes on all Btrees (because
563: ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
564: ** is not possible for another thread to start a new schema change
565: ** while this routine is running. Hence, we do not need to hold
566: ** locks on the schema, we just need to make sure nobody else is
567: ** holding them.
568: **
569: ** Note that setting READ_UNCOMMITTED overrides most lock detection,
570: ** but it does *not* override schema lock detection, so this all still
571: ** works even if READ_UNCOMMITTED is set.
572: */
573: for(i=0; i<db->nDb; i++) {
574: Btree *pBt = db->aDb[i].pBt;
575: if( pBt ){
576: assert( sqlite3BtreeHoldsMutex(pBt) );
577: rc = sqlite3BtreeSchemaLocked(pBt);
578: if( rc ){
579: const char *zDb = db->aDb[i].zName;
580: sqlite3Error(db, rc, "database schema is locked: %s", zDb);
581: testcase( db->flags & SQLITE_ReadUncommitted );
582: goto end_prepare;
583: }
584: }
585: }
586:
587: sqlite3VtabUnlockList(db);
588:
589: pParse->db = db;
590: pParse->nQueryLoop = (double)1;
591: if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
592: char *zSqlCopy;
593: int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
594: testcase( nBytes==mxLen );
595: testcase( nBytes==mxLen+1 );
596: if( nBytes>mxLen ){
597: sqlite3Error(db, SQLITE_TOOBIG, "statement too long");
598: rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
599: goto end_prepare;
600: }
601: zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
602: if( zSqlCopy ){
603: sqlite3RunParser(pParse, zSqlCopy, &zErrMsg);
604: sqlite3DbFree(db, zSqlCopy);
605: pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
606: }else{
607: pParse->zTail = &zSql[nBytes];
608: }
609: }else{
610: sqlite3RunParser(pParse, zSql, &zErrMsg);
611: }
612: assert( 1==(int)pParse->nQueryLoop );
613:
614: if( db->mallocFailed ){
615: pParse->rc = SQLITE_NOMEM;
616: }
617: if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
618: if( pParse->checkSchema ){
619: schemaIsValid(pParse);
620: }
621: if( db->mallocFailed ){
622: pParse->rc = SQLITE_NOMEM;
623: }
624: if( pzTail ){
625: *pzTail = pParse->zTail;
626: }
627: rc = pParse->rc;
628:
629: #ifndef SQLITE_OMIT_EXPLAIN
630: if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
631: static const char * const azColName[] = {
632: "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
633: "selectid", "order", "from", "detail"
634: };
635: int iFirst, mx;
636: if( pParse->explain==2 ){
637: sqlite3VdbeSetNumCols(pParse->pVdbe, 4);
638: iFirst = 8;
639: mx = 12;
640: }else{
641: sqlite3VdbeSetNumCols(pParse->pVdbe, 8);
642: iFirst = 0;
643: mx = 8;
644: }
645: for(i=iFirst; i<mx; i++){
646: sqlite3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME,
647: azColName[i], SQLITE_STATIC);
648: }
649: }
650: #endif
651:
652: assert( db->init.busy==0 || saveSqlFlag==0 );
653: if( db->init.busy==0 ){
654: Vdbe *pVdbe = pParse->pVdbe;
655: sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag);
656: }
657: if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
658: sqlite3VdbeFinalize(pParse->pVdbe);
659: assert(!(*ppStmt));
660: }else{
661: *ppStmt = (sqlite3_stmt*)pParse->pVdbe;
662: }
663:
664: if( zErrMsg ){
665: sqlite3Error(db, rc, "%s", zErrMsg);
666: sqlite3DbFree(db, zErrMsg);
667: }else{
668: sqlite3Error(db, rc, 0);
669: }
670:
671: /* Delete any TriggerPrg structures allocated while parsing this statement. */
672: while( pParse->pTriggerPrg ){
673: TriggerPrg *pT = pParse->pTriggerPrg;
674: pParse->pTriggerPrg = pT->pNext;
675: sqlite3DbFree(db, pT);
676: }
677:
678: end_prepare:
679:
680: sqlite3StackFree(db, pParse);
681: rc = sqlite3ApiExit(db, rc);
682: assert( (rc&db->errMask)==rc );
683: return rc;
684: }
685: static int sqlite3LockAndPrepare(
686: sqlite3 *db, /* Database handle. */
687: const char *zSql, /* UTF-8 encoded SQL statement. */
688: int nBytes, /* Length of zSql in bytes. */
689: int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
690: Vdbe *pOld, /* VM being reprepared */
691: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
692: const char **pzTail /* OUT: End of parsed string */
693: ){
694: int rc;
695: assert( ppStmt!=0 );
696: *ppStmt = 0;
697: if( !sqlite3SafetyCheckOk(db) ){
698: return SQLITE_MISUSE_BKPT;
699: }
700: sqlite3_mutex_enter(db->mutex);
701: sqlite3BtreeEnterAll(db);
702: rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
703: if( rc==SQLITE_SCHEMA ){
704: sqlite3_finalize(*ppStmt);
705: rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, pOld, ppStmt, pzTail);
706: }
707: sqlite3BtreeLeaveAll(db);
708: sqlite3_mutex_leave(db->mutex);
709: return rc;
710: }
711:
712: /*
713: ** Rerun the compilation of a statement after a schema change.
714: **
715: ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
716: ** if the statement cannot be recompiled because another connection has
717: ** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error
718: ** occurs, return SQLITE_SCHEMA.
719: */
720: int sqlite3Reprepare(Vdbe *p){
721: int rc;
722: sqlite3_stmt *pNew;
723: const char *zSql;
724: sqlite3 *db;
725:
726: assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
727: zSql = sqlite3_sql((sqlite3_stmt *)p);
728: assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
729: db = sqlite3VdbeDb(p);
730: assert( sqlite3_mutex_held(db->mutex) );
731: rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
732: if( rc ){
733: if( rc==SQLITE_NOMEM ){
734: db->mallocFailed = 1;
735: }
736: assert( pNew==0 );
737: return rc;
738: }else{
739: assert( pNew!=0 );
740: }
741: sqlite3VdbeSwap((Vdbe*)pNew, p);
742: sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
743: sqlite3VdbeResetStepResult((Vdbe*)pNew);
744: sqlite3VdbeFinalize((Vdbe*)pNew);
745: return SQLITE_OK;
746: }
747:
748:
749: /*
750: ** Two versions of the official API. Legacy and new use. In the legacy
751: ** version, the original SQL text is not saved in the prepared statement
752: ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
753: ** sqlite3_step(). In the new version, the original SQL text is retained
754: ** and the statement is automatically recompiled if an schema change
755: ** occurs.
756: */
757: int sqlite3_prepare(
758: sqlite3 *db, /* Database handle. */
759: const char *zSql, /* UTF-8 encoded SQL statement. */
760: int nBytes, /* Length of zSql in bytes. */
761: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
762: const char **pzTail /* OUT: End of parsed string */
763: ){
764: int rc;
765: rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail);
766: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
767: return rc;
768: }
769: int sqlite3_prepare_v2(
770: sqlite3 *db, /* Database handle. */
771: const char *zSql, /* UTF-8 encoded SQL statement. */
772: int nBytes, /* Length of zSql in bytes. */
773: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
774: const char **pzTail /* OUT: End of parsed string */
775: ){
776: int rc;
777: rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,0,ppStmt,pzTail);
778: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
779: return rc;
780: }
781:
782:
783: #ifndef SQLITE_OMIT_UTF16
784: /*
785: ** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
786: */
787: static int sqlite3Prepare16(
788: sqlite3 *db, /* Database handle. */
789: const void *zSql, /* UTF-16 encoded SQL statement. */
790: int nBytes, /* Length of zSql in bytes. */
791: int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
792: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
793: const void **pzTail /* OUT: End of parsed string */
794: ){
795: /* This function currently works by first transforming the UTF-16
796: ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
797: ** tricky bit is figuring out the pointer to return in *pzTail.
798: */
799: char *zSql8;
800: const char *zTail8 = 0;
801: int rc = SQLITE_OK;
802:
803: assert( ppStmt );
804: *ppStmt = 0;
805: if( !sqlite3SafetyCheckOk(db) ){
806: return SQLITE_MISUSE_BKPT;
807: }
808: sqlite3_mutex_enter(db->mutex);
809: zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE);
810: if( zSql8 ){
811: rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, 0, ppStmt, &zTail8);
812: }
813:
814: if( zTail8 && pzTail ){
815: /* If sqlite3_prepare returns a tail pointer, we calculate the
816: ** equivalent pointer into the UTF-16 string by counting the unicode
817: ** characters between zSql8 and zTail8, and then returning a pointer
818: ** the same number of characters into the UTF-16 string.
819: */
820: int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
821: *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
822: }
823: sqlite3DbFree(db, zSql8);
824: rc = sqlite3ApiExit(db, rc);
825: sqlite3_mutex_leave(db->mutex);
826: return rc;
827: }
828:
829: /*
830: ** Two versions of the official API. Legacy and new use. In the legacy
831: ** version, the original SQL text is not saved in the prepared statement
832: ** and so if a schema change occurs, SQLITE_SCHEMA is returned by
833: ** sqlite3_step(). In the new version, the original SQL text is retained
834: ** and the statement is automatically recompiled if an schema change
835: ** occurs.
836: */
837: int sqlite3_prepare16(
838: sqlite3 *db, /* Database handle. */
839: const void *zSql, /* UTF-16 encoded SQL statement. */
840: int nBytes, /* Length of zSql in bytes. */
841: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
842: const void **pzTail /* OUT: End of parsed string */
843: ){
844: int rc;
845: rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
846: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
847: return rc;
848: }
849: int sqlite3_prepare16_v2(
850: sqlite3 *db, /* Database handle. */
851: const void *zSql, /* UTF-16 encoded SQL statement. */
852: int nBytes, /* Length of zSql in bytes. */
853: sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
854: const void **pzTail /* OUT: End of parsed string */
855: ){
856: int rc;
857: rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
858: assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
859: return rc;
860: }
861:
862: #endif /* SQLITE_OMIT_UTF16 */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to prepare.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / src