Annotation of embedaddon/sqlite3/src/main.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2001 September 15
3: **
4: ** The author disclaims copyright to this source code. In place of
5: ** a legal notice, here is a blessing:
6: **
7: ** May you do good and not evil.
8: ** May you find forgiveness for yourself and forgive others.
9: ** May you share freely, never taking more than you give.
10: **
11: *************************************************************************
12: ** Main file for the SQLite library. The routines in this file
13: ** implement the programmer interface to the library. Routines in
14: ** other files are for internal use by SQLite and should not be
15: ** accessed by users of the library.
16: */
17: #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