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,v 1.164.2.2 2004/06/26 14:40:05 drh Exp $ 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 } 1144