blob: f68b802b394c1b9113eca9b5a3ceb43e7d633e4c [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**
danielk197794b30732009-07-02 17:21:57 +000016** $Id: prepare.c,v 1.127 2009/07/02 17:21:58 danielk1977 Exp $
danielk1977fa256a32005-05-25 04:11:56 +000017*/
18#include "sqliteInt.h"
danielk1977fa256a32005-05-25 04:11:56 +000019
20/*
21** Fill the InitData structure with an error message that indicates
22** that the database is corrupt.
23*/
drh34533152008-03-19 13:03:33 +000024static void corruptSchema(
25 InitData *pData, /* Initialization context */
26 const char *zObj, /* Object being parsed at the point of error */
27 const char *zExtra /* Error information */
28){
drhc456e572008-08-11 18:44:58 +000029 sqlite3 *db = pData->db;
30 if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
drh34533152008-03-19 13:03:33 +000031 if( zObj==0 ) zObj = "?";
drhf089aa42008-07-08 19:34:06 +000032 sqlite3SetString(pData->pzErrMsg, pData->db,
33 "malformed database schema (%s)", zObj);
drh9da742f2009-06-16 17:49:36 +000034 if( zExtra ){
drh633e6d52008-07-28 19:34:53 +000035 *pData->pzErrMsg = sqlite3MAppendf(pData->db, *pData->pzErrMsg, "%s - %s",
drhf089aa42008-07-08 19:34:06 +000036 *pData->pzErrMsg, zExtra);
37 }
danielk1977fa256a32005-05-25 04:11:56 +000038 }
drh9da742f2009-06-16 17:49:36 +000039 pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT;
danielk1977fa256a32005-05-25 04:11:56 +000040}
41
42/*
43** This is the callback routine for the code that initializes the
44** database. See sqlite3Init() below for additional information.
45** This routine is also called from the OP_ParseSchema opcode of the VDBE.
46**
47** Each callback contains the following information:
48**
49** argv[0] = name of thing being created
danielk197778efaba2006-06-12 06:09:17 +000050** argv[1] = root page number for table or index. 0 for trigger or view.
danielk1977fa256a32005-05-25 04:11:56 +000051** argv[2] = SQL text for the CREATE statement.
danielk1977fa256a32005-05-25 04:11:56 +000052**
53*/
danielk197762c14b32008-11-19 09:05:26 +000054int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){
danielk1977fa256a32005-05-25 04:11:56 +000055 InitData *pData = (InitData*)pInit;
56 sqlite3 *db = pData->db;
drhece3c722006-09-23 20:36:01 +000057 int iDb = pData->iDb;
danielk1977fa256a32005-05-25 04:11:56 +000058
danielk1977f3d3c272008-11-19 16:52:44 +000059 assert( argc==3 );
60 UNUSED_PARAMETER2(NotUsed, argc);
drhb1ab8ea2007-08-29 00:33:07 +000061 assert( sqlite3_mutex_held(db->mutex) );
drhece3c722006-09-23 20:36:01 +000062 DbClearProperty(db, iDb, DB_Empty);
drh17435752007-08-16 04:30:38 +000063 if( db->mallocFailed ){
drh34533152008-03-19 13:03:33 +000064 corruptSchema(pData, argv[0], 0);
drh9da742f2009-06-16 17:49:36 +000065 return 1;
danielk1977da184232006-01-05 11:34:32 +000066 }
67
danielk1977ff9b2e72008-09-08 09:06:18 +000068 assert( iDb>=0 && iDb<db->nDb );
danielk1977fa256a32005-05-25 04:11:56 +000069 if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
drhece3c722006-09-23 20:36:01 +000070 if( argv[1]==0 ){
drh34533152008-03-19 13:03:33 +000071 corruptSchema(pData, argv[0], 0);
danielk1977ff9b2e72008-09-08 09:06:18 +000072 }else if( argv[2] && argv[2][0] ){
danielk1977fa256a32005-05-25 04:11:56 +000073 /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
74 ** But because db->init.busy is set to 1, no VDBE code is generated
75 ** or executed. All the parser does is build the internal data
76 ** structures that describe the table, index, or view.
77 */
78 char *zErr;
79 int rc;
80 assert( db->init.busy );
81 db->init.iDb = iDb;
82 db->init.newTnum = atoi(argv[1]);
83 rc = sqlite3_exec(db, argv[2], 0, 0, &zErr);
84 db->init.iDb = 0;
drh43617e92006-03-06 20:55:46 +000085 assert( rc!=SQLITE_OK || zErr==0 );
danielk1977fa256a32005-05-25 04:11:56 +000086 if( SQLITE_OK!=rc ){
drh15ca1df2006-07-26 13:43:30 +000087 pData->rc = rc;
danielk1977261919c2005-12-06 12:52:59 +000088 if( rc==SQLITE_NOMEM ){
drh17435752007-08-16 04:30:38 +000089 db->mallocFailed = 1;
drh9635cc72009-06-25 11:50:21 +000090 }else if( rc!=SQLITE_INTERRUPT && rc!=SQLITE_LOCKED ){
drh34533152008-03-19 13:03:33 +000091 corruptSchema(pData, argv[0], zErr);
danielk1977261919c2005-12-06 12:52:59 +000092 }
drh633e6d52008-07-28 19:34:53 +000093 sqlite3DbFree(db, zErr);
danielk1977fa256a32005-05-25 04:11:56 +000094 }
drh02cd2b82008-01-22 19:34:27 +000095 }else if( argv[0]==0 ){
drh34533152008-03-19 13:03:33 +000096 corruptSchema(pData, 0, 0);
danielk1977fa256a32005-05-25 04:11:56 +000097 }else{
98 /* If the SQL column is blank it means this is an index that
99 ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
100 ** constraint for a CREATE TABLE. The index should have already
101 ** been created when we processed the CREATE TABLE. All we have
102 ** to do here is record the root page number for that index.
103 */
104 Index *pIndex;
105 pIndex = sqlite3FindIndex(db, argv[0], db->aDb[iDb].zName);
drh9da742f2009-06-16 17:49:36 +0000106 if( pIndex==0 ){
danielk1977fa256a32005-05-25 04:11:56 +0000107 /* This can occur if there exists an index on a TEMP table which
108 ** has the same name as another index on a permanent index. Since
109 ** the permanent table is hidden by the TEMP table, we can also
110 ** safely ignore the index on the permanent table.
111 */
112 /* Do Nothing */;
drh9da742f2009-06-16 17:49:36 +0000113 }else if( sqlite3GetInt32(argv[1], &pIndex->tnum)==0 ){
114 corruptSchema(pData, argv[0], "invalid rootpage");
danielk1977fa256a32005-05-25 04:11:56 +0000115 }
116 }
117 return 0;
118}
119
120/*
121** Attempt to read the database schema and initialize internal
122** data structures for a single database file. The index of the
123** database file is given by iDb. iDb==0 is used for the main
124** database. iDb==1 should never be used. iDb>=2 is used for
125** auxiliary databases. Return one of the SQLITE_ error codes to
126** indicate success or failure.
127*/
128static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
129 int rc;
drh8a939192009-04-20 17:43:03 +0000130 int i;
danielk1977fa256a32005-05-25 04:11:56 +0000131 int size;
132 Table *pTab;
drhfdd6e852005-12-16 01:06:16 +0000133 Db *pDb;
drhece3c722006-09-23 20:36:01 +0000134 char const *azArg[4];
danielk19770d19f7a2009-06-03 11:25:07 +0000135 int meta[5];
danielk1977fa256a32005-05-25 04:11:56 +0000136 InitData initData;
137 char const *zMasterSchema;
138 char const *zMasterName = SCHEMA_TABLE(iDb);
danielk197794b30732009-07-02 17:21:57 +0000139 int openedTransaction = 0;
danielk1977fa256a32005-05-25 04:11:56 +0000140
141 /*
142 ** The master database table has a structure like this
143 */
144 static const char master_schema[] =
145 "CREATE TABLE sqlite_master(\n"
146 " type text,\n"
147 " name text,\n"
148 " tbl_name text,\n"
149 " rootpage integer,\n"
150 " sql text\n"
151 ")"
152 ;
153#ifndef SQLITE_OMIT_TEMPDB
154 static const char temp_master_schema[] =
155 "CREATE TEMP TABLE sqlite_temp_master(\n"
156 " type text,\n"
157 " name text,\n"
158 " tbl_name text,\n"
159 " rootpage integer,\n"
160 " sql text\n"
161 ")"
162 ;
163#else
164 #define temp_master_schema 0
165#endif
166
167 assert( iDb>=0 && iDb<db->nDb );
danielk197714db2662006-01-09 16:12:04 +0000168 assert( db->aDb[iDb].pSchema );
drhb1ab8ea2007-08-29 00:33:07 +0000169 assert( sqlite3_mutex_held(db->mutex) );
danielk19774eab8b72007-12-27 15:12:16 +0000170 assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
danielk1977da184232006-01-05 11:34:32 +0000171
danielk1977fa256a32005-05-25 04:11:56 +0000172 /* zMasterSchema and zInitScript are set to point at the master schema
173 ** and initialisation script appropriate for the database being
174 ** initialised. zMasterName is the name of the master table.
175 */
176 if( !OMIT_TEMPDB && iDb==1 ){
177 zMasterSchema = temp_master_schema;
178 }else{
179 zMasterSchema = master_schema;
180 }
181 zMasterName = SCHEMA_TABLE(iDb);
182
183 /* Construct the schema tables. */
danielk1977fa256a32005-05-25 04:11:56 +0000184 azArg[0] = zMasterName;
185 azArg[1] = "1";
186 azArg[2] = zMasterSchema;
drhece3c722006-09-23 20:36:01 +0000187 azArg[3] = 0;
danielk1977fa256a32005-05-25 04:11:56 +0000188 initData.db = db;
drhece3c722006-09-23 20:36:01 +0000189 initData.iDb = iDb;
drhc456e572008-08-11 18:44:58 +0000190 initData.rc = SQLITE_OK;
danielk1977fa256a32005-05-25 04:11:56 +0000191 initData.pzErrMsg = pzErrMsg;
drh7e8b8482008-01-23 03:03:05 +0000192 (void)sqlite3SafetyOff(db);
drhc456e572008-08-11 18:44:58 +0000193 sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
drh7e8b8482008-01-23 03:03:05 +0000194 (void)sqlite3SafetyOn(db);
drhc456e572008-08-11 18:44:58 +0000195 if( initData.rc ){
danielk1977a1644fd2007-08-29 12:31:25 +0000196 rc = initData.rc;
197 goto error_out;
danielk1977fa256a32005-05-25 04:11:56 +0000198 }
199 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
drh9da742f2009-06-16 17:49:36 +0000200 if( ALWAYS(pTab) ){
drh7d10d5a2008-08-20 16:35:10 +0000201 pTab->tabFlags |= TF_Readonly;
danielk1977fa256a32005-05-25 04:11:56 +0000202 }
danielk1977fa256a32005-05-25 04:11:56 +0000203
204 /* Create a cursor to hold the database open
205 */
drhfdd6e852005-12-16 01:06:16 +0000206 pDb = &db->aDb[iDb];
207 if( pDb->pBt==0 ){
drh9da742f2009-06-16 17:49:36 +0000208 if( !OMIT_TEMPDB && ALWAYS(iDb==1) ){
danielk1977b82e7ed2006-01-11 14:09:31 +0000209 DbSetProperty(db, 1, DB_SchemaLoaded);
210 }
danielk1977fa256a32005-05-25 04:11:56 +0000211 return SQLITE_OK;
212 }
danielk1977602b4662009-07-02 07:47:33 +0000213
214 /* If there is not already a read-only (or read-write) transaction opened
215 ** on the b-tree database, open one now. If a transaction is opened, it
216 ** will be closed before this function returns. */
drhb1ab8ea2007-08-29 00:33:07 +0000217 sqlite3BtreeEnter(pDb->pBt);
danielk1977602b4662009-07-02 07:47:33 +0000218 if( !sqlite3BtreeIsInReadTrans(pDb->pBt) ){
219 rc = sqlite3BtreeBeginTrans(pDb->pBt, 0);
220 if( rc!=SQLITE_OK ){
221 sqlite3SetString(pzErrMsg, db, "%s", sqlite3ErrStr(rc));
222 goto initone_error_out;
223 }
224 openedTransaction = 1;
danielk1977602b4662009-07-02 07:47:33 +0000225 }
danielk1977fa256a32005-05-25 04:11:56 +0000226
227 /* Get the database meta information.
228 **
229 ** Meta values are as follows:
230 ** meta[0] Schema cookie. Changes with each schema change.
231 ** meta[1] File format of schema layer.
232 ** meta[2] Size of the page cache.
drh27731d72009-06-22 12:05:10 +0000233 ** meta[3] Largest rootpage (auto/incr_vacuum mode)
drh8159a352006-05-23 23:22:29 +0000234 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
drh27731d72009-06-22 12:05:10 +0000235 ** meta[5] User version
236 ** meta[6] Incremental vacuum mode
237 ** meta[7] unused
238 ** meta[8] unused
239 ** meta[9] unused
danielk1977fa256a32005-05-25 04:11:56 +0000240 **
drhf248e212006-01-25 22:50:38 +0000241 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
danielk1977fa256a32005-05-25 04:11:56 +0000242 ** the possible values of meta[4].
243 */
danielk1977602b4662009-07-02 07:47:33 +0000244 for(i=0; i<ArraySize(meta); i++){
245 sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
danielk19770d19f7a2009-06-03 11:25:07 +0000246 }
247 pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1];
danielk1977fa256a32005-05-25 04:11:56 +0000248
249 /* If opening a non-empty database, check the text encoding. For the
250 ** main database, set sqlite3.enc to the encoding of the main database.
251 ** For an attached db, it is an error if the encoding is not the same
252 ** as sqlite3.enc.
253 */
danielk19770d19f7a2009-06-03 11:25:07 +0000254 if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */
danielk1977fa256a32005-05-25 04:11:56 +0000255 if( iDb==0 ){
drhc5e47ac2009-06-04 00:11:56 +0000256 u8 encoding;
danielk197714db2662006-01-09 16:12:04 +0000257 /* If opening the main database, set ENC(db). */
drhc5e47ac2009-06-04 00:11:56 +0000258 encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3;
259 if( encoding==0 ) encoding = SQLITE_UTF8;
260 ENC(db) = encoding;
drhc4a64fa2009-05-11 20:53:28 +0000261 db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);
danielk1977fa256a32005-05-25 04:11:56 +0000262 }else{
danielk197714db2662006-01-09 16:12:04 +0000263 /* If opening an attached database, the encoding much match ENC(db) */
danielk19770d19f7a2009-06-03 11:25:07 +0000264 if( meta[BTREE_TEXT_ENCODING-1]!=ENC(db) ){
drhf089aa42008-07-08 19:34:06 +0000265 sqlite3SetString(pzErrMsg, db, "attached databases must use the same"
266 " text encoding as main database");
danielk1977cd3e8f72008-03-25 09:47:35 +0000267 rc = SQLITE_ERROR;
drh701bb3b2008-08-02 03:50:39 +0000268 goto initone_error_out;
danielk1977fa256a32005-05-25 04:11:56 +0000269 }
270 }
danielk1977b82e7ed2006-01-11 14:09:31 +0000271 }else{
272 DbSetProperty(db, iDb, DB_Empty);
danielk1977fa256a32005-05-25 04:11:56 +0000273 }
danielk197714db2662006-01-09 16:12:04 +0000274 pDb->pSchema->enc = ENC(db);
danielk1977fa256a32005-05-25 04:11:56 +0000275
danielk19778cf6c552008-06-23 16:53:46 +0000276 if( pDb->pSchema->cache_size==0 ){
danielk19770d19f7a2009-06-03 11:25:07 +0000277 size = meta[BTREE_DEFAULT_CACHE_SIZE-1];
danielk19778cf6c552008-06-23 16:53:46 +0000278 if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
279 if( size<0 ) size = -size;
280 pDb->pSchema->cache_size = size;
281 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
282 }
danielk1977fa256a32005-05-25 04:11:56 +0000283
284 /*
285 ** file_format==1 Version 3.0.0.
drhfdd6e852005-12-16 01:06:16 +0000286 ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
287 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
drhd946db02005-12-29 19:23:06 +0000288 ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
danielk1977fa256a32005-05-25 04:11:56 +0000289 */
danielk19770d19f7a2009-06-03 11:25:07 +0000290 pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1];
danielk1977da184232006-01-05 11:34:32 +0000291 if( pDb->pSchema->file_format==0 ){
292 pDb->pSchema->file_format = 1;
drhfdd6e852005-12-16 01:06:16 +0000293 }
danielk1977da184232006-01-05 11:34:32 +0000294 if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
drhf089aa42008-07-08 19:34:06 +0000295 sqlite3SetString(pzErrMsg, db, "unsupported file format");
danielk1977cd3e8f72008-03-25 09:47:35 +0000296 rc = SQLITE_ERROR;
drh701bb3b2008-08-02 03:50:39 +0000297 goto initone_error_out;
danielk1977fa256a32005-05-25 04:11:56 +0000298 }
299
drh4aa2bfe2007-11-28 13:43:16 +0000300 /* Ticket #2804: When we open a database in the newer file format,
301 ** clear the legacy_file_format pragma flag so that a VACUUM will
302 ** not downgrade the database and thus invalidate any descending
303 ** indices that the user might have created.
304 */
danielk19770d19f7a2009-06-03 11:25:07 +0000305 if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){
drh4aa2bfe2007-11-28 13:43:16 +0000306 db->flags &= ~SQLITE_LegacyFileFmt;
307 }
danielk1977fa256a32005-05-25 04:11:56 +0000308
309 /* Read the schema information out of the schema tables
310 */
311 assert( db->init.busy );
drh9da742f2009-06-16 17:49:36 +0000312 {
danielk1977fa256a32005-05-25 04:11:56 +0000313 char *zSql;
danielk19771e536952007-08-16 10:09:01 +0000314 zSql = sqlite3MPrintf(db,
drhece3c722006-09-23 20:36:01 +0000315 "SELECT name, rootpage, sql FROM '%q'.%s",
316 db->aDb[iDb].zName, zMasterName);
drh7e8b8482008-01-23 03:03:05 +0000317 (void)sqlite3SafetyOff(db);
drha6d0ffc2007-10-12 20:42:28 +0000318#ifndef SQLITE_OMIT_AUTHORIZATION
319 {
320 int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
321 xAuth = db->xAuth;
322 db->xAuth = 0;
323#endif
324 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
325#ifndef SQLITE_OMIT_AUTHORIZATION
326 db->xAuth = xAuth;
327 }
328#endif
drhc456e572008-08-11 18:44:58 +0000329 if( rc==SQLITE_OK ) rc = initData.rc;
drh7e8b8482008-01-23 03:03:05 +0000330 (void)sqlite3SafetyOn(db);
drh633e6d52008-07-28 19:34:53 +0000331 sqlite3DbFree(db, zSql);
drh497e4462005-07-23 03:18:40 +0000332#ifndef SQLITE_OMIT_ANALYZE
333 if( rc==SQLITE_OK ){
334 sqlite3AnalysisLoad(db, iDb);
335 }
336#endif
danielk1977fa256a32005-05-25 04:11:56 +0000337 }
drh17435752007-08-16 04:30:38 +0000338 if( db->mallocFailed ){
danielk1977fa256a32005-05-25 04:11:56 +0000339 rc = SQLITE_NOMEM;
340 sqlite3ResetInternalSchema(db, 0);
341 }
danielk197734c68fb2007-03-14 15:37:04 +0000342 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
343 /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
shanebe217792009-03-05 04:20:31 +0000344 ** the schema loaded, even if errors occurred. In this situation the
danielk197734c68fb2007-03-14 15:37:04 +0000345 ** current sqlite3_prepare() operation will fail, but the following one
346 ** will attempt to compile the supplied statement against whatever subset
shanebe217792009-03-05 04:20:31 +0000347 ** of the schema was loaded before the error occurred. The primary
danielk197734c68fb2007-03-14 15:37:04 +0000348 ** purpose of this is to allow access to the sqlite_master table
drh85b623f2007-12-13 21:54:09 +0000349 ** even when its contents have been corrupted.
danielk197734c68fb2007-03-14 15:37:04 +0000350 */
danielk1977fa256a32005-05-25 04:11:56 +0000351 DbSetProperty(db, iDb, DB_SchemaLoaded);
danielk197734c68fb2007-03-14 15:37:04 +0000352 rc = SQLITE_OK;
danielk1977fa256a32005-05-25 04:11:56 +0000353 }
danielk1977cd3e8f72008-03-25 09:47:35 +0000354
355 /* Jump here for an error that occurs after successfully allocating
356 ** curMain and calling sqlite3BtreeEnter(). For an error that occurs
357 ** before that point, jump to error_out.
358 */
drh701bb3b2008-08-02 03:50:39 +0000359initone_error_out:
danielk1977602b4662009-07-02 07:47:33 +0000360 if( openedTransaction ){
361 sqlite3BtreeCommit(pDb->pBt);
362 }
drhb1ab8ea2007-08-29 00:33:07 +0000363 sqlite3BtreeLeave(pDb->pBt);
danielk1977a1644fd2007-08-29 12:31:25 +0000364
365error_out:
danielk1977ae72d982007-10-03 08:46:44 +0000366 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
danielk1977a1644fd2007-08-29 12:31:25 +0000367 db->mallocFailed = 1;
368 }
danielk1977fa256a32005-05-25 04:11:56 +0000369 return rc;
370}
371
372/*
373** Initialize all database files - the main database file, the file
374** used to store temporary tables, and any additional database files
375** created using ATTACH statements. Return a success code. If an
376** error occurs, write an error message into *pzErrMsg.
377**
danielk1977e7259292006-01-13 06:33:23 +0000378** After a database is initialized, the DB_SchemaLoaded bit is set
379** bit is set in the flags field of the Db structure. If the database
380** file was of zero-length, then the DB_Empty flag is also set.
danielk1977fa256a32005-05-25 04:11:56 +0000381*/
382int sqlite3Init(sqlite3 *db, char **pzErrMsg){
383 int i, rc;
danielk19775814c1a2007-08-13 14:41:19 +0000384 int commit_internal = !(db->flags&SQLITE_InternChanges);
danielk1977fa256a32005-05-25 04:11:56 +0000385
drhb1ab8ea2007-08-29 00:33:07 +0000386 assert( sqlite3_mutex_held(db->mutex) );
danielk1977fa256a32005-05-25 04:11:56 +0000387 rc = SQLITE_OK;
388 db->init.busy = 1;
389 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
390 if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
391 rc = sqlite3InitOne(db, i, pzErrMsg);
392 if( rc ){
393 sqlite3ResetInternalSchema(db, i);
394 }
395 }
396
397 /* Once all the other databases have been initialised, load the schema
398 ** for the TEMP database. This is loaded last, as the TEMP database
399 ** schema may contain references to objects in other databases.
400 */
401#ifndef SQLITE_OMIT_TEMPDB
drh9da742f2009-06-16 17:49:36 +0000402 if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
403 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
danielk1977fa256a32005-05-25 04:11:56 +0000404 rc = sqlite3InitOne(db, 1, pzErrMsg);
405 if( rc ){
406 sqlite3ResetInternalSchema(db, 1);
407 }
408 }
409#endif
410
411 db->init.busy = 0;
danielk19775814c1a2007-08-13 14:41:19 +0000412 if( rc==SQLITE_OK && commit_internal ){
danielk1977fa256a32005-05-25 04:11:56 +0000413 sqlite3CommitInternalChanges(db);
414 }
415
danielk1977b82e7ed2006-01-11 14:09:31 +0000416 return rc;
danielk1977fa256a32005-05-25 04:11:56 +0000417}
418
419/*
420** This routine is a no-op if the database schema is already initialised.
421** Otherwise, the schema is loaded. An error code is returned.
422*/
423int sqlite3ReadSchema(Parse *pParse){
424 int rc = SQLITE_OK;
425 sqlite3 *db = pParse->db;
drhb1ab8ea2007-08-29 00:33:07 +0000426 assert( sqlite3_mutex_held(db->mutex) );
danielk1977fa256a32005-05-25 04:11:56 +0000427 if( !db->init.busy ){
danielk1977b82e7ed2006-01-11 14:09:31 +0000428 rc = sqlite3Init(db, &pParse->zErrMsg);
danielk1977fa256a32005-05-25 04:11:56 +0000429 }
danielk1977fa256a32005-05-25 04:11:56 +0000430 if( rc!=SQLITE_OK ){
431 pParse->rc = rc;
432 pParse->nErr++;
433 }
434 return rc;
435}
436
437
438/*
439** Check schema cookies in all databases. If any cookie is out
440** of date, return 0. If all schema cookies are current, return 1.
441*/
danielk1977602b4662009-07-02 07:47:33 +0000442static void schemaIsValid(Parse *pParse){
443 sqlite3 *db = pParse->db;
danielk1977fa256a32005-05-25 04:11:56 +0000444 int iDb;
445 int rc;
danielk1977fa256a32005-05-25 04:11:56 +0000446 int cookie;
danielk1977fa256a32005-05-25 04:11:56 +0000447
danielk1977602b4662009-07-02 07:47:33 +0000448 assert( pParse->checkSchema );
449 assert( sqlite3_mutex_held(db->mutex) );
450 for(iDb=0; iDb<db->nDb; iDb++){
451 int openedTransaction = 0; /* True if a transaction is opened */
452 Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */
453 if( pBt==0 ) continue;
454
455 /* If there is not already a read-only (or read-write) transaction opened
456 ** on the b-tree database, open one now. If a transaction is opened, it
457 ** will be closed immediately after reading the meta-value. */
458 if( !sqlite3BtreeIsInReadTrans(pBt) ){
459 rc = sqlite3BtreeBeginTrans(pBt, 0);
460 if( NEVER(rc==SQLITE_NOMEM) || rc==SQLITE_IOERR_NOMEM ){
461 db->mallocFailed = 1;
462 }
463 if( rc!=SQLITE_OK ) return;
464 openedTransaction = 1;
465 }
466
467 /* Read the schema cookie from the database. If it does not match the
468 ** value stored as part of the in the in-memory schema representation,
469 ** set Parse.rc to SQLITE_SCHEMA. */
470 sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
471 if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){
472 pParse->rc = SQLITE_SCHEMA;
473 }
474
475 /* Close the transaction, if one was opened. */
476 if( openedTransaction ){
477 sqlite3BtreeCommit(pBt);
478 }
479 }
480
481#if 0
drhe5ae5732008-06-15 02:51:47 +0000482 curTemp = (BtCursor *)sqlite3Malloc(sqlite3BtreeCursorSize());
danielk1977cd3e8f72008-03-25 09:47:35 +0000483 if( curTemp ){
484 assert( sqlite3_mutex_held(db->mutex) );
485 for(iDb=0; allOk && iDb<db->nDb; iDb++){
486 Btree *pBt;
487 pBt = db->aDb[iDb].pBt;
488 if( pBt==0 ) continue;
489 memset(curTemp, 0, sqlite3BtreeCursorSize());
490 rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, curTemp);
491 if( rc==SQLITE_OK ){
danielk19770d19f7a2009-06-03 11:25:07 +0000492 rc = sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie);
drh58fbb312009-06-17 00:35:30 +0000493 if( ALWAYS(rc==SQLITE_OK)
494 && cookie!=db->aDb[iDb].pSchema->schema_cookie ){
danielk1977cd3e8f72008-03-25 09:47:35 +0000495 allOk = 0;
496 }
497 sqlite3BtreeCloseCursor(curTemp);
danielk1977fa256a32005-05-25 04:11:56 +0000498 }
drh58fbb312009-06-17 00:35:30 +0000499 if( NEVER(rc==SQLITE_NOMEM) || rc==SQLITE_IOERR_NOMEM ){
danielk1977cd3e8f72008-03-25 09:47:35 +0000500 db->mallocFailed = 1;
501 }
danielk1977fa256a32005-05-25 04:11:56 +0000502 }
danielk1977cd3e8f72008-03-25 09:47:35 +0000503 sqlite3_free(curTemp);
504 }else{
505 allOk = 0;
506 db->mallocFailed = 1;
danielk1977fa256a32005-05-25 04:11:56 +0000507 }
508 return allOk;
danielk1977602b4662009-07-02 07:47:33 +0000509#endif
danielk1977fa256a32005-05-25 04:11:56 +0000510}
511
512/*
drhf248e212006-01-25 22:50:38 +0000513** Convert a schema pointer into the iDb index that indicates
514** which database file in db->aDb[] the schema refers to.
515**
516** If the same database is attached more than once, the first
517** attached database is returned.
518*/
danielk1977e501b892006-01-09 06:29:47 +0000519int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
drh198bf392006-01-06 21:52:49 +0000520 int i = -1000000;
521
522 /* If pSchema is NULL, then return -1000000. This happens when code in
523 ** expr.c is trying to resolve a reference to a transient table (i.e. one
524 ** created by a sub-select). In this case the return value of this
525 ** function should never be used.
526 **
527 ** We return -1000000 instead of the more usual -1 simply because using
drh1c767f02009-01-09 02:49:31 +0000528 ** -1000000 as the incorrect index into db->aDb[] is much
drh198bf392006-01-06 21:52:49 +0000529 ** more likely to cause a segfault than -1 (of course there are assert()
530 ** statements too, but it never hurts to play the odds).
531 */
drhb1ab8ea2007-08-29 00:33:07 +0000532 assert( sqlite3_mutex_held(db->mutex) );
drh198bf392006-01-06 21:52:49 +0000533 if( pSchema ){
drh1c767f02009-01-09 02:49:31 +0000534 for(i=0; ALWAYS(i<db->nDb); i++){
drh198bf392006-01-06 21:52:49 +0000535 if( db->aDb[i].pSchema==pSchema ){
536 break;
537 }
538 }
drh1c767f02009-01-09 02:49:31 +0000539 assert( i>=0 && i<db->nDb );
drh198bf392006-01-06 21:52:49 +0000540 }
541 return i;
542}
543
544/*
danielk1977fa256a32005-05-25 04:11:56 +0000545** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
546*/
mlcreech3a00f902008-03-04 17:45:01 +0000547static int sqlite3Prepare(
danielk1977fa256a32005-05-25 04:11:56 +0000548 sqlite3 *db, /* Database handle. */
549 const char *zSql, /* UTF-8 encoded SQL statement. */
550 int nBytes, /* Length of zSql in bytes. */
drhb900aaf2006-11-09 00:24:53 +0000551 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
danielk1977fa256a32005-05-25 04:11:56 +0000552 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
drhb900aaf2006-11-09 00:24:53 +0000553 const char **pzTail /* OUT: End of parsed string */
danielk1977fa256a32005-05-25 04:11:56 +0000554){
drhe7b347072009-06-01 18:18:20 +0000555 Parse *pParse; /* Parsing context */
556 char *zErrMsg = 0; /* Error message */
557 int rc = SQLITE_OK; /* Result code */
558 int i; /* Loop counter */
danielk1977fa256a32005-05-25 04:11:56 +0000559
drhe7b347072009-06-01 18:18:20 +0000560 /* Allocate the parsing context */
561 pParse = sqlite3StackAllocZero(db, sizeof(*pParse));
562 if( pParse==0 ){
563 rc = SQLITE_NOMEM;
564 goto end_prepare;
565 }
566
567 if( sqlite3SafetyOn(db) ){
568 rc = SQLITE_MISUSE;
569 goto end_prepare;
570 }
drh860e0772009-04-02 18:32:26 +0000571 assert( ppStmt && *ppStmt==0 );
drh86f8c192007-08-22 00:39:19 +0000572 assert( !db->mallocFailed );
drhb21c8cd2007-08-21 19:33:56 +0000573 assert( sqlite3_mutex_held(db->mutex) );
danielk1977fa256a32005-05-25 04:11:56 +0000574
drhc74d0b1d2009-02-24 16:18:05 +0000575 /* Check to verify that it is possible to get a read lock on all
576 ** database schemas. The inability to get a read lock indicates that
577 ** some other database connection is holding a write-lock, which in
578 ** turn means that the other connection has made uncommitted changes
579 ** to the schema.
580 **
581 ** Were we to proceed and prepare the statement against the uncommitted
582 ** schema changes and if those schema changes are subsequently rolled
583 ** back and different changes are made in their place, then when this
584 ** prepared statement goes to run the schema cookie would fail to detect
585 ** the schema change. Disaster would follow.
586 **
587 ** This thread is currently holding mutexes on all Btrees (because
588 ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it
589 ** is not possible for another thread to start a new schema change
590 ** while this routine is running. Hence, we do not need to hold
591 ** locks on the schema, we just need to make sure nobody else is
592 ** holding them.
593 **
594 ** Note that setting READ_UNCOMMITTED overrides most lock detection,
595 ** but it does *not* override schema lock detection, so this all still
596 ** works even if READ_UNCOMMITTED is set.
danielk1977c87d34d2006-01-06 13:00:28 +0000597 */
598 for(i=0; i<db->nDb; i++) {
599 Btree *pBt = db->aDb[i].pBt;
drhb1ab8ea2007-08-29 00:33:07 +0000600 if( pBt ){
drhc74d0b1d2009-02-24 16:18:05 +0000601 assert( sqlite3BtreeHoldsMutex(pBt) );
drhb1ab8ea2007-08-29 00:33:07 +0000602 rc = sqlite3BtreeSchemaLocked(pBt);
603 if( rc ){
604 const char *zDb = db->aDb[i].zName;
danielk1977404ca072009-03-16 13:19:36 +0000605 sqlite3Error(db, rc, "database schema is locked: %s", zDb);
drh7e8b8482008-01-23 03:03:05 +0000606 (void)sqlite3SafetyOff(db);
drhc74d0b1d2009-02-24 16:18:05 +0000607 testcase( db->flags & SQLITE_ReadUncommitted );
drhe7b347072009-06-01 18:18:20 +0000608 goto end_prepare;
drhb1ab8ea2007-08-29 00:33:07 +0000609 }
danielk1977c87d34d2006-01-06 13:00:28 +0000610 }
611 }
drhe7b347072009-06-01 18:18:20 +0000612
613
614 pParse->db = db;
drhd2d88bb2008-05-23 14:32:18 +0000615 if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){
drhe5c941b2007-05-08 13:58:26 +0000616 char *zSqlCopy;
drhbb4957f2008-03-20 14:03:29 +0000617 int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH];
drh58fbb312009-06-17 00:35:30 +0000618 testcase( nBytes==mxLen );
619 testcase( nBytes==mxLen+1 );
drhbb4957f2008-03-20 14:03:29 +0000620 if( nBytes>mxLen ){
drhbe69bf62007-12-18 17:50:33 +0000621 sqlite3Error(db, SQLITE_TOOBIG, "statement too long");
drh7e8b8482008-01-23 03:03:05 +0000622 (void)sqlite3SafetyOff(db);
drhe7b347072009-06-01 18:18:20 +0000623 rc = sqlite3ApiExit(db, SQLITE_TOOBIG);
624 goto end_prepare;
drhe5c941b2007-05-08 13:58:26 +0000625 }
drh17435752007-08-16 04:30:38 +0000626 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
drh276fdbf2007-04-30 21:39:16 +0000627 if( zSqlCopy ){
drhe7b347072009-06-01 18:18:20 +0000628 sqlite3RunParser(pParse, zSqlCopy, &zErrMsg);
drh633e6d52008-07-28 19:34:53 +0000629 sqlite3DbFree(db, zSqlCopy);
drhe7b347072009-06-01 18:18:20 +0000630 pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
danielk19773a2c8c82008-04-03 14:36:25 +0000631 }else{
drhe7b347072009-06-01 18:18:20 +0000632 pParse->zTail = &zSql[nBytes];
drh276fdbf2007-04-30 21:39:16 +0000633 }
drh9051a422006-01-30 22:35:43 +0000634 }else{
drhe7b347072009-06-01 18:18:20 +0000635 sqlite3RunParser(pParse, zSql, &zErrMsg);
drh9051a422006-01-30 22:35:43 +0000636 }
danielk1977fa256a32005-05-25 04:11:56 +0000637
drh17435752007-08-16 04:30:38 +0000638 if( db->mallocFailed ){
drhe7b347072009-06-01 18:18:20 +0000639 pParse->rc = SQLITE_NOMEM;
danielk1977fa256a32005-05-25 04:11:56 +0000640 }
drhe7b347072009-06-01 18:18:20 +0000641 if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
danielk1977602b4662009-07-02 07:47:33 +0000642 if( pParse->checkSchema ){
643 schemaIsValid(pParse);
danielk1977fa256a32005-05-25 04:11:56 +0000644 }
drhe7b347072009-06-01 18:18:20 +0000645 if( pParse->rc==SQLITE_SCHEMA ){
danielk1977fa256a32005-05-25 04:11:56 +0000646 sqlite3ResetInternalSchema(db, 0);
647 }
drh17435752007-08-16 04:30:38 +0000648 if( db->mallocFailed ){
drhe7b347072009-06-01 18:18:20 +0000649 pParse->rc = SQLITE_NOMEM;
drh344a6272006-06-26 12:50:09 +0000650 }
drhb900aaf2006-11-09 00:24:53 +0000651 if( pzTail ){
drhe7b347072009-06-01 18:18:20 +0000652 *pzTail = pParse->zTail;
drhb900aaf2006-11-09 00:24:53 +0000653 }
drhe7b347072009-06-01 18:18:20 +0000654 rc = pParse->rc;
danielk1977fa256a32005-05-25 04:11:56 +0000655
656#ifndef SQLITE_OMIT_EXPLAIN
drhe7b347072009-06-01 18:18:20 +0000657 if( rc==SQLITE_OK && pParse->pVdbe && pParse->explain ){
658 static const char * const azColName[] = {
659 "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",
660 "order", "from", "detail"
661 };
662 int iFirst, mx;
663 if( pParse->explain==2 ){
664 sqlite3VdbeSetNumCols(pParse->pVdbe, 3);
665 iFirst = 8;
666 mx = 11;
drhecc92422005-09-10 16:46:12 +0000667 }else{
drhe7b347072009-06-01 18:18:20 +0000668 sqlite3VdbeSetNumCols(pParse->pVdbe, 8);
669 iFirst = 0;
670 mx = 8;
671 }
672 for(i=iFirst; i<mx; i++){
673 sqlite3VdbeSetColName(pParse->pVdbe, i-iFirst, COLNAME_NAME,
674 azColName[i], SQLITE_STATIC);
drhecc92422005-09-10 16:46:12 +0000675 }
drhb900aaf2006-11-09 00:24:53 +0000676 }
danielk1977fa256a32005-05-25 04:11:56 +0000677#endif
678
danielk1977fa256a32005-05-25 04:11:56 +0000679 if( sqlite3SafetyOff(db) ){
680 rc = SQLITE_MISUSE;
681 }
danielk19777e29e952007-04-19 11:09:01 +0000682
danielk19776ab3a2e2009-02-19 14:39:25 +0000683 assert( db->init.busy==0 || saveSqlFlag==0 );
684 if( db->init.busy==0 ){
drhe7b347072009-06-01 18:18:20 +0000685 Vdbe *pVdbe = pParse->pVdbe;
686 sqlite3VdbeSetSql(pVdbe, zSql, (int)(pParse->zTail-zSql), saveSqlFlag);
danielk19777e29e952007-04-19 11:09:01 +0000687 }
drhe7b347072009-06-01 18:18:20 +0000688 if( pParse->pVdbe && (rc!=SQLITE_OK || db->mallocFailed) ){
689 sqlite3VdbeFinalize(pParse->pVdbe);
danielk19777e29e952007-04-19 11:09:01 +0000690 assert(!(*ppStmt));
691 }else{
drhe7b347072009-06-01 18:18:20 +0000692 *ppStmt = (sqlite3_stmt*)pParse->pVdbe;
danielk1977fa256a32005-05-25 04:11:56 +0000693 }
694
695 if( zErrMsg ){
696 sqlite3Error(db, rc, "%s", zErrMsg);
drh633e6d52008-07-28 19:34:53 +0000697 sqlite3DbFree(db, zErrMsg);
danielk1977fa256a32005-05-25 04:11:56 +0000698 }else{
699 sqlite3Error(db, rc, 0);
700 }
danielk1977261919c2005-12-06 12:52:59 +0000701
drhe7b347072009-06-01 18:18:20 +0000702end_prepare:
703
704 sqlite3StackFree(db, pParse);
danielk197754f01982006-01-18 15:25:17 +0000705 rc = sqlite3ApiExit(db, rc);
drh4ac285a2006-09-15 07:28:50 +0000706 assert( (rc&db->errMask)==rc );
danielk1977fa256a32005-05-25 04:11:56 +0000707 return rc;
708}
drhb21c8cd2007-08-21 19:33:56 +0000709static int sqlite3LockAndPrepare(
710 sqlite3 *db, /* Database handle. */
711 const char *zSql, /* UTF-8 encoded SQL statement. */
712 int nBytes, /* Length of zSql in bytes. */
713 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
714 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
715 const char **pzTail /* OUT: End of parsed string */
716){
717 int rc;
drh860e0772009-04-02 18:32:26 +0000718 assert( ppStmt!=0 );
719 *ppStmt = 0;
drh7e8b8482008-01-23 03:03:05 +0000720 if( !sqlite3SafetyCheckOk(db) ){
drh27641702007-08-22 02:56:42 +0000721 return SQLITE_MISUSE;
722 }
drhb21c8cd2007-08-21 19:33:56 +0000723 sqlite3_mutex_enter(db->mutex);
drhb1ab8ea2007-08-29 00:33:07 +0000724 sqlite3BtreeEnterAll(db);
drhb21c8cd2007-08-21 19:33:56 +0000725 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);
drh9da742f2009-06-16 17:49:36 +0000726 if( rc==SQLITE_SCHEMA ){
727 sqlite3_finalize(*ppStmt);
728 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);
729 }
drhb1ab8ea2007-08-29 00:33:07 +0000730 sqlite3BtreeLeaveAll(db);
drhb21c8cd2007-08-21 19:33:56 +0000731 sqlite3_mutex_leave(db->mutex);
732 return rc;
733}
danielk1977fa256a32005-05-25 04:11:56 +0000734
drhb900aaf2006-11-09 00:24:53 +0000735/*
736** Rerun the compilation of a statement after a schema change.
danielk197765a2ea12009-03-19 07:58:31 +0000737**
738** If the statement is successfully recompiled, return SQLITE_OK. Otherwise,
739** if the statement cannot be recompiled because another connection has
740** locked the sqlite3_master table, return SQLITE_LOCKED. If any other error
741** occurs, return SQLITE_SCHEMA.
drhb900aaf2006-11-09 00:24:53 +0000742*/
743int sqlite3Reprepare(Vdbe *p){
744 int rc;
drh4f0c5872007-03-26 22:05:01 +0000745 sqlite3_stmt *pNew;
drhb900aaf2006-11-09 00:24:53 +0000746 const char *zSql;
747 sqlite3 *db;
drhb21c8cd2007-08-21 19:33:56 +0000748
drhb1ab8ea2007-08-29 00:33:07 +0000749 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
danielk1977d0e2a852007-11-14 06:48:48 +0000750 zSql = sqlite3_sql((sqlite3_stmt *)p);
drhc4dd3fd2008-01-22 01:48:05 +0000751 assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */
drhb900aaf2006-11-09 00:24:53 +0000752 db = sqlite3VdbeDb(p);
drhb21c8cd2007-08-21 19:33:56 +0000753 assert( sqlite3_mutex_held(db->mutex) );
drhb1ab8ea2007-08-29 00:33:07 +0000754 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0);
drhb900aaf2006-11-09 00:24:53 +0000755 if( rc ){
danielk19778e556522007-11-13 10:30:24 +0000756 if( rc==SQLITE_NOMEM ){
757 db->mallocFailed = 1;
758 }
drhb900aaf2006-11-09 00:24:53 +0000759 assert( pNew==0 );
danielk197765a2ea12009-03-19 07:58:31 +0000760 return (rc==SQLITE_LOCKED) ? SQLITE_LOCKED : SQLITE_SCHEMA;
drhb900aaf2006-11-09 00:24:53 +0000761 }else{
762 assert( pNew!=0 );
763 }
drh4f0c5872007-03-26 22:05:01 +0000764 sqlite3VdbeSwap((Vdbe*)pNew, p);
shane145834a2008-09-04 12:03:42 +0000765 sqlite3TransferBindings(pNew, (sqlite3_stmt*)p);
drh4f0c5872007-03-26 22:05:01 +0000766 sqlite3VdbeResetStepResult((Vdbe*)pNew);
767 sqlite3VdbeFinalize((Vdbe*)pNew);
danielk197765a2ea12009-03-19 07:58:31 +0000768 return SQLITE_OK;
drhb900aaf2006-11-09 00:24:53 +0000769}
770
771
772/*
773** Two versions of the official API. Legacy and new use. In the legacy
774** version, the original SQL text is not saved in the prepared statement
775** and so if a schema change occurs, SQLITE_SCHEMA is returned by
776** sqlite3_step(). In the new version, the original SQL text is retained
777** and the statement is automatically recompiled if an schema change
778** occurs.
779*/
780int sqlite3_prepare(
781 sqlite3 *db, /* Database handle. */
782 const char *zSql, /* UTF-8 encoded SQL statement. */
783 int nBytes, /* Length of zSql in bytes. */
784 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
785 const char **pzTail /* OUT: End of parsed string */
786){
drh17eaae72008-03-03 18:47:28 +0000787 int rc;
788 rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail);
drh58edb652008-03-08 12:23:30 +0000789 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
drh17eaae72008-03-03 18:47:28 +0000790 return rc;
drhb900aaf2006-11-09 00:24:53 +0000791}
792int sqlite3_prepare_v2(
793 sqlite3 *db, /* Database handle. */
794 const char *zSql, /* UTF-8 encoded SQL statement. */
795 int nBytes, /* Length of zSql in bytes. */
796 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
797 const char **pzTail /* OUT: End of parsed string */
798){
drh17eaae72008-03-03 18:47:28 +0000799 int rc;
800 rc = sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail);
drh58edb652008-03-08 12:23:30 +0000801 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
drh17eaae72008-03-03 18:47:28 +0000802 return rc;
drhb900aaf2006-11-09 00:24:53 +0000803}
804
805
danielk1977fa256a32005-05-25 04:11:56 +0000806#ifndef SQLITE_OMIT_UTF16
807/*
808** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
809*/
drhb900aaf2006-11-09 00:24:53 +0000810static int sqlite3Prepare16(
danielk1977fa256a32005-05-25 04:11:56 +0000811 sqlite3 *db, /* Database handle. */
812 const void *zSql, /* UTF-8 encoded SQL statement. */
813 int nBytes, /* Length of zSql in bytes. */
drhb900aaf2006-11-09 00:24:53 +0000814 int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
danielk1977fa256a32005-05-25 04:11:56 +0000815 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
816 const void **pzTail /* OUT: End of parsed string */
817){
818 /* This function currently works by first transforming the UTF-16
819 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
820 ** tricky bit is figuring out the pointer to return in *pzTail.
821 */
danielk197754f01982006-01-18 15:25:17 +0000822 char *zSql8;
danielk1977c87d34d2006-01-06 13:00:28 +0000823 const char *zTail8 = 0;
danielk197754f01982006-01-18 15:25:17 +0000824 int rc = SQLITE_OK;
danielk1977fa256a32005-05-25 04:11:56 +0000825
drh860e0772009-04-02 18:32:26 +0000826 assert( ppStmt );
drh769e97e2009-04-01 16:33:37 +0000827 *ppStmt = 0;
drh7e8b8482008-01-23 03:03:05 +0000828 if( !sqlite3SafetyCheckOk(db) ){
danielk1977fa256a32005-05-25 04:11:56 +0000829 return SQLITE_MISUSE;
830 }
drhb21c8cd2007-08-21 19:33:56 +0000831 sqlite3_mutex_enter(db->mutex);
danielk19771e536952007-08-16 10:09:01 +0000832 zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
danielk197754f01982006-01-18 15:25:17 +0000833 if( zSql8 ){
drhb1ab8ea2007-08-29 00:33:07 +0000834 rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
danielk1977fa256a32005-05-25 04:11:56 +0000835 }
danielk1977fa256a32005-05-25 04:11:56 +0000836
837 if( zTail8 && pzTail ){
838 /* If sqlite3_prepare returns a tail pointer, we calculate the
839 ** equivalent pointer into the UTF-16 string by counting the unicode
840 ** characters between zSql8 and zTail8, and then returning a pointer
841 ** the same number of characters into the UTF-16 string.
842 */
drhea678832008-12-10 19:26:22 +0000843 int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8));
drhee858132007-05-08 20:37:38 +0000844 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
danielk1977fa256a32005-05-25 04:11:56 +0000845 }
drh633e6d52008-07-28 19:34:53 +0000846 sqlite3DbFree(db, zSql8);
drhb21c8cd2007-08-21 19:33:56 +0000847 rc = sqlite3ApiExit(db, rc);
848 sqlite3_mutex_leave(db->mutex);
849 return rc;
danielk1977fa256a32005-05-25 04:11:56 +0000850}
drhb900aaf2006-11-09 00:24:53 +0000851
852/*
853** Two versions of the official API. Legacy and new use. In the legacy
854** version, the original SQL text is not saved in the prepared statement
855** and so if a schema change occurs, SQLITE_SCHEMA is returned by
856** sqlite3_step(). In the new version, the original SQL text is retained
857** and the statement is automatically recompiled if an schema change
858** occurs.
859*/
860int sqlite3_prepare16(
861 sqlite3 *db, /* Database handle. */
862 const void *zSql, /* UTF-8 encoded SQL statement. */
863 int nBytes, /* Length of zSql in bytes. */
864 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
865 const void **pzTail /* OUT: End of parsed string */
866){
drh17eaae72008-03-03 18:47:28 +0000867 int rc;
868 rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
drh58edb652008-03-08 12:23:30 +0000869 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
drh17eaae72008-03-03 18:47:28 +0000870 return rc;
drhb900aaf2006-11-09 00:24:53 +0000871}
872int sqlite3_prepare16_v2(
873 sqlite3 *db, /* Database handle. */
874 const void *zSql, /* UTF-8 encoded SQL statement. */
875 int nBytes, /* Length of zSql in bytes. */
876 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
877 const void **pzTail /* OUT: End of parsed string */
878){
drh17eaae72008-03-03 18:47:28 +0000879 int rc;
880 rc = sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
drh58edb652008-03-08 12:23:30 +0000881 assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */
drh17eaae72008-03-03 18:47:28 +0000882 return rc;
drhb900aaf2006-11-09 00:24:53 +0000883}
884
danielk1977fa256a32005-05-25 04:11:56 +0000885#endif /* SQLITE_OMIT_UTF16 */