Annotation of embedaddon/sqlite3/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: #include "sqliteInt.h"
! 18:
! 19: #ifdef SQLITE_ENABLE_FTS3
! 20: # include "fts3.h"
! 21: #endif
! 22: #ifdef SQLITE_ENABLE_RTREE
! 23: # include "rtree.h"
! 24: #endif
! 25: #ifdef SQLITE_ENABLE_ICU
! 26: # include "sqliteicu.h"
! 27: #endif
! 28:
! 29: #ifndef SQLITE_AMALGAMATION
! 30: /* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant
! 31: ** contains the text of SQLITE_VERSION macro.
! 32: */
! 33: const char sqlite3_version[] = SQLITE_VERSION;
! 34: #endif
! 35:
! 36: /* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns
! 37: ** a pointer to the to the sqlite3_version[] string constant.
! 38: */
! 39: const char *sqlite3_libversion(void){ return sqlite3_version; }
! 40:
! 41: /* IMPLEMENTATION-OF: R-63124-39300 The sqlite3_sourceid() function returns a
! 42: ** pointer to a string constant whose value is the same as the
! 43: ** SQLITE_SOURCE_ID C preprocessor macro.
! 44: */
! 45: const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
! 46:
! 47: /* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function
! 48: ** returns an integer equal to SQLITE_VERSION_NUMBER.
! 49: */
! 50: int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
! 51:
! 52: /* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
! 53: ** zero if and only if SQLite was compiled with mutexing code omitted due to
! 54: ** the SQLITE_THREADSAFE compile-time option being set to 0.
! 55: */
! 56: int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
! 57:
! 58: #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
! 59: /*
! 60: ** If the following function pointer is not NULL and if
! 61: ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
! 62: ** I/O active are written using this function. These messages
! 63: ** are intended for debugging activity only.
! 64: */
! 65: void (*sqlite3IoTrace)(const char*, ...) = 0;
! 66: #endif
! 67:
! 68: /*
! 69: ** If the following global variable points to a string which is the
! 70: ** name of a directory, then that directory will be used to store
! 71: ** temporary files.
! 72: **
! 73: ** See also the "PRAGMA temp_store_directory" SQL command.
! 74: */
! 75: char *sqlite3_temp_directory = 0;
! 76:
! 77: /*
! 78: ** Initialize SQLite.
! 79: **
! 80: ** This routine must be called to initialize the memory allocation,
! 81: ** VFS, and mutex subsystems prior to doing any serious work with
! 82: ** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
! 83: ** this routine will be called automatically by key routines such as
! 84: ** sqlite3_open().
! 85: **
! 86: ** This routine is a no-op except on its very first call for the process,
! 87: ** or for the first call after a call to sqlite3_shutdown.
! 88: **
! 89: ** The first thread to call this routine runs the initialization to
! 90: ** completion. If subsequent threads call this routine before the first
! 91: ** thread has finished the initialization process, then the subsequent
! 92: ** threads must block until the first thread finishes with the initialization.
! 93: **
! 94: ** The first thread might call this routine recursively. Recursive
! 95: ** calls to this routine should not block, of course. Otherwise the
! 96: ** initialization process would never complete.
! 97: **
! 98: ** Let X be the first thread to enter this routine. Let Y be some other
! 99: ** thread. Then while the initial invocation of this routine by X is
! 100: ** incomplete, it is required that:
! 101: **
! 102: ** * Calls to this routine from Y must block until the outer-most
! 103: ** call by X completes.
! 104: **
! 105: ** * Recursive calls to this routine from thread X return immediately
! 106: ** without blocking.
! 107: */
! 108: int sqlite3_initialize(void){
! 109: MUTEX_LOGIC( sqlite3_mutex *pMaster; ) /* The main static mutex */
! 110: int rc; /* Result code */
! 111:
! 112: #ifdef SQLITE_OMIT_WSD
! 113: rc = sqlite3_wsd_init(4096, 24);
! 114: if( rc!=SQLITE_OK ){
! 115: return rc;
! 116: }
! 117: #endif
! 118:
! 119: /* If SQLite is already completely initialized, then this call
! 120: ** to sqlite3_initialize() should be a no-op. But the initialization
! 121: ** must be complete. So isInit must not be set until the very end
! 122: ** of this routine.
! 123: */
! 124: if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
! 125:
! 126: /* Make sure the mutex subsystem is initialized. If unable to
! 127: ** initialize the mutex subsystem, return early with the error.
! 128: ** If the system is so sick that we are unable to allocate a mutex,
! 129: ** there is not much SQLite is going to be able to do.
! 130: **
! 131: ** The mutex subsystem must take care of serializing its own
! 132: ** initialization.
! 133: */
! 134: rc = sqlite3MutexInit();
! 135: if( rc ) return rc;
! 136:
! 137: /* Initialize the malloc() system and the recursive pInitMutex mutex.
! 138: ** This operation is protected by the STATIC_MASTER mutex. Note that
! 139: ** MutexAlloc() is called for a static mutex prior to initializing the
! 140: ** malloc subsystem - this implies that the allocation of a static
! 141: ** mutex must not require support from the malloc subsystem.
! 142: */
! 143: MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
! 144: sqlite3_mutex_enter(pMaster);
! 145: sqlite3GlobalConfig.isMutexInit = 1;
! 146: if( !sqlite3GlobalConfig.isMallocInit ){
! 147: rc = sqlite3MallocInit();
! 148: }
! 149: if( rc==SQLITE_OK ){
! 150: sqlite3GlobalConfig.isMallocInit = 1;
! 151: if( !sqlite3GlobalConfig.pInitMutex ){
! 152: sqlite3GlobalConfig.pInitMutex =
! 153: sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
! 154: if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
! 155: rc = SQLITE_NOMEM;
! 156: }
! 157: }
! 158: }
! 159: if( rc==SQLITE_OK ){
! 160: sqlite3GlobalConfig.nRefInitMutex++;
! 161: }
! 162: sqlite3_mutex_leave(pMaster);
! 163:
! 164: /* If rc is not SQLITE_OK at this point, then either the malloc
! 165: ** subsystem could not be initialized or the system failed to allocate
! 166: ** the pInitMutex mutex. Return an error in either case. */
! 167: if( rc!=SQLITE_OK ){
! 168: return rc;
! 169: }
! 170:
! 171: /* Do the rest of the initialization under the recursive mutex so
! 172: ** that we will be able to handle recursive calls into
! 173: ** sqlite3_initialize(). The recursive calls normally come through
! 174: ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
! 175: ** recursive calls might also be possible.
! 176: **
! 177: ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
! 178: ** to the xInit method, so the xInit method need not be threadsafe.
! 179: **
! 180: ** The following mutex is what serializes access to the appdef pcache xInit
! 181: ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the
! 182: ** call to sqlite3PcacheInitialize().
! 183: */
! 184: sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
! 185: if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
! 186: FuncDefHash *pHash = &GLOBAL(FuncDefHash, sqlite3GlobalFunctions);
! 187: sqlite3GlobalConfig.inProgress = 1;
! 188: memset(pHash, 0, sizeof(sqlite3GlobalFunctions));
! 189: sqlite3RegisterGlobalFunctions();
! 190: if( sqlite3GlobalConfig.isPCacheInit==0 ){
! 191: rc = sqlite3PcacheInitialize();
! 192: }
! 193: if( rc==SQLITE_OK ){
! 194: sqlite3GlobalConfig.isPCacheInit = 1;
! 195: rc = sqlite3OsInit();
! 196: }
! 197: if( rc==SQLITE_OK ){
! 198: sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
! 199: sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
! 200: sqlite3GlobalConfig.isInit = 1;
! 201: }
! 202: sqlite3GlobalConfig.inProgress = 0;
! 203: }
! 204: sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
! 205:
! 206: /* Go back under the static mutex and clean up the recursive
! 207: ** mutex to prevent a resource leak.
! 208: */
! 209: sqlite3_mutex_enter(pMaster);
! 210: sqlite3GlobalConfig.nRefInitMutex--;
! 211: if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
! 212: assert( sqlite3GlobalConfig.nRefInitMutex==0 );
! 213: sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
! 214: sqlite3GlobalConfig.pInitMutex = 0;
! 215: }
! 216: sqlite3_mutex_leave(pMaster);
! 217:
! 218: /* The following is just a sanity check to make sure SQLite has
! 219: ** been compiled correctly. It is important to run this code, but
! 220: ** we don't want to run it too often and soak up CPU cycles for no
! 221: ** reason. So we run it once during initialization.
! 222: */
! 223: #ifndef NDEBUG
! 224: #ifndef SQLITE_OMIT_FLOATING_POINT
! 225: /* This section of code's only "output" is via assert() statements. */
! 226: if ( rc==SQLITE_OK ){
! 227: u64 x = (((u64)1)<<63)-1;
! 228: double y;
! 229: assert(sizeof(x)==8);
! 230: assert(sizeof(x)==sizeof(y));
! 231: memcpy(&y, &x, 8);
! 232: assert( sqlite3IsNaN(y) );
! 233: }
! 234: #endif
! 235: #endif
! 236:
! 237: /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
! 238: ** compile-time option.
! 239: */
! 240: #ifdef SQLITE_EXTRA_INIT
! 241: if( rc==SQLITE_OK && sqlite3GlobalConfig.isInit ){
! 242: int SQLITE_EXTRA_INIT(const char*);
! 243: rc = SQLITE_EXTRA_INIT(0);
! 244: }
! 245: #endif
! 246:
! 247: return rc;
! 248: }
! 249:
! 250: /*
! 251: ** Undo the effects of sqlite3_initialize(). Must not be called while
! 252: ** there are outstanding database connections or memory allocations or
! 253: ** while any part of SQLite is otherwise in use in any thread. This
! 254: ** routine is not threadsafe. But it is safe to invoke this routine
! 255: ** on when SQLite is already shut down. If SQLite is already shut down
! 256: ** when this routine is invoked, then this routine is a harmless no-op.
! 257: */
! 258: int sqlite3_shutdown(void){
! 259: if( sqlite3GlobalConfig.isInit ){
! 260: #ifdef SQLITE_EXTRA_SHUTDOWN
! 261: void SQLITE_EXTRA_SHUTDOWN(void);
! 262: SQLITE_EXTRA_SHUTDOWN();
! 263: #endif
! 264: sqlite3_os_end();
! 265: sqlite3_reset_auto_extension();
! 266: sqlite3GlobalConfig.isInit = 0;
! 267: }
! 268: if( sqlite3GlobalConfig.isPCacheInit ){
! 269: sqlite3PcacheShutdown();
! 270: sqlite3GlobalConfig.isPCacheInit = 0;
! 271: }
! 272: if( sqlite3GlobalConfig.isMallocInit ){
! 273: sqlite3MallocEnd();
! 274: sqlite3GlobalConfig.isMallocInit = 0;
! 275: }
! 276: if( sqlite3GlobalConfig.isMutexInit ){
! 277: sqlite3MutexEnd();
! 278: sqlite3GlobalConfig.isMutexInit = 0;
! 279: }
! 280:
! 281: return SQLITE_OK;
! 282: }
! 283:
! 284: /*
! 285: ** This API allows applications to modify the global configuration of
! 286: ** the SQLite library at run-time.
! 287: **
! 288: ** This routine should only be called when there are no outstanding
! 289: ** database connections or memory allocations. This routine is not
! 290: ** threadsafe. Failure to heed these warnings can lead to unpredictable
! 291: ** behavior.
! 292: */
! 293: int sqlite3_config(int op, ...){
! 294: va_list ap;
! 295: int rc = SQLITE_OK;
! 296:
! 297: /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
! 298: ** the SQLite library is in use. */
! 299: if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;
! 300:
! 301: va_start(ap, op);
! 302: switch( op ){
! 303:
! 304: /* Mutex configuration options are only available in a threadsafe
! 305: ** compile.
! 306: */
! 307: #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0
! 308: case SQLITE_CONFIG_SINGLETHREAD: {
! 309: /* Disable all mutexing */
! 310: sqlite3GlobalConfig.bCoreMutex = 0;
! 311: sqlite3GlobalConfig.bFullMutex = 0;
! 312: break;
! 313: }
! 314: case SQLITE_CONFIG_MULTITHREAD: {
! 315: /* Disable mutexing of database connections */
! 316: /* Enable mutexing of core data structures */
! 317: sqlite3GlobalConfig.bCoreMutex = 1;
! 318: sqlite3GlobalConfig.bFullMutex = 0;
! 319: break;
! 320: }
! 321: case SQLITE_CONFIG_SERIALIZED: {
! 322: /* Enable all mutexing */
! 323: sqlite3GlobalConfig.bCoreMutex = 1;
! 324: sqlite3GlobalConfig.bFullMutex = 1;
! 325: break;
! 326: }
! 327: case SQLITE_CONFIG_MUTEX: {
! 328: /* Specify an alternative mutex implementation */
! 329: sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
! 330: break;
! 331: }
! 332: case SQLITE_CONFIG_GETMUTEX: {
! 333: /* Retrieve the current mutex implementation */
! 334: *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
! 335: break;
! 336: }
! 337: #endif
! 338:
! 339:
! 340: case SQLITE_CONFIG_MALLOC: {
! 341: /* Specify an alternative malloc implementation */
! 342: sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
! 343: break;
! 344: }
! 345: case SQLITE_CONFIG_GETMALLOC: {
! 346: /* Retrieve the current malloc() implementation */
! 347: if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
! 348: *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
! 349: break;
! 350: }
! 351: case SQLITE_CONFIG_MEMSTATUS: {
! 352: /* Enable or disable the malloc status collection */
! 353: sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
! 354: break;
! 355: }
! 356: case SQLITE_CONFIG_SCRATCH: {
! 357: /* Designate a buffer for scratch memory space */
! 358: sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
! 359: sqlite3GlobalConfig.szScratch = va_arg(ap, int);
! 360: sqlite3GlobalConfig.nScratch = va_arg(ap, int);
! 361: break;
! 362: }
! 363: case SQLITE_CONFIG_PAGECACHE: {
! 364: /* Designate a buffer for page cache memory space */
! 365: sqlite3GlobalConfig.pPage = va_arg(ap, void*);
! 366: sqlite3GlobalConfig.szPage = va_arg(ap, int);
! 367: sqlite3GlobalConfig.nPage = va_arg(ap, int);
! 368: break;
! 369: }
! 370:
! 371: case SQLITE_CONFIG_PCACHE: {
! 372: /* no-op */
! 373: break;
! 374: }
! 375: case SQLITE_CONFIG_GETPCACHE: {
! 376: /* now an error */
! 377: rc = SQLITE_ERROR;
! 378: break;
! 379: }
! 380:
! 381: case SQLITE_CONFIG_PCACHE2: {
! 382: /* Specify an alternative page cache implementation */
! 383: sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
! 384: break;
! 385: }
! 386: case SQLITE_CONFIG_GETPCACHE2: {
! 387: if( sqlite3GlobalConfig.pcache2.xInit==0 ){
! 388: sqlite3PCacheSetDefault();
! 389: }
! 390: *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
! 391: break;
! 392: }
! 393:
! 394: #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
! 395: case SQLITE_CONFIG_HEAP: {
! 396: /* Designate a buffer for heap memory space */
! 397: sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
! 398: sqlite3GlobalConfig.nHeap = va_arg(ap, int);
! 399: sqlite3GlobalConfig.mnReq = va_arg(ap, int);
! 400:
! 401: if( sqlite3GlobalConfig.mnReq<1 ){
! 402: sqlite3GlobalConfig.mnReq = 1;
! 403: }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
! 404: /* cap min request size at 2^12 */
! 405: sqlite3GlobalConfig.mnReq = (1<<12);
! 406: }
! 407:
! 408: if( sqlite3GlobalConfig.pHeap==0 ){
! 409: /* If the heap pointer is NULL, then restore the malloc implementation
! 410: ** back to NULL pointers too. This will cause the malloc to go
! 411: ** back to its default implementation when sqlite3_initialize() is
! 412: ** run.
! 413: */
! 414: memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
! 415: }else{
! 416: /* The heap pointer is not NULL, then install one of the
! 417: ** mem5.c/mem3.c methods. If neither ENABLE_MEMSYS3 nor
! 418: ** ENABLE_MEMSYS5 is defined, return an error.
! 419: */
! 420: #ifdef SQLITE_ENABLE_MEMSYS3
! 421: sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
! 422: #endif
! 423: #ifdef SQLITE_ENABLE_MEMSYS5
! 424: sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
! 425: #endif
! 426: }
! 427: break;
! 428: }
! 429: #endif
! 430:
! 431: case SQLITE_CONFIG_LOOKASIDE: {
! 432: sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
! 433: sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
! 434: break;
! 435: }
! 436:
! 437: /* Record a pointer to the logger funcction and its first argument.
! 438: ** The default is NULL. Logging is disabled if the function pointer is
! 439: ** NULL.
! 440: */
! 441: case SQLITE_CONFIG_LOG: {
! 442: /* MSVC is picky about pulling func ptrs from va lists.
! 443: ** http://support.microsoft.com/kb/47961
! 444: ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
! 445: */
! 446: typedef void(*LOGFUNC_t)(void*,int,const char*);
! 447: sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
! 448: sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
! 449: break;
! 450: }
! 451:
! 452: case SQLITE_CONFIG_URI: {
! 453: sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
! 454: break;
! 455: }
! 456:
! 457: default: {
! 458: rc = SQLITE_ERROR;
! 459: break;
! 460: }
! 461: }
! 462: va_end(ap);
! 463: return rc;
! 464: }
! 465:
! 466: /*
! 467: ** Set up the lookaside buffers for a database connection.
! 468: ** Return SQLITE_OK on success.
! 469: ** If lookaside is already active, return SQLITE_BUSY.
! 470: **
! 471: ** The sz parameter is the number of bytes in each lookaside slot.
! 472: ** The cnt parameter is the number of slots. If pStart is NULL the
! 473: ** space for the lookaside memory is obtained from sqlite3_malloc().
! 474: ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
! 475: ** the lookaside memory.
! 476: */
! 477: static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
! 478: void *pStart;
! 479: if( db->lookaside.nOut ){
! 480: return SQLITE_BUSY;
! 481: }
! 482: /* Free any existing lookaside buffer for this handle before
! 483: ** allocating a new one so we don't have to have space for
! 484: ** both at the same time.
! 485: */
! 486: if( db->lookaside.bMalloced ){
! 487: sqlite3_free(db->lookaside.pStart);
! 488: }
! 489: /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger
! 490: ** than a pointer to be useful.
! 491: */
! 492: sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */
! 493: if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
! 494: if( cnt<0 ) cnt = 0;
! 495: if( sz==0 || cnt==0 ){
! 496: sz = 0;
! 497: pStart = 0;
! 498: }else if( pBuf==0 ){
! 499: sqlite3BeginBenignMalloc();
! 500: pStart = sqlite3Malloc( sz*cnt ); /* IMP: R-61949-35727 */
! 501: sqlite3EndBenignMalloc();
! 502: if( pStart ) cnt = sqlite3MallocSize(pStart)/sz;
! 503: }else{
! 504: pStart = pBuf;
! 505: }
! 506: db->lookaside.pStart = pStart;
! 507: db->lookaside.pFree = 0;
! 508: db->lookaside.sz = (u16)sz;
! 509: if( pStart ){
! 510: int i;
! 511: LookasideSlot *p;
! 512: assert( sz > (int)sizeof(LookasideSlot*) );
! 513: p = (LookasideSlot*)pStart;
! 514: for(i=cnt-1; i>=0; i--){
! 515: p->pNext = db->lookaside.pFree;
! 516: db->lookaside.pFree = p;
! 517: p = (LookasideSlot*)&((u8*)p)[sz];
! 518: }
! 519: db->lookaside.pEnd = p;
! 520: db->lookaside.bEnabled = 1;
! 521: db->lookaside.bMalloced = pBuf==0 ?1:0;
! 522: }else{
! 523: db->lookaside.pEnd = 0;
! 524: db->lookaside.bEnabled = 0;
! 525: db->lookaside.bMalloced = 0;
! 526: }
! 527: return SQLITE_OK;
! 528: }
! 529:
! 530: /*
! 531: ** Return the mutex associated with a database connection.
! 532: */
! 533: sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){
! 534: return db->mutex;
! 535: }
! 536:
! 537: /*
! 538: ** Free up as much memory as we can from the given database
! 539: ** connection.
! 540: */
! 541: int sqlite3_db_release_memory(sqlite3 *db){
! 542: int i;
! 543: sqlite3_mutex_enter(db->mutex);
! 544: sqlite3BtreeEnterAll(db);
! 545: for(i=0; i<db->nDb; i++){
! 546: Btree *pBt = db->aDb[i].pBt;
! 547: if( pBt ){
! 548: Pager *pPager = sqlite3BtreePager(pBt);
! 549: sqlite3PagerShrink(pPager);
! 550: }
! 551: }
! 552: sqlite3BtreeLeaveAll(db);
! 553: sqlite3_mutex_leave(db->mutex);
! 554: return SQLITE_OK;
! 555: }
! 556:
! 557: /*
! 558: ** Configuration settings for an individual database connection
! 559: */
! 560: int sqlite3_db_config(sqlite3 *db, int op, ...){
! 561: va_list ap;
! 562: int rc;
! 563: va_start(ap, op);
! 564: switch( op ){
! 565: case SQLITE_DBCONFIG_LOOKASIDE: {
! 566: void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
! 567: int sz = va_arg(ap, int); /* IMP: R-47871-25994 */
! 568: int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */
! 569: rc = setupLookaside(db, pBuf, sz, cnt);
! 570: break;
! 571: }
! 572: default: {
! 573: static const struct {
! 574: int op; /* The opcode */
! 575: u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
! 576: } aFlagOp[] = {
! 577: { SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys },
! 578: { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger },
! 579: };
! 580: unsigned int i;
! 581: rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
! 582: for(i=0; i<ArraySize(aFlagOp); i++){
! 583: if( aFlagOp[i].op==op ){
! 584: int onoff = va_arg(ap, int);
! 585: int *pRes = va_arg(ap, int*);
! 586: int oldFlags = db->flags;
! 587: if( onoff>0 ){
! 588: db->flags |= aFlagOp[i].mask;
! 589: }else if( onoff==0 ){
! 590: db->flags &= ~aFlagOp[i].mask;
! 591: }
! 592: if( oldFlags!=db->flags ){
! 593: sqlite3ExpirePreparedStatements(db);
! 594: }
! 595: if( pRes ){
! 596: *pRes = (db->flags & aFlagOp[i].mask)!=0;
! 597: }
! 598: rc = SQLITE_OK;
! 599: break;
! 600: }
! 601: }
! 602: break;
! 603: }
! 604: }
! 605: va_end(ap);
! 606: return rc;
! 607: }
! 608:
! 609:
! 610: /*
! 611: ** Return true if the buffer z[0..n-1] contains all spaces.
! 612: */
! 613: static int allSpaces(const char *z, int n){
! 614: while( n>0 && z[n-1]==' ' ){ n--; }
! 615: return n==0;
! 616: }
! 617:
! 618: /*
! 619: ** This is the default collating function named "BINARY" which is always
! 620: ** available.
! 621: **
! 622: ** If the padFlag argument is not NULL then space padding at the end
! 623: ** of strings is ignored. This implements the RTRIM collation.
! 624: */
! 625: static int binCollFunc(
! 626: void *padFlag,
! 627: int nKey1, const void *pKey1,
! 628: int nKey2, const void *pKey2
! 629: ){
! 630: int rc, n;
! 631: n = nKey1<nKey2 ? nKey1 : nKey2;
! 632: rc = memcmp(pKey1, pKey2, n);
! 633: if( rc==0 ){
! 634: if( padFlag
! 635: && allSpaces(((char*)pKey1)+n, nKey1-n)
! 636: && allSpaces(((char*)pKey2)+n, nKey2-n)
! 637: ){
! 638: /* Leave rc unchanged at 0 */
! 639: }else{
! 640: rc = nKey1 - nKey2;
! 641: }
! 642: }
! 643: return rc;
! 644: }
! 645:
! 646: /*
! 647: ** Another built-in collating sequence: NOCASE.
! 648: **
! 649: ** This collating sequence is intended to be used for "case independant
! 650: ** comparison". SQLite's knowledge of upper and lower case equivalents
! 651: ** extends only to the 26 characters used in the English language.
! 652: **
! 653: ** At the moment there is only a UTF-8 implementation.
! 654: */
! 655: static int nocaseCollatingFunc(
! 656: void *NotUsed,
! 657: int nKey1, const void *pKey1,
! 658: int nKey2, const void *pKey2
! 659: ){
! 660: int r = sqlite3StrNICmp(
! 661: (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
! 662: UNUSED_PARAMETER(NotUsed);
! 663: if( 0==r ){
! 664: r = nKey1-nKey2;
! 665: }
! 666: return r;
! 667: }
! 668:
! 669: /*
! 670: ** Return the ROWID of the most recent insert
! 671: */
! 672: sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
! 673: return db->lastRowid;
! 674: }
! 675:
! 676: /*
! 677: ** Return the number of changes in the most recent call to sqlite3_exec().
! 678: */
! 679: int sqlite3_changes(sqlite3 *db){
! 680: return db->nChange;
! 681: }
! 682:
! 683: /*
! 684: ** Return the number of changes since the database handle was opened.
! 685: */
! 686: int sqlite3_total_changes(sqlite3 *db){
! 687: return db->nTotalChange;
! 688: }
! 689:
! 690: /*
! 691: ** Close all open savepoints. This function only manipulates fields of the
! 692: ** database handle object, it does not close any savepoints that may be open
! 693: ** at the b-tree/pager level.
! 694: */
! 695: void sqlite3CloseSavepoints(sqlite3 *db){
! 696: while( db->pSavepoint ){
! 697: Savepoint *pTmp = db->pSavepoint;
! 698: db->pSavepoint = pTmp->pNext;
! 699: sqlite3DbFree(db, pTmp);
! 700: }
! 701: db->nSavepoint = 0;
! 702: db->nStatement = 0;
! 703: db->isTransactionSavepoint = 0;
! 704: }
! 705:
! 706: /*
! 707: ** Invoke the destructor function associated with FuncDef p, if any. Except,
! 708: ** if this is not the last copy of the function, do not invoke it. Multiple
! 709: ** copies of a single function are created when create_function() is called
! 710: ** with SQLITE_ANY as the encoding.
! 711: */
! 712: static void functionDestroy(sqlite3 *db, FuncDef *p){
! 713: FuncDestructor *pDestructor = p->pDestructor;
! 714: if( pDestructor ){
! 715: pDestructor->nRef--;
! 716: if( pDestructor->nRef==0 ){
! 717: pDestructor->xDestroy(pDestructor->pUserData);
! 718: sqlite3DbFree(db, pDestructor);
! 719: }
! 720: }
! 721: }
! 722:
! 723: /*
! 724: ** Close an existing SQLite database
! 725: */
! 726: int sqlite3_close(sqlite3 *db){
! 727: HashElem *i; /* Hash table iterator */
! 728: int j;
! 729:
! 730: if( !db ){
! 731: return SQLITE_OK;
! 732: }
! 733: if( !sqlite3SafetyCheckSickOrOk(db) ){
! 734: return SQLITE_MISUSE_BKPT;
! 735: }
! 736: sqlite3_mutex_enter(db->mutex);
! 737:
! 738: /* Force xDestroy calls on all virtual tables */
! 739: sqlite3ResetInternalSchema(db, -1);
! 740:
! 741: /* If a transaction is open, the ResetInternalSchema() call above
! 742: ** will not have called the xDisconnect() method on any virtual
! 743: ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
! 744: ** call will do so. We need to do this before the check for active
! 745: ** SQL statements below, as the v-table implementation may be storing
! 746: ** some prepared statements internally.
! 747: */
! 748: sqlite3VtabRollback(db);
! 749:
! 750: /* If there are any outstanding VMs, return SQLITE_BUSY. */
! 751: if( db->pVdbe ){
! 752: sqlite3Error(db, SQLITE_BUSY,
! 753: "unable to close due to unfinalised statements");
! 754: sqlite3_mutex_leave(db->mutex);
! 755: return SQLITE_BUSY;
! 756: }
! 757: assert( sqlite3SafetyCheckSickOrOk(db) );
! 758:
! 759: for(j=0; j<db->nDb; j++){
! 760: Btree *pBt = db->aDb[j].pBt;
! 761: if( pBt && sqlite3BtreeIsInBackup(pBt) ){
! 762: sqlite3Error(db, SQLITE_BUSY,
! 763: "unable to close due to unfinished backup operation");
! 764: sqlite3_mutex_leave(db->mutex);
! 765: return SQLITE_BUSY;
! 766: }
! 767: }
! 768:
! 769: /* Free any outstanding Savepoint structures. */
! 770: sqlite3CloseSavepoints(db);
! 771:
! 772: for(j=0; j<db->nDb; j++){
! 773: struct Db *pDb = &db->aDb[j];
! 774: if( pDb->pBt ){
! 775: sqlite3BtreeClose(pDb->pBt);
! 776: pDb->pBt = 0;
! 777: if( j!=1 ){
! 778: pDb->pSchema = 0;
! 779: }
! 780: }
! 781: }
! 782: sqlite3ResetInternalSchema(db, -1);
! 783:
! 784: /* Tell the code in notify.c that the connection no longer holds any
! 785: ** locks and does not require any further unlock-notify callbacks.
! 786: */
! 787: sqlite3ConnectionClosed(db);
! 788:
! 789: assert( db->nDb<=2 );
! 790: assert( db->aDb==db->aDbStatic );
! 791: for(j=0; j<ArraySize(db->aFunc.a); j++){
! 792: FuncDef *pNext, *pHash, *p;
! 793: for(p=db->aFunc.a[j]; p; p=pHash){
! 794: pHash = p->pHash;
! 795: while( p ){
! 796: functionDestroy(db, p);
! 797: pNext = p->pNext;
! 798: sqlite3DbFree(db, p);
! 799: p = pNext;
! 800: }
! 801: }
! 802: }
! 803: for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
! 804: CollSeq *pColl = (CollSeq *)sqliteHashData(i);
! 805: /* Invoke any destructors registered for collation sequence user data. */
! 806: for(j=0; j<3; j++){
! 807: if( pColl[j].xDel ){
! 808: pColl[j].xDel(pColl[j].pUser);
! 809: }
! 810: }
! 811: sqlite3DbFree(db, pColl);
! 812: }
! 813: sqlite3HashClear(&db->aCollSeq);
! 814: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 815: for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
! 816: Module *pMod = (Module *)sqliteHashData(i);
! 817: if( pMod->xDestroy ){
! 818: pMod->xDestroy(pMod->pAux);
! 819: }
! 820: sqlite3DbFree(db, pMod);
! 821: }
! 822: sqlite3HashClear(&db->aModule);
! 823: #endif
! 824:
! 825: sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
! 826: if( db->pErr ){
! 827: sqlite3ValueFree(db->pErr);
! 828: }
! 829: sqlite3CloseExtensions(db);
! 830:
! 831: db->magic = SQLITE_MAGIC_ERROR;
! 832:
! 833: /* The temp-database schema is allocated differently from the other schema
! 834: ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
! 835: ** So it needs to be freed here. Todo: Why not roll the temp schema into
! 836: ** the same sqliteMalloc() as the one that allocates the database
! 837: ** structure?
! 838: */
! 839: sqlite3DbFree(db, db->aDb[1].pSchema);
! 840: sqlite3_mutex_leave(db->mutex);
! 841: db->magic = SQLITE_MAGIC_CLOSED;
! 842: sqlite3_mutex_free(db->mutex);
! 843: assert( db->lookaside.nOut==0 ); /* Fails on a lookaside memory leak */
! 844: if( db->lookaside.bMalloced ){
! 845: sqlite3_free(db->lookaside.pStart);
! 846: }
! 847: sqlite3_free(db);
! 848: return SQLITE_OK;
! 849: }
! 850:
! 851: /*
! 852: ** Rollback all database files.
! 853: */
! 854: void sqlite3RollbackAll(sqlite3 *db){
! 855: int i;
! 856: int inTrans = 0;
! 857: assert( sqlite3_mutex_held(db->mutex) );
! 858: sqlite3BeginBenignMalloc();
! 859: for(i=0; i<db->nDb; i++){
! 860: if( db->aDb[i].pBt ){
! 861: if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
! 862: inTrans = 1;
! 863: }
! 864: sqlite3BtreeRollback(db->aDb[i].pBt);
! 865: db->aDb[i].inTrans = 0;
! 866: }
! 867: }
! 868: sqlite3VtabRollback(db);
! 869: sqlite3EndBenignMalloc();
! 870:
! 871: if( db->flags&SQLITE_InternChanges ){
! 872: sqlite3ExpirePreparedStatements(db);
! 873: sqlite3ResetInternalSchema(db, -1);
! 874: }
! 875:
! 876: /* Any deferred constraint violations have now been resolved. */
! 877: db->nDeferredCons = 0;
! 878:
! 879: /* If one has been configured, invoke the rollback-hook callback */
! 880: if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
! 881: db->xRollbackCallback(db->pRollbackArg);
! 882: }
! 883: }
! 884:
! 885: /*
! 886: ** Return a static string that describes the kind of error specified in the
! 887: ** argument.
! 888: */
! 889: const char *sqlite3ErrStr(int rc){
! 890: static const char* const aMsg[] = {
! 891: /* SQLITE_OK */ "not an error",
! 892: /* SQLITE_ERROR */ "SQL logic error or missing database",
! 893: /* SQLITE_INTERNAL */ 0,
! 894: /* SQLITE_PERM */ "access permission denied",
! 895: /* SQLITE_ABORT */ "callback requested query abort",
! 896: /* SQLITE_BUSY */ "database is locked",
! 897: /* SQLITE_LOCKED */ "database table is locked",
! 898: /* SQLITE_NOMEM */ "out of memory",
! 899: /* SQLITE_READONLY */ "attempt to write a readonly database",
! 900: /* SQLITE_INTERRUPT */ "interrupted",
! 901: /* SQLITE_IOERR */ "disk I/O error",
! 902: /* SQLITE_CORRUPT */ "database disk image is malformed",
! 903: /* SQLITE_NOTFOUND */ "unknown operation",
! 904: /* SQLITE_FULL */ "database or disk is full",
! 905: /* SQLITE_CANTOPEN */ "unable to open database file",
! 906: /* SQLITE_PROTOCOL */ "locking protocol",
! 907: /* SQLITE_EMPTY */ "table contains no data",
! 908: /* SQLITE_SCHEMA */ "database schema has changed",
! 909: /* SQLITE_TOOBIG */ "string or blob too big",
! 910: /* SQLITE_CONSTRAINT */ "constraint failed",
! 911: /* SQLITE_MISMATCH */ "datatype mismatch",
! 912: /* SQLITE_MISUSE */ "library routine called out of sequence",
! 913: /* SQLITE_NOLFS */ "large file support is disabled",
! 914: /* SQLITE_AUTH */ "authorization denied",
! 915: /* SQLITE_FORMAT */ "auxiliary database format error",
! 916: /* SQLITE_RANGE */ "bind or column index out of range",
! 917: /* SQLITE_NOTADB */ "file is encrypted or is not a database",
! 918: };
! 919: rc &= 0xff;
! 920: if( ALWAYS(rc>=0) && rc<(int)(sizeof(aMsg)/sizeof(aMsg[0])) && aMsg[rc]!=0 ){
! 921: return aMsg[rc];
! 922: }else{
! 923: return "unknown error";
! 924: }
! 925: }
! 926:
! 927: /*
! 928: ** This routine implements a busy callback that sleeps and tries
! 929: ** again until a timeout value is reached. The timeout value is
! 930: ** an integer number of milliseconds passed in as the first
! 931: ** argument.
! 932: */
! 933: static int sqliteDefaultBusyCallback(
! 934: void *ptr, /* Database connection */
! 935: int count /* Number of times table has been busy */
! 936: ){
! 937: #if SQLITE_OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
! 938: static const u8 delays[] =
! 939: { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
! 940: static const u8 totals[] =
! 941: { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
! 942: # define NDELAY ArraySize(delays)
! 943: sqlite3 *db = (sqlite3 *)ptr;
! 944: int timeout = db->busyTimeout;
! 945: int delay, prior;
! 946:
! 947: assert( count>=0 );
! 948: if( count < NDELAY ){
! 949: delay = delays[count];
! 950: prior = totals[count];
! 951: }else{
! 952: delay = delays[NDELAY-1];
! 953: prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
! 954: }
! 955: if( prior + delay > timeout ){
! 956: delay = timeout - prior;
! 957: if( delay<=0 ) return 0;
! 958: }
! 959: sqlite3OsSleep(db->pVfs, delay*1000);
! 960: return 1;
! 961: #else
! 962: sqlite3 *db = (sqlite3 *)ptr;
! 963: int timeout = ((sqlite3 *)ptr)->busyTimeout;
! 964: if( (count+1)*1000 > timeout ){
! 965: return 0;
! 966: }
! 967: sqlite3OsSleep(db->pVfs, 1000000);
! 968: return 1;
! 969: #endif
! 970: }
! 971:
! 972: /*
! 973: ** Invoke the given busy handler.
! 974: **
! 975: ** This routine is called when an operation failed with a lock.
! 976: ** If this routine returns non-zero, the lock is retried. If it
! 977: ** returns 0, the operation aborts with an SQLITE_BUSY error.
! 978: */
! 979: int sqlite3InvokeBusyHandler(BusyHandler *p){
! 980: int rc;
! 981: if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0;
! 982: rc = p->xFunc(p->pArg, p->nBusy);
! 983: if( rc==0 ){
! 984: p->nBusy = -1;
! 985: }else{
! 986: p->nBusy++;
! 987: }
! 988: return rc;
! 989: }
! 990:
! 991: /*
! 992: ** This routine sets the busy callback for an Sqlite database to the
! 993: ** given callback function with the given argument.
! 994: */
! 995: int sqlite3_busy_handler(
! 996: sqlite3 *db,
! 997: int (*xBusy)(void*,int),
! 998: void *pArg
! 999: ){
! 1000: sqlite3_mutex_enter(db->mutex);
! 1001: db->busyHandler.xFunc = xBusy;
! 1002: db->busyHandler.pArg = pArg;
! 1003: db->busyHandler.nBusy = 0;
! 1004: sqlite3_mutex_leave(db->mutex);
! 1005: return SQLITE_OK;
! 1006: }
! 1007:
! 1008: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
! 1009: /*
! 1010: ** This routine sets the progress callback for an Sqlite database to the
! 1011: ** given callback function with the given argument. The progress callback will
! 1012: ** be invoked every nOps opcodes.
! 1013: */
! 1014: void sqlite3_progress_handler(
! 1015: sqlite3 *db,
! 1016: int nOps,
! 1017: int (*xProgress)(void*),
! 1018: void *pArg
! 1019: ){
! 1020: sqlite3_mutex_enter(db->mutex);
! 1021: if( nOps>0 ){
! 1022: db->xProgress = xProgress;
! 1023: db->nProgressOps = nOps;
! 1024: db->pProgressArg = pArg;
! 1025: }else{
! 1026: db->xProgress = 0;
! 1027: db->nProgressOps = 0;
! 1028: db->pProgressArg = 0;
! 1029: }
! 1030: sqlite3_mutex_leave(db->mutex);
! 1031: }
! 1032: #endif
! 1033:
! 1034:
! 1035: /*
! 1036: ** This routine installs a default busy handler that waits for the
! 1037: ** specified number of milliseconds before returning 0.
! 1038: */
! 1039: int sqlite3_busy_timeout(sqlite3 *db, int ms){
! 1040: if( ms>0 ){
! 1041: db->busyTimeout = ms;
! 1042: sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
! 1043: }else{
! 1044: sqlite3_busy_handler(db, 0, 0);
! 1045: }
! 1046: return SQLITE_OK;
! 1047: }
! 1048:
! 1049: /*
! 1050: ** Cause any pending operation to stop at its earliest opportunity.
! 1051: */
! 1052: void sqlite3_interrupt(sqlite3 *db){
! 1053: db->u1.isInterrupted = 1;
! 1054: }
! 1055:
! 1056:
! 1057: /*
! 1058: ** This function is exactly the same as sqlite3_create_function(), except
! 1059: ** that it is designed to be called by internal code. The difference is
! 1060: ** that if a malloc() fails in sqlite3_create_function(), an error code
! 1061: ** is returned and the mallocFailed flag cleared.
! 1062: */
! 1063: int sqlite3CreateFunc(
! 1064: sqlite3 *db,
! 1065: const char *zFunctionName,
! 1066: int nArg,
! 1067: int enc,
! 1068: void *pUserData,
! 1069: void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
! 1070: void (*xStep)(sqlite3_context*,int,sqlite3_value **),
! 1071: void (*xFinal)(sqlite3_context*),
! 1072: FuncDestructor *pDestructor
! 1073: ){
! 1074: FuncDef *p;
! 1075: int nName;
! 1076:
! 1077: assert( sqlite3_mutex_held(db->mutex) );
! 1078: if( zFunctionName==0 ||
! 1079: (xFunc && (xFinal || xStep)) ||
! 1080: (!xFunc && (xFinal && !xStep)) ||
! 1081: (!xFunc && (!xFinal && xStep)) ||
! 1082: (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) ||
! 1083: (255<(nName = sqlite3Strlen30( zFunctionName))) ){
! 1084: return SQLITE_MISUSE_BKPT;
! 1085: }
! 1086:
! 1087: #ifndef SQLITE_OMIT_UTF16
! 1088: /* If SQLITE_UTF16 is specified as the encoding type, transform this
! 1089: ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
! 1090: ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
! 1091: **
! 1092: ** If SQLITE_ANY is specified, add three versions of the function
! 1093: ** to the hash table.
! 1094: */
! 1095: if( enc==SQLITE_UTF16 ){
! 1096: enc = SQLITE_UTF16NATIVE;
! 1097: }else if( enc==SQLITE_ANY ){
! 1098: int rc;
! 1099: rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
! 1100: pUserData, xFunc, xStep, xFinal, pDestructor);
! 1101: if( rc==SQLITE_OK ){
! 1102: rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
! 1103: pUserData, xFunc, xStep, xFinal, pDestructor);
! 1104: }
! 1105: if( rc!=SQLITE_OK ){
! 1106: return rc;
! 1107: }
! 1108: enc = SQLITE_UTF16BE;
! 1109: }
! 1110: #else
! 1111: enc = SQLITE_UTF8;
! 1112: #endif
! 1113:
! 1114: /* Check if an existing function is being overridden or deleted. If so,
! 1115: ** and there are active VMs, then return SQLITE_BUSY. If a function
! 1116: ** is being overridden/deleted but there are no active VMs, allow the
! 1117: ** operation to continue but invalidate all precompiled statements.
! 1118: */
! 1119: p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 0);
! 1120: if( p && p->iPrefEnc==enc && p->nArg==nArg ){
! 1121: if( db->activeVdbeCnt ){
! 1122: sqlite3Error(db, SQLITE_BUSY,
! 1123: "unable to delete/modify user-function due to active statements");
! 1124: assert( !db->mallocFailed );
! 1125: return SQLITE_BUSY;
! 1126: }else{
! 1127: sqlite3ExpirePreparedStatements(db);
! 1128: }
! 1129: }
! 1130:
! 1131: p = sqlite3FindFunction(db, zFunctionName, nName, nArg, (u8)enc, 1);
! 1132: assert(p || db->mallocFailed);
! 1133: if( !p ){
! 1134: return SQLITE_NOMEM;
! 1135: }
! 1136:
! 1137: /* If an older version of the function with a configured destructor is
! 1138: ** being replaced invoke the destructor function here. */
! 1139: functionDestroy(db, p);
! 1140:
! 1141: if( pDestructor ){
! 1142: pDestructor->nRef++;
! 1143: }
! 1144: p->pDestructor = pDestructor;
! 1145: p->flags = 0;
! 1146: p->xFunc = xFunc;
! 1147: p->xStep = xStep;
! 1148: p->xFinalize = xFinal;
! 1149: p->pUserData = pUserData;
! 1150: p->nArg = (u16)nArg;
! 1151: return SQLITE_OK;
! 1152: }
! 1153:
! 1154: /*
! 1155: ** Create new user functions.
! 1156: */
! 1157: int sqlite3_create_function(
! 1158: sqlite3 *db,
! 1159: const char *zFunc,
! 1160: int nArg,
! 1161: int enc,
! 1162: void *p,
! 1163: void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
! 1164: void (*xStep)(sqlite3_context*,int,sqlite3_value **),
! 1165: void (*xFinal)(sqlite3_context*)
! 1166: ){
! 1167: return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep,
! 1168: xFinal, 0);
! 1169: }
! 1170:
! 1171: int sqlite3_create_function_v2(
! 1172: sqlite3 *db,
! 1173: const char *zFunc,
! 1174: int nArg,
! 1175: int enc,
! 1176: void *p,
! 1177: void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
! 1178: void (*xStep)(sqlite3_context*,int,sqlite3_value **),
! 1179: void (*xFinal)(sqlite3_context*),
! 1180: void (*xDestroy)(void *)
! 1181: ){
! 1182: int rc = SQLITE_ERROR;
! 1183: FuncDestructor *pArg = 0;
! 1184: sqlite3_mutex_enter(db->mutex);
! 1185: if( xDestroy ){
! 1186: pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
! 1187: if( !pArg ){
! 1188: xDestroy(p);
! 1189: goto out;
! 1190: }
! 1191: pArg->xDestroy = xDestroy;
! 1192: pArg->pUserData = p;
! 1193: }
! 1194: rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
! 1195: if( pArg && pArg->nRef==0 ){
! 1196: assert( rc!=SQLITE_OK );
! 1197: xDestroy(p);
! 1198: sqlite3DbFree(db, pArg);
! 1199: }
! 1200:
! 1201: out:
! 1202: rc = sqlite3ApiExit(db, rc);
! 1203: sqlite3_mutex_leave(db->mutex);
! 1204: return rc;
! 1205: }
! 1206:
! 1207: #ifndef SQLITE_OMIT_UTF16
! 1208: int sqlite3_create_function16(
! 1209: sqlite3 *db,
! 1210: const void *zFunctionName,
! 1211: int nArg,
! 1212: int eTextRep,
! 1213: void *p,
! 1214: void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
! 1215: void (*xStep)(sqlite3_context*,int,sqlite3_value**),
! 1216: void (*xFinal)(sqlite3_context*)
! 1217: ){
! 1218: int rc;
! 1219: char *zFunc8;
! 1220: sqlite3_mutex_enter(db->mutex);
! 1221: assert( !db->mallocFailed );
! 1222: zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
! 1223: rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0);
! 1224: sqlite3DbFree(db, zFunc8);
! 1225: rc = sqlite3ApiExit(db, rc);
! 1226: sqlite3_mutex_leave(db->mutex);
! 1227: return rc;
! 1228: }
! 1229: #endif
! 1230:
! 1231:
! 1232: /*
! 1233: ** Declare that a function has been overloaded by a virtual table.
! 1234: **
! 1235: ** If the function already exists as a regular global function, then
! 1236: ** this routine is a no-op. If the function does not exist, then create
! 1237: ** a new one that always throws a run-time error.
! 1238: **
! 1239: ** When virtual tables intend to provide an overloaded function, they
! 1240: ** should call this routine to make sure the global function exists.
! 1241: ** A global function must exist in order for name resolution to work
! 1242: ** properly.
! 1243: */
! 1244: int sqlite3_overload_function(
! 1245: sqlite3 *db,
! 1246: const char *zName,
! 1247: int nArg
! 1248: ){
! 1249: int nName = sqlite3Strlen30(zName);
! 1250: int rc = SQLITE_OK;
! 1251: sqlite3_mutex_enter(db->mutex);
! 1252: if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
! 1253: rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
! 1254: 0, sqlite3InvalidFunction, 0, 0, 0);
! 1255: }
! 1256: rc = sqlite3ApiExit(db, rc);
! 1257: sqlite3_mutex_leave(db->mutex);
! 1258: return rc;
! 1259: }
! 1260:
! 1261: #ifndef SQLITE_OMIT_TRACE
! 1262: /*
! 1263: ** Register a trace function. The pArg from the previously registered trace
! 1264: ** is returned.
! 1265: **
! 1266: ** A NULL trace function means that no tracing is executes. A non-NULL
! 1267: ** trace is a pointer to a function that is invoked at the start of each
! 1268: ** SQL statement.
! 1269: */
! 1270: void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
! 1271: void *pOld;
! 1272: sqlite3_mutex_enter(db->mutex);
! 1273: pOld = db->pTraceArg;
! 1274: db->xTrace = xTrace;
! 1275: db->pTraceArg = pArg;
! 1276: sqlite3_mutex_leave(db->mutex);
! 1277: return pOld;
! 1278: }
! 1279: /*
! 1280: ** Register a profile function. The pArg from the previously registered
! 1281: ** profile function is returned.
! 1282: **
! 1283: ** A NULL profile function means that no profiling is executes. A non-NULL
! 1284: ** profile is a pointer to a function that is invoked at the conclusion of
! 1285: ** each SQL statement that is run.
! 1286: */
! 1287: void *sqlite3_profile(
! 1288: sqlite3 *db,
! 1289: void (*xProfile)(void*,const char*,sqlite_uint64),
! 1290: void *pArg
! 1291: ){
! 1292: void *pOld;
! 1293: sqlite3_mutex_enter(db->mutex);
! 1294: pOld = db->pProfileArg;
! 1295: db->xProfile = xProfile;
! 1296: db->pProfileArg = pArg;
! 1297: sqlite3_mutex_leave(db->mutex);
! 1298: return pOld;
! 1299: }
! 1300: #endif /* SQLITE_OMIT_TRACE */
! 1301:
! 1302: /*** EXPERIMENTAL ***
! 1303: **
! 1304: ** Register a function to be invoked when a transaction comments.
! 1305: ** If the invoked function returns non-zero, then the commit becomes a
! 1306: ** rollback.
! 1307: */
! 1308: void *sqlite3_commit_hook(
! 1309: sqlite3 *db, /* Attach the hook to this database */
! 1310: int (*xCallback)(void*), /* Function to invoke on each commit */
! 1311: void *pArg /* Argument to the function */
! 1312: ){
! 1313: void *pOld;
! 1314: sqlite3_mutex_enter(db->mutex);
! 1315: pOld = db->pCommitArg;
! 1316: db->xCommitCallback = xCallback;
! 1317: db->pCommitArg = pArg;
! 1318: sqlite3_mutex_leave(db->mutex);
! 1319: return pOld;
! 1320: }
! 1321:
! 1322: /*
! 1323: ** Register a callback to be invoked each time a row is updated,
! 1324: ** inserted or deleted using this database connection.
! 1325: */
! 1326: void *sqlite3_update_hook(
! 1327: sqlite3 *db, /* Attach the hook to this database */
! 1328: void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
! 1329: void *pArg /* Argument to the function */
! 1330: ){
! 1331: void *pRet;
! 1332: sqlite3_mutex_enter(db->mutex);
! 1333: pRet = db->pUpdateArg;
! 1334: db->xUpdateCallback = xCallback;
! 1335: db->pUpdateArg = pArg;
! 1336: sqlite3_mutex_leave(db->mutex);
! 1337: return pRet;
! 1338: }
! 1339:
! 1340: /*
! 1341: ** Register a callback to be invoked each time a transaction is rolled
! 1342: ** back by this database connection.
! 1343: */
! 1344: void *sqlite3_rollback_hook(
! 1345: sqlite3 *db, /* Attach the hook to this database */
! 1346: void (*xCallback)(void*), /* Callback function */
! 1347: void *pArg /* Argument to the function */
! 1348: ){
! 1349: void *pRet;
! 1350: sqlite3_mutex_enter(db->mutex);
! 1351: pRet = db->pRollbackArg;
! 1352: db->xRollbackCallback = xCallback;
! 1353: db->pRollbackArg = pArg;
! 1354: sqlite3_mutex_leave(db->mutex);
! 1355: return pRet;
! 1356: }
! 1357:
! 1358: #ifndef SQLITE_OMIT_WAL
! 1359: /*
! 1360: ** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint().
! 1361: ** Invoke sqlite3_wal_checkpoint if the number of frames in the log file
! 1362: ** is greater than sqlite3.pWalArg cast to an integer (the value configured by
! 1363: ** wal_autocheckpoint()).
! 1364: */
! 1365: int sqlite3WalDefaultHook(
! 1366: void *pClientData, /* Argument */
! 1367: sqlite3 *db, /* Connection */
! 1368: const char *zDb, /* Database */
! 1369: int nFrame /* Size of WAL */
! 1370: ){
! 1371: if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){
! 1372: sqlite3BeginBenignMalloc();
! 1373: sqlite3_wal_checkpoint(db, zDb);
! 1374: sqlite3EndBenignMalloc();
! 1375: }
! 1376: return SQLITE_OK;
! 1377: }
! 1378: #endif /* SQLITE_OMIT_WAL */
! 1379:
! 1380: /*
! 1381: ** Configure an sqlite3_wal_hook() callback to automatically checkpoint
! 1382: ** a database after committing a transaction if there are nFrame or
! 1383: ** more frames in the log file. Passing zero or a negative value as the
! 1384: ** nFrame parameter disables automatic checkpoints entirely.
! 1385: **
! 1386: ** The callback registered by this function replaces any existing callback
! 1387: ** registered using sqlite3_wal_hook(). Likewise, registering a callback
! 1388: ** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
! 1389: ** configured by this function.
! 1390: */
! 1391: int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
! 1392: #ifdef SQLITE_OMIT_WAL
! 1393: UNUSED_PARAMETER(db);
! 1394: UNUSED_PARAMETER(nFrame);
! 1395: #else
! 1396: if( nFrame>0 ){
! 1397: sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));
! 1398: }else{
! 1399: sqlite3_wal_hook(db, 0, 0);
! 1400: }
! 1401: #endif
! 1402: return SQLITE_OK;
! 1403: }
! 1404:
! 1405: /*
! 1406: ** Register a callback to be invoked each time a transaction is written
! 1407: ** into the write-ahead-log by this database connection.
! 1408: */
! 1409: void *sqlite3_wal_hook(
! 1410: sqlite3 *db, /* Attach the hook to this db handle */
! 1411: int(*xCallback)(void *, sqlite3*, const char*, int),
! 1412: void *pArg /* First argument passed to xCallback() */
! 1413: ){
! 1414: #ifndef SQLITE_OMIT_WAL
! 1415: void *pRet;
! 1416: sqlite3_mutex_enter(db->mutex);
! 1417: pRet = db->pWalArg;
! 1418: db->xWalCallback = xCallback;
! 1419: db->pWalArg = pArg;
! 1420: sqlite3_mutex_leave(db->mutex);
! 1421: return pRet;
! 1422: #else
! 1423: return 0;
! 1424: #endif
! 1425: }
! 1426:
! 1427: /*
! 1428: ** Checkpoint database zDb.
! 1429: */
! 1430: int sqlite3_wal_checkpoint_v2(
! 1431: sqlite3 *db, /* Database handle */
! 1432: const char *zDb, /* Name of attached database (or NULL) */
! 1433: int eMode, /* SQLITE_CHECKPOINT_* value */
! 1434: int *pnLog, /* OUT: Size of WAL log in frames */
! 1435: int *pnCkpt /* OUT: Total number of frames checkpointed */
! 1436: ){
! 1437: #ifdef SQLITE_OMIT_WAL
! 1438: return SQLITE_OK;
! 1439: #else
! 1440: int rc; /* Return code */
! 1441: int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */
! 1442:
! 1443: /* Initialize the output variables to -1 in case an error occurs. */
! 1444: if( pnLog ) *pnLog = -1;
! 1445: if( pnCkpt ) *pnCkpt = -1;
! 1446:
! 1447: assert( SQLITE_CHECKPOINT_FULL>SQLITE_CHECKPOINT_PASSIVE );
! 1448: assert( SQLITE_CHECKPOINT_FULL<SQLITE_CHECKPOINT_RESTART );
! 1449: assert( SQLITE_CHECKPOINT_PASSIVE+2==SQLITE_CHECKPOINT_RESTART );
! 1450: if( eMode<SQLITE_CHECKPOINT_PASSIVE || eMode>SQLITE_CHECKPOINT_RESTART ){
! 1451: return SQLITE_MISUSE;
! 1452: }
! 1453:
! 1454: sqlite3_mutex_enter(db->mutex);
! 1455: if( zDb && zDb[0] ){
! 1456: iDb = sqlite3FindDbName(db, zDb);
! 1457: }
! 1458: if( iDb<0 ){
! 1459: rc = SQLITE_ERROR;
! 1460: sqlite3Error(db, SQLITE_ERROR, "unknown database: %s", zDb);
! 1461: }else{
! 1462: rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
! 1463: sqlite3Error(db, rc, 0);
! 1464: }
! 1465: rc = sqlite3ApiExit(db, rc);
! 1466: sqlite3_mutex_leave(db->mutex);
! 1467: return rc;
! 1468: #endif
! 1469: }
! 1470:
! 1471:
! 1472: /*
! 1473: ** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
! 1474: ** to contains a zero-length string, all attached databases are
! 1475: ** checkpointed.
! 1476: */
! 1477: int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
! 1478: return sqlite3_wal_checkpoint_v2(db, zDb, SQLITE_CHECKPOINT_PASSIVE, 0, 0);
! 1479: }
! 1480:
! 1481: #ifndef SQLITE_OMIT_WAL
! 1482: /*
! 1483: ** Run a checkpoint on database iDb. This is a no-op if database iDb is
! 1484: ** not currently open in WAL mode.
! 1485: **
! 1486: ** If a transaction is open on the database being checkpointed, this
! 1487: ** function returns SQLITE_LOCKED and a checkpoint is not attempted. If
! 1488: ** an error occurs while running the checkpoint, an SQLite error code is
! 1489: ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
! 1490: **
! 1491: ** The mutex on database handle db should be held by the caller. The mutex
! 1492: ** associated with the specific b-tree being checkpointed is taken by
! 1493: ** this function while the checkpoint is running.
! 1494: **
! 1495: ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
! 1496: ** checkpointed. If an error is encountered it is returned immediately -
! 1497: ** no attempt is made to checkpoint any remaining databases.
! 1498: **
! 1499: ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
! 1500: */
! 1501: int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
! 1502: int rc = SQLITE_OK; /* Return code */
! 1503: int i; /* Used to iterate through attached dbs */
! 1504: int bBusy = 0; /* True if SQLITE_BUSY has been encountered */
! 1505:
! 1506: assert( sqlite3_mutex_held(db->mutex) );
! 1507: assert( !pnLog || *pnLog==-1 );
! 1508: assert( !pnCkpt || *pnCkpt==-1 );
! 1509:
! 1510: for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
! 1511: if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
! 1512: rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
! 1513: pnLog = 0;
! 1514: pnCkpt = 0;
! 1515: if( rc==SQLITE_BUSY ){
! 1516: bBusy = 1;
! 1517: rc = SQLITE_OK;
! 1518: }
! 1519: }
! 1520: }
! 1521:
! 1522: return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
! 1523: }
! 1524: #endif /* SQLITE_OMIT_WAL */
! 1525:
! 1526: /*
! 1527: ** This function returns true if main-memory should be used instead of
! 1528: ** a temporary file for transient pager files and statement journals.
! 1529: ** The value returned depends on the value of db->temp_store (runtime
! 1530: ** parameter) and the compile time value of SQLITE_TEMP_STORE. The
! 1531: ** following table describes the relationship between these two values
! 1532: ** and this functions return value.
! 1533: **
! 1534: ** SQLITE_TEMP_STORE db->temp_store Location of temporary database
! 1535: ** ----------------- -------------- ------------------------------
! 1536: ** 0 any file (return 0)
! 1537: ** 1 1 file (return 0)
! 1538: ** 1 2 memory (return 1)
! 1539: ** 1 0 file (return 0)
! 1540: ** 2 1 file (return 0)
! 1541: ** 2 2 memory (return 1)
! 1542: ** 2 0 memory (return 1)
! 1543: ** 3 any memory (return 1)
! 1544: */
! 1545: int sqlite3TempInMemory(const sqlite3 *db){
! 1546: #if SQLITE_TEMP_STORE==1
! 1547: return ( db->temp_store==2 );
! 1548: #endif
! 1549: #if SQLITE_TEMP_STORE==2
! 1550: return ( db->temp_store!=1 );
! 1551: #endif
! 1552: #if SQLITE_TEMP_STORE==3
! 1553: return 1;
! 1554: #endif
! 1555: #if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3
! 1556: return 0;
! 1557: #endif
! 1558: }
! 1559:
! 1560: /*
! 1561: ** Return UTF-8 encoded English language explanation of the most recent
! 1562: ** error.
! 1563: */
! 1564: const char *sqlite3_errmsg(sqlite3 *db){
! 1565: const char *z;
! 1566: if( !db ){
! 1567: return sqlite3ErrStr(SQLITE_NOMEM);
! 1568: }
! 1569: if( !sqlite3SafetyCheckSickOrOk(db) ){
! 1570: return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
! 1571: }
! 1572: sqlite3_mutex_enter(db->mutex);
! 1573: if( db->mallocFailed ){
! 1574: z = sqlite3ErrStr(SQLITE_NOMEM);
! 1575: }else{
! 1576: z = (char*)sqlite3_value_text(db->pErr);
! 1577: assert( !db->mallocFailed );
! 1578: if( z==0 ){
! 1579: z = sqlite3ErrStr(db->errCode);
! 1580: }
! 1581: }
! 1582: sqlite3_mutex_leave(db->mutex);
! 1583: return z;
! 1584: }
! 1585:
! 1586: #ifndef SQLITE_OMIT_UTF16
! 1587: /*
! 1588: ** Return UTF-16 encoded English language explanation of the most recent
! 1589: ** error.
! 1590: */
! 1591: const void *sqlite3_errmsg16(sqlite3 *db){
! 1592: static const u16 outOfMem[] = {
! 1593: 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
! 1594: };
! 1595: static const u16 misuse[] = {
! 1596: 'l', 'i', 'b', 'r', 'a', 'r', 'y', ' ',
! 1597: 'r', 'o', 'u', 't', 'i', 'n', 'e', ' ',
! 1598: 'c', 'a', 'l', 'l', 'e', 'd', ' ',
! 1599: 'o', 'u', 't', ' ',
! 1600: 'o', 'f', ' ',
! 1601: 's', 'e', 'q', 'u', 'e', 'n', 'c', 'e', 0
! 1602: };
! 1603:
! 1604: const void *z;
! 1605: if( !db ){
! 1606: return (void *)outOfMem;
! 1607: }
! 1608: if( !sqlite3SafetyCheckSickOrOk(db) ){
! 1609: return (void *)misuse;
! 1610: }
! 1611: sqlite3_mutex_enter(db->mutex);
! 1612: if( db->mallocFailed ){
! 1613: z = (void *)outOfMem;
! 1614: }else{
! 1615: z = sqlite3_value_text16(db->pErr);
! 1616: if( z==0 ){
! 1617: sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
! 1618: SQLITE_UTF8, SQLITE_STATIC);
! 1619: z = sqlite3_value_text16(db->pErr);
! 1620: }
! 1621: /* A malloc() may have failed within the call to sqlite3_value_text16()
! 1622: ** above. If this is the case, then the db->mallocFailed flag needs to
! 1623: ** be cleared before returning. Do this directly, instead of via
! 1624: ** sqlite3ApiExit(), to avoid setting the database handle error message.
! 1625: */
! 1626: db->mallocFailed = 0;
! 1627: }
! 1628: sqlite3_mutex_leave(db->mutex);
! 1629: return z;
! 1630: }
! 1631: #endif /* SQLITE_OMIT_UTF16 */
! 1632:
! 1633: /*
! 1634: ** Return the most recent error code generated by an SQLite routine. If NULL is
! 1635: ** passed to this function, we assume a malloc() failed during sqlite3_open().
! 1636: */
! 1637: int sqlite3_errcode(sqlite3 *db){
! 1638: if( db && !sqlite3SafetyCheckSickOrOk(db) ){
! 1639: return SQLITE_MISUSE_BKPT;
! 1640: }
! 1641: if( !db || db->mallocFailed ){
! 1642: return SQLITE_NOMEM;
! 1643: }
! 1644: return db->errCode & db->errMask;
! 1645: }
! 1646: int sqlite3_extended_errcode(sqlite3 *db){
! 1647: if( db && !sqlite3SafetyCheckSickOrOk(db) ){
! 1648: return SQLITE_MISUSE_BKPT;
! 1649: }
! 1650: if( !db || db->mallocFailed ){
! 1651: return SQLITE_NOMEM;
! 1652: }
! 1653: return db->errCode;
! 1654: }
! 1655:
! 1656: /*
! 1657: ** Create a new collating function for database "db". The name is zName
! 1658: ** and the encoding is enc.
! 1659: */
! 1660: static int createCollation(
! 1661: sqlite3* db,
! 1662: const char *zName,
! 1663: u8 enc,
! 1664: void* pCtx,
! 1665: int(*xCompare)(void*,int,const void*,int,const void*),
! 1666: void(*xDel)(void*)
! 1667: ){
! 1668: CollSeq *pColl;
! 1669: int enc2;
! 1670: int nName = sqlite3Strlen30(zName);
! 1671:
! 1672: assert( sqlite3_mutex_held(db->mutex) );
! 1673:
! 1674: /* If SQLITE_UTF16 is specified as the encoding type, transform this
! 1675: ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
! 1676: ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
! 1677: */
! 1678: enc2 = enc;
! 1679: testcase( enc2==SQLITE_UTF16 );
! 1680: testcase( enc2==SQLITE_UTF16_ALIGNED );
! 1681: if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){
! 1682: enc2 = SQLITE_UTF16NATIVE;
! 1683: }
! 1684: if( enc2<SQLITE_UTF8 || enc2>SQLITE_UTF16BE ){
! 1685: return SQLITE_MISUSE_BKPT;
! 1686: }
! 1687:
! 1688: /* Check if this call is removing or replacing an existing collation
! 1689: ** sequence. If so, and there are active VMs, return busy. If there
! 1690: ** are no active VMs, invalidate any pre-compiled statements.
! 1691: */
! 1692: pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
! 1693: if( pColl && pColl->xCmp ){
! 1694: if( db->activeVdbeCnt ){
! 1695: sqlite3Error(db, SQLITE_BUSY,
! 1696: "unable to delete/modify collation sequence due to active statements");
! 1697: return SQLITE_BUSY;
! 1698: }
! 1699: sqlite3ExpirePreparedStatements(db);
! 1700:
! 1701: /* If collation sequence pColl was created directly by a call to
! 1702: ** sqlite3_create_collation, and not generated by synthCollSeq(),
! 1703: ** then any copies made by synthCollSeq() need to be invalidated.
! 1704: ** Also, collation destructor - CollSeq.xDel() - function may need
! 1705: ** to be called.
! 1706: */
! 1707: if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
! 1708: CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
! 1709: int j;
! 1710: for(j=0; j<3; j++){
! 1711: CollSeq *p = &aColl[j];
! 1712: if( p->enc==pColl->enc ){
! 1713: if( p->xDel ){
! 1714: p->xDel(p->pUser);
! 1715: }
! 1716: p->xCmp = 0;
! 1717: }
! 1718: }
! 1719: }
! 1720: }
! 1721:
! 1722: pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
! 1723: if( pColl==0 ) return SQLITE_NOMEM;
! 1724: pColl->xCmp = xCompare;
! 1725: pColl->pUser = pCtx;
! 1726: pColl->xDel = xDel;
! 1727: pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
! 1728: sqlite3Error(db, SQLITE_OK, 0);
! 1729: return SQLITE_OK;
! 1730: }
! 1731:
! 1732:
! 1733: /*
! 1734: ** This array defines hard upper bounds on limit values. The
! 1735: ** initializer must be kept in sync with the SQLITE_LIMIT_*
! 1736: ** #defines in sqlite3.h.
! 1737: */
! 1738: static const int aHardLimit[] = {
! 1739: SQLITE_MAX_LENGTH,
! 1740: SQLITE_MAX_SQL_LENGTH,
! 1741: SQLITE_MAX_COLUMN,
! 1742: SQLITE_MAX_EXPR_DEPTH,
! 1743: SQLITE_MAX_COMPOUND_SELECT,
! 1744: SQLITE_MAX_VDBE_OP,
! 1745: SQLITE_MAX_FUNCTION_ARG,
! 1746: SQLITE_MAX_ATTACHED,
! 1747: SQLITE_MAX_LIKE_PATTERN_LENGTH,
! 1748: SQLITE_MAX_VARIABLE_NUMBER,
! 1749: SQLITE_MAX_TRIGGER_DEPTH,
! 1750: };
! 1751:
! 1752: /*
! 1753: ** Make sure the hard limits are set to reasonable values
! 1754: */
! 1755: #if SQLITE_MAX_LENGTH<100
! 1756: # error SQLITE_MAX_LENGTH must be at least 100
! 1757: #endif
! 1758: #if SQLITE_MAX_SQL_LENGTH<100
! 1759: # error SQLITE_MAX_SQL_LENGTH must be at least 100
! 1760: #endif
! 1761: #if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
! 1762: # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
! 1763: #endif
! 1764: #if SQLITE_MAX_COMPOUND_SELECT<2
! 1765: # error SQLITE_MAX_COMPOUND_SELECT must be at least 2
! 1766: #endif
! 1767: #if SQLITE_MAX_VDBE_OP<40
! 1768: # error SQLITE_MAX_VDBE_OP must be at least 40
! 1769: #endif
! 1770: #if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>1000
! 1771: # error SQLITE_MAX_FUNCTION_ARG must be between 0 and 1000
! 1772: #endif
! 1773: #if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>62
! 1774: # error SQLITE_MAX_ATTACHED must be between 0 and 62
! 1775: #endif
! 1776: #if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
! 1777: # error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
! 1778: #endif
! 1779: #if SQLITE_MAX_COLUMN>32767
! 1780: # error SQLITE_MAX_COLUMN must not exceed 32767
! 1781: #endif
! 1782: #if SQLITE_MAX_TRIGGER_DEPTH<1
! 1783: # error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
! 1784: #endif
! 1785:
! 1786:
! 1787: /*
! 1788: ** Change the value of a limit. Report the old value.
! 1789: ** If an invalid limit index is supplied, report -1.
! 1790: ** Make no changes but still report the old value if the
! 1791: ** new limit is negative.
! 1792: **
! 1793: ** A new lower limit does not shrink existing constructs.
! 1794: ** It merely prevents new constructs that exceed the limit
! 1795: ** from forming.
! 1796: */
! 1797: int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
! 1798: int oldLimit;
! 1799:
! 1800:
! 1801: /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
! 1802: ** there is a hard upper bound set at compile-time by a C preprocessor
! 1803: ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
! 1804: ** "_MAX_".)
! 1805: */
! 1806: assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
! 1807: assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
! 1808: assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
! 1809: assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
! 1810: assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
! 1811: assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
! 1812: assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
! 1813: assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
! 1814: assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
! 1815: SQLITE_MAX_LIKE_PATTERN_LENGTH );
! 1816: assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
! 1817: assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
! 1818: assert( SQLITE_LIMIT_TRIGGER_DEPTH==(SQLITE_N_LIMIT-1) );
! 1819:
! 1820:
! 1821: if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
! 1822: return -1;
! 1823: }
! 1824: oldLimit = db->aLimit[limitId];
! 1825: if( newLimit>=0 ){ /* IMP: R-52476-28732 */
! 1826: if( newLimit>aHardLimit[limitId] ){
! 1827: newLimit = aHardLimit[limitId]; /* IMP: R-51463-25634 */
! 1828: }
! 1829: db->aLimit[limitId] = newLimit;
! 1830: }
! 1831: return oldLimit; /* IMP: R-53341-35419 */
! 1832: }
! 1833:
! 1834: /*
! 1835: ** This function is used to parse both URIs and non-URI filenames passed by the
! 1836: ** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database
! 1837: ** URIs specified as part of ATTACH statements.
! 1838: **
! 1839: ** The first argument to this function is the name of the VFS to use (or
! 1840: ** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
! 1841: ** query parameter. The second argument contains the URI (or non-URI filename)
! 1842: ** itself. When this function is called the *pFlags variable should contain
! 1843: ** the default flags to open the database handle with. The value stored in
! 1844: ** *pFlags may be updated before returning if the URI filename contains
! 1845: ** "cache=xxx" or "mode=xxx" query parameters.
! 1846: **
! 1847: ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
! 1848: ** the VFS that should be used to open the database file. *pzFile is set to
! 1849: ** point to a buffer containing the name of the file to open. It is the
! 1850: ** responsibility of the caller to eventually call sqlite3_free() to release
! 1851: ** this buffer.
! 1852: **
! 1853: ** If an error occurs, then an SQLite error code is returned and *pzErrMsg
! 1854: ** may be set to point to a buffer containing an English language error
! 1855: ** message. It is the responsibility of the caller to eventually release
! 1856: ** this buffer by calling sqlite3_free().
! 1857: */
! 1858: int sqlite3ParseUri(
! 1859: const char *zDefaultVfs, /* VFS to use if no "vfs=xxx" query option */
! 1860: const char *zUri, /* Nul-terminated URI to parse */
! 1861: unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */
! 1862: sqlite3_vfs **ppVfs, /* OUT: VFS to use */
! 1863: char **pzFile, /* OUT: Filename component of URI */
! 1864: char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
! 1865: ){
! 1866: int rc = SQLITE_OK;
! 1867: unsigned int flags = *pFlags;
! 1868: const char *zVfs = zDefaultVfs;
! 1869: char *zFile;
! 1870: char c;
! 1871: int nUri = sqlite3Strlen30(zUri);
! 1872:
! 1873: assert( *pzErrMsg==0 );
! 1874:
! 1875: if( ((flags & SQLITE_OPEN_URI) || sqlite3GlobalConfig.bOpenUri)
! 1876: && nUri>=5 && memcmp(zUri, "file:", 5)==0
! 1877: ){
! 1878: char *zOpt;
! 1879: int eState; /* Parser state when parsing URI */
! 1880: int iIn; /* Input character index */
! 1881: int iOut = 0; /* Output character index */
! 1882: int nByte = nUri+2; /* Bytes of space to allocate */
! 1883:
! 1884: /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
! 1885: ** method that there may be extra parameters following the file-name. */
! 1886: flags |= SQLITE_OPEN_URI;
! 1887:
! 1888: for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
! 1889: zFile = sqlite3_malloc(nByte);
! 1890: if( !zFile ) return SQLITE_NOMEM;
! 1891:
! 1892: /* Discard the scheme and authority segments of the URI. */
! 1893: if( zUri[5]=='/' && zUri[6]=='/' ){
! 1894: iIn = 7;
! 1895: while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
! 1896:
! 1897: if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
! 1898: *pzErrMsg = sqlite3_mprintf("invalid uri authority: %.*s",
! 1899: iIn-7, &zUri[7]);
! 1900: rc = SQLITE_ERROR;
! 1901: goto parse_uri_out;
! 1902: }
! 1903: }else{
! 1904: iIn = 5;
! 1905: }
! 1906:
! 1907: /* Copy the filename and any query parameters into the zFile buffer.
! 1908: ** Decode %HH escape codes along the way.
! 1909: **
! 1910: ** Within this loop, variable eState may be set to 0, 1 or 2, depending
! 1911: ** on the parsing context. As follows:
! 1912: **
! 1913: ** 0: Parsing file-name.
! 1914: ** 1: Parsing name section of a name=value query parameter.
! 1915: ** 2: Parsing value section of a name=value query parameter.
! 1916: */
! 1917: eState = 0;
! 1918: while( (c = zUri[iIn])!=0 && c!='#' ){
! 1919: iIn++;
! 1920: if( c=='%'
! 1921: && sqlite3Isxdigit(zUri[iIn])
! 1922: && sqlite3Isxdigit(zUri[iIn+1])
! 1923: ){
! 1924: int octet = (sqlite3HexToInt(zUri[iIn++]) << 4);
! 1925: octet += sqlite3HexToInt(zUri[iIn++]);
! 1926:
! 1927: assert( octet>=0 && octet<256 );
! 1928: if( octet==0 ){
! 1929: /* This branch is taken when "%00" appears within the URI. In this
! 1930: ** case we ignore all text in the remainder of the path, name or
! 1931: ** value currently being parsed. So ignore the current character
! 1932: ** and skip to the next "?", "=" or "&", as appropriate. */
! 1933: while( (c = zUri[iIn])!=0 && c!='#'
! 1934: && (eState!=0 || c!='?')
! 1935: && (eState!=1 || (c!='=' && c!='&'))
! 1936: && (eState!=2 || c!='&')
! 1937: ){
! 1938: iIn++;
! 1939: }
! 1940: continue;
! 1941: }
! 1942: c = octet;
! 1943: }else if( eState==1 && (c=='&' || c=='=') ){
! 1944: if( zFile[iOut-1]==0 ){
! 1945: /* An empty option name. Ignore this option altogether. */
! 1946: while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++;
! 1947: continue;
! 1948: }
! 1949: if( c=='&' ){
! 1950: zFile[iOut++] = '\0';
! 1951: }else{
! 1952: eState = 2;
! 1953: }
! 1954: c = 0;
! 1955: }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
! 1956: c = 0;
! 1957: eState = 1;
! 1958: }
! 1959: zFile[iOut++] = c;
! 1960: }
! 1961: if( eState==1 ) zFile[iOut++] = '\0';
! 1962: zFile[iOut++] = '\0';
! 1963: zFile[iOut++] = '\0';
! 1964:
! 1965: /* Check if there were any options specified that should be interpreted
! 1966: ** here. Options that are interpreted here include "vfs" and those that
! 1967: ** correspond to flags that may be passed to the sqlite3_open_v2()
! 1968: ** method. */
! 1969: zOpt = &zFile[sqlite3Strlen30(zFile)+1];
! 1970: while( zOpt[0] ){
! 1971: int nOpt = sqlite3Strlen30(zOpt);
! 1972: char *zVal = &zOpt[nOpt+1];
! 1973: int nVal = sqlite3Strlen30(zVal);
! 1974:
! 1975: if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){
! 1976: zVfs = zVal;
! 1977: }else{
! 1978: struct OpenMode {
! 1979: const char *z;
! 1980: int mode;
! 1981: } *aMode = 0;
! 1982: char *zModeType = 0;
! 1983: int mask = 0;
! 1984: int limit = 0;
! 1985:
! 1986: if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){
! 1987: static struct OpenMode aCacheMode[] = {
! 1988: { "shared", SQLITE_OPEN_SHAREDCACHE },
! 1989: { "private", SQLITE_OPEN_PRIVATECACHE },
! 1990: { 0, 0 }
! 1991: };
! 1992:
! 1993: mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE;
! 1994: aMode = aCacheMode;
! 1995: limit = mask;
! 1996: zModeType = "cache";
! 1997: }
! 1998: if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
! 1999: static struct OpenMode aOpenMode[] = {
! 2000: { "ro", SQLITE_OPEN_READONLY },
! 2001: { "rw", SQLITE_OPEN_READWRITE },
! 2002: { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE },
! 2003: { 0, 0 }
! 2004: };
! 2005:
! 2006: mask = SQLITE_OPEN_READONLY|SQLITE_OPEN_READWRITE|SQLITE_OPEN_CREATE;
! 2007: aMode = aOpenMode;
! 2008: limit = mask & flags;
! 2009: zModeType = "access";
! 2010: }
! 2011:
! 2012: if( aMode ){
! 2013: int i;
! 2014: int mode = 0;
! 2015: for(i=0; aMode[i].z; i++){
! 2016: const char *z = aMode[i].z;
! 2017: if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
! 2018: mode = aMode[i].mode;
! 2019: break;
! 2020: }
! 2021: }
! 2022: if( mode==0 ){
! 2023: *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
! 2024: rc = SQLITE_ERROR;
! 2025: goto parse_uri_out;
! 2026: }
! 2027: if( mode>limit ){
! 2028: *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
! 2029: zModeType, zVal);
! 2030: rc = SQLITE_PERM;
! 2031: goto parse_uri_out;
! 2032: }
! 2033: flags = (flags & ~mask) | mode;
! 2034: }
! 2035: }
! 2036:
! 2037: zOpt = &zVal[nVal+1];
! 2038: }
! 2039:
! 2040: }else{
! 2041: zFile = sqlite3_malloc(nUri+2);
! 2042: if( !zFile ) return SQLITE_NOMEM;
! 2043: memcpy(zFile, zUri, nUri);
! 2044: zFile[nUri] = '\0';
! 2045: zFile[nUri+1] = '\0';
! 2046: }
! 2047:
! 2048: *ppVfs = sqlite3_vfs_find(zVfs);
! 2049: if( *ppVfs==0 ){
! 2050: *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs);
! 2051: rc = SQLITE_ERROR;
! 2052: }
! 2053: parse_uri_out:
! 2054: if( rc!=SQLITE_OK ){
! 2055: sqlite3_free(zFile);
! 2056: zFile = 0;
! 2057: }
! 2058: *pFlags = flags;
! 2059: *pzFile = zFile;
! 2060: return rc;
! 2061: }
! 2062:
! 2063:
! 2064: /*
! 2065: ** This routine does the work of opening a database on behalf of
! 2066: ** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
! 2067: ** is UTF-8 encoded.
! 2068: */
! 2069: static int openDatabase(
! 2070: const char *zFilename, /* Database filename UTF-8 encoded */
! 2071: sqlite3 **ppDb, /* OUT: Returned database handle */
! 2072: unsigned int flags, /* Operational flags */
! 2073: const char *zVfs /* Name of the VFS to use */
! 2074: ){
! 2075: sqlite3 *db; /* Store allocated handle here */
! 2076: int rc; /* Return code */
! 2077: int isThreadsafe; /* True for threadsafe connections */
! 2078: char *zOpen = 0; /* Filename argument to pass to BtreeOpen() */
! 2079: char *zErrMsg = 0; /* Error message from sqlite3ParseUri() */
! 2080:
! 2081: *ppDb = 0;
! 2082: #ifndef SQLITE_OMIT_AUTOINIT
! 2083: rc = sqlite3_initialize();
! 2084: if( rc ) return rc;
! 2085: #endif
! 2086:
! 2087: /* Only allow sensible combinations of bits in the flags argument.
! 2088: ** Throw an error if any non-sense combination is used. If we
! 2089: ** do not block illegal combinations here, it could trigger
! 2090: ** assert() statements in deeper layers. Sensible combinations
! 2091: ** are:
! 2092: **
! 2093: ** 1: SQLITE_OPEN_READONLY
! 2094: ** 2: SQLITE_OPEN_READWRITE
! 2095: ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
! 2096: */
! 2097: assert( SQLITE_OPEN_READONLY == 0x01 );
! 2098: assert( SQLITE_OPEN_READWRITE == 0x02 );
! 2099: assert( SQLITE_OPEN_CREATE == 0x04 );
! 2100: testcase( (1<<(flags&7))==0x02 ); /* READONLY */
! 2101: testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
! 2102: testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
! 2103: if( ((1<<(flags&7)) & 0x46)==0 ) return SQLITE_MISUSE_BKPT;
! 2104:
! 2105: if( sqlite3GlobalConfig.bCoreMutex==0 ){
! 2106: isThreadsafe = 0;
! 2107: }else if( flags & SQLITE_OPEN_NOMUTEX ){
! 2108: isThreadsafe = 0;
! 2109: }else if( flags & SQLITE_OPEN_FULLMUTEX ){
! 2110: isThreadsafe = 1;
! 2111: }else{
! 2112: isThreadsafe = sqlite3GlobalConfig.bFullMutex;
! 2113: }
! 2114: if( flags & SQLITE_OPEN_PRIVATECACHE ){
! 2115: flags &= ~SQLITE_OPEN_SHAREDCACHE;
! 2116: }else if( sqlite3GlobalConfig.sharedCacheEnabled ){
! 2117: flags |= SQLITE_OPEN_SHAREDCACHE;
! 2118: }
! 2119:
! 2120: /* Remove harmful bits from the flags parameter
! 2121: **
! 2122: ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
! 2123: ** dealt with in the previous code block. Besides these, the only
! 2124: ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
! 2125: ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
! 2126: ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits. Silently mask
! 2127: ** off all other flags.
! 2128: */
! 2129: flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
! 2130: SQLITE_OPEN_EXCLUSIVE |
! 2131: SQLITE_OPEN_MAIN_DB |
! 2132: SQLITE_OPEN_TEMP_DB |
! 2133: SQLITE_OPEN_TRANSIENT_DB |
! 2134: SQLITE_OPEN_MAIN_JOURNAL |
! 2135: SQLITE_OPEN_TEMP_JOURNAL |
! 2136: SQLITE_OPEN_SUBJOURNAL |
! 2137: SQLITE_OPEN_MASTER_JOURNAL |
! 2138: SQLITE_OPEN_NOMUTEX |
! 2139: SQLITE_OPEN_FULLMUTEX |
! 2140: SQLITE_OPEN_WAL
! 2141: );
! 2142:
! 2143: /* Allocate the sqlite data structure */
! 2144: db = sqlite3MallocZero( sizeof(sqlite3) );
! 2145: if( db==0 ) goto opendb_out;
! 2146: if( isThreadsafe ){
! 2147: db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
! 2148: if( db->mutex==0 ){
! 2149: sqlite3_free(db);
! 2150: db = 0;
! 2151: goto opendb_out;
! 2152: }
! 2153: }
! 2154: sqlite3_mutex_enter(db->mutex);
! 2155: db->errMask = 0xff;
! 2156: db->nDb = 2;
! 2157: db->magic = SQLITE_MAGIC_BUSY;
! 2158: db->aDb = db->aDbStatic;
! 2159:
! 2160: assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
! 2161: memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
! 2162: db->autoCommit = 1;
! 2163: db->nextAutovac = -1;
! 2164: db->nextPagesize = 0;
! 2165: db->flags |= SQLITE_ShortColNames | SQLITE_AutoIndex | SQLITE_EnableTrigger
! 2166: #if SQLITE_DEFAULT_FILE_FORMAT<4
! 2167: | SQLITE_LegacyFileFmt
! 2168: #endif
! 2169: #ifdef SQLITE_ENABLE_LOAD_EXTENSION
! 2170: | SQLITE_LoadExtension
! 2171: #endif
! 2172: #if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
! 2173: | SQLITE_RecTriggers
! 2174: #endif
! 2175: #if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS
! 2176: | SQLITE_ForeignKeys
! 2177: #endif
! 2178: ;
! 2179: sqlite3HashInit(&db->aCollSeq);
! 2180: #ifndef SQLITE_OMIT_VIRTUALTABLE
! 2181: sqlite3HashInit(&db->aModule);
! 2182: #endif
! 2183:
! 2184: /* Add the default collation sequence BINARY. BINARY works for both UTF-8
! 2185: ** and UTF-16, so add a version for each to avoid any unnecessary
! 2186: ** conversions. The only error that can occur here is a malloc() failure.
! 2187: */
! 2188: createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
! 2189: createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
! 2190: createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
! 2191: createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
! 2192: if( db->mallocFailed ){
! 2193: goto opendb_out;
! 2194: }
! 2195: db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 0);
! 2196: assert( db->pDfltColl!=0 );
! 2197:
! 2198: /* Also add a UTF-8 case-insensitive collation sequence. */
! 2199: createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
! 2200:
! 2201: /* Parse the filename/URI argument. */
! 2202: db->openFlags = flags;
! 2203: rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
! 2204: if( rc!=SQLITE_OK ){
! 2205: if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
! 2206: sqlite3Error(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
! 2207: sqlite3_free(zErrMsg);
! 2208: goto opendb_out;
! 2209: }
! 2210:
! 2211: /* Open the backend database driver */
! 2212: rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
! 2213: flags | SQLITE_OPEN_MAIN_DB);
! 2214: if( rc!=SQLITE_OK ){
! 2215: if( rc==SQLITE_IOERR_NOMEM ){
! 2216: rc = SQLITE_NOMEM;
! 2217: }
! 2218: sqlite3Error(db, rc, 0);
! 2219: goto opendb_out;
! 2220: }
! 2221: db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
! 2222: db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
! 2223:
! 2224:
! 2225: /* The default safety_level for the main database is 'full'; for the temp
! 2226: ** database it is 'NONE'. This matches the pager layer defaults.
! 2227: */
! 2228: db->aDb[0].zName = "main";
! 2229: db->aDb[0].safety_level = 3;
! 2230: db->aDb[1].zName = "temp";
! 2231: db->aDb[1].safety_level = 1;
! 2232:
! 2233: db->magic = SQLITE_MAGIC_OPEN;
! 2234: if( db->mallocFailed ){
! 2235: goto opendb_out;
! 2236: }
! 2237:
! 2238: /* Register all built-in functions, but do not attempt to read the
! 2239: ** database schema yet. This is delayed until the first time the database
! 2240: ** is accessed.
! 2241: */
! 2242: sqlite3Error(db, SQLITE_OK, 0);
! 2243: sqlite3RegisterBuiltinFunctions(db);
! 2244:
! 2245: /* Load automatic extensions - extensions that have been registered
! 2246: ** using the sqlite3_automatic_extension() API.
! 2247: */
! 2248: rc = sqlite3_errcode(db);
! 2249: if( rc==SQLITE_OK ){
! 2250: sqlite3AutoLoadExtensions(db);
! 2251: rc = sqlite3_errcode(db);
! 2252: if( rc!=SQLITE_OK ){
! 2253: goto opendb_out;
! 2254: }
! 2255: }
! 2256:
! 2257: #ifdef SQLITE_ENABLE_FTS1
! 2258: if( !db->mallocFailed ){
! 2259: extern int sqlite3Fts1Init(sqlite3*);
! 2260: rc = sqlite3Fts1Init(db);
! 2261: }
! 2262: #endif
! 2263:
! 2264: #ifdef SQLITE_ENABLE_FTS2
! 2265: if( !db->mallocFailed && rc==SQLITE_OK ){
! 2266: extern int sqlite3Fts2Init(sqlite3*);
! 2267: rc = sqlite3Fts2Init(db);
! 2268: }
! 2269: #endif
! 2270:
! 2271: #ifdef SQLITE_ENABLE_FTS3
! 2272: if( !db->mallocFailed && rc==SQLITE_OK ){
! 2273: rc = sqlite3Fts3Init(db);
! 2274: }
! 2275: #endif
! 2276:
! 2277: #ifdef SQLITE_ENABLE_ICU
! 2278: if( !db->mallocFailed && rc==SQLITE_OK ){
! 2279: rc = sqlite3IcuInit(db);
! 2280: }
! 2281: #endif
! 2282:
! 2283: #ifdef SQLITE_ENABLE_RTREE
! 2284: if( !db->mallocFailed && rc==SQLITE_OK){
! 2285: rc = sqlite3RtreeInit(db);
! 2286: }
! 2287: #endif
! 2288:
! 2289: sqlite3Error(db, rc, 0);
! 2290:
! 2291: /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
! 2292: ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
! 2293: ** mode. Doing nothing at all also makes NORMAL the default.
! 2294: */
! 2295: #ifdef SQLITE_DEFAULT_LOCKING_MODE
! 2296: db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
! 2297: sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
! 2298: SQLITE_DEFAULT_LOCKING_MODE);
! 2299: #endif
! 2300:
! 2301: /* Enable the lookaside-malloc subsystem */
! 2302: setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside,
! 2303: sqlite3GlobalConfig.nLookaside);
! 2304:
! 2305: sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT);
! 2306:
! 2307: opendb_out:
! 2308: sqlite3_free(zOpen);
! 2309: if( db ){
! 2310: assert( db->mutex!=0 || isThreadsafe==0 || sqlite3GlobalConfig.bFullMutex==0 );
! 2311: sqlite3_mutex_leave(db->mutex);
! 2312: }
! 2313: rc = sqlite3_errcode(db);
! 2314: assert( db!=0 || rc==SQLITE_NOMEM );
! 2315: if( rc==SQLITE_NOMEM ){
! 2316: sqlite3_close(db);
! 2317: db = 0;
! 2318: }else if( rc!=SQLITE_OK ){
! 2319: db->magic = SQLITE_MAGIC_SICK;
! 2320: }
! 2321: *ppDb = db;
! 2322: return sqlite3ApiExit(0, rc);
! 2323: }
! 2324:
! 2325: /*
! 2326: ** Open a new database handle.
! 2327: */
! 2328: int sqlite3_open(
! 2329: const char *zFilename,
! 2330: sqlite3 **ppDb
! 2331: ){
! 2332: return openDatabase(zFilename, ppDb,
! 2333: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
! 2334: }
! 2335: int sqlite3_open_v2(
! 2336: const char *filename, /* Database filename (UTF-8) */
! 2337: sqlite3 **ppDb, /* OUT: SQLite db handle */
! 2338: int flags, /* Flags */
! 2339: const char *zVfs /* Name of VFS module to use */
! 2340: ){
! 2341: return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
! 2342: }
! 2343:
! 2344: #ifndef SQLITE_OMIT_UTF16
! 2345: /*
! 2346: ** Open a new database handle.
! 2347: */
! 2348: int sqlite3_open16(
! 2349: const void *zFilename,
! 2350: sqlite3 **ppDb
! 2351: ){
! 2352: char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
! 2353: sqlite3_value *pVal;
! 2354: int rc;
! 2355:
! 2356: assert( zFilename );
! 2357: assert( ppDb );
! 2358: *ppDb = 0;
! 2359: #ifndef SQLITE_OMIT_AUTOINIT
! 2360: rc = sqlite3_initialize();
! 2361: if( rc ) return rc;
! 2362: #endif
! 2363: pVal = sqlite3ValueNew(0);
! 2364: sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
! 2365: zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
! 2366: if( zFilename8 ){
! 2367: rc = openDatabase(zFilename8, ppDb,
! 2368: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
! 2369: assert( *ppDb || rc==SQLITE_NOMEM );
! 2370: if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
! 2371: ENC(*ppDb) = SQLITE_UTF16NATIVE;
! 2372: }
! 2373: }else{
! 2374: rc = SQLITE_NOMEM;
! 2375: }
! 2376: sqlite3ValueFree(pVal);
! 2377:
! 2378: return sqlite3ApiExit(0, rc);
! 2379: }
! 2380: #endif /* SQLITE_OMIT_UTF16 */
! 2381:
! 2382: /*
! 2383: ** Register a new collation sequence with the database handle db.
! 2384: */
! 2385: int sqlite3_create_collation(
! 2386: sqlite3* db,
! 2387: const char *zName,
! 2388: int enc,
! 2389: void* pCtx,
! 2390: int(*xCompare)(void*,int,const void*,int,const void*)
! 2391: ){
! 2392: int rc;
! 2393: sqlite3_mutex_enter(db->mutex);
! 2394: assert( !db->mallocFailed );
! 2395: rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, 0);
! 2396: rc = sqlite3ApiExit(db, rc);
! 2397: sqlite3_mutex_leave(db->mutex);
! 2398: return rc;
! 2399: }
! 2400:
! 2401: /*
! 2402: ** Register a new collation sequence with the database handle db.
! 2403: */
! 2404: int sqlite3_create_collation_v2(
! 2405: sqlite3* db,
! 2406: const char *zName,
! 2407: int enc,
! 2408: void* pCtx,
! 2409: int(*xCompare)(void*,int,const void*,int,const void*),
! 2410: void(*xDel)(void*)
! 2411: ){
! 2412: int rc;
! 2413: sqlite3_mutex_enter(db->mutex);
! 2414: assert( !db->mallocFailed );
! 2415: rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
! 2416: rc = sqlite3ApiExit(db, rc);
! 2417: sqlite3_mutex_leave(db->mutex);
! 2418: return rc;
! 2419: }
! 2420:
! 2421: #ifndef SQLITE_OMIT_UTF16
! 2422: /*
! 2423: ** Register a new collation sequence with the database handle db.
! 2424: */
! 2425: int sqlite3_create_collation16(
! 2426: sqlite3* db,
! 2427: const void *zName,
! 2428: int enc,
! 2429: void* pCtx,
! 2430: int(*xCompare)(void*,int,const void*,int,const void*)
! 2431: ){
! 2432: int rc = SQLITE_OK;
! 2433: char *zName8;
! 2434: sqlite3_mutex_enter(db->mutex);
! 2435: assert( !db->mallocFailed );
! 2436: zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
! 2437: if( zName8 ){
! 2438: rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
! 2439: sqlite3DbFree(db, zName8);
! 2440: }
! 2441: rc = sqlite3ApiExit(db, rc);
! 2442: sqlite3_mutex_leave(db->mutex);
! 2443: return rc;
! 2444: }
! 2445: #endif /* SQLITE_OMIT_UTF16 */
! 2446:
! 2447: /*
! 2448: ** Register a collation sequence factory callback with the database handle
! 2449: ** db. Replace any previously installed collation sequence factory.
! 2450: */
! 2451: int sqlite3_collation_needed(
! 2452: sqlite3 *db,
! 2453: void *pCollNeededArg,
! 2454: void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
! 2455: ){
! 2456: sqlite3_mutex_enter(db->mutex);
! 2457: db->xCollNeeded = xCollNeeded;
! 2458: db->xCollNeeded16 = 0;
! 2459: db->pCollNeededArg = pCollNeededArg;
! 2460: sqlite3_mutex_leave(db->mutex);
! 2461: return SQLITE_OK;
! 2462: }
! 2463:
! 2464: #ifndef SQLITE_OMIT_UTF16
! 2465: /*
! 2466: ** Register a collation sequence factory callback with the database handle
! 2467: ** db. Replace any previously installed collation sequence factory.
! 2468: */
! 2469: int sqlite3_collation_needed16(
! 2470: sqlite3 *db,
! 2471: void *pCollNeededArg,
! 2472: void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
! 2473: ){
! 2474: sqlite3_mutex_enter(db->mutex);
! 2475: db->xCollNeeded = 0;
! 2476: db->xCollNeeded16 = xCollNeeded16;
! 2477: db->pCollNeededArg = pCollNeededArg;
! 2478: sqlite3_mutex_leave(db->mutex);
! 2479: return SQLITE_OK;
! 2480: }
! 2481: #endif /* SQLITE_OMIT_UTF16 */
! 2482:
! 2483: #ifndef SQLITE_OMIT_DEPRECATED
! 2484: /*
! 2485: ** This function is now an anachronism. It used to be used to recover from a
! 2486: ** malloc() failure, but SQLite now does this automatically.
! 2487: */
! 2488: int sqlite3_global_recover(void){
! 2489: return SQLITE_OK;
! 2490: }
! 2491: #endif
! 2492:
! 2493: /*
! 2494: ** Test to see whether or not the database connection is in autocommit
! 2495: ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
! 2496: ** by default. Autocommit is disabled by a BEGIN statement and reenabled
! 2497: ** by the next COMMIT or ROLLBACK.
! 2498: **
! 2499: ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
! 2500: */
! 2501: int sqlite3_get_autocommit(sqlite3 *db){
! 2502: return db->autoCommit;
! 2503: }
! 2504:
! 2505: /*
! 2506: ** The following routines are subtitutes for constants SQLITE_CORRUPT,
! 2507: ** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_IOERR and possibly other error
! 2508: ** constants. They server two purposes:
! 2509: **
! 2510: ** 1. Serve as a convenient place to set a breakpoint in a debugger
! 2511: ** to detect when version error conditions occurs.
! 2512: **
! 2513: ** 2. Invoke sqlite3_log() to provide the source code location where
! 2514: ** a low-level error is first detected.
! 2515: */
! 2516: int sqlite3CorruptError(int lineno){
! 2517: testcase( sqlite3GlobalConfig.xLog!=0 );
! 2518: sqlite3_log(SQLITE_CORRUPT,
! 2519: "database corruption at line %d of [%.10s]",
! 2520: lineno, 20+sqlite3_sourceid());
! 2521: return SQLITE_CORRUPT;
! 2522: }
! 2523: int sqlite3MisuseError(int lineno){
! 2524: testcase( sqlite3GlobalConfig.xLog!=0 );
! 2525: sqlite3_log(SQLITE_MISUSE,
! 2526: "misuse at line %d of [%.10s]",
! 2527: lineno, 20+sqlite3_sourceid());
! 2528: return SQLITE_MISUSE;
! 2529: }
! 2530: int sqlite3CantopenError(int lineno){
! 2531: testcase( sqlite3GlobalConfig.xLog!=0 );
! 2532: sqlite3_log(SQLITE_CANTOPEN,
! 2533: "cannot open file at line %d of [%.10s]",
! 2534: lineno, 20+sqlite3_sourceid());
! 2535: return SQLITE_CANTOPEN;
! 2536: }
! 2537:
! 2538:
! 2539: #ifndef SQLITE_OMIT_DEPRECATED
! 2540: /*
! 2541: ** This is a convenience routine that makes sure that all thread-specific
! 2542: ** data for this thread has been deallocated.
! 2543: **
! 2544: ** SQLite no longer uses thread-specific data so this routine is now a
! 2545: ** no-op. It is retained for historical compatibility.
! 2546: */
! 2547: void sqlite3_thread_cleanup(void){
! 2548: }
! 2549: #endif
! 2550:
! 2551: /*
! 2552: ** Return meta information about a specific column of a database table.
! 2553: ** See comment in sqlite3.h (sqlite.h.in) for details.
! 2554: */
! 2555: #ifdef SQLITE_ENABLE_COLUMN_METADATA
! 2556: int sqlite3_table_column_metadata(
! 2557: sqlite3 *db, /* Connection handle */
! 2558: const char *zDbName, /* Database name or NULL */
! 2559: const char *zTableName, /* Table name */
! 2560: const char *zColumnName, /* Column name */
! 2561: char const **pzDataType, /* OUTPUT: Declared data type */
! 2562: char const **pzCollSeq, /* OUTPUT: Collation sequence name */
! 2563: int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
! 2564: int *pPrimaryKey, /* OUTPUT: True if column part of PK */
! 2565: int *pAutoinc /* OUTPUT: True if column is auto-increment */
! 2566: ){
! 2567: int rc;
! 2568: char *zErrMsg = 0;
! 2569: Table *pTab = 0;
! 2570: Column *pCol = 0;
! 2571: int iCol;
! 2572:
! 2573: char const *zDataType = 0;
! 2574: char const *zCollSeq = 0;
! 2575: int notnull = 0;
! 2576: int primarykey = 0;
! 2577: int autoinc = 0;
! 2578:
! 2579: /* Ensure the database schema has been loaded */
! 2580: sqlite3_mutex_enter(db->mutex);
! 2581: sqlite3BtreeEnterAll(db);
! 2582: rc = sqlite3Init(db, &zErrMsg);
! 2583: if( SQLITE_OK!=rc ){
! 2584: goto error_out;
! 2585: }
! 2586:
! 2587: /* Locate the table in question */
! 2588: pTab = sqlite3FindTable(db, zTableName, zDbName);
! 2589: if( !pTab || pTab->pSelect ){
! 2590: pTab = 0;
! 2591: goto error_out;
! 2592: }
! 2593:
! 2594: /* Find the column for which info is requested */
! 2595: if( sqlite3IsRowid(zColumnName) ){
! 2596: iCol = pTab->iPKey;
! 2597: if( iCol>=0 ){
! 2598: pCol = &pTab->aCol[iCol];
! 2599: }
! 2600: }else{
! 2601: for(iCol=0; iCol<pTab->nCol; iCol++){
! 2602: pCol = &pTab->aCol[iCol];
! 2603: if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
! 2604: break;
! 2605: }
! 2606: }
! 2607: if( iCol==pTab->nCol ){
! 2608: pTab = 0;
! 2609: goto error_out;
! 2610: }
! 2611: }
! 2612:
! 2613: /* The following block stores the meta information that will be returned
! 2614: ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
! 2615: ** and autoinc. At this point there are two possibilities:
! 2616: **
! 2617: ** 1. The specified column name was rowid", "oid" or "_rowid_"
! 2618: ** and there is no explicitly declared IPK column.
! 2619: **
! 2620: ** 2. The table is not a view and the column name identified an
! 2621: ** explicitly declared column. Copy meta information from *pCol.
! 2622: */
! 2623: if( pCol ){
! 2624: zDataType = pCol->zType;
! 2625: zCollSeq = pCol->zColl;
! 2626: notnull = pCol->notNull!=0;
! 2627: primarykey = pCol->isPrimKey!=0;
! 2628: autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
! 2629: }else{
! 2630: zDataType = "INTEGER";
! 2631: primarykey = 1;
! 2632: }
! 2633: if( !zCollSeq ){
! 2634: zCollSeq = "BINARY";
! 2635: }
! 2636:
! 2637: error_out:
! 2638: sqlite3BtreeLeaveAll(db);
! 2639:
! 2640: /* Whether the function call succeeded or failed, set the output parameters
! 2641: ** to whatever their local counterparts contain. If an error did occur,
! 2642: ** this has the effect of zeroing all output parameters.
! 2643: */
! 2644: if( pzDataType ) *pzDataType = zDataType;
! 2645: if( pzCollSeq ) *pzCollSeq = zCollSeq;
! 2646: if( pNotNull ) *pNotNull = notnull;
! 2647: if( pPrimaryKey ) *pPrimaryKey = primarykey;
! 2648: if( pAutoinc ) *pAutoinc = autoinc;
! 2649:
! 2650: if( SQLITE_OK==rc && !pTab ){
! 2651: sqlite3DbFree(db, zErrMsg);
! 2652: zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
! 2653: zColumnName);
! 2654: rc = SQLITE_ERROR;
! 2655: }
! 2656: sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
! 2657: sqlite3DbFree(db, zErrMsg);
! 2658: rc = sqlite3ApiExit(db, rc);
! 2659: sqlite3_mutex_leave(db->mutex);
! 2660: return rc;
! 2661: }
! 2662: #endif
! 2663:
! 2664: /*
! 2665: ** Sleep for a little while. Return the amount of time slept.
! 2666: */
! 2667: int sqlite3_sleep(int ms){
! 2668: sqlite3_vfs *pVfs;
! 2669: int rc;
! 2670: pVfs = sqlite3_vfs_find(0);
! 2671: if( pVfs==0 ) return 0;
! 2672:
! 2673: /* This function works in milliseconds, but the underlying OsSleep()
! 2674: ** API uses microseconds. Hence the 1000's.
! 2675: */
! 2676: rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
! 2677: return rc;
! 2678: }
! 2679:
! 2680: /*
! 2681: ** Enable or disable the extended result codes.
! 2682: */
! 2683: int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
! 2684: sqlite3_mutex_enter(db->mutex);
! 2685: db->errMask = onoff ? 0xffffffff : 0xff;
! 2686: sqlite3_mutex_leave(db->mutex);
! 2687: return SQLITE_OK;
! 2688: }
! 2689:
! 2690: /*
! 2691: ** Invoke the xFileControl method on a particular database.
! 2692: */
! 2693: int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
! 2694: int rc = SQLITE_ERROR;
! 2695: int iDb;
! 2696: sqlite3_mutex_enter(db->mutex);
! 2697: if( zDbName==0 ){
! 2698: iDb = 0;
! 2699: }else{
! 2700: for(iDb=0; iDb<db->nDb; iDb++){
! 2701: if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
! 2702: }
! 2703: }
! 2704: if( iDb<db->nDb ){
! 2705: Btree *pBtree = db->aDb[iDb].pBt;
! 2706: if( pBtree ){
! 2707: Pager *pPager;
! 2708: sqlite3_file *fd;
! 2709: sqlite3BtreeEnter(pBtree);
! 2710: pPager = sqlite3BtreePager(pBtree);
! 2711: assert( pPager!=0 );
! 2712: fd = sqlite3PagerFile(pPager);
! 2713: assert( fd!=0 );
! 2714: if( op==SQLITE_FCNTL_FILE_POINTER ){
! 2715: *(sqlite3_file**)pArg = fd;
! 2716: rc = SQLITE_OK;
! 2717: }else if( fd->pMethods ){
! 2718: rc = sqlite3OsFileControl(fd, op, pArg);
! 2719: }else{
! 2720: rc = SQLITE_NOTFOUND;
! 2721: }
! 2722: sqlite3BtreeLeave(pBtree);
! 2723: }
! 2724: }
! 2725: sqlite3_mutex_leave(db->mutex);
! 2726: return rc;
! 2727: }
! 2728:
! 2729: /*
! 2730: ** Interface to the testing logic.
! 2731: */
! 2732: int sqlite3_test_control(int op, ...){
! 2733: int rc = 0;
! 2734: #ifndef SQLITE_OMIT_BUILTIN_TEST
! 2735: va_list ap;
! 2736: va_start(ap, op);
! 2737: switch( op ){
! 2738:
! 2739: /*
! 2740: ** Save the current state of the PRNG.
! 2741: */
! 2742: case SQLITE_TESTCTRL_PRNG_SAVE: {
! 2743: sqlite3PrngSaveState();
! 2744: break;
! 2745: }
! 2746:
! 2747: /*
! 2748: ** Restore the state of the PRNG to the last state saved using
! 2749: ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
! 2750: ** this verb acts like PRNG_RESET.
! 2751: */
! 2752: case SQLITE_TESTCTRL_PRNG_RESTORE: {
! 2753: sqlite3PrngRestoreState();
! 2754: break;
! 2755: }
! 2756:
! 2757: /*
! 2758: ** Reset the PRNG back to its uninitialized state. The next call
! 2759: ** to sqlite3_randomness() will reseed the PRNG using a single call
! 2760: ** to the xRandomness method of the default VFS.
! 2761: */
! 2762: case SQLITE_TESTCTRL_PRNG_RESET: {
! 2763: sqlite3PrngResetState();
! 2764: break;
! 2765: }
! 2766:
! 2767: /*
! 2768: ** sqlite3_test_control(BITVEC_TEST, size, program)
! 2769: **
! 2770: ** Run a test against a Bitvec object of size. The program argument
! 2771: ** is an array of integers that defines the test. Return -1 on a
! 2772: ** memory allocation error, 0 on success, or non-zero for an error.
! 2773: ** See the sqlite3BitvecBuiltinTest() for additional information.
! 2774: */
! 2775: case SQLITE_TESTCTRL_BITVEC_TEST: {
! 2776: int sz = va_arg(ap, int);
! 2777: int *aProg = va_arg(ap, int*);
! 2778: rc = sqlite3BitvecBuiltinTest(sz, aProg);
! 2779: break;
! 2780: }
! 2781:
! 2782: /*
! 2783: ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
! 2784: **
! 2785: ** Register hooks to call to indicate which malloc() failures
! 2786: ** are benign.
! 2787: */
! 2788: case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
! 2789: typedef void (*void_function)(void);
! 2790: void_function xBenignBegin;
! 2791: void_function xBenignEnd;
! 2792: xBenignBegin = va_arg(ap, void_function);
! 2793: xBenignEnd = va_arg(ap, void_function);
! 2794: sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
! 2795: break;
! 2796: }
! 2797:
! 2798: /*
! 2799: ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
! 2800: **
! 2801: ** Set the PENDING byte to the value in the argument, if X>0.
! 2802: ** Make no changes if X==0. Return the value of the pending byte
! 2803: ** as it existing before this routine was called.
! 2804: **
! 2805: ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in
! 2806: ** an incompatible database file format. Changing the PENDING byte
! 2807: ** while any database connection is open results in undefined and
! 2808: ** dileterious behavior.
! 2809: */
! 2810: case SQLITE_TESTCTRL_PENDING_BYTE: {
! 2811: rc = PENDING_BYTE;
! 2812: #ifndef SQLITE_OMIT_WSD
! 2813: {
! 2814: unsigned int newVal = va_arg(ap, unsigned int);
! 2815: if( newVal ) sqlite3PendingByte = newVal;
! 2816: }
! 2817: #endif
! 2818: break;
! 2819: }
! 2820:
! 2821: /*
! 2822: ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
! 2823: **
! 2824: ** This action provides a run-time test to see whether or not
! 2825: ** assert() was enabled at compile-time. If X is true and assert()
! 2826: ** is enabled, then the return value is true. If X is true and
! 2827: ** assert() is disabled, then the return value is zero. If X is
! 2828: ** false and assert() is enabled, then the assertion fires and the
! 2829: ** process aborts. If X is false and assert() is disabled, then the
! 2830: ** return value is zero.
! 2831: */
! 2832: case SQLITE_TESTCTRL_ASSERT: {
! 2833: volatile int x = 0;
! 2834: assert( (x = va_arg(ap,int))!=0 );
! 2835: rc = x;
! 2836: break;
! 2837: }
! 2838:
! 2839:
! 2840: /*
! 2841: ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
! 2842: **
! 2843: ** This action provides a run-time test to see how the ALWAYS and
! 2844: ** NEVER macros were defined at compile-time.
! 2845: **
! 2846: ** The return value is ALWAYS(X).
! 2847: **
! 2848: ** The recommended test is X==2. If the return value is 2, that means
! 2849: ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
! 2850: ** default setting. If the return value is 1, then ALWAYS() is either
! 2851: ** hard-coded to true or else it asserts if its argument is false.
! 2852: ** The first behavior (hard-coded to true) is the case if
! 2853: ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
! 2854: ** behavior (assert if the argument to ALWAYS() is false) is the case if
! 2855: ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
! 2856: **
! 2857: ** The run-time test procedure might look something like this:
! 2858: **
! 2859: ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
! 2860: ** // ALWAYS() and NEVER() are no-op pass-through macros
! 2861: ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
! 2862: ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
! 2863: ** }else{
! 2864: ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0.
! 2865: ** }
! 2866: */
! 2867: case SQLITE_TESTCTRL_ALWAYS: {
! 2868: int x = va_arg(ap,int);
! 2869: rc = ALWAYS(x);
! 2870: break;
! 2871: }
! 2872:
! 2873: /* sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N)
! 2874: **
! 2875: ** Set the nReserve size to N for the main database on the database
! 2876: ** connection db.
! 2877: */
! 2878: case SQLITE_TESTCTRL_RESERVE: {
! 2879: sqlite3 *db = va_arg(ap, sqlite3*);
! 2880: int x = va_arg(ap,int);
! 2881: sqlite3_mutex_enter(db->mutex);
! 2882: sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
! 2883: sqlite3_mutex_leave(db->mutex);
! 2884: break;
! 2885: }
! 2886:
! 2887: /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
! 2888: **
! 2889: ** Enable or disable various optimizations for testing purposes. The
! 2890: ** argument N is a bitmask of optimizations to be disabled. For normal
! 2891: ** operation N should be 0. The idea is that a test program (like the
! 2892: ** SQL Logic Test or SLT test module) can run the same SQL multiple times
! 2893: ** with various optimizations disabled to verify that the same answer
! 2894: ** is obtained in every case.
! 2895: */
! 2896: case SQLITE_TESTCTRL_OPTIMIZATIONS: {
! 2897: sqlite3 *db = va_arg(ap, sqlite3*);
! 2898: int x = va_arg(ap,int);
! 2899: db->flags = (x & SQLITE_OptMask) | (db->flags & ~SQLITE_OptMask);
! 2900: break;
! 2901: }
! 2902:
! 2903: #ifdef SQLITE_N_KEYWORD
! 2904: /* sqlite3_test_control(SQLITE_TESTCTRL_ISKEYWORD, const char *zWord)
! 2905: **
! 2906: ** If zWord is a keyword recognized by the parser, then return the
! 2907: ** number of keywords. Or if zWord is not a keyword, return 0.
! 2908: **
! 2909: ** This test feature is only available in the amalgamation since
! 2910: ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
! 2911: ** is built using separate source files.
! 2912: */
! 2913: case SQLITE_TESTCTRL_ISKEYWORD: {
! 2914: const char *zWord = va_arg(ap, const char*);
! 2915: int n = sqlite3Strlen30(zWord);
! 2916: rc = (sqlite3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLITE_N_KEYWORD : 0;
! 2917: break;
! 2918: }
! 2919: #endif
! 2920:
! 2921: /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
! 2922: **
! 2923: ** Pass pFree into sqlite3ScratchFree().
! 2924: ** If sz>0 then allocate a scratch buffer into pNew.
! 2925: */
! 2926: case SQLITE_TESTCTRL_SCRATCHMALLOC: {
! 2927: void *pFree, **ppNew;
! 2928: int sz;
! 2929: sz = va_arg(ap, int);
! 2930: ppNew = va_arg(ap, void**);
! 2931: pFree = va_arg(ap, void*);
! 2932: if( sz ) *ppNew = sqlite3ScratchMalloc(sz);
! 2933: sqlite3ScratchFree(pFree);
! 2934: break;
! 2935: }
! 2936:
! 2937: /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
! 2938: **
! 2939: ** If parameter onoff is non-zero, configure the wrappers so that all
! 2940: ** subsequent calls to localtime() and variants fail. If onoff is zero,
! 2941: ** undo this setting.
! 2942: */
! 2943: case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
! 2944: sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
! 2945: break;
! 2946: }
! 2947:
! 2948: #if defined(SQLITE_ENABLE_TREE_EXPLAIN)
! 2949: /* sqlite3_test_control(SQLITE_TESTCTRL_EXPLAIN_STMT,
! 2950: ** sqlite3_stmt*,const char**);
! 2951: **
! 2952: ** If compiled with SQLITE_ENABLE_TREE_EXPLAIN, each sqlite3_stmt holds
! 2953: ** a string that describes the optimized parse tree. This test-control
! 2954: ** returns a pointer to that string.
! 2955: */
! 2956: case SQLITE_TESTCTRL_EXPLAIN_STMT: {
! 2957: sqlite3_stmt *pStmt = va_arg(ap, sqlite3_stmt*);
! 2958: const char **pzRet = va_arg(ap, const char**);
! 2959: *pzRet = sqlite3VdbeExplanation((Vdbe*)pStmt);
! 2960: break;
! 2961: }
! 2962: #endif
! 2963:
! 2964: }
! 2965: va_end(ap);
! 2966: #endif /* SQLITE_OMIT_BUILTIN_TEST */
! 2967: return rc;
! 2968: }
! 2969:
! 2970: /*
! 2971: ** This is a utility routine, useful to VFS implementations, that checks
! 2972: ** to see if a database file was a URI that contained a specific query
! 2973: ** parameter, and if so obtains the value of the query parameter.
! 2974: **
! 2975: ** The zFilename argument is the filename pointer passed into the xOpen()
! 2976: ** method of a VFS implementation. The zParam argument is the name of the
! 2977: ** query parameter we seek. This routine returns the value of the zParam
! 2978: ** parameter if it exists. If the parameter does not exist, this routine
! 2979: ** returns a NULL pointer.
! 2980: */
! 2981: const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam){
! 2982: if( zFilename==0 ) return 0;
! 2983: zFilename += sqlite3Strlen30(zFilename) + 1;
! 2984: while( zFilename[0] ){
! 2985: int x = strcmp(zFilename, zParam);
! 2986: zFilename += sqlite3Strlen30(zFilename) + 1;
! 2987: if( x==0 ) return zFilename;
! 2988: zFilename += sqlite3Strlen30(zFilename) + 1;
! 2989: }
! 2990: return 0;
! 2991: }
! 2992:
! 2993: /*
! 2994: ** Return a boolean value for a query parameter.
! 2995: */
! 2996: int sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){
! 2997: const char *z = sqlite3_uri_parameter(zFilename, zParam);
! 2998: return z ? sqlite3GetBoolean(z) : (bDflt!=0);
! 2999: }
! 3000:
! 3001: /*
! 3002: ** Return a 64-bit integer value for a query parameter.
! 3003: */
! 3004: sqlite3_int64 sqlite3_uri_int64(
! 3005: const char *zFilename, /* Filename as passed to xOpen */
! 3006: const char *zParam, /* URI parameter sought */
! 3007: sqlite3_int64 bDflt /* return if parameter is missing */
! 3008: ){
! 3009: const char *z = sqlite3_uri_parameter(zFilename, zParam);
! 3010: sqlite3_int64 v;
! 3011: if( z && sqlite3Atoi64(z, &v, sqlite3Strlen30(z), SQLITE_UTF8)==SQLITE_OK ){
! 3012: bDflt = v;
! 3013: }
! 3014: return bDflt;
! 3015: }
! 3016:
! 3017: /*
! 3018: ** Return the filename of the database associated with a database
! 3019: ** connection.
! 3020: */
! 3021: const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){
! 3022: int i;
! 3023: for(i=0; i<db->nDb; i++){
! 3024: if( db->aDb[i].pBt && sqlite3StrICmp(zDbName, db->aDb[i].zName)==0 ){
! 3025: return sqlite3BtreeGetFilename(db->aDb[i].pBt);
! 3026: }
! 3027: }
! 3028: return 0;
! 3029: }
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 / sqlite3 / src