Annotation of embedaddon/php/ext/sqlite/libsqlite/src/main.c, revision 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