Annotation of embedaddon/php/ext/sqlite/libsqlite/src/main.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2001 September 15
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: ** Main file for the SQLite library. The routines in this file
13: ** implement the programmer interface to the library. Routines in
14: ** other files are for internal use by SQLite and should not be
15: ** accessed by users of the library.
16: **
17: ** $Id: main.c 195361 2005-09-07 15:11:33Z iliaa $
18: */
19: #include "sqliteInt.h"
20: #include "os.h"
21: #include <ctype.h>
22:
23: /*
24: ** A pointer to this structure is used to communicate information
25: ** from sqliteInit into the sqliteInitCallback.
26: */
27: typedef struct {
28: sqlite *db; /* The database being initialized */
29: char **pzErrMsg; /* Error message stored here */
30: } InitData;
31:
32: /*
33: ** Fill the InitData structure with an error message that indicates
34: ** that the database is corrupt.
35: */
36: static void corruptSchema(InitData *pData, const char *zExtra){
37: sqliteSetString(pData->pzErrMsg, "malformed database schema",
38: zExtra!=0 && zExtra[0]!=0 ? " - " : (char*)0, zExtra, (char*)0);
39: }
40:
41: /*
42: ** This is the callback routine for the code that initializes the
43: ** database. See sqliteInit() below for additional information.
44: **
45: ** Each callback contains the following information:
46: **
47: ** argv[0] = "file-format" or "schema-cookie" or "table" or "index"
48: ** argv[1] = table or index name or meta statement type.
49: ** argv[2] = root page number for table or index. NULL for meta.
50: ** argv[3] = SQL text for a CREATE TABLE or CREATE INDEX statement.
51: ** argv[4] = "1" for temporary files, "0" for main database, "2" or more
52: ** for auxiliary database files.
53: **
54: */
55: static
56: int sqliteInitCallback(void *pInit, int argc, char **argv, char **azColName){
57: InitData *pData = (InitData*)pInit;
58: int nErr = 0;
59:
60: assert( argc==5 );
61: if( argv==0 ) return 0; /* Might happen if EMPTY_RESULT_CALLBACKS are on */
62: if( argv[0]==0 ){
63: corruptSchema(pData, 0);
64: return 1;
65: }
66: switch( argv[0][0] ){
67: case 'v':
68: case 'i':
69: case 't': { /* CREATE TABLE, CREATE INDEX, or CREATE VIEW statements */
70: sqlite *db = pData->db;
71: if( argv[2]==0 || argv[4]==0 ){
72: corruptSchema(pData, 0);
73: return 1;
74: }
75: if( argv[3] && argv[3][0] ){
76: /* Call the parser to process a CREATE TABLE, INDEX or VIEW.
77: ** But because db->init.busy is set to 1, no VDBE code is generated
78: ** or executed. All the parser does is build the internal data
79: ** structures that describe the table, index, or view.
80: */
81: char *zErr;
82: assert( db->init.busy );
83: db->init.iDb = atoi(argv[4]);
84: assert( db->init.iDb>=0 && db->init.iDb<db->nDb );
85: db->init.newTnum = atoi(argv[2]);
86: if( sqlite_exec(db, argv[3], 0, 0, &zErr) ){
87: corruptSchema(pData, zErr);
88: sqlite_freemem(zErr);
89: }
90: db->init.iDb = 0;
91: }else{
92: /* If the SQL column is blank it means this is an index that
93: ** was created to be the PRIMARY KEY or to fulfill a UNIQUE
94: ** constraint for a CREATE TABLE. The index should have already
95: ** been created when we processed the CREATE TABLE. All we have
96: ** to do here is record the root page number for that index.
97: */
98: int iDb;
99: Index *pIndex;
100:
101: iDb = atoi(argv[4]);
102: assert( iDb>=0 && iDb<db->nDb );
103: pIndex = sqliteFindIndex(db, argv[1], db->aDb[iDb].zName);
104: if( pIndex==0 || pIndex->tnum!=0 ){
105: /* This can occur if there exists an index on a TEMP table which
106: ** has the same name as another index on a permanent index. Since
107: ** the permanent table is hidden by the TEMP table, we can also
108: ** safely ignore the index on the permanent table.
109: */
110: /* Do Nothing */;
111: }else{
112: pIndex->tnum = atoi(argv[2]);
113: }
114: }
115: break;
116: }
117: default: {
118: /* This can not happen! */
119: nErr = 1;
120: assert( nErr==0 );
121: }
122: }
123: return nErr;
124: }
125:
126: /*
127: ** This is a callback procedure used to reconstruct a table. The
128: ** name of the table to be reconstructed is passed in as argv[0].
129: **
130: ** This routine is used to automatically upgrade a database from
131: ** format version 1 or 2 to version 3. The correct operation of
132: ** this routine relys on the fact that no indices are used when
133: ** copying a table out to a temporary file.
134: **
135: ** The change from version 2 to version 3 occurred between SQLite
136: ** version 2.5.6 and 2.6.0 on 2002-July-18.
137: */
138: static
139: int upgrade_3_callback(void *pInit, int argc, char **argv, char **NotUsed){
140: InitData *pData = (InitData*)pInit;
141: int rc;
142: Table *pTab;
143: Trigger *pTrig;
144: char *zErr = 0;
145:
146: pTab = sqliteFindTable(pData->db, argv[0], 0);
147: assert( pTab!=0 );
148: assert( sqliteStrICmp(pTab->zName, argv[0])==0 );
149: if( pTab ){
150: pTrig = pTab->pTrigger;
151: pTab->pTrigger = 0; /* Disable all triggers before rebuilding the table */
152: }
153: rc = sqlite_exec_printf(pData->db,
154: "CREATE TEMP TABLE sqlite_x AS SELECT * FROM '%q'; "
155: "DELETE FROM '%q'; "
156: "INSERT INTO '%q' SELECT * FROM sqlite_x; "
157: "DROP TABLE sqlite_x;",
158: 0, 0, &zErr, argv[0], argv[0], argv[0]);
159: if( zErr ){
160: if( *pData->pzErrMsg ) sqlite_freemem(*pData->pzErrMsg);
161: *pData->pzErrMsg = zErr;
162: }
163:
164: /* If an error occurred in the SQL above, then the transaction will
165: ** rollback which will delete the internal symbol tables. This will
166: ** cause the structure that pTab points to be deleted. In case that
167: ** happened, we need to refetch pTab.
168: */
169: pTab = sqliteFindTable(pData->db, argv[0], 0);
170: if( pTab ){
171: assert( sqliteStrICmp(pTab->zName, argv[0])==0 );
172: pTab->pTrigger = pTrig; /* Re-enable triggers */
173: }
174: return rc!=SQLITE_OK;
175: }
176:
177:
178:
179: /*
180: ** Attempt to read the database schema and initialize internal
181: ** data structures for a single database file. The index of the
182: ** database file is given by iDb. iDb==0 is used for the main
183: ** database. iDb==1 should never be used. iDb>=2 is used for
184: ** auxiliary databases. Return one of the SQLITE_ error codes to
185: ** indicate success or failure.
186: */
187: static int sqliteInitOne(sqlite *db, int iDb, char **pzErrMsg){
188: int rc;
189: BtCursor *curMain;
190: int size;
191: Table *pTab;
192: char const *azArg[6];
193: char zDbNum[30];
194: int meta[SQLITE_N_BTREE_META];
195: InitData initData;
196: char const *zMasterSchema;
197: char const *zMasterName;
198: char *zSql = 0;
199:
200: /*
201: ** The master database table has a structure like this
202: */
203: static char master_schema[] =
204: "CREATE TABLE sqlite_master(\n"
205: " type text,\n"
206: " name text,\n"
207: " tbl_name text,\n"
208: " rootpage integer,\n"
209: " sql text\n"
210: ")"
211: ;
212: static char temp_master_schema[] =
213: "CREATE TEMP TABLE sqlite_temp_master(\n"
214: " type text,\n"
215: " name text,\n"
216: " tbl_name text,\n"
217: " rootpage integer,\n"
218: " sql text\n"
219: ")"
220: ;
221:
222: assert( iDb>=0 && iDb<db->nDb );
223:
224: /* zMasterSchema and zInitScript are set to point at the master schema
225: ** and initialisation script appropriate for the database being
226: ** initialised. zMasterName is the name of the master table.
227: */
228: if( iDb==1 ){
229: zMasterSchema = temp_master_schema;
230: zMasterName = TEMP_MASTER_NAME;
231: }else{
232: zMasterSchema = master_schema;
233: zMasterName = MASTER_NAME;
234: }
235:
236: /* Construct the schema table.
237: */
238: sqliteSafetyOff(db);
239: azArg[0] = "table";
240: azArg[1] = zMasterName;
241: azArg[2] = "2";
242: azArg[3] = zMasterSchema;
243: sprintf(zDbNum, "%d", iDb);
244: azArg[4] = zDbNum;
245: azArg[5] = 0;
246: initData.db = db;
247: initData.pzErrMsg = pzErrMsg;
248: sqliteInitCallback(&initData, 5, (char **)azArg, 0);
249: pTab = sqliteFindTable(db, zMasterName, db->aDb[iDb].zName);
250: if( pTab ){
251: pTab->readOnly = 1;
252: }else{
253: return SQLITE_NOMEM;
254: }
255: sqliteSafetyOn(db);
256:
257: /* Create a cursor to hold the database open
258: */
259: if( db->aDb[iDb].pBt==0 ) return SQLITE_OK;
260: rc = sqliteBtreeCursor(db->aDb[iDb].pBt, 2, 0, &curMain);
261: if( rc ){
262: sqliteSetString(pzErrMsg, sqlite_error_string(rc), (char*)0);
263: return rc;
264: }
265:
266: /* Get the database meta information
267: */
268: rc = sqliteBtreeGetMeta(db->aDb[iDb].pBt, meta);
269: if( rc ){
270: sqliteSetString(pzErrMsg, sqlite_error_string(rc), (char*)0);
271: sqliteBtreeCloseCursor(curMain);
272: return rc;
273: }
274: db->aDb[iDb].schema_cookie = meta[1];
275: if( iDb==0 ){
276: db->next_cookie = meta[1];
277: db->file_format = meta[2];
278: size = meta[3];
279: if( size==0 ){ size = MAX_PAGES; }
280: db->cache_size = size;
281: db->safety_level = meta[4];
282: if( meta[6]>0 && meta[6]<=2 && db->temp_store==0 ){
283: db->temp_store = meta[6];
284: }
285: if( db->safety_level==0 ) db->safety_level = 2;
286:
287: /*
288: ** file_format==1 Version 2.1.0.
289: ** file_format==2 Version 2.2.0. Add support for INTEGER PRIMARY KEY.
290: ** file_format==3 Version 2.6.0. Fix empty-string index bug.
291: ** file_format==4 Version 2.7.0. Add support for separate numeric and
292: ** text datatypes.
293: */
294: if( db->file_format==0 ){
295: /* This happens if the database was initially empty */
296: db->file_format = 4;
297: }else if( db->file_format>4 ){
298: sqliteBtreeCloseCursor(curMain);
299: sqliteSetString(pzErrMsg, "unsupported file format", (char*)0);
300: return SQLITE_ERROR;
301: }
302: }else if( iDb!=1 && (db->file_format!=meta[2] || db->file_format<4) ){
303: assert( db->file_format>=4 );
304: if( meta[2]==0 ){
305: sqliteSetString(pzErrMsg, "cannot attach empty database: ",
306: db->aDb[iDb].zName, (char*)0);
307: }else{
308: sqliteSetString(pzErrMsg, "incompatible file format in auxiliary "
309: "database: ", db->aDb[iDb].zName, (char*)0);
310: }
311: sqliteBtreeClose(db->aDb[iDb].pBt);
312: db->aDb[iDb].pBt = 0;
313: return SQLITE_FORMAT;
314: }
315: sqliteBtreeSetCacheSize(db->aDb[iDb].pBt, db->cache_size);
316: sqliteBtreeSetSafetyLevel(db->aDb[iDb].pBt, meta[4]==0 ? 2 : meta[4]);
317:
318: /* Read the schema information out of the schema tables
319: */
320: assert( db->init.busy );
321: sqliteSafetyOff(db);
322:
323: /* The following SQL will read the schema from the master tables.
324: ** The first version works with SQLite file formats 2 or greater.
325: ** The second version is for format 1 files.
326: **
327: ** Beginning with file format 2, the rowid for new table entries
328: ** (including entries in sqlite_master) is an increasing integer.
329: ** So for file format 2 and later, we can play back sqlite_master
330: ** and all the CREATE statements will appear in the right order.
331: ** But with file format 1, table entries were random and so we
332: ** have to make sure the CREATE TABLEs occur before their corresponding
333: ** CREATE INDEXs. (We don't have to deal with CREATE VIEW or
334: ** CREATE TRIGGER in file format 1 because those constructs did
335: ** not exist then.)
336: */
337: if( db->file_format>=2 ){
338: sqliteSetString(&zSql,
339: "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"",
340: db->aDb[iDb].zName, "\".", zMasterName, (char*)0);
341: }else{
342: sqliteSetString(&zSql,
343: "SELECT type, name, rootpage, sql, ", zDbNum, " FROM \"",
344: db->aDb[iDb].zName, "\".", zMasterName,
345: " WHERE type IN ('table', 'index')"
346: " ORDER BY CASE type WHEN 'table' THEN 0 ELSE 1 END", (char*)0);
347: }
348: rc = sqlite_exec(db, zSql, sqliteInitCallback, &initData, 0);
349:
350: sqliteFree(zSql);
351: sqliteSafetyOn(db);
352: sqliteBtreeCloseCursor(curMain);
353: if( sqlite_malloc_failed ){
354: sqliteSetString(pzErrMsg, "out of memory", (char*)0);
355: rc = SQLITE_NOMEM;
356: sqliteResetInternalSchema(db, 0);
357: }
358: if( rc==SQLITE_OK ){
359: DbSetProperty(db, iDb, DB_SchemaLoaded);
360: }else{
361: sqliteResetInternalSchema(db, iDb);
362: }
363: return rc;
364: }
365:
366: /*
367: ** Initialize all database files - the main database file, the file
368: ** used to store temporary tables, and any additional database files
369: ** created using ATTACH statements. Return a success code. If an
370: ** error occurs, write an error message into *pzErrMsg.
371: **
372: ** After the database is initialized, the SQLITE_Initialized
373: ** bit is set in the flags field of the sqlite structure. An
374: ** attempt is made to initialize the database as soon as it
375: ** is opened. If that fails (perhaps because another process
376: ** has the sqlite_master table locked) than another attempt
377: ** is made the first time the database is accessed.
378: */
379: int sqliteInit(sqlite *db, char **pzErrMsg){
380: int i, rc;
381:
382: if( db->init.busy ) return SQLITE_OK;
383: assert( (db->flags & SQLITE_Initialized)==0 );
384: rc = SQLITE_OK;
385: db->init.busy = 1;
386: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
387: if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
388: rc = sqliteInitOne(db, i, pzErrMsg);
389: if( rc ){
390: sqliteResetInternalSchema(db, i);
391: }
392: }
393:
394: /* Once all the other databases have been initialised, load the schema
395: ** for the TEMP database. This is loaded last, as the TEMP database
396: ** schema may contain references to objects in other databases.
397: */
398: if( rc==SQLITE_OK && db->nDb>1 && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
399: rc = sqliteInitOne(db, 1, pzErrMsg);
400: if( rc ){
401: sqliteResetInternalSchema(db, 1);
402: }
403: }
404:
405: db->init.busy = 0;
406: if( rc==SQLITE_OK ){
407: db->flags |= SQLITE_Initialized;
408: sqliteCommitInternalChanges(db);
409: }
410:
411: /* If the database is in formats 1 or 2, then upgrade it to
412: ** version 3. This will reconstruct all indices. If the
413: ** upgrade fails for any reason (ex: out of disk space, database
414: ** is read only, interrupt received, etc.) then fail the init.
415: */
416: if( rc==SQLITE_OK && db->file_format<3 ){
417: char *zErr = 0;
418: InitData initData;
419: int meta[SQLITE_N_BTREE_META];
420:
421: db->magic = SQLITE_MAGIC_OPEN;
422: initData.db = db;
423: initData.pzErrMsg = &zErr;
424: db->file_format = 3;
425: rc = sqlite_exec(db,
426: "BEGIN; SELECT name FROM sqlite_master WHERE type='table';",
427: upgrade_3_callback,
428: &initData,
429: &zErr);
430: if( rc==SQLITE_OK ){
431: sqliteBtreeGetMeta(db->aDb[0].pBt, meta);
432: meta[2] = 4;
433: sqliteBtreeUpdateMeta(db->aDb[0].pBt, meta);
434: sqlite_exec(db, "COMMIT", 0, 0, 0);
435: }
436: if( rc!=SQLITE_OK ){
437: sqliteSetString(pzErrMsg,
438: "unable to upgrade database to the version 2.6 format",
439: zErr ? ": " : 0, zErr, (char*)0);
440: }
441: sqlite_freemem(zErr);
442: }
443:
444: if( rc!=SQLITE_OK ){
445: db->flags &= ~SQLITE_Initialized;
446: }
447: return rc;
448: }
449:
450: /*
451: ** The version of the library
452: */
453: const char rcsid[] = "@(#) \044Id: SQLite version " SQLITE_VERSION " $";
454: const char sqlite_version[] = SQLITE_VERSION;
455:
456: /*
457: ** Does the library expect data to be encoded as UTF-8 or iso8859? The
458: ** following global constant always lets us know.
459: */
460: #ifdef SQLITE_UTF8
461: const char sqlite_encoding[] = "UTF-8";
462: #else
463: const char sqlite_encoding[] = "iso8859";
464: #endif
465:
466: /*
467: ** Open a new SQLite database. Construct an "sqlite" structure to define
468: ** the state of this database and return a pointer to that structure.
469: **
470: ** An attempt is made to initialize the in-memory data structures that
471: ** hold the database schema. But if this fails (because the schema file
472: ** is locked) then that step is deferred until the first call to
473: ** sqlite_exec().
474: */
475: sqlite *sqlite_open(const char *zFilename, int mode, char **pzErrMsg){
476: sqlite *db;
477: int rc, i;
478:
479: /* Allocate the sqlite data structure */
480: db = sqliteMalloc( sizeof(sqlite) );
481: if( pzErrMsg ) *pzErrMsg = 0;
482: if( db==0 ) goto no_mem_on_open;
483: db->onError = OE_Default;
484: db->priorNewRowid = 0;
485: db->magic = SQLITE_MAGIC_BUSY;
486: db->nDb = 2;
487: db->aDb = db->aDbStatic;
488: /* db->flags |= SQLITE_ShortColNames; */
489: sqliteHashInit(&db->aFunc, SQLITE_HASH_STRING, 1);
490: for(i=0; i<db->nDb; i++){
491: sqliteHashInit(&db->aDb[i].tblHash, SQLITE_HASH_STRING, 0);
492: sqliteHashInit(&db->aDb[i].idxHash, SQLITE_HASH_STRING, 0);
493: sqliteHashInit(&db->aDb[i].trigHash, SQLITE_HASH_STRING, 0);
494: sqliteHashInit(&db->aDb[i].aFKey, SQLITE_HASH_STRING, 1);
495: }
496:
497: /* Open the backend database driver */
498: if( zFilename[0]==':' && strcmp(zFilename,":memory:")==0 ){
499: db->temp_store = 2;
500: }
501: rc = sqliteBtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);
502: if( rc!=SQLITE_OK ){
503: switch( rc ){
504: default: {
505: sqliteSetString(pzErrMsg, "unable to open database: ",
506: zFilename, (char*)0);
507: }
508: }
509: sqliteFree(db);
510: sqliteStrRealloc(pzErrMsg);
511: return 0;
512: }
513: db->aDb[0].zName = "main";
514: db->aDb[1].zName = "temp";
515:
516: /* Attempt to read the schema */
517: sqliteRegisterBuiltinFunctions(db);
518: rc = sqliteInit(db, pzErrMsg);
519: db->magic = SQLITE_MAGIC_OPEN;
520: if( sqlite_malloc_failed ){
521: sqlite_close(db);
522: goto no_mem_on_open;
523: }else if( rc!=SQLITE_OK && rc!=SQLITE_BUSY ){
524: sqlite_close(db);
525: sqliteStrRealloc(pzErrMsg);
526: return 0;
527: }else if( pzErrMsg ){
528: sqliteFree(*pzErrMsg);
529: *pzErrMsg = 0;
530: }
531:
532: /* Return a pointer to the newly opened database structure */
533: return db;
534:
535: no_mem_on_open:
536: sqliteSetString(pzErrMsg, "out of memory", (char*)0);
537: sqliteStrRealloc(pzErrMsg);
538: return 0;
539: }
540:
541: /*
542: ** Return the ROWID of the most recent insert
543: */
544: int sqlite_last_insert_rowid(sqlite *db){
545: return db->lastRowid;
546: }
547:
548: /*
549: ** Return the number of changes in the most recent call to sqlite_exec().
550: */
551: int sqlite_changes(sqlite *db){
552: return db->nChange;
553: }
554:
555: /*
556: ** Return the number of changes produced by the last INSERT, UPDATE, or
557: ** DELETE statement to complete execution. The count does not include
558: ** changes due to SQL statements executed in trigger programs that were
559: ** triggered by that statement
560: */
561: int sqlite_last_statement_changes(sqlite *db){
562: return db->lsChange;
563: }
564:
565: /*
566: ** Close an existing SQLite database
567: */
568: void sqlite_close(sqlite *db){
569: HashElem *i;
570: int j;
571: db->want_to_close = 1;
572: if( sqliteSafetyCheck(db) || sqliteSafetyOn(db) ){
573: /* printf("DID NOT CLOSE\n"); fflush(stdout); */
574: return;
575: }
576: db->magic = SQLITE_MAGIC_CLOSED;
577: for(j=0; j<db->nDb; j++){
578: struct Db *pDb = &db->aDb[j];
579: if( pDb->pBt ){
580: sqliteBtreeClose(pDb->pBt);
581: pDb->pBt = 0;
582: }
583: }
584: sqliteResetInternalSchema(db, 0);
585: assert( db->nDb<=2 );
586: assert( db->aDb==db->aDbStatic );
587: for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
588: FuncDef *pFunc, *pNext;
589: for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){
590: pNext = pFunc->pNext;
591: sqliteFree(pFunc);
592: }
593: }
594: sqliteHashClear(&db->aFunc);
595: sqliteFree(db);
596: }
597:
598: /*
599: ** Rollback all database files.
600: */
601: void sqliteRollbackAll(sqlite *db){
602: int i;
603: for(i=0; i<db->nDb; i++){
604: if( db->aDb[i].pBt ){
605: sqliteBtreeRollback(db->aDb[i].pBt);
606: db->aDb[i].inTrans = 0;
607: }
608: }
609: sqliteResetInternalSchema(db, 0);
610: /* sqliteRollbackInternalChanges(db); */
611: }
612:
613: /*
614: ** Execute SQL code. Return one of the SQLITE_ success/failure
615: ** codes. Also write an error message into memory obtained from
616: ** malloc() and make *pzErrMsg point to that message.
617: **
618: ** If the SQL is a query, then for each row in the query result
619: ** the xCallback() function is called. pArg becomes the first
620: ** argument to xCallback(). If xCallback=NULL then no callback
621: ** is invoked, even for queries.
622: */
623: int sqlite_exec(
624: sqlite *db, /* The database on which the SQL executes */
625: const char *zSql, /* The SQL to be executed */
626: sqlite_callback xCallback, /* Invoke this callback routine */
627: void *pArg, /* First argument to xCallback() */
628: char **pzErrMsg /* Write error messages here */
629: ){
630: int rc = SQLITE_OK;
631: const char *zLeftover;
632: sqlite_vm *pVm;
633: int nRetry = 0;
634: int nChange = 0;
635: int nCallback;
636:
637: if( zSql==0 ) return SQLITE_OK;
638: while( rc==SQLITE_OK && zSql[0] ){
639: pVm = 0;
640: rc = sqlite_compile(db, zSql, &zLeftover, &pVm, pzErrMsg);
641: if( rc!=SQLITE_OK ){
642: assert( pVm==0 || sqlite_malloc_failed );
643: return rc;
644: }
645: if( pVm==0 ){
646: /* This happens if the zSql input contained only whitespace */
647: break;
648: }
649: db->nChange += nChange;
650: nCallback = 0;
651: while(1){
652: int nArg;
653: char **azArg, **azCol;
654: rc = sqlite_step(pVm, &nArg, (const char***)&azArg,(const char***)&azCol);
655: if( rc==SQLITE_ROW ){
656: if( xCallback!=0 && xCallback(pArg, nArg, azArg, azCol) ){
657: sqlite_finalize(pVm, 0);
658: return SQLITE_ABORT;
659: }
660: nCallback++;
661: }else{
662: if( rc==SQLITE_DONE && nCallback==0
663: && (db->flags & SQLITE_NullCallback)!=0 && xCallback!=0 ){
664: xCallback(pArg, nArg, azArg, azCol);
665: }
666: rc = sqlite_finalize(pVm, pzErrMsg);
667: if( rc==SQLITE_SCHEMA && nRetry<2 ){
668: nRetry++;
669: rc = SQLITE_OK;
670: break;
671: }
672: if( db->pVdbe==0 ){
673: nChange = db->nChange;
674: }
675: nRetry = 0;
676: zSql = zLeftover;
677: while( isspace(zSql[0]) ) zSql++;
678: break;
679: }
680: }
681: }
682: return rc;
683: }
684:
685:
686: /*
687: ** Compile a single statement of SQL into a virtual machine. Return one
688: ** of the SQLITE_ success/failure codes. Also write an error message into
689: ** memory obtained from malloc() and make *pzErrMsg point to that message.
690: */
691: int sqlite_compile(
692: sqlite *db, /* The database on which the SQL executes */
693: const char *zSql, /* The SQL to be executed */
694: const char **pzTail, /* OUT: Next statement after the first */
695: sqlite_vm **ppVm, /* OUT: The virtual machine */
696: char **pzErrMsg /* OUT: Write error messages here */
697: ){
698: Parse sParse;
699:
700: if( pzErrMsg ) *pzErrMsg = 0;
701: if( sqliteSafetyOn(db) ) goto exec_misuse;
702: if( !db->init.busy ){
703: if( (db->flags & SQLITE_Initialized)==0 ){
704: int rc, cnt = 1;
705: while( (rc = sqliteInit(db, pzErrMsg))==SQLITE_BUSY
706: && db->xBusyCallback
707: && db->xBusyCallback(db->pBusyArg, "", cnt++)!=0 ){}
708: if( rc!=SQLITE_OK ){
709: sqliteStrRealloc(pzErrMsg);
710: sqliteSafetyOff(db);
711: return rc;
712: }
713: if( pzErrMsg ){
714: sqliteFree(*pzErrMsg);
715: *pzErrMsg = 0;
716: }
717: }
718: if( db->file_format<3 ){
719: sqliteSafetyOff(db);
720: sqliteSetString(pzErrMsg, "obsolete database file format", (char*)0);
721: return SQLITE_ERROR;
722: }
723: }
724: assert( (db->flags & SQLITE_Initialized)!=0 || db->init.busy );
725: if( db->pVdbe==0 ){ db->nChange = 0; }
726: memset(&sParse, 0, sizeof(sParse));
727: sParse.db = db;
728: sqliteRunParser(&sParse, zSql, pzErrMsg);
729: if( db->xTrace && !db->init.busy ){
730: /* Trace only the statment that was compiled.
731: ** Make a copy of that part of the SQL string since zSQL is const
732: ** and we must pass a zero terminated string to the trace function
733: ** The copy is unnecessary if the tail pointer is pointing at the
734: ** beginnig or end of the SQL string.
735: */
736: if( sParse.zTail && sParse.zTail!=zSql && *sParse.zTail ){
737: char *tmpSql = sqliteStrNDup(zSql, sParse.zTail - zSql);
738: if( tmpSql ){
739: db->xTrace(db->pTraceArg, tmpSql);
740: free(tmpSql);
741: }else{
742: /* If a memory error occurred during the copy,
743: ** trace entire SQL string and fall through to the
744: ** sqlite_malloc_failed test to report the error.
745: */
746: db->xTrace(db->pTraceArg, zSql);
747: }
748: }else{
749: db->xTrace(db->pTraceArg, zSql);
750: }
751: }
752: if( sqlite_malloc_failed ){
753: sqliteSetString(pzErrMsg, "out of memory", (char*)0);
754: sParse.rc = SQLITE_NOMEM;
755: sqliteRollbackAll(db);
756: sqliteResetInternalSchema(db, 0);
757: db->flags &= ~SQLITE_InTrans;
758: }
759: if( sParse.rc==SQLITE_DONE ) sParse.rc = SQLITE_OK;
760: if( sParse.rc!=SQLITE_OK && pzErrMsg && *pzErrMsg==0 ){
761: sqliteSetString(pzErrMsg, sqlite_error_string(sParse.rc), (char*)0);
762: }
763: sqliteStrRealloc(pzErrMsg);
764: if( sParse.rc==SQLITE_SCHEMA ){
765: sqliteResetInternalSchema(db, 0);
766: }
767: assert( ppVm );
768: *ppVm = (sqlite_vm*)sParse.pVdbe;
769: if( pzTail ) *pzTail = sParse.zTail;
770: if( sqliteSafetyOff(db) ) goto exec_misuse;
771: return sParse.rc;
772:
773: exec_misuse:
774: if( pzErrMsg ){
775: *pzErrMsg = 0;
776: sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0);
777: sqliteStrRealloc(pzErrMsg);
778: }
779: return SQLITE_MISUSE;
780: }
781:
782:
783: /*
784: ** The following routine destroys a virtual machine that is created by
785: ** the sqlite_compile() routine.
786: **
787: ** The integer returned is an SQLITE_ success/failure code that describes
788: ** the result of executing the virtual machine. An error message is
789: ** written into memory obtained from malloc and *pzErrMsg is made to
790: ** point to that error if pzErrMsg is not NULL. The calling routine
791: ** should use sqlite_freemem() to delete the message when it has finished
792: ** with it.
793: */
794: int sqlite_finalize(
795: sqlite_vm *pVm, /* The virtual machine to be destroyed */
796: char **pzErrMsg /* OUT: Write error messages here */
797: ){
798: int rc = sqliteVdbeFinalize((Vdbe*)pVm, pzErrMsg);
799: sqliteStrRealloc(pzErrMsg);
800: return rc;
801: }
802:
803: /*
804: ** Terminate the current execution of a virtual machine then
805: ** reset the virtual machine back to its starting state so that it
806: ** can be reused. Any error message resulting from the prior execution
807: ** is written into *pzErrMsg. A success code from the prior execution
808: ** is returned.
809: */
810: int sqlite_reset(
811: sqlite_vm *pVm, /* The virtual machine to be destroyed */
812: char **pzErrMsg /* OUT: Write error messages here */
813: ){
814: int rc = sqliteVdbeReset((Vdbe*)pVm, pzErrMsg);
815: sqliteVdbeMakeReady((Vdbe*)pVm, -1, 0);
816: sqliteStrRealloc(pzErrMsg);
817: return rc;
818: }
819:
820: /*
821: ** Return a static string that describes the kind of error specified in the
822: ** argument.
823: */
824: const char *sqlite_error_string(int rc){
825: const char *z;
826: switch( rc ){
827: case SQLITE_OK: z = "not an error"; break;
828: case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
829: case SQLITE_INTERNAL: z = "internal SQLite implementation flaw"; break;
830: case SQLITE_PERM: z = "access permission denied"; break;
831: case SQLITE_ABORT: z = "callback requested query abort"; break;
832: case SQLITE_BUSY: z = "database is locked"; break;
833: case SQLITE_LOCKED: z = "database table is locked"; break;
834: case SQLITE_NOMEM: z = "out of memory"; break;
835: case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
836: case SQLITE_INTERRUPT: z = "interrupted"; break;
837: case SQLITE_IOERR: z = "disk I/O error"; break;
838: case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
839: case SQLITE_NOTFOUND: z = "table or record not found"; break;
840: case SQLITE_FULL: z = "database is full"; break;
841: case SQLITE_CANTOPEN: z = "unable to open database file"; break;
842: case SQLITE_PROTOCOL: z = "database locking protocol failure"; break;
843: case SQLITE_EMPTY: z = "table contains no data"; break;
844: case SQLITE_SCHEMA: z = "database schema has changed"; break;
845: case SQLITE_TOOBIG: z = "too much data for one table row"; break;
846: case SQLITE_CONSTRAINT: z = "constraint failed"; break;
847: case SQLITE_MISMATCH: z = "datatype mismatch"; break;
848: case SQLITE_MISUSE: z = "library routine called out of sequence";break;
849: case SQLITE_NOLFS: z = "kernel lacks large file support"; break;
850: case SQLITE_AUTH: z = "authorization denied"; break;
851: case SQLITE_FORMAT: z = "auxiliary database format error"; break;
852: case SQLITE_RANGE: z = "bind index out of range"; break;
853: case SQLITE_NOTADB: z = "file is encrypted or is not a database";break;
854: default: z = "unknown error"; break;
855: }
856: return z;
857: }
858:
859: /*
860: ** This routine implements a busy callback that sleeps and tries
861: ** again until a timeout value is reached. The timeout value is
862: ** an integer number of milliseconds passed in as the first
863: ** argument.
864: */
865: static int sqliteDefaultBusyCallback(
866: void *Timeout, /* Maximum amount of time to wait */
867: const char *NotUsed, /* The name of the table that is busy */
868: int count /* Number of times table has been busy */
869: ){
870: #if SQLITE_MIN_SLEEP_MS==1
871: static const char delays[] =
872: { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 50, 100};
873: static const short int totals[] =
874: { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228, 287};
875: # define NDELAY (sizeof(delays)/sizeof(delays[0]))
876: int timeout = (int)(long)Timeout;
877: int delay, prior;
878:
879: if( count <= NDELAY ){
880: delay = delays[count-1];
881: prior = totals[count-1];
882: }else{
883: delay = delays[NDELAY-1];
884: prior = totals[NDELAY-1] + delay*(count-NDELAY-1);
885: }
886: if( prior + delay > timeout ){
887: delay = timeout - prior;
888: if( delay<=0 ) return 0;
889: }
890: sqliteOsSleep(delay);
891: return 1;
892: #else
893: int timeout = (int)(long)Timeout;
894: if( (count+1)*1000 > timeout ){
895: return 0;
896: }
897: sqliteOsSleep(1000);
898: return 1;
899: #endif
900: }
901:
902: /*
903: ** This routine sets the busy callback for an Sqlite database to the
904: ** given callback function with the given argument.
905: */
906: void sqlite_busy_handler(
907: sqlite *db,
908: int (*xBusy)(void*,const char*,int),
909: void *pArg
910: ){
911: db->xBusyCallback = xBusy;
912: db->pBusyArg = pArg;
913: }
914:
915: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
916: /*
917: ** This routine sets the progress callback for an Sqlite database to the
918: ** given callback function with the given argument. The progress callback will
919: ** be invoked every nOps opcodes.
920: */
921: void sqlite_progress_handler(
922: sqlite *db,
923: int nOps,
924: int (*xProgress)(void*),
925: void *pArg
926: ){
927: if( nOps>0 ){
928: db->xProgress = xProgress;
929: db->nProgressOps = nOps;
930: db->pProgressArg = pArg;
931: }else{
932: db->xProgress = 0;
933: db->nProgressOps = 0;
934: db->pProgressArg = 0;
935: }
936: }
937: #endif
938:
939:
940: /*
941: ** This routine installs a default busy handler that waits for the
942: ** specified number of milliseconds before returning 0.
943: */
944: void sqlite_busy_timeout(sqlite *db, int ms){
945: if( ms>0 ){
946: sqlite_busy_handler(db, sqliteDefaultBusyCallback, (void*)(long)ms);
947: }else{
948: sqlite_busy_handler(db, 0, 0);
949: }
950: }
951:
952: /*
953: ** Cause any pending operation to stop at its earliest opportunity.
954: */
955: void sqlite_interrupt(sqlite *db){
956: db->flags |= SQLITE_Interrupt;
957: }
958:
959: /*
960: ** Windows systems should call this routine to free memory that
961: ** is returned in the in the errmsg parameter of sqlite_open() when
962: ** SQLite is a DLL. For some reason, it does not work to call free()
963: ** directly.
964: **
965: ** Note that we need to call free() not sqliteFree() here, since every
966: ** string that is exported from SQLite should have already passed through
967: ** sqliteStrRealloc().
968: */
969: void sqlite_freemem(void *p){ free(p); }
970:
971: /*
972: ** Windows systems need functions to call to return the sqlite_version
973: ** and sqlite_encoding strings since they are unable to access constants
974: ** within DLLs.
975: */
976: const char *sqlite_libversion(void){ return sqlite_version; }
977: const char *sqlite_libencoding(void){ return sqlite_encoding; }
978:
979: /*
980: ** Create new user-defined functions. The sqlite_create_function()
981: ** routine creates a regular function and sqlite_create_aggregate()
982: ** creates an aggregate function.
983: **
984: ** Passing a NULL xFunc argument or NULL xStep and xFinalize arguments
985: ** disables the function. Calling sqlite_create_function() with the
986: ** same name and number of arguments as a prior call to
987: ** sqlite_create_aggregate() disables the prior call to
988: ** sqlite_create_aggregate(), and vice versa.
989: **
990: ** If nArg is -1 it means that this function will accept any number
991: ** of arguments, including 0. The maximum allowed value of nArg is 127.
992: */
993: int sqlite_create_function(
994: sqlite *db, /* Add the function to this database connection */
995: const char *zName, /* Name of the function to add */
996: int nArg, /* Number of arguments */
997: void (*xFunc)(sqlite_func*,int,const char**), /* The implementation */
998: void *pUserData /* User data */
999: ){
1000: FuncDef *p;
1001: int nName;
1002: if( db==0 || zName==0 || sqliteSafetyCheck(db) ) return 1;
1003: if( nArg<-1 || nArg>127 ) return 1;
1004: nName = strlen(zName);
1005: if( nName>255 ) return 1;
1006: p = sqliteFindFunction(db, zName, nName, nArg, 1);
1007: if( p==0 ) return 1;
1008: p->xFunc = xFunc;
1009: p->xStep = 0;
1010: p->xFinalize = 0;
1011: p->pUserData = pUserData;
1012: return 0;
1013: }
1014: int sqlite_create_aggregate(
1015: sqlite *db, /* Add the function to this database connection */
1016: const char *zName, /* Name of the function to add */
1017: int nArg, /* Number of arguments */
1018: void (*xStep)(sqlite_func*,int,const char**), /* The step function */
1019: void (*xFinalize)(sqlite_func*), /* The finalizer */
1020: void *pUserData /* User data */
1021: ){
1022: FuncDef *p;
1023: int nName;
1024: if( db==0 || zName==0 || sqliteSafetyCheck(db) ) return 1;
1025: if( nArg<-1 || nArg>127 ) return 1;
1026: nName = strlen(zName);
1027: if( nName>255 ) return 1;
1028: p = sqliteFindFunction(db, zName, nName, nArg, 1);
1029: if( p==0 ) return 1;
1030: p->xFunc = 0;
1031: p->xStep = xStep;
1032: p->xFinalize = xFinalize;
1033: p->pUserData = pUserData;
1034: return 0;
1035: }
1036:
1037: /*
1038: ** Change the datatype for all functions with a given name. See the
1039: ** header comment for the prototype of this function in sqlite.h for
1040: ** additional information.
1041: */
1042: int sqlite_function_type(sqlite *db, const char *zName, int dataType){
1043: FuncDef *p = (FuncDef*)sqliteHashFind(&db->aFunc, zName, strlen(zName));
1044: while( p ){
1045: p->dataType = dataType;
1046: p = p->pNext;
1047: }
1048: return SQLITE_OK;
1049: }
1050:
1051: /*
1052: ** Register a trace function. The pArg from the previously registered trace
1053: ** is returned.
1054: **
1055: ** A NULL trace function means that no tracing is executes. A non-NULL
1056: ** trace is a pointer to a function that is invoked at the start of each
1057: ** sqlite_exec().
1058: */
1059: void *sqlite_trace(sqlite *db, void (*xTrace)(void*,const char*), void *pArg){
1060: void *pOld = db->pTraceArg;
1061: db->xTrace = xTrace;
1062: db->pTraceArg = pArg;
1063: return pOld;
1064: }
1065:
1066: /*** EXPERIMENTAL ***
1067: **
1068: ** Register a function to be invoked when a transaction comments.
1069: ** If either function returns non-zero, then the commit becomes a
1070: ** rollback.
1071: */
1072: void *sqlite_commit_hook(
1073: sqlite *db, /* Attach the hook to this database */
1074: int (*xCallback)(void*), /* Function to invoke on each commit */
1075: void *pArg /* Argument to the function */
1076: ){
1077: void *pOld = db->pCommitArg;
1078: db->xCommitCallback = xCallback;
1079: db->pCommitArg = pArg;
1080: return pOld;
1081: }
1082:
1083:
1084: /*
1085: ** This routine is called to create a connection to a database BTree
1086: ** driver. If zFilename is the name of a file, then that file is
1087: ** opened and used. If zFilename is the magic name ":memory:" then
1088: ** the database is stored in memory (and is thus forgotten as soon as
1089: ** the connection is closed.) If zFilename is NULL then the database
1090: ** is for temporary use only and is deleted as soon as the connection
1091: ** is closed.
1092: **
1093: ** A temporary database can be either a disk file (that is automatically
1094: ** deleted when the file is closed) or a set of red-black trees held in memory,
1095: ** depending on the values of the TEMP_STORE compile-time macro and the
1096: ** db->temp_store variable, according to the following chart:
1097: **
1098: ** TEMP_STORE db->temp_store Location of temporary database
1099: ** ---------- -------------- ------------------------------
1100: ** 0 any file
1101: ** 1 1 file
1102: ** 1 2 memory
1103: ** 1 0 file
1104: ** 2 1 file
1105: ** 2 2 memory
1106: ** 2 0 memory
1107: ** 3 any memory
1108: */
1109: int sqliteBtreeFactory(
1110: const sqlite *db, /* Main database when opening aux otherwise 0 */
1111: const char *zFilename, /* Name of the file containing the BTree database */
1112: int omitJournal, /* if TRUE then do not journal this file */
1113: int nCache, /* How many pages in the page cache */
1114: Btree **ppBtree){ /* Pointer to new Btree object written here */
1115:
1116: assert( ppBtree != 0);
1117:
1118: #ifndef SQLITE_OMIT_INMEMORYDB
1119: if( zFilename==0 ){
1120: if (TEMP_STORE == 0) {
1121: /* Always use file based temporary DB */
1122: return sqliteBtreeOpen(0, omitJournal, nCache, ppBtree);
1123: } else if (TEMP_STORE == 1 || TEMP_STORE == 2) {
1124: /* Switch depending on compile-time and/or runtime settings. */
1125: int location = db->temp_store==0 ? TEMP_STORE : db->temp_store;
1126:
1127: if (location == 1) {
1128: return sqliteBtreeOpen(zFilename, omitJournal, nCache, ppBtree);
1129: } else {
1130: return sqliteRbtreeOpen(0, 0, 0, ppBtree);
1131: }
1132: } else {
1133: /* Always use in-core DB */
1134: return sqliteRbtreeOpen(0, 0, 0, ppBtree);
1135: }
1136: }else if( zFilename[0]==':' && strcmp(zFilename,":memory:")==0 ){
1137: return sqliteRbtreeOpen(0, 0, 0, ppBtree);
1138: }else
1139: #endif
1140: {
1141: return sqliteBtreeOpen(zFilename, omitJournal, nCache, ppBtree);
1142: }
1143: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src