blob: 33e3fda89a9d7e99d1a0001191a4686363220d0c [file] [log] [blame]
danielk1977fa256a32005-05-25 04:11:56 +00001/*
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**
danielk19770d78bae2008-01-03 07:09:48 +000016** $Id: prepare.c,v 1.70 2008/01/03 07:09:48 danielk1977 Exp $
danielk1977fa256a32005-05-25 04:11:56 +000017*/
18#include "sqliteInt.h"
danielk1977fa256a32005-05-25 04:11:56 +000019#include <ctype.h>
20
21/*
22** Fill the InitData structure with an error message that indicates
23** that the database is corrupt.
24*/
25static void corruptSchema(InitData *pData, const char *zExtra){
drh17435752007-08-16 04:30:38 +000026 if( !pData->db->mallocFailed ){
danielk1977fa256a32005-05-25 04:11:56 +000027 sqlite3SetString(pData->pzErrMsg, "malformed database schema",
28 zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0);
29 }
drh15ca1df2006-07-26 13:43:30 +000030 pData->rc = SQLITE_CORRUPT;
danielk1977fa256a32005-05-25 04:11:56 +000031}
32
33/*
34** This is the callback routine for the code that initializes the
35** database. See sqlite3Init() below for additional information.
36** This routine is also called from the OP_ParseSchema opcode of the VDBE.
37**
38** Each callback contains the following information:
39**
40** argv[0] = name of thing being created
danielk197778efaba2006-06-12 06:09:17 +000041** argv[1] = root page number for table or index. 0 for trigger or view.
danielk1977fa256a32005-05-25 04:11:56 +000042** argv[2] = SQL text for the CREATE statement.
danielk1977fa256a32005-05-25 04:11:56 +000043**
44*/
45int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){
46 InitData *pData = (InitData*)pInit;
47 sqlite3 *db = pData->db;
drhece3c722006-09-23 20:36:01 +000048 int iDb = pData->iDb;
danielk1977fa256a32005-05-25 04:11:56 +000049
drhb1ab8ea2007-08-29 00:33:07 +000050 assert( sqlite3_mutex_held(db->mutex) );
drh15ca1df2006-07-26 13:43:30 +000051 pData->rc = SQLITE_OK;
drhece3c722006-09-23 20:36:01 +000052 DbClearProperty(db, iDb, DB_Empty);
drh17435752007-08-16 04:30:38 +000053 if( db->mallocFailed ){
drhfe5a8162006-08-12 13:28:23 +000054 corruptSchema(pData, 0);
danielk1977da184232006-01-05 11:34:32 +000055 return SQLITE_NOMEM;
56 }
57
drhece3c722006-09-23 20:36:01 +000058 assert( argc==3 );
danielk1977fa256a32005-05-25 04:11:56 +000059 if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
drhece3c722006-09-23 20:36:01 +000060 if( argv[1]==0 ){
danielk1977fa256a32005-05-25 04:11:56 +000061 corruptSchema(pData, 0);
62 return 1;
63 }
danielk1977fa256a32005-05-25 04:11:56 +000064 assert( iDb>=0 && iDb<db->nDb );
65 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 db->init.iDb = iDb;
75 db->init.newTnum = atoi(argv[1]);
76 rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
77 db->init.iDb = 0;
drh43617e92006-03-06 20:55:46 +000078 assert( rc!=SQLITE_OK || zErr==0 );
danielk1977fa256a32005-05-25 04:11:56 +000079 if( SQLITE_OK!=rc ){
drh15ca1df2006-07-26 13:43:30 +000080 pData->rc = rc;
danielk1977261919c2005-12-06 12:52:59 +000081 if( rc==SQLITE_NOMEM ){
drh17435752007-08-16 04:30:38 +000082 db->mallocFailed = 1;
drh15ca1df2006-07-26 13:43:30 +000083 }else if( rc!=SQLITE_INTERRUPT ){
danielk19779e128002006-01-18 16:51:35 +000084 corruptSchema(pData, zErr);
danielk1977261919c2005-12-06 12:52:59 +000085 }
danielk1977fa256a32005-05-25 04:11:56 +000086 sqlite3_free(zErr);
drh15ca1df2006-07-26 13:43:30 +000087 return 1;
danielk1977fa256a32005-05-25 04:11:56 +000088 }
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 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
98 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 pIndex->tnum = atoi(argv[1]);
107 }
108 }
109 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*/
120static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
121 int rc;
122 BtCursor *curMain;
123 int size;
124 Table *pTab;
drhfdd6e852005-12-16 01:06:16 +0000125 Db *pDb;
drhece3c722006-09-23 20:36:01 +0000126 char const *azArg[4];
danielk1977fa256a32005-05-25 04:11:56 +0000127 int meta[10];
128 InitData initData;
129 char const *zMasterSchema;
130 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 );
danielk197714db2662006-01-09 16:12:04 +0000159 assert( db->aDb[iDb].pSchema );
drhb1ab8ea2007-08-29 00:33:07 +0000160 assert( sqlite3_mutex_held(db->mutex) );
danielk19774eab8b72007-12-27 15:12:16 +0000161 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
danielk1977da184232006-01-05 11:34:32 +0000162
danielk1977fa256a32005-05-25 04:11:56 +0000163 /* zMasterSchema and zInitScript are set to point at the master schema
164 ** and initialisation script appropriate for the database being
165 ** initialised. zMasterName is the name of the master table.
166 */
167 if( !OMIT_TEMPDB && iDb==1 ){
168 zMasterSchema = temp_master_schema;
169 }else{
170 zMasterSchema = master_schema;
171 }
172 zMasterName = SCHEMA_TABLE(iDb);
173
174 /* Construct the schema tables. */
175 sqlite3SafetyOff(db);
176 azArg[0] = zMasterName;
177 azArg[1] = "1";
178 azArg[2] = zMasterSchema;
drhece3c722006-09-23 20:36:01 +0000179 azArg[3] = 0;
danielk1977fa256a32005-05-25 04:11:56 +0000180 initData.db = db;
drhece3c722006-09-23 20:36:01 +0000181 initData.iDb = iDb;
danielk1977fa256a32005-05-25 04:11:56 +0000182 initData.pzErrMsg = pzErrMsg;
drhece3c722006-09-23 20:36:01 +0000183 rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
drh15ca1df2006-07-26 13:43:30 +0000184 if( rc ){
danielk1977fa256a32005-05-25 04:11:56 +0000185 sqlite3SafetyOn(db);
danielk1977a1644fd2007-08-29 12:31:25 +0000186 rc = initData.rc;
187 goto error_out;
danielk1977fa256a32005-05-25 04:11:56 +0000188 }
189 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
190 if( pTab ){
191 pTab->readOnly = 1;
192 }
193 sqlite3SafetyOn(db);
194
195 /* Create a cursor to hold the database open
196 */
drhfdd6e852005-12-16 01:06:16 +0000197 pDb = &db->aDb[iDb];
198 if( pDb->pBt==0 ){
danielk1977b82e7ed2006-01-11 14:09:31 +0000199 if( !OMIT_TEMPDB && iDb==1 ){
200 DbSetProperty(db, 1, DB_SchemaLoaded);
201 }
danielk1977fa256a32005-05-25 04:11:56 +0000202 return SQLITE_OK;
203 }
drhb1ab8ea2007-08-29 00:33:07 +0000204 sqlite3BtreeEnter(pDb->pBt);
drhfdd6e852005-12-16 01:06:16 +0000205 rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain);
danielk1977fa256a32005-05-25 04:11:56 +0000206 if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){
207 sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
drhb1ab8ea2007-08-29 00:33:07 +0000208 sqlite3BtreeLeave(pDb->pBt);
danielk1977a1644fd2007-08-29 12:31:25 +0000209 goto error_out;
danielk1977fa256a32005-05-25 04:11:56 +0000210 }
211
212 /* Get the database meta information.
213 **
214 ** Meta values are as follows:
215 ** meta[0] Schema cookie. Changes with each schema change.
216 ** meta[1] File format of schema layer.
217 ** meta[2] Size of the page cache.
218 ** meta[3] Use freelist if 0. Autovacuum if greater than zero.
drh8159a352006-05-23 23:22:29 +0000219 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
danielk1977fa256a32005-05-25 04:11:56 +0000220 ** meta[5] The user cookie. Used by the application.
danielk1977418899a2007-06-24 10:14:00 +0000221 ** meta[6] Incremental-vacuum flag.
danielk1977fa256a32005-05-25 04:11:56 +0000222 ** meta[7]
223 ** meta[8]
224 ** meta[9]
225 **
drhf248e212006-01-25 22:50:38 +0000226 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
danielk1977fa256a32005-05-25 04:11:56 +0000227 ** the possible values of meta[4].
228 */
229 if( rc==SQLITE_OK ){
230 int i;
231 for(i=0; rc==SQLITE_OK && i<sizeof(meta)/sizeof(meta[0]); i++){
drhfdd6e852005-12-16 01:06:16 +0000232 rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
danielk1977fa256a32005-05-25 04:11:56 +0000233 }
234 if( rc ){
235 sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
236 sqlite3BtreeCloseCursor(curMain);
drhb1ab8ea2007-08-29 00:33:07 +0000237 sqlite3BtreeLeave(pDb->pBt);
danielk1977a1644fd2007-08-29 12:31:25 +0000238 goto error_out;
danielk1977fa256a32005-05-25 04:11:56 +0000239 }
240 }else{
241 memset(meta, 0, sizeof(meta));
242 }
danielk1977da184232006-01-05 11:34:32 +0000243 pDb->pSchema->schema_cookie = meta[0];
danielk1977fa256a32005-05-25 04:11:56 +0000244
245 /* If opening a non-empty database, check the text encoding. For the
246 ** main database, set sqlite3.enc to the encoding of the main database.
247 ** For an attached db, it is an error if the encoding is not the same
248 ** as sqlite3.enc.
249 */
250 if( meta[4] ){ /* text encoding */
251 if( iDb==0 ){
danielk197714db2662006-01-09 16:12:04 +0000252 /* If opening the main database, set ENC(db). */
253 ENC(db) = (u8)meta[4];
danielk1977b3bf5562006-01-10 17:58:23 +0000254 db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
danielk1977fa256a32005-05-25 04:11:56 +0000255 }else{
danielk197714db2662006-01-09 16:12:04 +0000256 /* If opening an attached database, the encoding much match ENC(db) */
257 if( meta[4]!=ENC(db) ){
danielk1977fa256a32005-05-25 04:11:56 +0000258 sqlite3BtreeCloseCursor(curMain);
259 sqlite3SetString(pzErrMsg, "attached databases must use the same"
260 " text encoding as main database", (char*)0);
drhb1ab8ea2007-08-29 00:33:07 +0000261 sqlite3BtreeLeave(pDb->pBt);
danielk1977fa256a32005-05-25 04:11:56 +0000262 return SQLITE_ERROR;
263 }
264 }
danielk1977b82e7ed2006-01-11 14:09:31 +0000265 }else{
266 DbSetProperty(db, iDb, DB_Empty);
danielk1977fa256a32005-05-25 04:11:56 +0000267 }
danielk197714db2662006-01-09 16:12:04 +0000268 pDb->pSchema->enc = ENC(db);
danielk1977fa256a32005-05-25 04:11:56 +0000269
270 size = meta[2];
drhc797d4d2007-05-08 01:08:49 +0000271 if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
danielk197714db2662006-01-09 16:12:04 +0000272 pDb->pSchema->cache_size = size;
273 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
danielk1977fa256a32005-05-25 04:11:56 +0000274
275 /*
276 ** file_format==1 Version 3.0.0.
drhfdd6e852005-12-16 01:06:16 +0000277 ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
278 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
drhd946db02005-12-29 19:23:06 +0000279 ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
danielk1977fa256a32005-05-25 04:11:56 +0000280 */
danielk1977da184232006-01-05 11:34:32 +0000281 pDb->pSchema->file_format = meta[1];
282 if( pDb->pSchema->file_format==0 ){
283 pDb->pSchema->file_format = 1;
drhfdd6e852005-12-16 01:06:16 +0000284 }
danielk1977da184232006-01-05 11:34:32 +0000285 if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
danielk1977fa256a32005-05-25 04:11:56 +0000286 sqlite3BtreeCloseCursor(curMain);
287 sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);
drhb1ab8ea2007-08-29 00:33:07 +0000288 sqlite3BtreeLeave(pDb->pBt);
danielk1977fa256a32005-05-25 04:11:56 +0000289 return SQLITE_ERROR;
290 }
291
drh4aa2bfe2007-11-28 13:43:16 +0000292 /* Ticket #2804: When we open a database in the newer file format,
293 ** clear the legacy_file_format pragma flag so that a VACUUM will
294 ** not downgrade the database and thus invalidate any descending
295 ** indices that the user might have created.
296 */
297 if( iDb==0 && meta[1]>=4 ){
298 db->flags &= ~SQLITE_LegacyFileFmt;
299 }
danielk1977fa256a32005-05-25 04:11:56 +0000300
301 /* Read the schema information out of the schema tables
302 */
303 assert( db->init.busy );
304 if( rc==SQLITE_EMPTY ){
305 /* For an empty database, there is nothing to read */
306 rc = SQLITE_OK;
307 }else{
308 char *zSql;
danielk19771e536952007-08-16 10:09:01 +0000309 zSql = sqlite3MPrintf(db,
drhece3c722006-09-23 20:36:01 +0000310 "SELECT name, rootpage, sql FROM '%q'.%s",
311 db->aDb[iDb].zName, zMasterName);
danielk1977fa256a32005-05-25 04:11:56 +0000312 sqlite3SafetyOff(db);
drha6d0ffc2007-10-12 20:42:28 +0000313#ifndef SQLITE_OMIT_AUTHORIZATION
314 {
315 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
316 xAuth = db->xAuth;
317 db->xAuth = 0;
318#endif
319 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
320#ifndef SQLITE_OMIT_AUTHORIZATION
321 db->xAuth = xAuth;
322 }
323#endif
drh15ca1df2006-07-26 13:43:30 +0000324 if( rc==SQLITE_ABORT ) rc = initData.rc;
danielk1977fa256a32005-05-25 04:11:56 +0000325 sqlite3SafetyOn(db);
drh17435752007-08-16 04:30:38 +0000326 sqlite3_free(zSql);
drh497e4462005-07-23 03:18:40 +0000327#ifndef SQLITE_OMIT_ANALYZE
328 if( rc==SQLITE_OK ){
329 sqlite3AnalysisLoad(db, iDb);
330 }
331#endif
danielk1977fa256a32005-05-25 04:11:56 +0000332 sqlite3BtreeCloseCursor(curMain);
333 }
drh17435752007-08-16 04:30:38 +0000334 if( db->mallocFailed ){
danielk19779e128002006-01-18 16:51:35 +0000335 /* sqlite3SetString(pzErrMsg, "out of memory", (char*)0); */
danielk1977fa256a32005-05-25 04:11:56 +0000336 rc = SQLITE_NOMEM;
337 sqlite3ResetInternalSchema(db, 0);
338 }
danielk197734c68fb2007-03-14 15:37:04 +0000339 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
340 /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
341 ** the schema loaded, even if errors occured. In this situation the
342 ** current sqlite3_prepare() operation will fail, but the following one
343 ** will attempt to compile the supplied statement against whatever subset
344 ** of the schema was loaded before the error occured. The primary
345 ** purpose of this is to allow access to the sqlite_master table
drh85b623f2007-12-13 21:54:09 +0000346 ** even when its contents have been corrupted.
danielk197734c68fb2007-03-14 15:37:04 +0000347 */
danielk1977fa256a32005-05-25 04:11:56 +0000348 DbSetProperty(db, iDb, DB_SchemaLoaded);
danielk197734c68fb2007-03-14 15:37:04 +0000349 rc = SQLITE_OK;
danielk1977fa256a32005-05-25 04:11:56 +0000350 }
drhb1ab8ea2007-08-29 00:33:07 +0000351 sqlite3BtreeLeave(pDb->pBt);
danielk1977a1644fd2007-08-29 12:31:25 +0000352
353error_out:
danielk1977ae72d982007-10-03 08:46:44 +0000354 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
danielk1977a1644fd2007-08-29 12:31:25 +0000355 db->mallocFailed = 1;
356 }
danielk1977fa256a32005-05-25 04:11:56 +0000357 return rc;
358}
359
360/*
361** Initialize all database files - the main database file, the file
362** used to store temporary tables, and any additional database files
363** created using ATTACH statements. Return a success code. If an
364** error occurs, write an error message into *pzErrMsg.
365**
danielk1977e7259292006-01-13 06:33:23 +0000366** After a database is initialized, the DB_SchemaLoaded bit is set
367** bit is set in the flags field of the Db structure. If the database
368** file was of zero-length, then the DB_Empty flag is also set.
danielk1977fa256a32005-05-25 04:11:56 +0000369*/
370int sqlite3Init(sqlite3 *db, char **pzErrMsg){
371 int i, rc;
danielk19775814c1a2007-08-13 14:41:19 +0000372 int commit_internal = !(db->flags&SQLITE_InternChanges);
danielk1977fa256a32005-05-25 04:11:56 +0000373
drhb1ab8ea2007-08-29 00:33:07 +0000374 assert( sqlite3_mutex_held(db->mutex) );
danielk1977fa256a32005-05-25 04:11:56 +0000375 if( db->init.busy ) return SQLITE_OK;
danielk1977fa256a32005-05-25 04:11:56 +0000376 rc = SQLITE_OK;
377 db->init.busy = 1;
378 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
379 if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
380 rc = sqlite3InitOne(db, i, pzErrMsg);
381 if( rc ){
382 sqlite3ResetInternalSchema(db, i);
383 }
384 }
385
386 /* Once all the other databases have been initialised, load the schema
387 ** for the TEMP database. This is loaded last, as the TEMP database
388 ** schema may contain references to objects in other databases.
389 */
390#ifndef SQLITE_OMIT_TEMPDB
391 if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
392 rc = sqlite3InitOne(db, 1, pzErrMsg);
393 if( rc ){
394 sqlite3ResetInternalSchema(db, 1);
395 }
396 }
397#endif
398
399 db->init.busy = 0;
danielk19775814c1a2007-08-13 14:41:19 +0000400 if( rc==SQLITE_OK && commit_internal ){
danielk1977fa256a32005-05-25 04:11:56 +0000401 sqlite3CommitInternalChanges(db);
402 }
403
danielk1977b82e7ed2006-01-11 14:09:31 +0000404 return rc;
danielk1977fa256a32005-05-25 04:11:56 +0000405}
406
407/*
408** This routine is a no-op if the database schema is already initialised.
409** Otherwise, the schema is loaded. An error code is returned.
410*/
411int sqlite3ReadSchema(Parse *pParse){
412 int rc = SQLITE_OK;
413 sqlite3 *db = pParse->db;
drhb1ab8ea2007-08-29 00:33:07 +0000414 assert( sqlite3_mutex_held(db->mutex) );
danielk1977fa256a32005-05-25 04:11:56 +0000415 if( !db->init.busy ){
danielk1977b82e7ed2006-01-11 14:09:31 +0000416 rc = sqlite3Init(db, &pParse->zErrMsg);
danielk1977fa256a32005-05-25 04:11:56 +0000417 }
danielk1977fa256a32005-05-25 04:11:56 +0000418 if( rc!=SQLITE_OK ){
419 pParse->rc = rc;
420 pParse->nErr++;
421 }
422 return rc;
423}
424
425
426/*
427** Check schema cookies in all databases. If any cookie is out
428** of date, return 0. If all schema cookies are current, return 1.
429*/
430static int schemaIsValid(sqlite3 *db){
431 int iDb;
432 int rc;
433 BtCursor *curTemp;
434 int cookie;
435 int allOk = 1;
436
drhb1ab8ea2007-08-29 00:33:07 +0000437 assert( sqlite3_mutex_held(db->mutex) );
danielk1977fa256a32005-05-25 04:11:56 +0000438 for(iDb=0; allOk && iDb<db->nDb; iDb++){
439 Btree *pBt;
440 pBt = db->aDb[iDb].pBt;
441 if( pBt==0 ) continue;
442 rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, 0, &curTemp);
443 if( rc==SQLITE_OK ){
444 rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie);
danielk1977da184232006-01-05 11:34:32 +0000445 if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){
danielk1977fa256a32005-05-25 04:11:56 +0000446 allOk = 0;
447 }
448 sqlite3BtreeCloseCursor(curTemp);
449 }
danielk1977ae72d982007-10-03 08:46:44 +0000450 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
danielk1977a1644fd2007-08-29 12:31:25 +0000451 db->mallocFailed = 1;
452 }
danielk1977fa256a32005-05-25 04:11:56 +0000453 }
454 return allOk;
455}
456
457/*
drhf248e212006-01-25 22:50:38 +0000458** Convert a schema pointer into the iDb index that indicates
459** which database file in db->aDb[] the schema refers to.
460**
461** If the same database is attached more than once, the first
462** attached database is returned.
463*/
danielk1977e501b892006-01-09 06:29:47 +0000464int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
drh198bf392006-01-06 21:52:49 +0000465 int i = -1000000;
466
467 /* If pSchema is NULL, then return -1000000. This happens when code in
468 ** expr.c is trying to resolve a reference to a transient table (i.e. one
469 ** created by a sub-select). In this case the return value of this
470 ** function should never be used.
471 **
472 ** We return -1000000 instead of the more usual -1 simply because using
473 ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much
474 ** more likely to cause a segfault than -1 (of course there are assert()
475 ** statements too, but it never hurts to play the odds).
476 */
drhb1ab8ea2007-08-29 00:33:07 +0000477 assert( sqlite3_mutex_held(db->mutex) );
drh198bf392006-01-06 21:52:49 +0000478 if( pSchema ){
479 for(i=0; i<db->nDb; i++){
480 if( db->aDb[i].pSchema==pSchema ){
481 break;
482 }
483 }
484 assert( i>=0 &&i>=0 && i<db->nDb );
485 }
486 return i;
487}
488
489/*
danielk1977fa256a32005-05-25 04:11:56 +0000490** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
491*/
drhb900aaf2006-11-09 00:24:53 +0000492int sqlite3Prepare(
danielk1977fa256a32005-05-25 04:11:56 +0000493 sqlite3 *db, /* Database handle. */
494 const char *zSql, /* UTF-8 encoded SQL statement. */
495 int nBytes, /* Length of zSql in bytes. */
drhb900aaf2006-11-09 00:24:53 +0000496 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
danielk1977fa256a32005-05-25 04:11:56 +0000497 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
drhb900aaf2006-11-09 00:24:53 +0000498 const char **pzTail /* OUT: End of parsed string */
danielk1977fa256a32005-05-25 04:11:56 +0000499){
500 Parse sParse;
501 char *zErrMsg = 0;
502 int rc = SQLITE_OK;
danielk1977c87d34d2006-01-06 13:00:28 +0000503 int i;
danielk1977fa256a32005-05-25 04:11:56 +0000504
danielk1977fa256a32005-05-25 04:11:56 +0000505 assert( ppStmt );
506 *ppStmt = 0;
507 if( sqlite3SafetyOn(db) ){
508 return SQLITE_MISUSE;
509 }
drh86f8c192007-08-22 00:39:19 +0000510 assert( !db->mallocFailed );
drhb21c8cd2007-08-21 19:33:56 +0000511 assert( sqlite3_mutex_held(db->mutex) );
danielk1977fa256a32005-05-25 04:11:56 +0000512
danielk1977c87d34d2006-01-06 13:00:28 +0000513 /* If any attached database schemas are locked, do not proceed with
514 ** compilation. Instead return SQLITE_LOCKED immediately.
515 */
516 for(i=0; i<db->nDb; i++) {
517 Btree *pBt = db->aDb[i].pBt;
drhb1ab8ea2007-08-29 00:33:07 +0000518 if( pBt ){
519 int rc;
520 rc = sqlite3BtreeSchemaLocked(pBt);
521 if( rc ){
522 const char *zDb = db->aDb[i].zName;
523 sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);
524 sqlite3SafetyOff(db);
525 return SQLITE_LOCKED;
526 }
danielk1977c87d34d2006-01-06 13:00:28 +0000527 }
528 }
529
danielk1977fa256a32005-05-25 04:11:56 +0000530 memset(&sParse, 0, sizeof(sParse));
531 sParse.db = db;
drh9051a422006-01-30 22:35:43 +0000532 if( nBytes>=0 && zSql[nBytes]!=0 ){
drhe5c941b2007-05-08 13:58:26 +0000533 char *zSqlCopy;
drhbe69bf62007-12-18 17:50:33 +0000534 if( SQLITE_MAX_SQL_LENGTH>0 && nBytes>SQLITE_MAX_SQL_LENGTH ){
535 sqlite3Error(db, SQLITE_TOOBIG, "statement too long");
536 sqlite3SafetyOff(db);
drhe5c941b2007-05-08 13:58:26 +0000537 return SQLITE_TOOBIG;
538 }
drh17435752007-08-16 04:30:38 +0000539 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
drh276fdbf2007-04-30 21:39:16 +0000540 if( zSqlCopy ){
541 sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
drh17435752007-08-16 04:30:38 +0000542 sqlite3_free(zSqlCopy);
drh276fdbf2007-04-30 21:39:16 +0000543 }
544 sParse.zTail = &zSql[nBytes];
drh9051a422006-01-30 22:35:43 +0000545 }else{
546 sqlite3RunParser(&sParse, zSql, &zErrMsg);
547 }
danielk1977fa256a32005-05-25 04:11:56 +0000548
drh17435752007-08-16 04:30:38 +0000549 if( db->mallocFailed ){
danielk1977261919c2005-12-06 12:52:59 +0000550 sParse.rc = SQLITE_NOMEM;
danielk1977fa256a32005-05-25 04:11:56 +0000551 }
552 if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
drh4d91a702006-01-04 15:54:36 +0000553 if( sParse.checkSchema && !schemaIsValid(db) ){
danielk1977fa256a32005-05-25 04:11:56 +0000554 sParse.rc = SQLITE_SCHEMA;
555 }
556 if( sParse.rc==SQLITE_SCHEMA ){
557 sqlite3ResetInternalSchema(db, 0);
558 }
drh17435752007-08-16 04:30:38 +0000559 if( db->mallocFailed ){
drh344a6272006-06-26 12:50:09 +0000560 sParse.rc = SQLITE_NOMEM;
561 }
drhb900aaf2006-11-09 00:24:53 +0000562 if( pzTail ){
563 *pzTail = sParse.zTail;
564 }
danielk1977fa256a32005-05-25 04:11:56 +0000565 rc = sParse.rc;
566
567#ifndef SQLITE_OMIT_EXPLAIN
568 if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){
drhecc92422005-09-10 16:46:12 +0000569 if( sParse.explain==2 ){
570 sqlite3VdbeSetNumCols(sParse.pVdbe, 3);
drh66a51672008-01-03 00:01:23 +0000571 sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P4_STATIC);
572 sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P4_STATIC);
573 sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P4_STATIC);
drhecc92422005-09-10 16:46:12 +0000574 }else{
danielk19770d78bae2008-01-03 07:09:48 +0000575 sqlite3VdbeSetNumCols(sParse.pVdbe, 8);
drh66a51672008-01-03 00:01:23 +0000576 sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P4_STATIC);
577 sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P4_STATIC);
578 sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P4_STATIC);
579 sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P4_STATIC);
580 sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P4_STATIC);
danielk19770d78bae2008-01-03 07:09:48 +0000581 sqlite3VdbeSetColName(sParse.pVdbe, 5, COLNAME_NAME, "p4", P4_STATIC);
582 sqlite3VdbeSetColName(sParse.pVdbe, 6, COLNAME_NAME, "p5", P4_STATIC);
583 sqlite3VdbeSetColName(sParse.pVdbe, 7, COLNAME_NAME, "comment",P4_STATIC);
drhecc92422005-09-10 16:46:12 +0000584 }
drhb900aaf2006-11-09 00:24:53 +0000585 }
danielk1977fa256a32005-05-25 04:11:56 +0000586#endif
587
danielk1977fa256a32005-05-25 04:11:56 +0000588 if( sqlite3SafetyOff(db) ){
589 rc = SQLITE_MISUSE;
590 }
danielk19777e29e952007-04-19 11:09:01 +0000591
592 if( saveSqlFlag ){
593 sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);
594 }
drh17435752007-08-16 04:30:38 +0000595 if( rc!=SQLITE_OK || db->mallocFailed ){
danielk1977fa256a32005-05-25 04:11:56 +0000596 sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
danielk19777e29e952007-04-19 11:09:01 +0000597 assert(!(*ppStmt));
598 }else{
599 *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
danielk1977fa256a32005-05-25 04:11:56 +0000600 }
601
602 if( zErrMsg ){
603 sqlite3Error(db, rc, "%s", zErrMsg);
drh17435752007-08-16 04:30:38 +0000604 sqlite3_free(zErrMsg);
danielk1977fa256a32005-05-25 04:11:56 +0000605 }else{
606 sqlite3Error(db, rc, 0);
607 }
danielk1977261919c2005-12-06 12:52:59 +0000608
danielk197754f01982006-01-18 15:25:17 +0000609 rc = sqlite3ApiExit(db, rc);
drh4ac285a2006-09-15 07:28:50 +0000610 assert( (rc&db->errMask)==rc );
danielk1977fa256a32005-05-25 04:11:56 +0000611 return rc;
612}
drhb21c8cd2007-08-21 19:33:56 +0000613static int sqlite3LockAndPrepare(
614 sqlite3 *db, /* Database handle. */
615 const char *zSql, /* UTF-8 encoded SQL statement. */
616 int nBytes, /* Length of zSql in bytes. */
617 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
618 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
619 const char **pzTail /* OUT: End of parsed string */
620){
621 int rc;
drh27641702007-08-22 02:56:42 +0000622 if( sqlite3SafetyCheck(db) ){
623 return SQLITE_MISUSE;
624 }
drhb21c8cd2007-08-21 19:33:56 +0000625 sqlite3_mutex_enter(db->mutex);
drhb1ab8ea2007-08-29 00:33:07 +0000626 sqlite3BtreeEnterAll(db);
drhb21c8cd2007-08-21 19:33:56 +0000627 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);
drhb1ab8ea2007-08-29 00:33:07 +0000628 sqlite3BtreeLeaveAll(db);
drhb21c8cd2007-08-21 19:33:56 +0000629 sqlite3_mutex_leave(db->mutex);
630 return rc;
631}
danielk1977fa256a32005-05-25 04:11:56 +0000632
drhb900aaf2006-11-09 00:24:53 +0000633/*
634** Rerun the compilation of a statement after a schema change.
635** Return true if the statement was recompiled successfully.
636** Return false if there is an error of some kind.
637*/
638int sqlite3Reprepare(Vdbe *p){
639 int rc;
drh4f0c5872007-03-26 22:05:01 +0000640 sqlite3_stmt *pNew;
drhb900aaf2006-11-09 00:24:53 +0000641 const char *zSql;
642 sqlite3 *db;
drhb21c8cd2007-08-21 19:33:56 +0000643
drhb1ab8ea2007-08-29 00:33:07 +0000644 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
danielk1977d0e2a852007-11-14 06:48:48 +0000645 zSql = sqlite3_sql((sqlite3_stmt *)p);
drhb900aaf2006-11-09 00:24:53 +0000646 if( zSql==0 ){
647 return 0;
648 }
649 db = sqlite3VdbeDb(p);
drhb21c8cd2007-08-21 19:33:56 +0000650 assert( sqlite3_mutex_held(db->mutex) );
drhb1ab8ea2007-08-29 00:33:07 +0000651 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0);
drhb900aaf2006-11-09 00:24:53 +0000652 if( rc ){
danielk19778e556522007-11-13 10:30:24 +0000653 if( rc==SQLITE_NOMEM ){
654 db->mallocFailed = 1;
655 }
drhb900aaf2006-11-09 00:24:53 +0000656 assert( pNew==0 );
657 return 0;
658 }else{
659 assert( pNew!=0 );
660 }
drh4f0c5872007-03-26 22:05:01 +0000661 sqlite3VdbeSwap((Vdbe*)pNew, p);
662 sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p);
663 sqlite3VdbeResetStepResult((Vdbe*)pNew);
664 sqlite3VdbeFinalize((Vdbe*)pNew);
drhb900aaf2006-11-09 00:24:53 +0000665 return 1;
666}
667
668
669/*
670** Two versions of the official API. Legacy and new use. In the legacy
671** version, the original SQL text is not saved in the prepared statement
672** and so if a schema change occurs, SQLITE_SCHEMA is returned by
673** sqlite3_step(). In the new version, the original SQL text is retained
674** and the statement is automatically recompiled if an schema change
675** occurs.
676*/
677int sqlite3_prepare(
678 sqlite3 *db, /* Database handle. */
679 const char *zSql, /* UTF-8 encoded SQL statement. */
680 int nBytes, /* Length of zSql in bytes. */
681 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
682 const char **pzTail /* OUT: End of parsed string */
683){
drhb21c8cd2007-08-21 19:33:56 +0000684 return sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail);
drhb900aaf2006-11-09 00:24:53 +0000685}
686int sqlite3_prepare_v2(
687 sqlite3 *db, /* Database handle. */
688 const char *zSql, /* UTF-8 encoded SQL statement. */
689 int nBytes, /* Length of zSql in bytes. */
690 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
691 const char **pzTail /* OUT: End of parsed string */
692){
drhb21c8cd2007-08-21 19:33:56 +0000693 return sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail);
drhb900aaf2006-11-09 00:24:53 +0000694}
695
696
danielk1977fa256a32005-05-25 04:11:56 +0000697#ifndef SQLITE_OMIT_UTF16
698/*
699** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
700*/
drhb900aaf2006-11-09 00:24:53 +0000701static int sqlite3Prepare16(
danielk1977fa256a32005-05-25 04:11:56 +0000702 sqlite3 *db, /* Database handle. */
703 const void *zSql, /* UTF-8 encoded SQL statement. */
704 int nBytes, /* Length of zSql in bytes. */
drhb900aaf2006-11-09 00:24:53 +0000705 int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
danielk1977fa256a32005-05-25 04:11:56 +0000706 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
707 const void **pzTail /* OUT: End of parsed string */
708){
709 /* This function currently works by first transforming the UTF-16
710 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
711 ** tricky bit is figuring out the pointer to return in *pzTail.
712 */
danielk197754f01982006-01-18 15:25:17 +0000713 char *zSql8;
danielk1977c87d34d2006-01-06 13:00:28 +0000714 const char *zTail8 = 0;
danielk197754f01982006-01-18 15:25:17 +0000715 int rc = SQLITE_OK;
danielk1977fa256a32005-05-25 04:11:56 +0000716
717 if( sqlite3SafetyCheck(db) ){
718 return SQLITE_MISUSE;
719 }
drhb21c8cd2007-08-21 19:33:56 +0000720 sqlite3_mutex_enter(db->mutex);
danielk19771e536952007-08-16 10:09:01 +0000721 zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
danielk197754f01982006-01-18 15:25:17 +0000722 if( zSql8 ){
drhb1ab8ea2007-08-29 00:33:07 +0000723 rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
danielk1977fa256a32005-05-25 04:11:56 +0000724 }
danielk1977fa256a32005-05-25 04:11:56 +0000725
726 if( zTail8 && pzTail ){
727 /* If sqlite3_prepare returns a tail pointer, we calculate the
728 ** equivalent pointer into the UTF-16 string by counting the unicode
729 ** characters between zSql8 and zTail8, and then returning a pointer
730 ** the same number of characters into the UTF-16 string.
731 */
drhee858132007-05-08 20:37:38 +0000732 int chars_parsed = sqlite3Utf8CharLen(zSql8, zTail8-zSql8);
733 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
danielk1977fa256a32005-05-25 04:11:56 +0000734 }
drh17435752007-08-16 04:30:38 +0000735 sqlite3_free(zSql8);
drhb21c8cd2007-08-21 19:33:56 +0000736 rc = sqlite3ApiExit(db, rc);
737 sqlite3_mutex_leave(db->mutex);
738 return rc;
danielk1977fa256a32005-05-25 04:11:56 +0000739}
drhb900aaf2006-11-09 00:24:53 +0000740
741/*
742** Two versions of the official API. Legacy and new use. In the legacy
743** version, the original SQL text is not saved in the prepared statement
744** and so if a schema change occurs, SQLITE_SCHEMA is returned by
745** sqlite3_step(). In the new version, the original SQL text is retained
746** and the statement is automatically recompiled if an schema change
747** occurs.
748*/
749int sqlite3_prepare16(
750 sqlite3 *db, /* Database handle. */
751 const void *zSql, /* UTF-8 encoded SQL statement. */
752 int nBytes, /* Length of zSql in bytes. */
753 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
754 const void **pzTail /* OUT: End of parsed string */
755){
756 return sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
757}
758int sqlite3_prepare16_v2(
759 sqlite3 *db, /* Database handle. */
760 const void *zSql, /* UTF-8 encoded SQL statement. */
761 int nBytes, /* Length of zSql in bytes. */
762 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
763 const void **pzTail /* OUT: End of parsed string */
764){
765 return sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
766}
767
danielk1977fa256a32005-05-25 04:11:56 +0000768#endif /* SQLITE_OMIT_UTF16 */