aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/libraries/sqlite/win32/prepare.c
diff options
context:
space:
mode:
Diffstat (limited to '')
-rwxr-xr-xlibraries/sqlite/win32/prepare.c742
1 files changed, 0 insertions, 742 deletions
diff --git a/libraries/sqlite/win32/prepare.c b/libraries/sqlite/win32/prepare.c
deleted file mode 100755
index a1a0a40..0000000
--- a/libraries/sqlite/win32/prepare.c
+++ /dev/null
@@ -1,742 +0,0 @@
1/*
2** 2005 May 25
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12** This file contains the implementation of the sqlite3_prepare()
13** interface, and routines that contribute to loading the database schema
14** from disk.
15**
16** $Id: prepare.c,v 1.61 2007/10/03 08:46:45 danielk1977 Exp $
17*/
18#include "sqliteInt.h"
19#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){
26 if( !pData->db->mallocFailed ){
27 sqlite3SetString(pData->pzErrMsg, "malformed database schema",
28 zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0);
29 }
30 pData->rc = SQLITE_CORRUPT;
31}
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
41** argv[1] = root page number for table or index. 0 for trigger or view.
42** argv[2] = SQL text for the CREATE statement.
43**
44*/
45int sqlite3InitCallback(void *pInit, int argc, char **argv, char **azColName){
46 InitData *pData = (InitData*)pInit;
47 sqlite3 *db = pData->db;
48 int iDb = pData->iDb;
49
50 assert( sqlite3_mutex_held(db->mutex) );
51 pData->rc = SQLITE_OK;
52 DbClearProperty(db, iDb, DB_Empty);
53 if( db->mallocFailed ){
54 corruptSchema(pData, 0);
55 return SQLITE_NOMEM;
56 }
57
58 assert( argc==3 );
59 if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
60 if( argv[1]==0 ){
61 corruptSchema(pData, 0);
62 return 1;
63 }
64 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;
78 assert( rc!=SQLITE_OK || zErr==0 );
79 if( SQLITE_OK!=rc ){
80 pData->rc = rc;
81 if( rc==SQLITE_NOMEM ){
82 db->mallocFailed = 1;
83 }else if( rc!=SQLITE_INTERRUPT ){
84 corruptSchema(pData, zErr);
85 }
86 sqlite3_free(zErr);
87 return 1;
88 }
89 }else{
90 /* If the SQL column is blank it means this is an index that
91 ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
92 ** constraint for a CREATE TABLE. The index should have already
93 ** been created when we processed the CREATE TABLE. All we have
94 ** to do here is record the root page number for that index.
95 */
96 Index *pIndex;
97 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;
125 Db *pDb;
126 char const *azArg[4];
127 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 );
159 assert( db->aDb[iDb].pSchema );
160 assert( sqlite3_mutex_held(db->mutex) );
161
162 /* zMasterSchema and zInitScript are set to point at the master schema
163 ** and initialisation script appropriate for the database being
164 ** initialised. zMasterName is the name of the master table.
165 */
166 if( !OMIT_TEMPDB && iDb==1 ){
167 zMasterSchema = temp_master_schema;
168 }else{
169 zMasterSchema = master_schema;
170 }
171 zMasterName = SCHEMA_TABLE(iDb);
172
173 /* Construct the schema tables. */
174 sqlite3SafetyOff(db);
175 azArg[0] = zMasterName;
176 azArg[1] = "1";
177 azArg[2] = zMasterSchema;
178 azArg[3] = 0;
179 initData.db = db;
180 initData.iDb = iDb;
181 initData.pzErrMsg = pzErrMsg;
182 rc = sqlite3InitCallback(&initData, 3, (char **)azArg, 0);
183 if( rc ){
184 sqlite3SafetyOn(db);
185 rc = initData.rc;
186 goto error_out;
187 }
188 pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
189 if( pTab ){
190 pTab->readOnly = 1;
191 }
192 sqlite3SafetyOn(db);
193
194 /* Create a cursor to hold the database open
195 */
196 pDb = &db->aDb[iDb];
197 if( pDb->pBt==0 ){
198 if( !OMIT_TEMPDB && iDb==1 ){
199 DbSetProperty(db, 1, DB_SchemaLoaded);
200 }
201 return SQLITE_OK;
202 }
203 sqlite3BtreeEnter(pDb->pBt);
204 rc = sqlite3BtreeCursor(pDb->pBt, MASTER_ROOT, 0, 0, 0, &curMain);
205 if( rc!=SQLITE_OK && rc!=SQLITE_EMPTY ){
206 sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
207 sqlite3BtreeLeave(pDb->pBt);
208 goto error_out;
209 }
210
211 /* Get the database meta information.
212 **
213 ** Meta values are as follows:
214 ** meta[0] Schema cookie. Changes with each schema change.
215 ** meta[1] File format of schema layer.
216 ** meta[2] Size of the page cache.
217 ** meta[3] Use freelist if 0. Autovacuum if greater than zero.
218 ** meta[4] Db text encoding. 1:UTF-8 2:UTF-16LE 3:UTF-16BE
219 ** meta[5] The user cookie. Used by the application.
220 ** meta[6] Incremental-vacuum flag.
221 ** meta[7]
222 ** meta[8]
223 ** meta[9]
224 **
225 ** Note: The #defined SQLITE_UTF* symbols in sqliteInt.h correspond to
226 ** the possible values of meta[4].
227 */
228 if( rc==SQLITE_OK ){
229 int i;
230 for(i=0; rc==SQLITE_OK && i<sizeof(meta)/sizeof(meta[0]); i++){
231 rc = sqlite3BtreeGetMeta(pDb->pBt, i+1, (u32 *)&meta[i]);
232 }
233 if( rc ){
234 sqlite3SetString(pzErrMsg, sqlite3ErrStr(rc), (char*)0);
235 sqlite3BtreeCloseCursor(curMain);
236 sqlite3BtreeLeave(pDb->pBt);
237 goto error_out;
238 }
239 }else{
240 memset(meta, 0, sizeof(meta));
241 }
242 pDb->pSchema->schema_cookie = meta[0];
243
244 /* If opening a non-empty database, check the text encoding. For the
245 ** main database, set sqlite3.enc to the encoding of the main database.
246 ** For an attached db, it is an error if the encoding is not the same
247 ** as sqlite3.enc.
248 */
249 if( meta[4] ){ /* text encoding */
250 if( iDb==0 ){
251 /* If opening the main database, set ENC(db). */
252 ENC(db) = (u8)meta[4];
253 db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
254 }else{
255 /* If opening an attached database, the encoding much match ENC(db) */
256 if( meta[4]!=ENC(db) ){
257 sqlite3BtreeCloseCursor(curMain);
258 sqlite3SetString(pzErrMsg, "attached databases must use the same"
259 " text encoding as main database", (char*)0);
260 sqlite3BtreeLeave(pDb->pBt);
261 return SQLITE_ERROR;
262 }
263 }
264 }else{
265 DbSetProperty(db, iDb, DB_Empty);
266 }
267 pDb->pSchema->enc = ENC(db);
268
269 size = meta[2];
270 if( size==0 ){ size = SQLITE_DEFAULT_CACHE_SIZE; }
271 pDb->pSchema->cache_size = size;
272 sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
273
274 /*
275 ** file_format==1 Version 3.0.0.
276 ** file_format==2 Version 3.1.3. // ALTER TABLE ADD COLUMN
277 ** file_format==3 Version 3.1.4. // ditto but with non-NULL defaults
278 ** file_format==4 Version 3.3.0. // DESC indices. Boolean constants
279 */
280 pDb->pSchema->file_format = meta[1];
281 if( pDb->pSchema->file_format==0 ){
282 pDb->pSchema->file_format = 1;
283 }
284 if( pDb->pSchema->file_format>SQLITE_MAX_FILE_FORMAT ){
285 sqlite3BtreeCloseCursor(curMain);
286 sqlite3SetString(pzErrMsg, "unsupported file format", (char*)0);
287 sqlite3BtreeLeave(pDb->pBt);
288 return SQLITE_ERROR;
289 }
290
291
292 /* Read the schema information out of the schema tables
293 */
294 assert( db->init.busy );
295 if( rc==SQLITE_EMPTY ){
296 /* For an empty database, there is nothing to read */
297 rc = SQLITE_OK;
298 }else{
299 char *zSql;
300 zSql = sqlite3MPrintf(db,
301 "SELECT name, rootpage, sql FROM '%q'.%s",
302 db->aDb[iDb].zName, zMasterName);
303 sqlite3SafetyOff(db);
304 rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
305 if( rc==SQLITE_ABORT ) rc = initData.rc;
306 sqlite3SafetyOn(db);
307 sqlite3_free(zSql);
308#ifndef SQLITE_OMIT_ANALYZE
309 if( rc==SQLITE_OK ){
310 sqlite3AnalysisLoad(db, iDb);
311 }
312#endif
313 sqlite3BtreeCloseCursor(curMain);
314 }
315 if( db->mallocFailed ){
316 /* sqlite3SetString(pzErrMsg, "out of memory", (char*)0); */
317 rc = SQLITE_NOMEM;
318 sqlite3ResetInternalSchema(db, 0);
319 }
320 if( rc==SQLITE_OK || (db->flags&SQLITE_RecoveryMode)){
321 /* Black magic: If the SQLITE_RecoveryMode flag is set, then consider
322 ** the schema loaded, even if errors occured. In this situation the
323 ** current sqlite3_prepare() operation will fail, but the following one
324 ** will attempt to compile the supplied statement against whatever subset
325 ** of the schema was loaded before the error occured. The primary
326 ** purpose of this is to allow access to the sqlite_master table
327 ** even when it's contents have been corrupted.
328 */
329 DbSetProperty(db, iDb, DB_SchemaLoaded);
330 rc = SQLITE_OK;
331 }
332 sqlite3BtreeLeave(pDb->pBt);
333
334error_out:
335 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
336 db->mallocFailed = 1;
337 }
338 return rc;
339}
340
341/*
342** Initialize all database files - the main database file, the file
343** used to store temporary tables, and any additional database files
344** created using ATTACH statements. Return a success code. If an
345** error occurs, write an error message into *pzErrMsg.
346**
347** After a database is initialized, the DB_SchemaLoaded bit is set
348** bit is set in the flags field of the Db structure. If the database
349** file was of zero-length, then the DB_Empty flag is also set.
350*/
351int sqlite3Init(sqlite3 *db, char **pzErrMsg){
352 int i, rc;
353 int commit_internal = !(db->flags&SQLITE_InternChanges);
354
355 assert( sqlite3_mutex_held(db->mutex) );
356 if( db->init.busy ) return SQLITE_OK;
357 rc = SQLITE_OK;
358 db->init.busy = 1;
359 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
360 if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
361 rc = sqlite3InitOne(db, i, pzErrMsg);
362 if( rc ){
363 sqlite3ResetInternalSchema(db, i);
364 }
365 }
366
367 /* Once all the other databases have been initialised, load the schema
368 ** for the TEMP database. This is loaded last, as the TEMP database
369 ** schema may contain references to objects in other databases.
370 */
371#ifndef SQLITE_OMIT_TEMPDB
372 if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
373 rc = sqlite3InitOne(db, 1, pzErrMsg);
374 if( rc ){
375 sqlite3ResetInternalSchema(db, 1);
376 }
377 }
378#endif
379
380 db->init.busy = 0;
381 if( rc==SQLITE_OK && commit_internal ){
382 sqlite3CommitInternalChanges(db);
383 }
384
385 return rc;
386}
387
388/*
389** This routine is a no-op if the database schema is already initialised.
390** Otherwise, the schema is loaded. An error code is returned.
391*/
392int sqlite3ReadSchema(Parse *pParse){
393 int rc = SQLITE_OK;
394 sqlite3 *db = pParse->db;
395 assert( sqlite3_mutex_held(db->mutex) );
396 if( !db->init.busy ){
397 rc = sqlite3Init(db, &pParse->zErrMsg);
398 }
399 if( rc!=SQLITE_OK ){
400 pParse->rc = rc;
401 pParse->nErr++;
402 }
403 return rc;
404}
405
406
407/*
408** Check schema cookies in all databases. If any cookie is out
409** of date, return 0. If all schema cookies are current, return 1.
410*/
411static int schemaIsValid(sqlite3 *db){
412 int iDb;
413 int rc;
414 BtCursor *curTemp;
415 int cookie;
416 int allOk = 1;
417
418 assert( sqlite3_mutex_held(db->mutex) );
419 for(iDb=0; allOk && iDb<db->nDb; iDb++){
420 Btree *pBt;
421 pBt = db->aDb[iDb].pBt;
422 if( pBt==0 ) continue;
423 rc = sqlite3BtreeCursor(pBt, MASTER_ROOT, 0, 0, 0, &curTemp);
424 if( rc==SQLITE_OK ){
425 rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&cookie);
426 if( rc==SQLITE_OK && cookie!=db->aDb[iDb].pSchema->schema_cookie ){
427 allOk = 0;
428 }
429 sqlite3BtreeCloseCursor(curTemp);
430 }
431 if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
432 db->mallocFailed = 1;
433 }
434 }
435 return allOk;
436}
437
438/*
439** Convert a schema pointer into the iDb index that indicates
440** which database file in db->aDb[] the schema refers to.
441**
442** If the same database is attached more than once, the first
443** attached database is returned.
444*/
445int sqlite3SchemaToIndex(sqlite3 *db, Schema *pSchema){
446 int i = -1000000;
447
448 /* If pSchema is NULL, then return -1000000. This happens when code in
449 ** expr.c is trying to resolve a reference to a transient table (i.e. one
450 ** created by a sub-select). In this case the return value of this
451 ** function should never be used.
452 **
453 ** We return -1000000 instead of the more usual -1 simply because using
454 ** -1000000 as incorrectly using -1000000 index into db->aDb[] is much
455 ** more likely to cause a segfault than -1 (of course there are assert()
456 ** statements too, but it never hurts to play the odds).
457 */
458 assert( sqlite3_mutex_held(db->mutex) );
459 if( pSchema ){
460 for(i=0; i<db->nDb; i++){
461 if( db->aDb[i].pSchema==pSchema ){
462 break;
463 }
464 }
465 assert( i>=0 &&i>=0 && i<db->nDb );
466 }
467 return i;
468}
469
470/*
471** Compile the UTF-8 encoded SQL statement zSql into a statement handle.
472*/
473int sqlite3Prepare(
474 sqlite3 *db, /* Database handle. */
475 const char *zSql, /* UTF-8 encoded SQL statement. */
476 int nBytes, /* Length of zSql in bytes. */
477 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
478 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
479 const char **pzTail /* OUT: End of parsed string */
480){
481 Parse sParse;
482 char *zErrMsg = 0;
483 int rc = SQLITE_OK;
484 int i;
485
486 assert( ppStmt );
487 *ppStmt = 0;
488 if( sqlite3SafetyOn(db) ){
489 return SQLITE_MISUSE;
490 }
491 assert( !db->mallocFailed );
492 assert( sqlite3_mutex_held(db->mutex) );
493
494 /* If any attached database schemas are locked, do not proceed with
495 ** compilation. Instead return SQLITE_LOCKED immediately.
496 */
497 for(i=0; i<db->nDb; i++) {
498 Btree *pBt = db->aDb[i].pBt;
499 if( pBt ){
500 int rc;
501 rc = sqlite3BtreeSchemaLocked(pBt);
502 if( rc ){
503 const char *zDb = db->aDb[i].zName;
504 sqlite3Error(db, SQLITE_LOCKED, "database schema is locked: %s", zDb);
505 sqlite3SafetyOff(db);
506 return SQLITE_LOCKED;
507 }
508 }
509 }
510
511 memset(&sParse, 0, sizeof(sParse));
512 sParse.db = db;
513 if( nBytes>=0 && zSql[nBytes]!=0 ){
514 char *zSqlCopy;
515 if( nBytes>SQLITE_MAX_SQL_LENGTH ){
516 return SQLITE_TOOBIG;
517 }
518 zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
519 if( zSqlCopy ){
520 sqlite3RunParser(&sParse, zSqlCopy, &zErrMsg);
521 sqlite3_free(zSqlCopy);
522 }
523 sParse.zTail = &zSql[nBytes];
524 }else{
525 sqlite3RunParser(&sParse, zSql, &zErrMsg);
526 }
527
528 if( db->mallocFailed ){
529 sParse.rc = SQLITE_NOMEM;
530 }
531 if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
532 if( sParse.checkSchema && !schemaIsValid(db) ){
533 sParse.rc = SQLITE_SCHEMA;
534 }
535 if( sParse.rc==SQLITE_SCHEMA ){
536 sqlite3ResetInternalSchema(db, 0);
537 }
538 if( db->mallocFailed ){
539 sParse.rc = SQLITE_NOMEM;
540 }
541 if( pzTail ){
542 *pzTail = sParse.zTail;
543 }
544 rc = sParse.rc;
545
546#ifndef SQLITE_OMIT_EXPLAIN
547 if( rc==SQLITE_OK && sParse.pVdbe && sParse.explain ){
548 if( sParse.explain==2 ){
549 sqlite3VdbeSetNumCols(sParse.pVdbe, 3);
550 sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "order", P3_STATIC);
551 sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "from", P3_STATIC);
552 sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "detail", P3_STATIC);
553 }else{
554 sqlite3VdbeSetNumCols(sParse.pVdbe, 5);
555 sqlite3VdbeSetColName(sParse.pVdbe, 0, COLNAME_NAME, "addr", P3_STATIC);
556 sqlite3VdbeSetColName(sParse.pVdbe, 1, COLNAME_NAME, "opcode", P3_STATIC);
557 sqlite3VdbeSetColName(sParse.pVdbe, 2, COLNAME_NAME, "p1", P3_STATIC);
558 sqlite3VdbeSetColName(sParse.pVdbe, 3, COLNAME_NAME, "p2", P3_STATIC);
559 sqlite3VdbeSetColName(sParse.pVdbe, 4, COLNAME_NAME, "p3", P3_STATIC);
560 }
561 }
562#endif
563
564 if( sqlite3SafetyOff(db) ){
565 rc = SQLITE_MISUSE;
566 }
567
568 if( saveSqlFlag ){
569 sqlite3VdbeSetSql(sParse.pVdbe, zSql, sParse.zTail - zSql);
570 }
571 if( rc!=SQLITE_OK || db->mallocFailed ){
572 sqlite3_finalize((sqlite3_stmt*)sParse.pVdbe);
573 assert(!(*ppStmt));
574 }else{
575 *ppStmt = (sqlite3_stmt*)sParse.pVdbe;
576 }
577
578 if( zErrMsg ){
579 sqlite3Error(db, rc, "%s", zErrMsg);
580 sqlite3_free(zErrMsg);
581 }else{
582 sqlite3Error(db, rc, 0);
583 }
584
585 rc = sqlite3ApiExit(db, rc);
586 /* sqlite3ReleaseThreadData(); */
587 assert( (rc&db->errMask)==rc );
588 return rc;
589}
590static int sqlite3LockAndPrepare(
591 sqlite3 *db, /* Database handle. */
592 const char *zSql, /* UTF-8 encoded SQL statement. */
593 int nBytes, /* Length of zSql in bytes. */
594 int saveSqlFlag, /* True to copy SQL text into the sqlite3_stmt */
595 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
596 const char **pzTail /* OUT: End of parsed string */
597){
598 int rc;
599 if( sqlite3SafetyCheck(db) ){
600 return SQLITE_MISUSE;
601 }
602 sqlite3_mutex_enter(db->mutex);
603 sqlite3BtreeEnterAll(db);
604 rc = sqlite3Prepare(db, zSql, nBytes, saveSqlFlag, ppStmt, pzTail);
605 sqlite3BtreeLeaveAll(db);
606 sqlite3_mutex_leave(db->mutex);
607 return rc;
608}
609
610/*
611** Rerun the compilation of a statement after a schema change.
612** Return true if the statement was recompiled successfully.
613** Return false if there is an error of some kind.
614*/
615int sqlite3Reprepare(Vdbe *p){
616 int rc;
617 sqlite3_stmt *pNew;
618 const char *zSql;
619 sqlite3 *db;
620
621 assert( sqlite3_mutex_held(sqlite3VdbeDb(p)->mutex) );
622 zSql = sqlite3VdbeGetSql(p);
623 if( zSql==0 ){
624 return 0;
625 }
626 db = sqlite3VdbeDb(p);
627 assert( sqlite3_mutex_held(db->mutex) );
628 rc = sqlite3LockAndPrepare(db, zSql, -1, 0, &pNew, 0);
629 if( rc ){
630 assert( pNew==0 );
631 return 0;
632 }else{
633 assert( pNew!=0 );
634 }
635 sqlite3VdbeSwap((Vdbe*)pNew, p);
636 sqlite3_transfer_bindings(pNew, (sqlite3_stmt*)p);
637 sqlite3VdbeResetStepResult((Vdbe*)pNew);
638 sqlite3VdbeFinalize((Vdbe*)pNew);
639 return 1;
640}
641
642
643/*
644** Two versions of the official API. Legacy and new use. In the legacy
645** version, the original SQL text is not saved in the prepared statement
646** and so if a schema change occurs, SQLITE_SCHEMA is returned by
647** sqlite3_step(). In the new version, the original SQL text is retained
648** and the statement is automatically recompiled if an schema change
649** occurs.
650*/
651int sqlite3_prepare(
652 sqlite3 *db, /* Database handle. */
653 const char *zSql, /* UTF-8 encoded SQL statement. */
654 int nBytes, /* Length of zSql in bytes. */
655 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
656 const char **pzTail /* OUT: End of parsed string */
657){
658 return sqlite3LockAndPrepare(db,zSql,nBytes,0,ppStmt,pzTail);
659}
660int sqlite3_prepare_v2(
661 sqlite3 *db, /* Database handle. */
662 const char *zSql, /* UTF-8 encoded SQL statement. */
663 int nBytes, /* Length of zSql in bytes. */
664 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
665 const char **pzTail /* OUT: End of parsed string */
666){
667 return sqlite3LockAndPrepare(db,zSql,nBytes,1,ppStmt,pzTail);
668}
669
670
671#ifndef SQLITE_OMIT_UTF16
672/*
673** Compile the UTF-16 encoded SQL statement zSql into a statement handle.
674*/
675static int sqlite3Prepare16(
676 sqlite3 *db, /* Database handle. */
677 const void *zSql, /* UTF-8 encoded SQL statement. */
678 int nBytes, /* Length of zSql in bytes. */
679 int saveSqlFlag, /* True to save SQL text into the sqlite3_stmt */
680 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
681 const void **pzTail /* OUT: End of parsed string */
682){
683 /* This function currently works by first transforming the UTF-16
684 ** encoded string to UTF-8, then invoking sqlite3_prepare(). The
685 ** tricky bit is figuring out the pointer to return in *pzTail.
686 */
687 char *zSql8;
688 const char *zTail8 = 0;
689 int rc = SQLITE_OK;
690
691 if( sqlite3SafetyCheck(db) ){
692 return SQLITE_MISUSE;
693 }
694 sqlite3_mutex_enter(db->mutex);
695 zSql8 = sqlite3Utf16to8(db, zSql, nBytes);
696 if( zSql8 ){
697 rc = sqlite3LockAndPrepare(db, zSql8, -1, saveSqlFlag, ppStmt, &zTail8);
698 }
699
700 if( zTail8 && pzTail ){
701 /* If sqlite3_prepare returns a tail pointer, we calculate the
702 ** equivalent pointer into the UTF-16 string by counting the unicode
703 ** characters between zSql8 and zTail8, and then returning a pointer
704 ** the same number of characters into the UTF-16 string.
705 */
706 int chars_parsed = sqlite3Utf8CharLen(zSql8, zTail8-zSql8);
707 *pzTail = (u8 *)zSql + sqlite3Utf16ByteLen(zSql, chars_parsed);
708 }
709 sqlite3_free(zSql8);
710 rc = sqlite3ApiExit(db, rc);
711 sqlite3_mutex_leave(db->mutex);
712 return rc;
713}
714
715/*
716** Two versions of the official API. Legacy and new use. In the legacy
717** version, the original SQL text is not saved in the prepared statement
718** and so if a schema change occurs, SQLITE_SCHEMA is returned by
719** sqlite3_step(). In the new version, the original SQL text is retained
720** and the statement is automatically recompiled if an schema change
721** occurs.
722*/
723int sqlite3_prepare16(
724 sqlite3 *db, /* Database handle. */
725 const void *zSql, /* UTF-8 encoded SQL statement. */
726 int nBytes, /* Length of zSql in bytes. */
727 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
728 const void **pzTail /* OUT: End of parsed string */
729){
730 return sqlite3Prepare16(db,zSql,nBytes,0,ppStmt,pzTail);
731}
732int sqlite3_prepare16_v2(
733 sqlite3 *db, /* Database handle. */
734 const void *zSql, /* UTF-8 encoded SQL statement. */
735 int nBytes, /* Length of zSql in bytes. */
736 sqlite3_stmt **ppStmt, /* OUT: A pointer to the prepared statement */
737 const void **pzTail /* OUT: End of parsed string */
738){
739 return sqlite3Prepare16(db,zSql,nBytes,1,ppStmt,pzTail);
740}
741
742#endif /* SQLITE_OMIT_UTF16 */
generated by cgit v1.1 at 2024-12-22 06:39:29 +0000