monotone

monotone Mtn Source Tree

Root/sqlite/prepare.c

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

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status