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 | char **azObj, /* Type and name of object being parsed */ |
25 | const char * /* Error information */ |
26 | ){ |
27 | sqlite3 *db = pData->db; |
28 | if( db->mallocFailed ){ |
29 | pData->rc = SQLITE_NOMEM_BKPT; |
30 | }else if( pData->pzErrMsg[0]!=0 ){ |
31 | /* A error message has already been generated. Do not overwrite it */ |
32 | }else if( pData->mInitFlags & (INITFLAG_AlterMask) ){ |
33 | static const char *azAlterType[] = { |
34 | "rename" , |
35 | "drop column" , |
36 | "add column" |
37 | }; |
38 | *pData->pzErrMsg = sqlite3MPrintf(db, |
39 | "error in %s %s after %s: %s" , azObj[0], azObj[1], |
40 | azAlterType[(pData->mInitFlags&INITFLAG_AlterMask)-1], |
41 | zExtra |
42 | ); |
43 | pData->rc = SQLITE_ERROR; |
44 | }else if( db->flags & SQLITE_WriteSchema ){ |
45 | pData->rc = SQLITE_CORRUPT_BKPT; |
46 | }else{ |
47 | char *z; |
48 | const char *zObj = azObj[1] ? azObj[1] : "?" ; |
49 | z = sqlite3MPrintf(db, "malformed database schema (%s)" , zObj); |
50 | if( zExtra && zExtra[0] ) z = sqlite3MPrintf(db, "%z - %s" , z, zExtra); |
51 | *pData->pzErrMsg = z; |
52 | pData->rc = SQLITE_CORRUPT_BKPT; |
53 | } |
54 | } |
55 | |
56 | /* |
57 | ** Check to see if any sibling index (another index on the same table) |
58 | ** of pIndex has the same root page number, and if it does, return true. |
59 | ** This would indicate a corrupt schema. |
60 | */ |
61 | int sqlite3IndexHasDuplicateRootPage(Index *pIndex){ |
62 | Index *p; |
63 | for(p=pIndex->pTable->pIndex; p; p=p->pNext){ |
64 | if( p->tnum==pIndex->tnum && p!=pIndex ) return 1; |
65 | } |
66 | return 0; |
67 | } |
68 | |
69 | /* forward declaration */ |
70 | static int sqlite3Prepare( |
71 | sqlite3 *db, /* Database handle. */ |
72 | const char *zSql, /* UTF-8 encoded SQL statement. */ |
73 | int nBytes, /* Length of zSql in bytes. */ |
74 | u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ |
75 | Vdbe *pReprepare, /* VM being reprepared */ |
76 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
77 | const char **pzTail /* OUT: End of parsed string */ |
78 | ); |
79 | |
80 | |
81 | /* |
82 | ** This is the callback routine for the code that initializes the |
83 | ** database. See sqlite3Init() below for additional information. |
84 | ** This routine is also called from the OP_ParseSchema opcode of the VDBE. |
85 | ** |
86 | ** Each callback contains the following information: |
87 | ** |
88 | ** argv[0] = type of object: "table", "index", "trigger", or "view". |
89 | ** argv[1] = name of thing being created |
90 | ** argv[2] = associated table if an index or trigger |
91 | ** argv[3] = root page number for table or index. 0 for trigger or view. |
92 | ** argv[4] = SQL text for the CREATE statement. |
93 | ** |
94 | */ |
95 | int sqlite3InitCallback(void *pInit, int argc, char **argv, char **NotUsed){ |
96 | InitData *pData = (InitData*)pInit; |
97 | sqlite3 *db = pData->db; |
98 | int iDb = pData->iDb; |
99 | |
100 | assert( argc==5 ); |
101 | UNUSED_PARAMETER2(NotUsed, argc); |
102 | assert( sqlite3_mutex_held(db->mutex) ); |
103 | db->mDbFlags |= DBFLAG_EncodingFixed; |
104 | if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */ |
105 | pData->nInitRow++; |
106 | if( db->mallocFailed ){ |
107 | corruptSchema(pData, argv, 0); |
108 | return 1; |
109 | } |
110 | |
111 | assert( iDb>=0 && iDb<db->nDb ); |
112 | if( argv[3]==0 ){ |
113 | corruptSchema(pData, argv, 0); |
114 | }else if( argv[4] |
115 | && 'c'==sqlite3UpperToLower[(unsigned char)argv[4][0]] |
116 | && 'r'==sqlite3UpperToLower[(unsigned char)argv[4][1]] ){ |
117 | /* Call the parser to process a CREATE TABLE, INDEX or VIEW. |
118 | ** But because db->init.busy is set to 1, no VDBE code is generated |
119 | ** or executed. All the parser does is build the internal data |
120 | ** structures that describe the table, index, or view. |
121 | ** |
122 | ** No other valid SQL statement, other than the variable CREATE statements, |
123 | ** can begin with the letters "C" and "R". Thus, it is not possible run |
124 | ** any other kind of statement while parsing the schema, even a corrupt |
125 | ** schema. |
126 | */ |
127 | int rc; |
128 | u8 saved_iDb = db->init.iDb; |
129 | sqlite3_stmt *pStmt; |
130 | TESTONLY(int rcp); /* Return code from sqlite3_prepare() */ |
131 | |
132 | assert( db->init.busy ); |
133 | db->init.iDb = iDb; |
134 | if( sqlite3GetUInt32(argv[3], &db->init.newTnum)==0 |
135 | || (db->init.newTnum>pData->mxPage && pData->mxPage>0) |
136 | ){ |
137 | if( sqlite3Config.bExtraSchemaChecks ){ |
138 | corruptSchema(pData, argv, "invalid rootpage" ); |
139 | } |
140 | } |
141 | db->init.orphanTrigger = 0; |
142 | db->init.azInit = (const char**)argv; |
143 | pStmt = 0; |
144 | TESTONLY(rcp = ) sqlite3Prepare(db, argv[4], -1, 0, 0, &pStmt, 0); |
145 | rc = db->errCode; |
146 | assert( (rc&0xFF)==(rcp&0xFF) ); |
147 | db->init.iDb = saved_iDb; |
148 | /* assert( saved_iDb==0 || (db->mDbFlags & DBFLAG_Vacuum)!=0 ); */ |
149 | if( SQLITE_OK!=rc ){ |
150 | if( db->init.orphanTrigger ){ |
151 | assert( iDb==1 ); |
152 | }else{ |
153 | if( rc > pData->rc ) pData->rc = rc; |
154 | if( rc==SQLITE_NOMEM ){ |
155 | sqlite3OomFault(db); |
156 | }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){ |
157 | corruptSchema(pData, argv, sqlite3_errmsg(db)); |
158 | } |
159 | } |
160 | } |
161 | db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */ |
162 | sqlite3_finalize(pStmt); |
163 | }else if( argv[1]==0 || (argv[4]!=0 && argv[4][0]!=0) ){ |
164 | corruptSchema(pData, argv, 0); |
165 | }else{ |
166 | /* If the SQL column is blank it means this is an index that |
167 | ** was created to be the PRIMARY KEY or to fulfill a UNIQUE |
168 | ** constraint for a CREATE TABLE. The index should have already |
169 | ** been created when we processed the CREATE TABLE. All we have |
170 | ** to do here is record the root page number for that index. |
171 | */ |
172 | Index *pIndex; |
173 | pIndex = sqlite3FindIndex(db, argv[1], db->aDb[iDb].zDbSName); |
174 | if( pIndex==0 ){ |
175 | corruptSchema(pData, argv, "orphan index" ); |
176 | }else |
177 | if( sqlite3GetUInt32(argv[3],&pIndex->tnum)==0 |
178 | || pIndex->tnum<2 |
179 | || pIndex->tnum>pData->mxPage |
180 | || sqlite3IndexHasDuplicateRootPage(pIndex) |
181 | ){ |
182 | if( sqlite3Config.bExtraSchemaChecks ){ |
183 | corruptSchema(pData, argv, "invalid rootpage" ); |
184 | } |
185 | } |
186 | } |
187 | return 0; |
188 | } |
189 | |
190 | /* |
191 | ** Attempt to read the database schema and initialize internal |
192 | ** data structures for a single database file. The index of the |
193 | ** database file is given by iDb. iDb==0 is used for the main |
194 | ** database. iDb==1 should never be used. iDb>=2 is used for |
195 | ** auxiliary databases. Return one of the SQLITE_ error codes to |
196 | ** indicate success or failure. |
197 | */ |
198 | int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg, u32 mFlags){ |
199 | int rc; |
200 | int i; |
201 | #ifndef SQLITE_OMIT_DEPRECATED |
202 | int size; |
203 | #endif |
204 | Db *pDb; |
205 | char const *azArg[6]; |
206 | int meta[5]; |
207 | InitData initData; |
208 | const char *zSchemaTabName; |
209 | int openedTransaction = 0; |
210 | int mask = ((db->mDbFlags & DBFLAG_EncodingFixed) | ~DBFLAG_EncodingFixed); |
211 | |
212 | assert( (db->mDbFlags & DBFLAG_SchemaKnownOk)==0 ); |
213 | assert( iDb>=0 && iDb<db->nDb ); |
214 | assert( db->aDb[iDb].pSchema ); |
215 | assert( sqlite3_mutex_held(db->mutex) ); |
216 | assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); |
217 | |
218 | db->init.busy = 1; |
219 | |
220 | /* Construct the in-memory representation schema tables (sqlite_schema or |
221 | ** sqlite_temp_schema) by invoking the parser directly. The appropriate |
222 | ** table name will be inserted automatically by the parser so we can just |
223 | ** use the abbreviation "x" here. The parser will also automatically tag |
224 | ** the schema table as read-only. */ |
225 | azArg[0] = "table" ; |
226 | azArg[1] = zSchemaTabName = SCHEMA_TABLE(iDb); |
227 | azArg[2] = azArg[1]; |
228 | azArg[3] = "1" ; |
229 | azArg[4] = "CREATE TABLE x(type text,name text,tbl_name text," |
230 | "rootpage int,sql text)" ; |
231 | azArg[5] = 0; |
232 | initData.db = db; |
233 | initData.iDb = iDb; |
234 | initData.rc = SQLITE_OK; |
235 | initData.pzErrMsg = pzErrMsg; |
236 | initData.mInitFlags = mFlags; |
237 | initData.nInitRow = 0; |
238 | initData.mxPage = 0; |
239 | sqlite3InitCallback(&initData, 5, (char **)azArg, 0); |
240 | db->mDbFlags &= mask; |
241 | if( initData.rc ){ |
242 | rc = initData.rc; |
243 | goto error_out; |
244 | } |
245 | |
246 | /* Create a cursor to hold the database open |
247 | */ |
248 | pDb = &db->aDb[iDb]; |
249 | if( pDb->pBt==0 ){ |
250 | assert( iDb==1 ); |
251 | DbSetProperty(db, 1, DB_SchemaLoaded); |
252 | rc = SQLITE_OK; |
253 | goto error_out; |
254 | } |
255 | |
256 | /* If there is not already a read-only (or read-write) transaction opened |
257 | ** on the b-tree database, open one now. If a transaction is opened, it |
258 | ** will be closed before this function returns. */ |
259 | sqlite3BtreeEnter(pDb->pBt); |
260 | if( sqlite3BtreeTxnState(pDb->pBt)==SQLITE_TXN_NONE ){ |
261 | rc = sqlite3BtreeBeginTrans(pDb->pBt, 0, 0); |
262 | if( rc!=SQLITE_OK ){ |
263 | sqlite3SetString(pzErrMsg, db, sqlite3ErrStr(rc)); |
264 | goto initone_error_out; |
265 | } |
266 | openedTransaction = 1; |
267 | } |
268 | |
269 | /* Get the database meta information. |
270 | ** |
271 | ** Meta values are as follows: |
272 | ** meta[0] Schema cookie. Changes with each schema change. |
273 | ** meta[1] File format of schema layer. |
274 | ** meta[2] Size of the page cache. |
275 | ** meta[3] Largest rootpage (auto/incr_vacuum mode) |
276 | ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE |
277 | ** meta[5] User version |
278 | ** meta[6] Incremental vacuum mode |
279 | ** meta[7] unused |
280 | ** meta[8] unused |
281 | ** meta[9] unused |
282 | ** |
283 | ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to |
284 | ** the possible values of meta[4]. |
285 | */ |
286 | for(i=0; i<ArraySize(meta); i++){ |
287 | sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]); |
288 | } |
289 | if( (db->flags & SQLITE_ResetDatabase)!=0 ){ |
290 | memset(meta, 0, sizeof(meta)); |
291 | } |
292 | pDb->pSchema->schema_cookie = meta[BTREE_SCHEMA_VERSION-1]; |
293 | |
294 | /* If opening a non-empty database, check the text encoding. For the |
295 | ** main database, set sqlite3.enc to the encoding of the main database. |
296 | ** For an attached db, it is an error if the encoding is not the same |
297 | ** as sqlite3.enc. |
298 | */ |
299 | if( meta[BTREE_TEXT_ENCODING-1] ){ /* text encoding */ |
300 | if( iDb==0 && (db->mDbFlags & DBFLAG_EncodingFixed)==0 ){ |
301 | u8 encoding; |
302 | #ifndef SQLITE_OMIT_UTF16 |
303 | /* If opening the main database, set ENC(db). */ |
304 | encoding = (u8)meta[BTREE_TEXT_ENCODING-1] & 3; |
305 | if( encoding==0 ) encoding = SQLITE_UTF8; |
306 | #else |
307 | encoding = SQLITE_UTF8; |
308 | #endif |
309 | sqlite3SetTextEncoding(db, encoding); |
310 | }else{ |
311 | /* If opening an attached database, the encoding much match ENC(db) */ |
312 | if( (meta[BTREE_TEXT_ENCODING-1] & 3)!=ENC(db) ){ |
313 | sqlite3SetString(pzErrMsg, db, "attached databases must use the same" |
314 | " text encoding as main database" ); |
315 | rc = SQLITE_ERROR; |
316 | goto initone_error_out; |
317 | } |
318 | } |
319 | } |
320 | pDb->pSchema->enc = ENC(db); |
321 | |
322 | if( pDb->pSchema->cache_size==0 ){ |
323 | #ifndef SQLITE_OMIT_DEPRECATED |
324 | size = sqlite3AbsInt32(meta[BTREE_DEFAULT_CACHE_SIZE-1]); |
325 | if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; } |
326 | pDb->pSchema->cache_size = size; |
327 | #else |
328 | pDb->pSchema->cache_size = SQLITE_DEFAULT_CACHE_SIZE; |
329 | #endif |
330 | sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size); |
331 | } |
332 | |
333 | /* |
334 | ** file_format==1 Version 3.0.0. |
335 | ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN |
336 | ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults |
337 | ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants |
338 | */ |
339 | pDb->pSchema->file_format = (u8)meta[BTREE_FILE_FORMAT-1]; |
340 | if( pDb->pSchema->file_format==0 ){ |
341 | pDb->pSchema->file_format = 1; |
342 | } |
343 | if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){ |
344 | sqlite3SetString(pzErrMsg, db, "unsupported file format" ); |
345 | rc = SQLITE_ERROR; |
346 | goto initone_error_out; |
347 | } |
348 | |
349 | /* Ticket #2804: When we open a database in the newer file format, |
350 | ** clear the legacy_file_format pragma flag so that a VACUUM will |
351 | ** not downgrade the database and thus invalidate any descending |
352 | ** indices that the user might have created. |
353 | */ |
354 | if( iDb==0 && meta[BTREE_FILE_FORMAT-1]>=4 ){ |
355 | db->flags &= ~(u64)SQLITE_LegacyFileFmt; |
356 | } |
357 | |
358 | /* Read the schema information out of the schema tables |
359 | */ |
360 | assert( db->init.busy ); |
361 | initData.mxPage = sqlite3BtreeLastPage(pDb->pBt); |
362 | { |
363 | char *zSql; |
364 | zSql = sqlite3MPrintf(db, |
365 | "SELECT*FROM\"%w\".%s ORDER BY rowid" , |
366 | db->aDb[iDb].zDbSName, zSchemaTabName); |
367 | #ifndef SQLITE_OMIT_AUTHORIZATION |
368 | { |
369 | sqlite3_xauth xAuth; |
370 | xAuth = db->xAuth; |
371 | db->xAuth = 0; |
372 | #endif |
373 | rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); |
374 | #ifndef SQLITE_OMIT_AUTHORIZATION |
375 | db->xAuth = xAuth; |
376 | } |
377 | #endif |
378 | if( rc==SQLITE_OK ) rc = initData.rc; |
379 | sqlite3DbFree(db, zSql); |
380 | #ifndef SQLITE_OMIT_ANALYZE |
381 | if( rc==SQLITE_OK ){ |
382 | sqlite3AnalysisLoad(db, iDb); |
383 | } |
384 | #endif |
385 | } |
386 | assert( pDb == &(db->aDb[iDb]) ); |
387 | if( db->mallocFailed ){ |
388 | rc = SQLITE_NOMEM_BKPT; |
389 | sqlite3ResetAllSchemasOfConnection(db); |
390 | pDb = &db->aDb[iDb]; |
391 | }else |
392 | if( rc==SQLITE_OK || ((db->flags&SQLITE_NoSchemaError) && rc!=SQLITE_NOMEM)){ |
393 | /* Hack: If the SQLITE_NoSchemaError flag is set, then consider |
394 | ** the schema loaded, even if errors (other than OOM) occurred. In |
395 | ** this situation the current sqlite3_prepare() operation will fail, |
396 | ** but the following one will attempt to compile the supplied statement |
397 | ** against whatever subset of the schema was loaded before the error |
398 | ** occurred. |
399 | ** |
400 | ** The primary purpose of this is to allow access to the sqlite_schema |
401 | ** table even when its contents have been corrupted. |
402 | */ |
403 | DbSetProperty(db, iDb, DB_SchemaLoaded); |
404 | rc = SQLITE_OK; |
405 | } |
406 | |
407 | /* Jump here for an error that occurs after successfully allocating |
408 | ** curMain and calling sqlite3BtreeEnter(). For an error that occurs |
409 | ** before that point, jump to error_out. |
410 | */ |
411 | initone_error_out: |
412 | if( openedTransaction ){ |
413 | sqlite3BtreeCommit(pDb->pBt); |
414 | } |
415 | sqlite3BtreeLeave(pDb->pBt); |
416 | |
417 | error_out: |
418 | if( rc ){ |
419 | if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ |
420 | sqlite3OomFault(db); |
421 | } |
422 | sqlite3ResetOneSchema(db, iDb); |
423 | } |
424 | db->init.busy = 0; |
425 | return rc; |
426 | } |
427 | |
428 | /* |
429 | ** Initialize all database files - the main database file, the file |
430 | ** used to store temporary tables, and any additional database files |
431 | ** created using ATTACH statements. Return a success code. If an |
432 | ** error occurs, write an error message into *pzErrMsg. |
433 | ** |
434 | ** After a database is initialized, the DB_SchemaLoaded bit is set |
435 | ** bit is set in the flags field of the Db structure. |
436 | */ |
437 | int sqlite3Init(sqlite3 *db, char **pzErrMsg){ |
438 | int i, rc; |
439 | int commit_internal = !(db->mDbFlags&DBFLAG_SchemaChange); |
440 | |
441 | assert( sqlite3_mutex_held(db->mutex) ); |
442 | assert( sqlite3BtreeHoldsMutex(db->aDb[0].pBt) ); |
443 | assert( db->init.busy==0 ); |
444 | ENC(db) = SCHEMA_ENC(db); |
445 | assert( db->nDb>0 ); |
446 | /* Do the main schema first */ |
447 | if( !DbHasProperty(db, 0, DB_SchemaLoaded) ){ |
448 | rc = sqlite3InitOne(db, 0, pzErrMsg, 0); |
449 | if( rc ) return rc; |
450 | } |
451 | /* All other schemas after the main schema. The "temp" schema must be last */ |
452 | for(i=db->nDb-1; i>0; i--){ |
453 | assert( i==1 || sqlite3BtreeHoldsMutex(db->aDb[i].pBt) ); |
454 | if( !DbHasProperty(db, i, DB_SchemaLoaded) ){ |
455 | rc = sqlite3InitOne(db, i, pzErrMsg, 0); |
456 | if( rc ) return rc; |
457 | } |
458 | } |
459 | if( commit_internal ){ |
460 | sqlite3CommitInternalChanges(db); |
461 | } |
462 | return SQLITE_OK; |
463 | } |
464 | |
465 | /* |
466 | ** This routine is a no-op if the database schema is already initialized. |
467 | ** Otherwise, the schema is loaded. An error code is returned. |
468 | */ |
469 | int sqlite3ReadSchema(Parse *pParse){ |
470 | int rc = SQLITE_OK; |
471 | sqlite3 *db = pParse->db; |
472 | assert( sqlite3_mutex_held(db->mutex) ); |
473 | if( !db->init.busy ){ |
474 | rc = sqlite3Init(db, &pParse->zErrMsg); |
475 | if( rc!=SQLITE_OK ){ |
476 | pParse->rc = rc; |
477 | pParse->nErr++; |
478 | }else if( db->noSharedCache ){ |
479 | db->mDbFlags |= DBFLAG_SchemaKnownOk; |
480 | } |
481 | } |
482 | return rc; |
483 | } |
484 | |
485 | |
486 | /* |
487 | ** Check schema cookies in all databases. If any cookie is out |
488 | ** of date set pParse->rc to SQLITE_SCHEMA. If all schema cookies |
489 | ** make no changes to pParse->rc. |
490 | */ |
491 | static void schemaIsValid(Parse *pParse){ |
492 | sqlite3 *db = pParse->db; |
493 | int iDb; |
494 | int rc; |
495 | int cookie; |
496 | |
497 | assert( pParse->checkSchema ); |
498 | assert( sqlite3_mutex_held(db->mutex) ); |
499 | for(iDb=0; iDb<db->nDb; iDb++){ |
500 | int openedTransaction = 0; /* True if a transaction is opened */ |
501 | Btree *pBt = db->aDb[iDb].pBt; /* Btree database to read cookie from */ |
502 | if( pBt==0 ) continue; |
503 | |
504 | /* If there is not already a read-only (or read-write) transaction opened |
505 | ** on the b-tree database, open one now. If a transaction is opened, it |
506 | ** will be closed immediately after reading the meta-value. */ |
507 | if( sqlite3BtreeTxnState(pBt)==SQLITE_TXN_NONE ){ |
508 | rc = sqlite3BtreeBeginTrans(pBt, 0, 0); |
509 | if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){ |
510 | sqlite3OomFault(db); |
511 | pParse->rc = SQLITE_NOMEM; |
512 | } |
513 | if( rc!=SQLITE_OK ) return; |
514 | openedTransaction = 1; |
515 | } |
516 | |
517 | /* Read the schema cookie from the database. If it does not match the |
518 | ** value stored as part of the in-memory schema representation, |
519 | ** set Parse.rc to SQLITE_SCHEMA. */ |
520 | sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&cookie); |
521 | assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
522 | if( cookie!=db->aDb[iDb].pSchema->schema_cookie ){ |
523 | sqlite3ResetOneSchema(db, iDb); |
524 | pParse->rc = SQLITE_SCHEMA; |
525 | } |
526 | |
527 | /* Close the transaction, if one was opened. */ |
528 | if( openedTransaction ){ |
529 | sqlite3BtreeCommit(pBt); |
530 | } |
531 | } |
532 | } |
533 | |
534 | /* |
535 | ** Convert a schema pointer into the iDb index that indicates |
536 | ** which database file in db->aDb[] the schema refers to. |
537 | ** |
538 | ** If the same database is attached more than once, the first |
539 | ** attached database is returned. |
540 | */ |
541 | int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){ |
542 | int i = -32768; |
543 | |
544 | /* If pSchema is NULL, then return -32768. This happens when code in |
545 | ** expr.c is trying to resolve a reference to a transient table (i.e. one |
546 | ** created by a sub-select). In this case the return value of this |
547 | ** function should never be used. |
548 | ** |
549 | ** We return -32768 instead of the more usual -1 simply because using |
550 | ** -32768 as the incorrect index into db->aDb[] is much |
551 | ** more likely to cause a segfault than -1 (of course there are assert() |
552 | ** statements too, but it never hurts to play the odds) and |
553 | ** -32768 will still fit into a 16-bit signed integer. |
554 | */ |
555 | assert( sqlite3_mutex_held(db->mutex) ); |
556 | if( pSchema ){ |
557 | for(i=0; 1; i++){ |
558 | assert( i<db->nDb ); |
559 | if( db->aDb[i].pSchema==pSchema ){ |
560 | break; |
561 | } |
562 | } |
563 | assert( i>=0 && i<db->nDb ); |
564 | } |
565 | return i; |
566 | } |
567 | |
568 | /* |
569 | ** Free all memory allocations in the pParse object |
570 | */ |
571 | void sqlite3ParseObjectReset(Parse *pParse){ |
572 | sqlite3 *db = pParse->db; |
573 | assert( db!=0 ); |
574 | assert( db->pParse==pParse ); |
575 | assert( pParse->nested==0 ); |
576 | #ifndef SQLITE_OMIT_SHARED_CACHE |
577 | if( pParse->aTableLock ) sqlite3DbNNFreeNN(db, pParse->aTableLock); |
578 | #endif |
579 | while( pParse->pCleanup ){ |
580 | ParseCleanup *pCleanup = pParse->pCleanup; |
581 | pParse->pCleanup = pCleanup->pNext; |
582 | pCleanup->xCleanup(db, pCleanup->pPtr); |
583 | sqlite3DbNNFreeNN(db, pCleanup); |
584 | } |
585 | if( pParse->aLabel ) sqlite3DbNNFreeNN(db, pParse->aLabel); |
586 | if( pParse->pConstExpr ){ |
587 | sqlite3ExprListDelete(db, pParse->pConstExpr); |
588 | } |
589 | assert( db->lookaside.bDisable >= pParse->disableLookaside ); |
590 | db->lookaside.bDisable -= pParse->disableLookaside; |
591 | db->lookaside.sz = db->lookaside.bDisable ? 0 : db->lookaside.szTrue; |
592 | assert( pParse->db->pParse==pParse ); |
593 | db->pParse = pParse->pOuterParse; |
594 | pParse->db = 0; |
595 | pParse->disableLookaside = 0; |
596 | } |
597 | |
598 | /* |
599 | ** Add a new cleanup operation to a Parser. The cleanup should happen when |
600 | ** the parser object is destroyed. But, beware: the cleanup might happen |
601 | ** immediately. |
602 | ** |
603 | ** Use this mechanism for uncommon cleanups. There is a higher setup |
604 | ** cost for this mechansim (an extra malloc), so it should not be used |
605 | ** for common cleanups that happen on most calls. But for less |
606 | ** common cleanups, we save a single NULL-pointer comparison in |
607 | ** sqlite3ParseObjectReset(), which reduces the total CPU cycle count. |
608 | ** |
609 | ** If a memory allocation error occurs, then the cleanup happens immediately. |
610 | ** When either SQLITE_DEBUG or SQLITE_COVERAGE_TEST are defined, the |
611 | ** pParse->earlyCleanup flag is set in that case. Calling code show verify |
612 | ** that test cases exist for which this happens, to guard against possible |
613 | ** use-after-free errors following an OOM. The preferred way to do this is |
614 | ** to immediately follow the call to this routine with: |
615 | ** |
616 | ** testcase( pParse->earlyCleanup ); |
617 | ** |
618 | ** This routine returns a copy of its pPtr input (the third parameter) |
619 | ** except if an early cleanup occurs, in which case it returns NULL. So |
620 | ** another way to check for early cleanup is to check the return value. |
621 | ** Or, stop using the pPtr parameter with this call and use only its |
622 | ** return value thereafter. Something like this: |
623 | ** |
624 | ** pObj = sqlite3ParserAddCleanup(pParse, destructor, pObj); |
625 | */ |
626 | void *sqlite3ParserAddCleanup( |
627 | Parse *pParse, /* Destroy when this Parser finishes */ |
628 | void (*xCleanup)(sqlite3*,void*), /* The cleanup routine */ |
629 | void *pPtr /* Pointer to object to be cleaned up */ |
630 | ){ |
631 | ParseCleanup *pCleanup = sqlite3DbMallocRaw(pParse->db, sizeof(*pCleanup)); |
632 | if( pCleanup ){ |
633 | pCleanup->pNext = pParse->pCleanup; |
634 | pParse->pCleanup = pCleanup; |
635 | pCleanup->pPtr = pPtr; |
636 | pCleanup->xCleanup = xCleanup; |
637 | }else{ |
638 | xCleanup(pParse->db, pPtr); |
639 | pPtr = 0; |
640 | #if defined(SQLITE_DEBUG) || defined(SQLITE_COVERAGE_TEST) |
641 | pParse->earlyCleanup = 1; |
642 | #endif |
643 | } |
644 | return pPtr; |
645 | } |
646 | |
647 | /* |
648 | ** Turn bulk memory into a valid Parse object and link that Parse object |
649 | ** into database connection db. |
650 | ** |
651 | ** Call sqlite3ParseObjectReset() to undo this operation. |
652 | ** |
653 | ** Caution: Do not confuse this routine with sqlite3ParseObjectInit() which |
654 | ** is generated by Lemon. |
655 | */ |
656 | void sqlite3ParseObjectInit(Parse *pParse, sqlite3 *db){ |
657 | memset(PARSE_HDR(pParse), 0, PARSE_HDR_SZ); |
658 | memset(PARSE_TAIL(pParse), 0, PARSE_TAIL_SZ); |
659 | assert( db->pParse!=pParse ); |
660 | pParse->pOuterParse = db->pParse; |
661 | db->pParse = pParse; |
662 | pParse->db = db; |
663 | if( db->mallocFailed ) sqlite3ErrorMsg(pParse, "out of memory" ); |
664 | } |
665 | |
666 | /* |
667 | ** Maximum number of times that we will try again to prepare a statement |
668 | ** that returns SQLITE_ERROR_RETRY. |
669 | */ |
670 | #ifndef SQLITE_MAX_PREPARE_RETRY |
671 | # define SQLITE_MAX_PREPARE_RETRY 25 |
672 | #endif |
673 | |
674 | /* |
675 | ** Compile the UTF-8 encoded SQL statement zSql into a statement handle. |
676 | */ |
677 | static int sqlite3Prepare( |
678 | sqlite3 *db, /* Database handle. */ |
679 | const char *zSql, /* UTF-8 encoded SQL statement. */ |
680 | int nBytes, /* Length of zSql in bytes. */ |
681 | u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ |
682 | Vdbe *pReprepare, /* VM being reprepared */ |
683 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
684 | const char **pzTail /* OUT: End of parsed string */ |
685 | ){ |
686 | int rc = SQLITE_OK; /* Result code */ |
687 | int i; /* Loop counter */ |
688 | Parse sParse; /* Parsing context */ |
689 | |
690 | /* sqlite3ParseObjectInit(&sParse, db); // inlined for performance */ |
691 | memset(PARSE_HDR(&sParse), 0, PARSE_HDR_SZ); |
692 | memset(PARSE_TAIL(&sParse), 0, PARSE_TAIL_SZ); |
693 | sParse.pOuterParse = db->pParse; |
694 | db->pParse = &sParse; |
695 | sParse.db = db; |
696 | sParse.pReprepare = pReprepare; |
697 | assert( ppStmt && *ppStmt==0 ); |
698 | if( db->mallocFailed ) sqlite3ErrorMsg(&sParse, "out of memory" ); |
699 | assert( sqlite3_mutex_held(db->mutex) ); |
700 | |
701 | /* For a long-term use prepared statement avoid the use of |
702 | ** lookaside memory. |
703 | */ |
704 | if( prepFlags & SQLITE_PREPARE_PERSISTENT ){ |
705 | sParse.disableLookaside++; |
706 | DisableLookaside; |
707 | } |
708 | sParse.prepFlags = prepFlags & 0xff; |
709 | |
710 | /* Check to verify that it is possible to get a read lock on all |
711 | ** database schemas. The inability to get a read lock indicates that |
712 | ** some other database connection is holding a write-lock, which in |
713 | ** turn means that the other connection has made uncommitted changes |
714 | ** to the schema. |
715 | ** |
716 | ** Were we to proceed and prepare the statement against the uncommitted |
717 | ** schema changes and if those schema changes are subsequently rolled |
718 | ** back and different changes are made in their place, then when this |
719 | ** prepared statement goes to run the schema cookie would fail to detect |
720 | ** the schema change. Disaster would follow. |
721 | ** |
722 | ** This thread is currently holding mutexes on all Btrees (because |
723 | ** of the sqlite3BtreeEnterAll() in sqlite3LockAndPrepare()) so it |
724 | ** is not possible for another thread to start a new schema change |
725 | ** while this routine is running. Hence, we do not need to hold |
726 | ** locks on the schema, we just need to make sure nobody else is |
727 | ** holding them. |
728 | ** |
729 | ** Note that setting READ_UNCOMMITTED overrides most lock detection, |
730 | ** but it does *not* override schema lock detection, so this all still |
731 | ** works even if READ_UNCOMMITTED is set. |
732 | */ |
733 | if( !db->noSharedCache ){ |
734 | for(i=0; i<db->nDb; i++) { |
735 | Btree *pBt = db->aDb[i].pBt; |
736 | if( pBt ){ |
737 | assert( sqlite3BtreeHoldsMutex(pBt) ); |
738 | rc = sqlite3BtreeSchemaLocked(pBt); |
739 | if( rc ){ |
740 | const char *zDb = db->aDb[i].zDbSName; |
741 | sqlite3ErrorWithMsg(db, rc, "database schema is locked: %s" , zDb); |
742 | testcase( db->flags & SQLITE_ReadUncommit ); |
743 | goto end_prepare; |
744 | } |
745 | } |
746 | } |
747 | } |
748 | |
749 | #ifndef SQLITE_OMIT_VIRTUALTABLE |
750 | if( db->pDisconnect ) sqlite3VtabUnlockList(db); |
751 | #endif |
752 | |
753 | if( nBytes>=0 && (nBytes==0 || zSql[nBytes-1]!=0) ){ |
754 | char *zSqlCopy; |
755 | int mxLen = db->aLimit[SQLITE_LIMIT_SQL_LENGTH]; |
756 | testcase( nBytes==mxLen ); |
757 | testcase( nBytes==mxLen+1 ); |
758 | if( nBytes>mxLen ){ |
759 | sqlite3ErrorWithMsg(db, SQLITE_TOOBIG, "statement too long" ); |
760 | rc = sqlite3ApiExit(db, SQLITE_TOOBIG); |
761 | goto end_prepare; |
762 | } |
763 | zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes); |
764 | if( zSqlCopy ){ |
765 | sqlite3RunParser(&sParse, zSqlCopy); |
766 | sParse.zTail = &zSql[sParse.zTail-zSqlCopy]; |
767 | sqlite3DbFree(db, zSqlCopy); |
768 | }else{ |
769 | sParse.zTail = &zSql[nBytes]; |
770 | } |
771 | }else{ |
772 | sqlite3RunParser(&sParse, zSql); |
773 | } |
774 | assert( 0==sParse.nQueryLoop ); |
775 | |
776 | if( pzTail ){ |
777 | *pzTail = sParse.zTail; |
778 | } |
779 | |
780 | if( db->init.busy==0 ){ |
781 | sqlite3VdbeSetSql(sParse.pVdbe, zSql, (int)(sParse.zTail-zSql), prepFlags); |
782 | } |
783 | if( db->mallocFailed ){ |
784 | sParse.rc = SQLITE_NOMEM_BKPT; |
785 | sParse.checkSchema = 0; |
786 | } |
787 | if( sParse.rc!=SQLITE_OK && sParse.rc!=SQLITE_DONE ){ |
788 | if( sParse.checkSchema && db->init.busy==0 ){ |
789 | schemaIsValid(&sParse); |
790 | } |
791 | if( sParse.pVdbe ){ |
792 | sqlite3VdbeFinalize(sParse.pVdbe); |
793 | } |
794 | assert( 0==(*ppStmt) ); |
795 | rc = sParse.rc; |
796 | if( sParse.zErrMsg ){ |
797 | sqlite3ErrorWithMsg(db, rc, "%s" , sParse.zErrMsg); |
798 | sqlite3DbFree(db, sParse.zErrMsg); |
799 | }else{ |
800 | sqlite3Error(db, rc); |
801 | } |
802 | }else{ |
803 | assert( sParse.zErrMsg==0 ); |
804 | *ppStmt = (sqlite3_stmt*)sParse.pVdbe; |
805 | rc = SQLITE_OK; |
806 | sqlite3ErrorClear(db); |
807 | } |
808 | |
809 | |
810 | /* Delete any TriggerPrg structures allocated while parsing this statement. */ |
811 | while( sParse.pTriggerPrg ){ |
812 | TriggerPrg *pT = sParse.pTriggerPrg; |
813 | sParse.pTriggerPrg = pT->pNext; |
814 | sqlite3DbFree(db, pT); |
815 | } |
816 | |
817 | end_prepare: |
818 | |
819 | sqlite3ParseObjectReset(&sParse); |
820 | return rc; |
821 | } |
822 | static int sqlite3LockAndPrepare( |
823 | sqlite3 *db, /* Database handle. */ |
824 | const char *zSql, /* UTF-8 encoded SQL statement. */ |
825 | int nBytes, /* Length of zSql in bytes. */ |
826 | u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ |
827 | Vdbe *pOld, /* VM being reprepared */ |
828 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
829 | const char **pzTail /* OUT: End of parsed string */ |
830 | ){ |
831 | int rc; |
832 | int cnt = 0; |
833 | |
834 | #ifdef SQLITE_ENABLE_API_ARMOR |
835 | if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; |
836 | #endif |
837 | *ppStmt = 0; |
838 | if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ |
839 | return SQLITE_MISUSE_BKPT; |
840 | } |
841 | sqlite3_mutex_enter(db->mutex); |
842 | sqlite3BtreeEnterAll(db); |
843 | do{ |
844 | /* Make multiple attempts to compile the SQL, until it either succeeds |
845 | ** or encounters a permanent error. A schema problem after one schema |
846 | ** reset is considered a permanent error. */ |
847 | rc = sqlite3Prepare(db, zSql, nBytes, prepFlags, pOld, ppStmt, pzTail); |
848 | assert( rc==SQLITE_OK || *ppStmt==0 ); |
849 | if( rc==SQLITE_OK || db->mallocFailed ) break; |
850 | }while( (rc==SQLITE_ERROR_RETRY && (cnt++)<SQLITE_MAX_PREPARE_RETRY) |
851 | || (rc==SQLITE_SCHEMA && (sqlite3ResetOneSchema(db,-1), cnt++)==0) ); |
852 | sqlite3BtreeLeaveAll(db); |
853 | rc = sqlite3ApiExit(db, rc); |
854 | assert( (rc&db->errMask)==rc ); |
855 | db->busyHandler.nBusy = 0; |
856 | sqlite3_mutex_leave(db->mutex); |
857 | return rc; |
858 | } |
859 | |
860 | |
861 | /* |
862 | ** Rerun the compilation of a statement after a schema change. |
863 | ** |
864 | ** If the statement is successfully recompiled, return SQLITE_OK. Otherwise, |
865 | ** if the statement cannot be recompiled because another connection has |
866 | ** locked the sqlite3_schema table, return SQLITE_LOCKED. If any other error |
867 | ** occurs, return SQLITE_SCHEMA. |
868 | */ |
869 | int sqlite3Reprepare(Vdbe *p){ |
870 | int rc; |
871 | sqlite3_stmt *pNew; |
872 | const char *zSql; |
873 | sqlite3 *db; |
874 | u8 prepFlags; |
875 | |
876 | assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) ); |
877 | zSql = sqlite3_sql((sqlite3_stmt *)p); |
878 | assert( zSql!=0 ); /* Reprepare only called for prepare_v2() statements */ |
879 | db = sqlite3VdbeDb(p); |
880 | assert( sqlite3_mutex_held(db->mutex) ); |
881 | prepFlags = sqlite3VdbePrepareFlags(p); |
882 | rc = sqlite3LockAndPrepare(db, zSql, -1, prepFlags, p, &pNew, 0); |
883 | if( rc ){ |
884 | if( rc==SQLITE_NOMEM ){ |
885 | sqlite3OomFault(db); |
886 | } |
887 | assert( pNew==0 ); |
888 | return rc; |
889 | }else{ |
890 | assert( pNew!=0 ); |
891 | } |
892 | sqlite3VdbeSwap((Vdbe*)pNew, p); |
893 | sqlite3TransferBindings(pNew, (sqlite3_stmt*)p); |
894 | sqlite3VdbeResetStepResult((Vdbe*)pNew); |
895 | sqlite3VdbeFinalize((Vdbe*)pNew); |
896 | return SQLITE_OK; |
897 | } |
898 | |
899 | |
900 | /* |
901 | ** Two versions of the official API. Legacy and new use. In the legacy |
902 | ** version, the original SQL text is not saved in the prepared statement |
903 | ** and so if a schema change occurs, SQLITE_SCHEMA is returned by |
904 | ** sqlite3_step(). In the new version, the original SQL text is retained |
905 | ** and the statement is automatically recompiled if an schema change |
906 | ** occurs. |
907 | */ |
908 | int sqlite3_prepare( |
909 | sqlite3 *db, /* Database handle. */ |
910 | const char *zSql, /* UTF-8 encoded SQL statement. */ |
911 | int nBytes, /* Length of zSql in bytes. */ |
912 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
913 | const char **pzTail /* OUT: End of parsed string */ |
914 | ){ |
915 | int rc; |
916 | rc = sqlite3LockAndPrepare(db,zSql,nBytes,0,0,ppStmt,pzTail); |
917 | assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ |
918 | return rc; |
919 | } |
920 | int sqlite3_prepare_v2( |
921 | sqlite3 *db, /* Database handle. */ |
922 | const char *zSql, /* UTF-8 encoded SQL statement. */ |
923 | int nBytes, /* Length of zSql in bytes. */ |
924 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
925 | const char **pzTail /* OUT: End of parsed string */ |
926 | ){ |
927 | int rc; |
928 | /* EVIDENCE-OF: R-37923-12173 The sqlite3_prepare_v2() interface works |
929 | ** exactly the same as sqlite3_prepare_v3() with a zero prepFlags |
930 | ** parameter. |
931 | ** |
932 | ** Proof in that the 5th parameter to sqlite3LockAndPrepare is 0 */ |
933 | rc = sqlite3LockAndPrepare(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,0, |
934 | ppStmt,pzTail); |
935 | assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); |
936 | return rc; |
937 | } |
938 | int sqlite3_prepare_v3( |
939 | sqlite3 *db, /* Database handle. */ |
940 | const char *zSql, /* UTF-8 encoded SQL statement. */ |
941 | int nBytes, /* Length of zSql in bytes. */ |
942 | unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ |
943 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
944 | const char **pzTail /* OUT: End of parsed string */ |
945 | ){ |
946 | int rc; |
947 | /* EVIDENCE-OF: R-56861-42673 sqlite3_prepare_v3() differs from |
948 | ** sqlite3_prepare_v2() only in having the extra prepFlags parameter, |
949 | ** which is a bit array consisting of zero or more of the |
950 | ** SQLITE_PREPARE_* flags. |
951 | ** |
952 | ** Proof by comparison to the implementation of sqlite3_prepare_v2() |
953 | ** directly above. */ |
954 | rc = sqlite3LockAndPrepare(db,zSql,nBytes, |
955 | SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), |
956 | 0,ppStmt,pzTail); |
957 | assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); |
958 | return rc; |
959 | } |
960 | |
961 | |
962 | #ifndef SQLITE_OMIT_UTF16 |
963 | /* |
964 | ** Compile the UTF-16 encoded SQL statement zSql into a statement handle. |
965 | */ |
966 | static int sqlite3Prepare16( |
967 | sqlite3 *db, /* Database handle. */ |
968 | const void *zSql, /* UTF-16 encoded SQL statement. */ |
969 | int nBytes, /* Length of zSql in bytes. */ |
970 | u32 prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ |
971 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
972 | const void **pzTail /* OUT: End of parsed string */ |
973 | ){ |
974 | /* This function currently works by first transforming the UTF-16 |
975 | ** encoded string to UTF-8, then invoking sqlite3_prepare(). The |
976 | ** tricky bit is figuring out the pointer to return in *pzTail. |
977 | */ |
978 | char *zSql8; |
979 | const char *zTail8 = 0; |
980 | int rc = SQLITE_OK; |
981 | |
982 | #ifdef SQLITE_ENABLE_API_ARMOR |
983 | if( ppStmt==0 ) return SQLITE_MISUSE_BKPT; |
984 | #endif |
985 | *ppStmt = 0; |
986 | if( !sqlite3SafetyCheckOk(db)||zSql==0 ){ |
987 | return SQLITE_MISUSE_BKPT; |
988 | } |
989 | if( nBytes>=0 ){ |
990 | int sz; |
991 | const char *z = (const char*)zSql; |
992 | for(sz=0; sz<nBytes && (z[sz]!=0 || z[sz+1]!=0); sz += 2){} |
993 | nBytes = sz; |
994 | } |
995 | sqlite3_mutex_enter(db->mutex); |
996 | zSql8 = sqlite3Utf16to8(db, zSql, nBytes, SQLITE_UTF16NATIVE); |
997 | if( zSql8 ){ |
998 | rc = sqlite3LockAndPrepare(db, zSql8, -1, prepFlags, 0, ppStmt, &zTail8); |
999 | } |
1000 | |
1001 | if( zTail8 && pzTail ){ |
1002 | /* If sqlite3_prepare returns a tail pointer, we calculate the |
1003 | ** equivalent pointer into the UTF-16 string by counting the unicode |
1004 | ** characters between zSql8 and zTail8, and then returning a pointer |
1005 | ** the same number of characters into the UTF-16 string. |
1006 | */ |
1007 | int chars_parsed = sqlite3Utf8CharLen(zSql8, (int)(zTail8-zSql8)); |
1008 | *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed); |
1009 | } |
1010 | sqlite3DbFree(db, zSql8); |
1011 | rc = sqlite3ApiExit(db, rc); |
1012 | sqlite3_mutex_leave(db->mutex); |
1013 | return rc; |
1014 | } |
1015 | |
1016 | /* |
1017 | ** Two versions of the official API. Legacy and new use. In the legacy |
1018 | ** version, the original SQL text is not saved in the prepared statement |
1019 | ** and so if a schema change occurs, SQLITE_SCHEMA is returned by |
1020 | ** sqlite3_step(). In the new version, the original SQL text is retained |
1021 | ** and the statement is automatically recompiled if an schema change |
1022 | ** occurs. |
1023 | */ |
1024 | int sqlite3_prepare16( |
1025 | sqlite3 *db, /* Database handle. */ |
1026 | const void *zSql, /* UTF-16 encoded SQL statement. */ |
1027 | int nBytes, /* Length of zSql in bytes. */ |
1028 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
1029 | const void **pzTail /* OUT: End of parsed string */ |
1030 | ){ |
1031 | int rc; |
1032 | rc = sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail); |
1033 | assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ |
1034 | return rc; |
1035 | } |
1036 | int sqlite3_prepare16_v2( |
1037 | sqlite3 *db, /* Database handle. */ |
1038 | const void *zSql, /* UTF-16 encoded SQL statement. */ |
1039 | int nBytes, /* Length of zSql in bytes. */ |
1040 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
1041 | const void **pzTail /* OUT: End of parsed string */ |
1042 | ){ |
1043 | int rc; |
1044 | rc = sqlite3Prepare16(db,zSql,nBytes,SQLITE_PREPARE_SAVESQL,ppStmt,pzTail); |
1045 | assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ |
1046 | return rc; |
1047 | } |
1048 | int sqlite3_prepare16_v3( |
1049 | sqlite3 *db, /* Database handle. */ |
1050 | const void *zSql, /* UTF-16 encoded SQL statement. */ |
1051 | int nBytes, /* Length of zSql in bytes. */ |
1052 | unsigned int prepFlags, /* Zero or more SQLITE_PREPARE_* flags */ |
1053 | sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */ |
1054 | const void **pzTail /* OUT: End of parsed string */ |
1055 | ){ |
1056 | int rc; |
1057 | rc = sqlite3Prepare16(db,zSql,nBytes, |
1058 | SQLITE_PREPARE_SAVESQL|(prepFlags&SQLITE_PREPARE_MASK), |
1059 | ppStmt,pzTail); |
1060 | assert( rc==SQLITE_OK || ppStmt==0 || *ppStmt==0 ); /* VERIFY: F13021 */ |
1061 | return rc; |
1062 | } |
1063 | |
1064 | #endif /* SQLITE_OMIT_UTF16 */ |
1065 | |