4 ** The author disclaims copyright to this source code. In place of
5 ** a legal notice, here is a blessing:
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.
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.
17 #include "sqliteInt.h"
19 #ifdef SQLITE_ENABLE_FTS3
22 #ifdef SQLITE_ENABLE_RTREE
25 #if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS)
26 # include "sqliteicu.h"
28 #ifdef SQLITE_ENABLE_JSON1
29 int sqlite3Json1Init(sqlite3
*);
31 #ifdef SQLITE_ENABLE_STMTVTAB
32 int sqlite3StmtVtabInit(sqlite3
*);
34 #ifdef SQLITE_ENABLE_FTS5
35 int sqlite3Fts5Init(sqlite3
*);
38 #ifndef SQLITE_AMALGAMATION
39 /* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant
40 ** contains the text of SQLITE_VERSION macro.
42 const char sqlite3_version
[] = SQLITE_VERSION
;
45 /* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns
46 ** a pointer to the to the sqlite3_version[] string constant.
48 const char *sqlite3_libversion(void){ return sqlite3_version
; }
50 /* IMPLEMENTATION-OF: R-25063-23286 The sqlite3_sourceid() function returns a
51 ** pointer to a string constant whose value is the same as the
52 ** SQLITE_SOURCE_ID C preprocessor macro. Except if SQLite is built using
53 ** an edited copy of the amalgamation, then the last four characters of
54 ** the hash might be different from SQLITE_SOURCE_ID.
56 const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID
; }
58 /* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function
59 ** returns an integer equal to SQLITE_VERSION_NUMBER.
61 int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER
; }
63 /* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
64 ** zero if and only if SQLite was compiled with mutexing code omitted due to
65 ** the SQLITE_THREADSAFE compile-time option being set to 0.
67 int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE
; }
70 ** When compiling the test fixture or with debugging enabled (on Win32),
71 ** this variable being set to non-zero will cause OSTRACE macros to emit
72 ** extra diagnostic information.
74 #ifdef SQLITE_HAVE_OS_TRACE
75 # ifndef SQLITE_DEBUG_OS_TRACE
76 # define SQLITE_DEBUG_OS_TRACE 0
78 int sqlite3OSTrace
= SQLITE_DEBUG_OS_TRACE
;
81 #if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
83 ** If the following function pointer is not NULL and if
84 ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
85 ** I/O active are written using this function. These messages
86 ** are intended for debugging activity only.
88 SQLITE_API
void (SQLITE_CDECL
*sqlite3IoTrace
)(const char*, ...) = 0;
92 ** If the following global variable points to a string which is the
93 ** name of a directory, then that directory will be used to store
96 ** See also the "PRAGMA temp_store_directory" SQL command.
98 char *sqlite3_temp_directory
= 0;
101 ** If the following global variable points to a string which is the
102 ** name of a directory, then that directory will be used to store
103 ** all database files specified with a relative pathname.
105 ** See also the "PRAGMA data_store_directory" SQL command.
107 char *sqlite3_data_directory
= 0;
110 ** Initialize SQLite.
112 ** This routine must be called to initialize the memory allocation,
113 ** VFS, and mutex subsystems prior to doing any serious work with
114 ** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
115 ** this routine will be called automatically by key routines such as
118 ** This routine is a no-op except on its very first call for the process,
119 ** or for the first call after a call to sqlite3_shutdown.
121 ** The first thread to call this routine runs the initialization to
122 ** completion. If subsequent threads call this routine before the first
123 ** thread has finished the initialization process, then the subsequent
124 ** threads must block until the first thread finishes with the initialization.
126 ** The first thread might call this routine recursively. Recursive
127 ** calls to this routine should not block, of course. Otherwise the
128 ** initialization process would never complete.
130 ** Let X be the first thread to enter this routine. Let Y be some other
131 ** thread. Then while the initial invocation of this routine by X is
132 ** incomplete, it is required that:
134 ** * Calls to this routine from Y must block until the outer-most
135 ** call by X completes.
137 ** * Recursive calls to this routine from thread X return immediately
140 int sqlite3_initialize(void){
141 MUTEX_LOGIC( sqlite3_mutex
*pMaster
; ) /* The main static mutex */
142 int rc
; /* Result code */
143 #ifdef SQLITE_EXTRA_INIT
144 int bRunExtraInit
= 0; /* Extra initialization needed */
147 #ifdef SQLITE_OMIT_WSD
148 rc
= sqlite3_wsd_init(4096, 24);
154 /* If the following assert() fails on some obscure processor/compiler
155 ** combination, the work-around is to set the correct pointer
156 ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
157 assert( SQLITE_PTRSIZE
==sizeof(char*) );
159 /* If SQLite is already completely initialized, then this call
160 ** to sqlite3_initialize() should be a no-op. But the initialization
161 ** must be complete. So isInit must not be set until the very end
164 if( sqlite3GlobalConfig
.isInit
) return SQLITE_OK
;
166 /* Make sure the mutex subsystem is initialized. If unable to
167 ** initialize the mutex subsystem, return early with the error.
168 ** If the system is so sick that we are unable to allocate a mutex,
169 ** there is not much SQLite is going to be able to do.
171 ** The mutex subsystem must take care of serializing its own
174 rc
= sqlite3MutexInit();
177 /* Initialize the malloc() system and the recursive pInitMutex mutex.
178 ** This operation is protected by the STATIC_MASTER mutex. Note that
179 ** MutexAlloc() is called for a static mutex prior to initializing the
180 ** malloc subsystem - this implies that the allocation of a static
181 ** mutex must not require support from the malloc subsystem.
183 MUTEX_LOGIC( pMaster
= sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER
); )
184 sqlite3_mutex_enter(pMaster
);
185 sqlite3GlobalConfig
.isMutexInit
= 1;
186 if( !sqlite3GlobalConfig
.isMallocInit
){
187 rc
= sqlite3MallocInit();
190 sqlite3GlobalConfig
.isMallocInit
= 1;
191 if( !sqlite3GlobalConfig
.pInitMutex
){
192 sqlite3GlobalConfig
.pInitMutex
=
193 sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE
);
194 if( sqlite3GlobalConfig
.bCoreMutex
&& !sqlite3GlobalConfig
.pInitMutex
){
195 rc
= SQLITE_NOMEM_BKPT
;
200 sqlite3GlobalConfig
.nRefInitMutex
++;
202 sqlite3_mutex_leave(pMaster
);
204 /* If rc is not SQLITE_OK at this point, then either the malloc
205 ** subsystem could not be initialized or the system failed to allocate
206 ** the pInitMutex mutex. Return an error in either case. */
211 /* Do the rest of the initialization under the recursive mutex so
212 ** that we will be able to handle recursive calls into
213 ** sqlite3_initialize(). The recursive calls normally come through
214 ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
215 ** recursive calls might also be possible.
217 ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
218 ** to the xInit method, so the xInit method need not be threadsafe.
220 ** The following mutex is what serializes access to the appdef pcache xInit
221 ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the
222 ** call to sqlite3PcacheInitialize().
224 sqlite3_mutex_enter(sqlite3GlobalConfig
.pInitMutex
);
225 if( sqlite3GlobalConfig
.isInit
==0 && sqlite3GlobalConfig
.inProgress
==0 ){
226 sqlite3GlobalConfig
.inProgress
= 1;
227 #ifdef SQLITE_ENABLE_SQLLOG
229 extern void sqlite3_init_sqllog(void);
230 sqlite3_init_sqllog();
233 memset(&sqlite3BuiltinFunctions
, 0, sizeof(sqlite3BuiltinFunctions
));
234 sqlite3RegisterBuiltinFunctions();
235 if( sqlite3GlobalConfig
.isPCacheInit
==0 ){
236 rc
= sqlite3PcacheInitialize();
239 sqlite3GlobalConfig
.isPCacheInit
= 1;
240 rc
= sqlite3OsInit();
242 #ifdef SQLITE_ENABLE_DESERIALIZE
244 rc
= sqlite3MemdbInit();
248 sqlite3PCacheBufferSetup( sqlite3GlobalConfig
.pPage
,
249 sqlite3GlobalConfig
.szPage
, sqlite3GlobalConfig
.nPage
);
250 sqlite3GlobalConfig
.isInit
= 1;
251 #ifdef SQLITE_EXTRA_INIT
255 sqlite3GlobalConfig
.inProgress
= 0;
257 sqlite3_mutex_leave(sqlite3GlobalConfig
.pInitMutex
);
259 /* Go back under the static mutex and clean up the recursive
260 ** mutex to prevent a resource leak.
262 sqlite3_mutex_enter(pMaster
);
263 sqlite3GlobalConfig
.nRefInitMutex
--;
264 if( sqlite3GlobalConfig
.nRefInitMutex
<=0 ){
265 assert( sqlite3GlobalConfig
.nRefInitMutex
==0 );
266 sqlite3_mutex_free(sqlite3GlobalConfig
.pInitMutex
);
267 sqlite3GlobalConfig
.pInitMutex
= 0;
269 sqlite3_mutex_leave(pMaster
);
271 /* The following is just a sanity check to make sure SQLite has
272 ** been compiled correctly. It is important to run this code, but
273 ** we don't want to run it too often and soak up CPU cycles for no
274 ** reason. So we run it once during initialization.
277 #ifndef SQLITE_OMIT_FLOATING_POINT
278 /* This section of code's only "output" is via assert() statements. */
280 u64 x
= (((u64
)1)<<63)-1;
282 assert(sizeof(x
)==8);
283 assert(sizeof(x
)==sizeof(y
));
285 assert( sqlite3IsNaN(y
) );
290 /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
291 ** compile-time option.
293 #ifdef SQLITE_EXTRA_INIT
295 int SQLITE_EXTRA_INIT(const char*);
296 rc
= SQLITE_EXTRA_INIT(0);
304 ** Undo the effects of sqlite3_initialize(). Must not be called while
305 ** there are outstanding database connections or memory allocations or
306 ** while any part of SQLite is otherwise in use in any thread. This
307 ** routine is not threadsafe. But it is safe to invoke this routine
308 ** on when SQLite is already shut down. If SQLite is already shut down
309 ** when this routine is invoked, then this routine is a harmless no-op.
311 int sqlite3_shutdown(void){
312 #ifdef SQLITE_OMIT_WSD
313 int rc
= sqlite3_wsd_init(4096, 24);
319 if( sqlite3GlobalConfig
.isInit
){
320 #ifdef SQLITE_EXTRA_SHUTDOWN
321 void SQLITE_EXTRA_SHUTDOWN(void);
322 SQLITE_EXTRA_SHUTDOWN();
325 sqlite3_reset_auto_extension();
326 sqlite3GlobalConfig
.isInit
= 0;
328 if( sqlite3GlobalConfig
.isPCacheInit
){
329 sqlite3PcacheShutdown();
330 sqlite3GlobalConfig
.isPCacheInit
= 0;
332 if( sqlite3GlobalConfig
.isMallocInit
){
334 sqlite3GlobalConfig
.isMallocInit
= 0;
336 #ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
337 /* The heap subsystem has now been shutdown and these values are supposed
338 ** to be NULL or point to memory that was obtained from sqlite3_malloc(),
339 ** which would rely on that heap subsystem; therefore, make sure these
340 ** values cannot refer to heap memory that was just invalidated when the
341 ** heap subsystem was shutdown. This is only done if the current call to
342 ** this function resulted in the heap subsystem actually being shutdown.
344 sqlite3_data_directory
= 0;
345 sqlite3_temp_directory
= 0;
348 if( sqlite3GlobalConfig
.isMutexInit
){
350 sqlite3GlobalConfig
.isMutexInit
= 0;
357 ** This API allows applications to modify the global configuration of
358 ** the SQLite library at run-time.
360 ** This routine should only be called when there are no outstanding
361 ** database connections or memory allocations. This routine is not
362 ** threadsafe. Failure to heed these warnings can lead to unpredictable
365 int sqlite3_config(int op
, ...){
369 /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
370 ** the SQLite library is in use. */
371 if( sqlite3GlobalConfig
.isInit
) return SQLITE_MISUSE_BKPT
;
376 /* Mutex configuration options are only available in a threadsafe
379 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */
380 case SQLITE_CONFIG_SINGLETHREAD
: {
381 /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
383 sqlite3GlobalConfig
.bCoreMutex
= 0; /* Disable mutex on core */
384 sqlite3GlobalConfig
.bFullMutex
= 0; /* Disable mutex on connections */
388 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
389 case SQLITE_CONFIG_MULTITHREAD
: {
390 /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
392 sqlite3GlobalConfig
.bCoreMutex
= 1; /* Enable mutex on core */
393 sqlite3GlobalConfig
.bFullMutex
= 0; /* Disable mutex on connections */
397 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
398 case SQLITE_CONFIG_SERIALIZED
: {
399 /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
401 sqlite3GlobalConfig
.bCoreMutex
= 1; /* Enable mutex on core */
402 sqlite3GlobalConfig
.bFullMutex
= 1; /* Enable mutex on connections */
406 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
407 case SQLITE_CONFIG_MUTEX
: {
408 /* Specify an alternative mutex implementation */
409 sqlite3GlobalConfig
.mutex
= *va_arg(ap
, sqlite3_mutex_methods
*);
413 #if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
414 case SQLITE_CONFIG_GETMUTEX
: {
415 /* Retrieve the current mutex implementation */
416 *va_arg(ap
, sqlite3_mutex_methods
*) = sqlite3GlobalConfig
.mutex
;
421 case SQLITE_CONFIG_MALLOC
: {
422 /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
423 ** single argument which is a pointer to an instance of the
424 ** sqlite3_mem_methods structure. The argument specifies alternative
425 ** low-level memory allocation routines to be used in place of the memory
426 ** allocation routines built into SQLite. */
427 sqlite3GlobalConfig
.m
= *va_arg(ap
, sqlite3_mem_methods
*);
430 case SQLITE_CONFIG_GETMALLOC
: {
431 /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
432 ** single argument which is a pointer to an instance of the
433 ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
434 ** filled with the currently defined memory allocation routines. */
435 if( sqlite3GlobalConfig
.m
.xMalloc
==0 ) sqlite3MemSetDefault();
436 *va_arg(ap
, sqlite3_mem_methods
*) = sqlite3GlobalConfig
.m
;
439 case SQLITE_CONFIG_MEMSTATUS
: {
440 /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
441 ** single argument of type int, interpreted as a boolean, which enables
442 ** or disables the collection of memory allocation statistics. */
443 sqlite3GlobalConfig
.bMemstat
= va_arg(ap
, int);
446 case SQLITE_CONFIG_SMALL_MALLOC
: {
447 sqlite3GlobalConfig
.bSmallMalloc
= va_arg(ap
, int);
450 case SQLITE_CONFIG_PAGECACHE
: {
451 /* EVIDENCE-OF: R-18761-36601 There are three arguments to
452 ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem),
453 ** the size of each page cache line (sz), and the number of cache lines
455 sqlite3GlobalConfig
.pPage
= va_arg(ap
, void*);
456 sqlite3GlobalConfig
.szPage
= va_arg(ap
, int);
457 sqlite3GlobalConfig
.nPage
= va_arg(ap
, int);
460 case SQLITE_CONFIG_PCACHE_HDRSZ
: {
461 /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes
462 ** a single parameter which is a pointer to an integer and writes into
463 ** that integer the number of extra bytes per page required for each page
464 ** in SQLITE_CONFIG_PAGECACHE. */
466 sqlite3HeaderSizeBtree() +
467 sqlite3HeaderSizePcache() +
468 sqlite3HeaderSizePcache1();
472 case SQLITE_CONFIG_PCACHE
: {
476 case SQLITE_CONFIG_GETPCACHE
: {
482 case SQLITE_CONFIG_PCACHE2
: {
483 /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a
484 ** single argument which is a pointer to an sqlite3_pcache_methods2
485 ** object. This object specifies the interface to a custom page cache
486 ** implementation. */
487 sqlite3GlobalConfig
.pcache2
= *va_arg(ap
, sqlite3_pcache_methods2
*);
490 case SQLITE_CONFIG_GETPCACHE2
: {
491 /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a
492 ** single argument which is a pointer to an sqlite3_pcache_methods2
493 ** object. SQLite copies of the current page cache implementation into
495 if( sqlite3GlobalConfig
.pcache2
.xInit
==0 ){
496 sqlite3PCacheSetDefault();
498 *va_arg(ap
, sqlite3_pcache_methods2
*) = sqlite3GlobalConfig
.pcache2
;
502 /* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
503 ** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
504 ** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */
505 #if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
506 case SQLITE_CONFIG_HEAP
: {
507 /* EVIDENCE-OF: R-19854-42126 There are three arguments to
508 ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
509 ** number of bytes in the memory buffer, and the minimum allocation size.
511 sqlite3GlobalConfig
.pHeap
= va_arg(ap
, void*);
512 sqlite3GlobalConfig
.nHeap
= va_arg(ap
, int);
513 sqlite3GlobalConfig
.mnReq
= va_arg(ap
, int);
515 if( sqlite3GlobalConfig
.mnReq
<1 ){
516 sqlite3GlobalConfig
.mnReq
= 1;
517 }else if( sqlite3GlobalConfig
.mnReq
>(1<<12) ){
518 /* cap min request size at 2^12 */
519 sqlite3GlobalConfig
.mnReq
= (1<<12);
522 if( sqlite3GlobalConfig
.pHeap
==0 ){
523 /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
524 ** is NULL, then SQLite reverts to using its default memory allocator
525 ** (the system malloc() implementation), undoing any prior invocation of
526 ** SQLITE_CONFIG_MALLOC.
528 ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
529 ** revert to its default implementation when sqlite3_initialize() is run
531 memset(&sqlite3GlobalConfig
.m
, 0, sizeof(sqlite3GlobalConfig
.m
));
533 /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
534 ** alternative memory allocator is engaged to handle all of SQLites
535 ** memory allocation needs. */
536 #ifdef SQLITE_ENABLE_MEMSYS3
537 sqlite3GlobalConfig
.m
= *sqlite3MemGetMemsys3();
539 #ifdef SQLITE_ENABLE_MEMSYS5
540 sqlite3GlobalConfig
.m
= *sqlite3MemGetMemsys5();
547 case SQLITE_CONFIG_LOOKASIDE
: {
548 sqlite3GlobalConfig
.szLookaside
= va_arg(ap
, int);
549 sqlite3GlobalConfig
.nLookaside
= va_arg(ap
, int);
553 /* Record a pointer to the logger function and its first argument.
554 ** The default is NULL. Logging is disabled if the function pointer is
557 case SQLITE_CONFIG_LOG
: {
558 /* MSVC is picky about pulling func ptrs from va lists.
559 ** http://support.microsoft.com/kb/47961
560 ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
562 typedef void(*LOGFUNC_t
)(void*,int,const char*);
563 sqlite3GlobalConfig
.xLog
= va_arg(ap
, LOGFUNC_t
);
564 sqlite3GlobalConfig
.pLogArg
= va_arg(ap
, void*);
568 /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
569 ** can be changed at start-time using the
570 ** sqlite3_config(SQLITE_CONFIG_URI,1) or
571 ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.
573 case SQLITE_CONFIG_URI
: {
574 /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
575 ** argument of type int. If non-zero, then URI handling is globally
576 ** enabled. If the parameter is zero, then URI handling is globally
578 sqlite3GlobalConfig
.bOpenUri
= va_arg(ap
, int);
582 case SQLITE_CONFIG_COVERING_INDEX_SCAN
: {
583 /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN
584 ** option takes a single integer argument which is interpreted as a
585 ** boolean in order to enable or disable the use of covering indices for
586 ** full table scans in the query optimizer. */
587 sqlite3GlobalConfig
.bUseCis
= va_arg(ap
, int);
591 #ifdef SQLITE_ENABLE_SQLLOG
592 case SQLITE_CONFIG_SQLLOG
: {
593 typedef void(*SQLLOGFUNC_t
)(void*, sqlite3
*, const char*, int);
594 sqlite3GlobalConfig
.xSqllog
= va_arg(ap
, SQLLOGFUNC_t
);
595 sqlite3GlobalConfig
.pSqllogArg
= va_arg(ap
, void *);
600 case SQLITE_CONFIG_MMAP_SIZE
: {
601 /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit
602 ** integer (sqlite3_int64) values that are the default mmap size limit
603 ** (the default setting for PRAGMA mmap_size) and the maximum allowed
604 ** mmap size limit. */
605 sqlite3_int64 szMmap
= va_arg(ap
, sqlite3_int64
);
606 sqlite3_int64 mxMmap
= va_arg(ap
, sqlite3_int64
);
607 /* EVIDENCE-OF: R-53367-43190 If either argument to this option is
608 ** negative, then that argument is changed to its compile-time default.
610 ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
611 ** silently truncated if necessary so that it does not exceed the
612 ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
613 ** compile-time option.
615 if( mxMmap
<0 || mxMmap
>SQLITE_MAX_MMAP_SIZE
){
616 mxMmap
= SQLITE_MAX_MMAP_SIZE
;
618 if( szMmap
<0 ) szMmap
= SQLITE_DEFAULT_MMAP_SIZE
;
619 if( szMmap
>mxMmap
) szMmap
= mxMmap
;
620 sqlite3GlobalConfig
.mxMmap
= mxMmap
;
621 sqlite3GlobalConfig
.szMmap
= szMmap
;
625 #if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */
626 case SQLITE_CONFIG_WIN32_HEAPSIZE
: {
627 /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit
628 ** unsigned integer value that specifies the maximum size of the created
630 sqlite3GlobalConfig
.nHeap
= va_arg(ap
, int);
635 case SQLITE_CONFIG_PMASZ
: {
636 sqlite3GlobalConfig
.szPma
= va_arg(ap
, unsigned int);
640 case SQLITE_CONFIG_STMTJRNL_SPILL
: {
641 sqlite3GlobalConfig
.nStmtSpill
= va_arg(ap
, int);
645 #ifdef SQLITE_ENABLE_SORTER_REFERENCES
646 case SQLITE_CONFIG_SORTERREF_SIZE
: {
647 int iVal
= va_arg(ap
, int);
649 iVal
= SQLITE_DEFAULT_SORTERREF_SIZE
;
651 sqlite3GlobalConfig
.szSorterRef
= (u32
)iVal
;
654 #endif /* SQLITE_ENABLE_SORTER_REFERENCES */
656 #ifdef SQLITE_ENABLE_DESERIALIZE
657 case SQLITE_CONFIG_MEMDB_MAXSIZE
: {
658 sqlite3GlobalConfig
.mxMemdbSize
= va_arg(ap
, sqlite3_int64
);
661 #endif /* SQLITE_ENABLE_DESERIALIZE */
673 ** Set up the lookaside buffers for a database connection.
674 ** Return SQLITE_OK on success.
675 ** If lookaside is already active, return SQLITE_BUSY.
677 ** The sz parameter is the number of bytes in each lookaside slot.
678 ** The cnt parameter is the number of slots. If pStart is NULL the
679 ** space for the lookaside memory is obtained from sqlite3_malloc().
680 ** If pStart is not NULL then it is sz*cnt bytes of memory to use for
681 ** the lookaside memory.
683 static int setupLookaside(sqlite3
*db
, void *pBuf
, int sz
, int cnt
){
684 #ifndef SQLITE_OMIT_LOOKASIDE
687 if( sqlite3LookasideUsed(db
,0)>0 ){
690 /* Free any existing lookaside buffer for this handle before
691 ** allocating a new one so we don't have to have space for
692 ** both at the same time.
694 if( db
->lookaside
.bMalloced
){
695 sqlite3_free(db
->lookaside
.pStart
);
697 /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger
698 ** than a pointer to be useful.
700 sz
= ROUNDDOWN8(sz
); /* IMP: R-33038-09382 */
701 if( sz
<=(int)sizeof(LookasideSlot
*) ) sz
= 0;
703 if( sz
==0 || cnt
==0 ){
707 sqlite3BeginBenignMalloc();
708 pStart
= sqlite3Malloc( sz
*cnt
); /* IMP: R-61949-35727 */
709 sqlite3EndBenignMalloc();
710 if( pStart
) cnt
= sqlite3MallocSize(pStart
)/sz
;
714 db
->lookaside
.pStart
= pStart
;
715 db
->lookaside
.pInit
= 0;
716 db
->lookaside
.pFree
= 0;
717 db
->lookaside
.sz
= (u16
)sz
;
721 assert( sz
> (int)sizeof(LookasideSlot
*) );
722 db
->lookaside
.nSlot
= cnt
;
723 p
= (LookasideSlot
*)pStart
;
724 for(i
=cnt
-1; i
>=0; i
--){
725 p
->pNext
= db
->lookaside
.pInit
;
726 db
->lookaside
.pInit
= p
;
727 p
= (LookasideSlot
*)&((u8
*)p
)[sz
];
729 db
->lookaside
.pEnd
= p
;
730 db
->lookaside
.bDisable
= 0;
731 db
->lookaside
.bMalloced
= pBuf
==0 ?1:0;
733 db
->lookaside
.pStart
= db
;
734 db
->lookaside
.pEnd
= db
;
735 db
->lookaside
.bDisable
= 1;
736 db
->lookaside
.bMalloced
= 0;
737 db
->lookaside
.nSlot
= 0;
739 #endif /* SQLITE_OMIT_LOOKASIDE */
744 ** Return the mutex associated with a database connection.
746 sqlite3_mutex
*sqlite3_db_mutex(sqlite3
*db
){
747 #ifdef SQLITE_ENABLE_API_ARMOR
748 if( !sqlite3SafetyCheckOk(db
) ){
749 (void)SQLITE_MISUSE_BKPT
;
757 ** Free up as much memory as we can from the given database
760 int sqlite3_db_release_memory(sqlite3
*db
){
763 #ifdef SQLITE_ENABLE_API_ARMOR
764 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
766 sqlite3_mutex_enter(db
->mutex
);
767 sqlite3BtreeEnterAll(db
);
768 for(i
=0; i
<db
->nDb
; i
++){
769 Btree
*pBt
= db
->aDb
[i
].pBt
;
771 Pager
*pPager
= sqlite3BtreePager(pBt
);
772 sqlite3PagerShrink(pPager
);
775 sqlite3BtreeLeaveAll(db
);
776 sqlite3_mutex_leave(db
->mutex
);
781 ** Flush any dirty pages in the pager-cache for any attached database
784 int sqlite3_db_cacheflush(sqlite3
*db
){
789 #ifdef SQLITE_ENABLE_API_ARMOR
790 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
792 sqlite3_mutex_enter(db
->mutex
);
793 sqlite3BtreeEnterAll(db
);
794 for(i
=0; rc
==SQLITE_OK
&& i
<db
->nDb
; i
++){
795 Btree
*pBt
= db
->aDb
[i
].pBt
;
796 if( pBt
&& sqlite3BtreeIsInTrans(pBt
) ){
797 Pager
*pPager
= sqlite3BtreePager(pBt
);
798 rc
= sqlite3PagerFlush(pPager
);
799 if( rc
==SQLITE_BUSY
){
805 sqlite3BtreeLeaveAll(db
);
806 sqlite3_mutex_leave(db
->mutex
);
807 return ((rc
==SQLITE_OK
&& bSeenBusy
) ? SQLITE_BUSY
: rc
);
811 ** Configuration settings for an individual database connection
813 int sqlite3_db_config(sqlite3
*db
, int op
, ...){
818 case SQLITE_DBCONFIG_MAINDBNAME
: {
819 /* IMP: R-06824-28531 */
820 /* IMP: R-36257-52125 */
821 db
->aDb
[0].zDbSName
= va_arg(ap
,char*);
825 case SQLITE_DBCONFIG_LOOKASIDE
: {
826 void *pBuf
= va_arg(ap
, void*); /* IMP: R-26835-10964 */
827 int sz
= va_arg(ap
, int); /* IMP: R-47871-25994 */
828 int cnt
= va_arg(ap
, int); /* IMP: R-04460-53386 */
829 rc
= setupLookaside(db
, pBuf
, sz
, cnt
);
833 static const struct {
834 int op
; /* The opcode */
835 u32 mask
; /* Mask of the bit in sqlite3.flags to set/clear */
837 { SQLITE_DBCONFIG_ENABLE_FKEY
, SQLITE_ForeignKeys
},
838 { SQLITE_DBCONFIG_ENABLE_TRIGGER
, SQLITE_EnableTrigger
},
839 { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
, SQLITE_Fts3Tokenizer
},
840 { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION
, SQLITE_LoadExtension
},
841 { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
, SQLITE_NoCkptOnClose
},
842 { SQLITE_DBCONFIG_ENABLE_QPSG
, SQLITE_EnableQPSG
},
843 { SQLITE_DBCONFIG_TRIGGER_EQP
, SQLITE_TriggerEQP
},
844 { SQLITE_DBCONFIG_RESET_DATABASE
, SQLITE_ResetDatabase
},
845 { SQLITE_DBCONFIG_DEFENSIVE
, SQLITE_Defensive
},
848 rc
= SQLITE_ERROR
; /* IMP: R-42790-23372 */
849 for(i
=0; i
<ArraySize(aFlagOp
); i
++){
850 if( aFlagOp
[i
].op
==op
){
851 int onoff
= va_arg(ap
, int);
852 int *pRes
= va_arg(ap
, int*);
853 u64 oldFlags
= db
->flags
;
855 db
->flags
|= aFlagOp
[i
].mask
;
856 }else if( onoff
==0 ){
857 db
->flags
&= ~(u64
)aFlagOp
[i
].mask
;
859 if( oldFlags
!=db
->flags
){
860 sqlite3ExpirePreparedStatements(db
, 0);
863 *pRes
= (db
->flags
& aFlagOp
[i
].mask
)!=0;
878 ** Return true if the buffer z[0..n-1] contains all spaces.
880 static int allSpaces(const char *z
, int n
){
881 while( n
>0 && z
[n
-1]==' ' ){ n
--; }
886 ** This is the default collating function named "BINARY" which is always
889 ** If the padFlag argument is not NULL then space padding at the end
890 ** of strings is ignored. This implements the RTRIM collation.
892 static int binCollFunc(
894 int nKey1
, const void *pKey1
,
895 int nKey2
, const void *pKey2
898 n
= nKey1
<nKey2
? nKey1
: nKey2
;
899 /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
900 ** strings byte by byte using the memcmp() function from the standard C
902 assert( pKey1
&& pKey2
);
903 rc
= memcmp(pKey1
, pKey2
, n
);
906 && allSpaces(((char*)pKey1
)+n
, nKey1
-n
)
907 && allSpaces(((char*)pKey2
)+n
, nKey2
-n
)
909 /* EVIDENCE-OF: R-31624-24737 RTRIM is like BINARY except that extra
910 ** spaces at the end of either string do not change the result. In other
911 ** words, strings will compare equal to one another as long as they
912 ** differ only in the number of spaces at the end.
922 ** Return true if CollSeq is the default built-in BINARY.
924 int sqlite3IsBinary(const CollSeq
*p
){
925 assert( p
==0 || p
->xCmp
!=binCollFunc
|| p
->pUser
!=0
926 || strcmp(p
->zName
,"BINARY")==0 );
927 return p
==0 || (p
->xCmp
==binCollFunc
&& p
->pUser
==0);
931 ** Another built-in collating sequence: NOCASE.
933 ** This collating sequence is intended to be used for "case independent
934 ** comparison". SQLite's knowledge of upper and lower case equivalents
935 ** extends only to the 26 characters used in the English language.
937 ** At the moment there is only a UTF-8 implementation.
939 static int nocaseCollatingFunc(
941 int nKey1
, const void *pKey1
,
942 int nKey2
, const void *pKey2
944 int r
= sqlite3StrNICmp(
945 (const char *)pKey1
, (const char *)pKey2
, (nKey1
<nKey2
)?nKey1
:nKey2
);
946 UNUSED_PARAMETER(NotUsed
);
954 ** Return the ROWID of the most recent insert
956 sqlite_int64
sqlite3_last_insert_rowid(sqlite3
*db
){
957 #ifdef SQLITE_ENABLE_API_ARMOR
958 if( !sqlite3SafetyCheckOk(db
) ){
959 (void)SQLITE_MISUSE_BKPT
;
963 return db
->lastRowid
;
967 ** Set the value returned by the sqlite3_last_insert_rowid() API function.
969 void sqlite3_set_last_insert_rowid(sqlite3
*db
, sqlite3_int64 iRowid
){
970 #ifdef SQLITE_ENABLE_API_ARMOR
971 if( !sqlite3SafetyCheckOk(db
) ){
972 (void)SQLITE_MISUSE_BKPT
;
976 sqlite3_mutex_enter(db
->mutex
);
977 db
->lastRowid
= iRowid
;
978 sqlite3_mutex_leave(db
->mutex
);
982 ** Return the number of changes in the most recent call to sqlite3_exec().
984 int sqlite3_changes(sqlite3
*db
){
985 #ifdef SQLITE_ENABLE_API_ARMOR
986 if( !sqlite3SafetyCheckOk(db
) ){
987 (void)SQLITE_MISUSE_BKPT
;
995 ** Return the number of changes since the database handle was opened.
997 int sqlite3_total_changes(sqlite3
*db
){
998 #ifdef SQLITE_ENABLE_API_ARMOR
999 if( !sqlite3SafetyCheckOk(db
) ){
1000 (void)SQLITE_MISUSE_BKPT
;
1004 return db
->nTotalChange
;
1008 ** Close all open savepoints. This function only manipulates fields of the
1009 ** database handle object, it does not close any savepoints that may be open
1010 ** at the b-tree/pager level.
1012 void sqlite3CloseSavepoints(sqlite3
*db
){
1013 while( db
->pSavepoint
){
1014 Savepoint
*pTmp
= db
->pSavepoint
;
1015 db
->pSavepoint
= pTmp
->pNext
;
1016 sqlite3DbFree(db
, pTmp
);
1020 db
->isTransactionSavepoint
= 0;
1024 ** Invoke the destructor function associated with FuncDef p, if any. Except,
1025 ** if this is not the last copy of the function, do not invoke it. Multiple
1026 ** copies of a single function are created when create_function() is called
1027 ** with SQLITE_ANY as the encoding.
1029 static void functionDestroy(sqlite3
*db
, FuncDef
*p
){
1030 FuncDestructor
*pDestructor
= p
->u
.pDestructor
;
1032 pDestructor
->nRef
--;
1033 if( pDestructor
->nRef
==0 ){
1034 pDestructor
->xDestroy(pDestructor
->pUserData
);
1035 sqlite3DbFree(db
, pDestructor
);
1041 ** Disconnect all sqlite3_vtab objects that belong to database connection
1042 ** db. This is called when db is being closed.
1044 static void disconnectAllVtab(sqlite3
*db
){
1045 #ifndef SQLITE_OMIT_VIRTUALTABLE
1048 sqlite3BtreeEnterAll(db
);
1049 for(i
=0; i
<db
->nDb
; i
++){
1050 Schema
*pSchema
= db
->aDb
[i
].pSchema
;
1052 for(p
=sqliteHashFirst(&pSchema
->tblHash
); p
; p
=sqliteHashNext(p
)){
1053 Table
*pTab
= (Table
*)sqliteHashData(p
);
1054 if( IsVirtual(pTab
) ) sqlite3VtabDisconnect(db
, pTab
);
1058 for(p
=sqliteHashFirst(&db
->aModule
); p
; p
=sqliteHashNext(p
)){
1059 Module
*pMod
= (Module
*)sqliteHashData(p
);
1060 if( pMod
->pEpoTab
){
1061 sqlite3VtabDisconnect(db
, pMod
->pEpoTab
);
1064 sqlite3VtabUnlockList(db
);
1065 sqlite3BtreeLeaveAll(db
);
1067 UNUSED_PARAMETER(db
);
1072 ** Return TRUE if database connection db has unfinalized prepared
1073 ** statements or unfinished sqlite3_backup objects.
1075 static int connectionIsBusy(sqlite3
*db
){
1077 assert( sqlite3_mutex_held(db
->mutex
) );
1078 if( db
->pVdbe
) return 1;
1079 for(j
=0; j
<db
->nDb
; j
++){
1080 Btree
*pBt
= db
->aDb
[j
].pBt
;
1081 if( pBt
&& sqlite3BtreeIsInBackup(pBt
) ) return 1;
1087 ** Close an existing SQLite database
1089 static int sqlite3Close(sqlite3
*db
, int forceZombie
){
1091 /* EVIDENCE-OF: R-63257-11740 Calling sqlite3_close() or
1092 ** sqlite3_close_v2() with a NULL pointer argument is a harmless no-op. */
1095 if( !sqlite3SafetyCheckSickOrOk(db
) ){
1096 return SQLITE_MISUSE_BKPT
;
1098 sqlite3_mutex_enter(db
->mutex
);
1099 if( db
->mTrace
& SQLITE_TRACE_CLOSE
){
1100 db
->xTrace(SQLITE_TRACE_CLOSE
, db
->pTraceArg
, db
, 0);
1103 /* Force xDisconnect calls on all virtual tables */
1104 disconnectAllVtab(db
);
1106 /* If a transaction is open, the disconnectAllVtab() call above
1107 ** will not have called the xDisconnect() method on any virtual
1108 ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
1109 ** call will do so. We need to do this before the check for active
1110 ** SQL statements below, as the v-table implementation may be storing
1111 ** some prepared statements internally.
1113 sqlite3VtabRollback(db
);
1115 /* Legacy behavior (sqlite3_close() behavior) is to return
1116 ** SQLITE_BUSY if the connection can not be closed immediately.
1118 if( !forceZombie
&& connectionIsBusy(db
) ){
1119 sqlite3ErrorWithMsg(db
, SQLITE_BUSY
, "unable to close due to unfinalized "
1120 "statements or unfinished backups");
1121 sqlite3_mutex_leave(db
->mutex
);
1125 #ifdef SQLITE_ENABLE_SQLLOG
1126 if( sqlite3GlobalConfig
.xSqllog
){
1127 /* Closing the handle. Fourth parameter is passed the value 2. */
1128 sqlite3GlobalConfig
.xSqllog(sqlite3GlobalConfig
.pSqllogArg
, db
, 0, 2);
1132 /* Convert the connection into a zombie and then close it.
1134 db
->magic
= SQLITE_MAGIC_ZOMBIE
;
1135 sqlite3LeaveMutexAndCloseZombie(db
);
1140 ** Two variations on the public interface for closing a database
1141 ** connection. The sqlite3_close() version returns SQLITE_BUSY and
1142 ** leaves the connection option if there are unfinalized prepared
1143 ** statements or unfinished sqlite3_backups. The sqlite3_close_v2()
1144 ** version forces the connection to become a zombie if there are
1145 ** unclosed resources, and arranges for deallocation when the last
1146 ** prepare statement or sqlite3_backup closes.
1148 int sqlite3_close(sqlite3
*db
){ return sqlite3Close(db
,0); }
1149 int sqlite3_close_v2(sqlite3
*db
){ return sqlite3Close(db
,1); }
1153 ** Close the mutex on database connection db.
1155 ** Furthermore, if database connection db is a zombie (meaning that there
1156 ** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and
1157 ** every sqlite3_stmt has now been finalized and every sqlite3_backup has
1158 ** finished, then free all resources.
1160 void sqlite3LeaveMutexAndCloseZombie(sqlite3
*db
){
1161 HashElem
*i
; /* Hash table iterator */
1164 /* If there are outstanding sqlite3_stmt or sqlite3_backup objects
1165 ** or if the connection has not yet been closed by sqlite3_close_v2(),
1166 ** then just leave the mutex and return.
1168 if( db
->magic
!=SQLITE_MAGIC_ZOMBIE
|| connectionIsBusy(db
) ){
1169 sqlite3_mutex_leave(db
->mutex
);
1173 /* If we reach this point, it means that the database connection has
1174 ** closed all sqlite3_stmt and sqlite3_backup objects and has been
1175 ** passed to sqlite3_close (meaning that it is a zombie). Therefore,
1176 ** go ahead and free all resources.
1179 /* If a transaction is open, roll it back. This also ensures that if
1180 ** any database schemas have been modified by an uncommitted transaction
1181 ** they are reset. And that the required b-tree mutex is held to make
1182 ** the pager rollback and schema reset an atomic operation. */
1183 sqlite3RollbackAll(db
, SQLITE_OK
);
1185 /* Free any outstanding Savepoint structures. */
1186 sqlite3CloseSavepoints(db
);
1188 /* Close all database connections */
1189 for(j
=0; j
<db
->nDb
; j
++){
1190 struct Db
*pDb
= &db
->aDb
[j
];
1192 sqlite3BtreeClose(pDb
->pBt
);
1199 /* Clear the TEMP schema separately and last */
1200 if( db
->aDb
[1].pSchema
){
1201 sqlite3SchemaClear(db
->aDb
[1].pSchema
);
1203 sqlite3VtabUnlockList(db
);
1205 /* Free up the array of auxiliary databases */
1206 sqlite3CollapseDatabaseArray(db
);
1207 assert( db
->nDb
<=2 );
1208 assert( db
->aDb
==db
->aDbStatic
);
1210 /* Tell the code in notify.c that the connection no longer holds any
1211 ** locks and does not require any further unlock-notify callbacks.
1213 sqlite3ConnectionClosed(db
);
1215 for(i
=sqliteHashFirst(&db
->aFunc
); i
; i
=sqliteHashNext(i
)){
1217 p
= sqliteHashData(i
);
1219 functionDestroy(db
, p
);
1221 sqlite3DbFree(db
, p
);
1225 sqlite3HashClear(&db
->aFunc
);
1226 for(i
=sqliteHashFirst(&db
->aCollSeq
); i
; i
=sqliteHashNext(i
)){
1227 CollSeq
*pColl
= (CollSeq
*)sqliteHashData(i
);
1228 /* Invoke any destructors registered for collation sequence user data. */
1230 if( pColl
[j
].xDel
){
1231 pColl
[j
].xDel(pColl
[j
].pUser
);
1234 sqlite3DbFree(db
, pColl
);
1236 sqlite3HashClear(&db
->aCollSeq
);
1237 #ifndef SQLITE_OMIT_VIRTUALTABLE
1238 for(i
=sqliteHashFirst(&db
->aModule
); i
; i
=sqliteHashNext(i
)){
1239 Module
*pMod
= (Module
*)sqliteHashData(i
);
1240 if( pMod
->xDestroy
){
1241 pMod
->xDestroy(pMod
->pAux
);
1243 sqlite3VtabEponymousTableClear(db
, pMod
);
1244 sqlite3DbFree(db
, pMod
);
1246 sqlite3HashClear(&db
->aModule
);
1249 sqlite3Error(db
, SQLITE_OK
); /* Deallocates any cached error strings. */
1250 sqlite3ValueFree(db
->pErr
);
1251 sqlite3CloseExtensions(db
);
1252 #if SQLITE_USER_AUTHENTICATION
1253 sqlite3_free(db
->auth
.zAuthUser
);
1254 sqlite3_free(db
->auth
.zAuthPW
);
1257 db
->magic
= SQLITE_MAGIC_ERROR
;
1259 /* The temp-database schema is allocated differently from the other schema
1260 ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
1261 ** So it needs to be freed here. Todo: Why not roll the temp schema into
1262 ** the same sqliteMalloc() as the one that allocates the database
1265 sqlite3DbFree(db
, db
->aDb
[1].pSchema
);
1266 sqlite3_mutex_leave(db
->mutex
);
1267 db
->magic
= SQLITE_MAGIC_CLOSED
;
1268 sqlite3_mutex_free(db
->mutex
);
1269 assert( sqlite3LookasideUsed(db
,0)==0 );
1270 if( db
->lookaside
.bMalloced
){
1271 sqlite3_free(db
->lookaside
.pStart
);
1277 ** Rollback all database files. If tripCode is not SQLITE_OK, then
1278 ** any write cursors are invalidated ("tripped" - as in "tripping a circuit
1279 ** breaker") and made to return tripCode if there are any further
1280 ** attempts to use that cursor. Read cursors remain open and valid
1281 ** but are "saved" in case the table pages are moved around.
1283 void sqlite3RollbackAll(sqlite3
*db
, int tripCode
){
1287 assert( sqlite3_mutex_held(db
->mutex
) );
1288 sqlite3BeginBenignMalloc();
1290 /* Obtain all b-tree mutexes before making any calls to BtreeRollback().
1291 ** This is important in case the transaction being rolled back has
1292 ** modified the database schema. If the b-tree mutexes are not taken
1293 ** here, then another shared-cache connection might sneak in between
1294 ** the database rollback and schema reset, which can cause false
1295 ** corruption reports in some cases. */
1296 sqlite3BtreeEnterAll(db
);
1297 schemaChange
= (db
->mDbFlags
& DBFLAG_SchemaChange
)!=0 && db
->init
.busy
==0;
1299 for(i
=0; i
<db
->nDb
; i
++){
1300 Btree
*p
= db
->aDb
[i
].pBt
;
1302 if( sqlite3BtreeIsInTrans(p
) ){
1305 sqlite3BtreeRollback(p
, tripCode
, !schemaChange
);
1308 sqlite3VtabRollback(db
);
1309 sqlite3EndBenignMalloc();
1312 sqlite3ExpirePreparedStatements(db
, 0);
1313 sqlite3ResetAllSchemasOfConnection(db
);
1315 sqlite3BtreeLeaveAll(db
);
1317 /* Any deferred constraint violations have now been resolved. */
1318 db
->nDeferredCons
= 0;
1319 db
->nDeferredImmCons
= 0;
1320 db
->flags
&= ~(u64
)SQLITE_DeferFKs
;
1322 /* If one has been configured, invoke the rollback-hook callback */
1323 if( db
->xRollbackCallback
&& (inTrans
|| !db
->autoCommit
) ){
1324 db
->xRollbackCallback(db
->pRollbackArg
);
1329 ** Return a static string containing the name corresponding to the error code
1330 ** specified in the argument.
1332 #if defined(SQLITE_NEED_ERR_NAME)
1333 const char *sqlite3ErrName(int rc
){
1334 const char *zName
= 0;
1336 for(i
=0; i
<2 && zName
==0; i
++, rc
&= 0xff){
1338 case SQLITE_OK
: zName
= "SQLITE_OK"; break;
1339 case SQLITE_ERROR
: zName
= "SQLITE_ERROR"; break;
1340 case SQLITE_ERROR_SNAPSHOT
: zName
= "SQLITE_ERROR_SNAPSHOT"; break;
1341 case SQLITE_INTERNAL
: zName
= "SQLITE_INTERNAL"; break;
1342 case SQLITE_PERM
: zName
= "SQLITE_PERM"; break;
1343 case SQLITE_ABORT
: zName
= "SQLITE_ABORT"; break;
1344 case SQLITE_ABORT_ROLLBACK
: zName
= "SQLITE_ABORT_ROLLBACK"; break;
1345 case SQLITE_BUSY
: zName
= "SQLITE_BUSY"; break;
1346 case SQLITE_BUSY_RECOVERY
: zName
= "SQLITE_BUSY_RECOVERY"; break;
1347 case SQLITE_BUSY_SNAPSHOT
: zName
= "SQLITE_BUSY_SNAPSHOT"; break;
1348 case SQLITE_LOCKED
: zName
= "SQLITE_LOCKED"; break;
1349 case SQLITE_LOCKED_SHAREDCACHE
: zName
= "SQLITE_LOCKED_SHAREDCACHE";break;
1350 case SQLITE_NOMEM
: zName
= "SQLITE_NOMEM"; break;
1351 case SQLITE_READONLY
: zName
= "SQLITE_READONLY"; break;
1352 case SQLITE_READONLY_RECOVERY
: zName
= "SQLITE_READONLY_RECOVERY"; break;
1353 case SQLITE_READONLY_CANTINIT
: zName
= "SQLITE_READONLY_CANTINIT"; break;
1354 case SQLITE_READONLY_ROLLBACK
: zName
= "SQLITE_READONLY_ROLLBACK"; break;
1355 case SQLITE_READONLY_DBMOVED
: zName
= "SQLITE_READONLY_DBMOVED"; break;
1356 case SQLITE_READONLY_DIRECTORY
: zName
= "SQLITE_READONLY_DIRECTORY";break;
1357 case SQLITE_INTERRUPT
: zName
= "SQLITE_INTERRUPT"; break;
1358 case SQLITE_IOERR
: zName
= "SQLITE_IOERR"; break;
1359 case SQLITE_IOERR_READ
: zName
= "SQLITE_IOERR_READ"; break;
1360 case SQLITE_IOERR_SHORT_READ
: zName
= "SQLITE_IOERR_SHORT_READ"; break;
1361 case SQLITE_IOERR_WRITE
: zName
= "SQLITE_IOERR_WRITE"; break;
1362 case SQLITE_IOERR_FSYNC
: zName
= "SQLITE_IOERR_FSYNC"; break;
1363 case SQLITE_IOERR_DIR_FSYNC
: zName
= "SQLITE_IOERR_DIR_FSYNC"; break;
1364 case SQLITE_IOERR_TRUNCATE
: zName
= "SQLITE_IOERR_TRUNCATE"; break;
1365 case SQLITE_IOERR_FSTAT
: zName
= "SQLITE_IOERR_FSTAT"; break;
1366 case SQLITE_IOERR_UNLOCK
: zName
= "SQLITE_IOERR_UNLOCK"; break;
1367 case SQLITE_IOERR_RDLOCK
: zName
= "SQLITE_IOERR_RDLOCK"; break;
1368 case SQLITE_IOERR_DELETE
: zName
= "SQLITE_IOERR_DELETE"; break;
1369 case SQLITE_IOERR_NOMEM
: zName
= "SQLITE_IOERR_NOMEM"; break;
1370 case SQLITE_IOERR_ACCESS
: zName
= "SQLITE_IOERR_ACCESS"; break;
1371 case SQLITE_IOERR_CHECKRESERVEDLOCK
:
1372 zName
= "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
1373 case SQLITE_IOERR_LOCK
: zName
= "SQLITE_IOERR_LOCK"; break;
1374 case SQLITE_IOERR_CLOSE
: zName
= "SQLITE_IOERR_CLOSE"; break;
1375 case SQLITE_IOERR_DIR_CLOSE
: zName
= "SQLITE_IOERR_DIR_CLOSE"; break;
1376 case SQLITE_IOERR_SHMOPEN
: zName
= "SQLITE_IOERR_SHMOPEN"; break;
1377 case SQLITE_IOERR_SHMSIZE
: zName
= "SQLITE_IOERR_SHMSIZE"; break;
1378 case SQLITE_IOERR_SHMLOCK
: zName
= "SQLITE_IOERR_SHMLOCK"; break;
1379 case SQLITE_IOERR_SHMMAP
: zName
= "SQLITE_IOERR_SHMMAP"; break;
1380 case SQLITE_IOERR_SEEK
: zName
= "SQLITE_IOERR_SEEK"; break;
1381 case SQLITE_IOERR_DELETE_NOENT
: zName
= "SQLITE_IOERR_DELETE_NOENT";break;
1382 case SQLITE_IOERR_MMAP
: zName
= "SQLITE_IOERR_MMAP"; break;
1383 case SQLITE_IOERR_GETTEMPPATH
: zName
= "SQLITE_IOERR_GETTEMPPATH"; break;
1384 case SQLITE_IOERR_CONVPATH
: zName
= "SQLITE_IOERR_CONVPATH"; break;
1385 case SQLITE_CORRUPT
: zName
= "SQLITE_CORRUPT"; break;
1386 case SQLITE_CORRUPT_VTAB
: zName
= "SQLITE_CORRUPT_VTAB"; break;
1387 case SQLITE_NOTFOUND
: zName
= "SQLITE_NOTFOUND"; break;
1388 case SQLITE_FULL
: zName
= "SQLITE_FULL"; break;
1389 case SQLITE_CANTOPEN
: zName
= "SQLITE_CANTOPEN"; break;
1390 case SQLITE_CANTOPEN_NOTEMPDIR
: zName
= "SQLITE_CANTOPEN_NOTEMPDIR";break;
1391 case SQLITE_CANTOPEN_ISDIR
: zName
= "SQLITE_CANTOPEN_ISDIR"; break;
1392 case SQLITE_CANTOPEN_FULLPATH
: zName
= "SQLITE_CANTOPEN_FULLPATH"; break;
1393 case SQLITE_CANTOPEN_CONVPATH
: zName
= "SQLITE_CANTOPEN_CONVPATH"; break;
1394 case SQLITE_PROTOCOL
: zName
= "SQLITE_PROTOCOL"; break;
1395 case SQLITE_EMPTY
: zName
= "SQLITE_EMPTY"; break;
1396 case SQLITE_SCHEMA
: zName
= "SQLITE_SCHEMA"; break;
1397 case SQLITE_TOOBIG
: zName
= "SQLITE_TOOBIG"; break;
1398 case SQLITE_CONSTRAINT
: zName
= "SQLITE_CONSTRAINT"; break;
1399 case SQLITE_CONSTRAINT_UNIQUE
: zName
= "SQLITE_CONSTRAINT_UNIQUE"; break;
1400 case SQLITE_CONSTRAINT_TRIGGER
: zName
= "SQLITE_CONSTRAINT_TRIGGER";break;
1401 case SQLITE_CONSTRAINT_FOREIGNKEY
:
1402 zName
= "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
1403 case SQLITE_CONSTRAINT_CHECK
: zName
= "SQLITE_CONSTRAINT_CHECK"; break;
1404 case SQLITE_CONSTRAINT_PRIMARYKEY
:
1405 zName
= "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
1406 case SQLITE_CONSTRAINT_NOTNULL
: zName
= "SQLITE_CONSTRAINT_NOTNULL";break;
1407 case SQLITE_CONSTRAINT_COMMITHOOK
:
1408 zName
= "SQLITE_CONSTRAINT_COMMITHOOK"; break;
1409 case SQLITE_CONSTRAINT_VTAB
: zName
= "SQLITE_CONSTRAINT_VTAB"; break;
1410 case SQLITE_CONSTRAINT_FUNCTION
:
1411 zName
= "SQLITE_CONSTRAINT_FUNCTION"; break;
1412 case SQLITE_CONSTRAINT_ROWID
: zName
= "SQLITE_CONSTRAINT_ROWID"; break;
1413 case SQLITE_MISMATCH
: zName
= "SQLITE_MISMATCH"; break;
1414 case SQLITE_MISUSE
: zName
= "SQLITE_MISUSE"; break;
1415 case SQLITE_NOLFS
: zName
= "SQLITE_NOLFS"; break;
1416 case SQLITE_AUTH
: zName
= "SQLITE_AUTH"; break;
1417 case SQLITE_FORMAT
: zName
= "SQLITE_FORMAT"; break;
1418 case SQLITE_RANGE
: zName
= "SQLITE_RANGE"; break;
1419 case SQLITE_NOTADB
: zName
= "SQLITE_NOTADB"; break;
1420 case SQLITE_ROW
: zName
= "SQLITE_ROW"; break;
1421 case SQLITE_NOTICE
: zName
= "SQLITE_NOTICE"; break;
1422 case SQLITE_NOTICE_RECOVER_WAL
: zName
= "SQLITE_NOTICE_RECOVER_WAL";break;
1423 case SQLITE_NOTICE_RECOVER_ROLLBACK
:
1424 zName
= "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
1425 case SQLITE_WARNING
: zName
= "SQLITE_WARNING"; break;
1426 case SQLITE_WARNING_AUTOINDEX
: zName
= "SQLITE_WARNING_AUTOINDEX"; break;
1427 case SQLITE_DONE
: zName
= "SQLITE_DONE"; break;
1431 static char zBuf
[50];
1432 sqlite3_snprintf(sizeof(zBuf
), zBuf
, "SQLITE_UNKNOWN(%d)", origRc
);
1440 ** Return a static string that describes the kind of error specified in the
1443 const char *sqlite3ErrStr(int rc
){
1444 static const char* const aMsg
[] = {
1445 /* SQLITE_OK */ "not an error",
1446 /* SQLITE_ERROR */ "SQL logic error",
1447 /* SQLITE_INTERNAL */ 0,
1448 /* SQLITE_PERM */ "access permission denied",
1449 /* SQLITE_ABORT */ "query aborted",
1450 /* SQLITE_BUSY */ "database is locked",
1451 /* SQLITE_LOCKED */ "database table is locked",
1452 /* SQLITE_NOMEM */ "out of memory",
1453 /* SQLITE_READONLY */ "attempt to write a readonly database",
1454 /* SQLITE_INTERRUPT */ "interrupted",
1455 /* SQLITE_IOERR */ "disk I/O error",
1456 /* SQLITE_CORRUPT */ "database disk image is malformed",
1457 /* SQLITE_NOTFOUND */ "unknown operation",
1458 /* SQLITE_FULL */ "database or disk is full",
1459 /* SQLITE_CANTOPEN */ "unable to open database file",
1460 /* SQLITE_PROTOCOL */ "locking protocol",
1461 /* SQLITE_EMPTY */ 0,
1462 /* SQLITE_SCHEMA */ "database schema has changed",
1463 /* SQLITE_TOOBIG */ "string or blob too big",
1464 /* SQLITE_CONSTRAINT */ "constraint failed",
1465 /* SQLITE_MISMATCH */ "datatype mismatch",
1466 /* SQLITE_MISUSE */ "bad parameter or other API misuse",
1467 #ifdef SQLITE_DISABLE_LFS
1468 /* SQLITE_NOLFS */ "large file support is disabled",
1470 /* SQLITE_NOLFS */ 0,
1472 /* SQLITE_AUTH */ "authorization denied",
1473 /* SQLITE_FORMAT */ 0,
1474 /* SQLITE_RANGE */ "column index out of range",
1475 /* SQLITE_NOTADB */ "file is not a database",
1476 /* SQLITE_NOTICE */ "notification message",
1477 /* SQLITE_WARNING */ "warning message",
1479 const char *zErr
= "unknown error";
1481 case SQLITE_ABORT_ROLLBACK
: {
1482 zErr
= "abort due to ROLLBACK";
1486 zErr
= "another row available";
1490 zErr
= "no more rows available";
1495 if( ALWAYS(rc
>=0) && rc
<ArraySize(aMsg
) && aMsg
[rc
]!=0 ){
1505 ** This routine implements a busy callback that sleeps and tries
1506 ** again until a timeout value is reached. The timeout value is
1507 ** an integer number of milliseconds passed in as the first
1510 ** Return non-zero to retry the lock. Return zero to stop trying
1511 ** and cause SQLite to return SQLITE_BUSY.
1513 static int sqliteDefaultBusyCallback(
1514 void *ptr
, /* Database connection */
1515 int count
, /* Number of times table has been busy */
1516 sqlite3_file
*pFile
/* The file on which the lock occurred */
1518 #if SQLITE_OS_WIN || HAVE_USLEEP
1519 /* This case is for systems that have support for sleeping for fractions of
1520 ** a second. Examples: All windows systems, unix systems with usleep() */
1521 static const u8 delays
[] =
1522 { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
1523 static const u8 totals
[] =
1524 { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
1525 # define NDELAY ArraySize(delays)
1526 sqlite3
*db
= (sqlite3
*)ptr
;
1527 int tmout
= db
->busyTimeout
;
1530 #ifdef SQLITE_ENABLE_SETLK_TIMEOUT
1531 if( sqlite3OsFileControl(pFile
,SQLITE_FCNTL_LOCK_TIMEOUT
,&tmout
)==SQLITE_OK
){
1534 sqlite3OsFileControl(pFile
, SQLITE_FCNTL_LOCK_TIMEOUT
, &tmout
);
1541 UNUSED_PARAMETER(pFile
);
1544 if( count
< NDELAY
){
1545 delay
= delays
[count
];
1546 prior
= totals
[count
];
1548 delay
= delays
[NDELAY
-1];
1549 prior
= totals
[NDELAY
-1] + delay
*(count
-(NDELAY
-1));
1551 if( prior
+ delay
> tmout
){
1552 delay
= tmout
- prior
;
1553 if( delay
<=0 ) return 0;
1555 sqlite3OsSleep(db
->pVfs
, delay
*1000);
1558 /* This case for unix systems that lack usleep() support. Sleeping
1559 ** must be done in increments of whole seconds */
1560 sqlite3
*db
= (sqlite3
*)ptr
;
1561 int tmout
= ((sqlite3
*)ptr
)->busyTimeout
;
1562 UNUSED_PARAMETER(pFile
);
1563 if( (count
+1)*1000 > tmout
){
1566 sqlite3OsSleep(db
->pVfs
, 1000000);
1572 ** Invoke the given busy handler.
1574 ** This routine is called when an operation failed to acquire a
1575 ** lock on VFS file pFile.
1577 ** If this routine returns non-zero, the lock is retried. If it
1578 ** returns 0, the operation aborts with an SQLITE_BUSY error.
1580 int sqlite3InvokeBusyHandler(BusyHandler
*p
, sqlite3_file
*pFile
){
1582 if( p
->xBusyHandler
==0 || p
->nBusy
<0 ) return 0;
1583 if( p
->bExtraFileArg
){
1584 /* Add an extra parameter with the pFile pointer to the end of the
1585 ** callback argument list */
1586 int (*xTra
)(void*,int,sqlite3_file
*);
1587 xTra
= (int(*)(void*,int,sqlite3_file
*))p
->xBusyHandler
;
1588 rc
= xTra(p
->pBusyArg
, p
->nBusy
, pFile
);
1590 /* Legacy style busy handler callback */
1591 rc
= p
->xBusyHandler(p
->pBusyArg
, p
->nBusy
);
1602 ** This routine sets the busy callback for an Sqlite database to the
1603 ** given callback function with the given argument.
1605 int sqlite3_busy_handler(
1607 int (*xBusy
)(void*,int),
1610 #ifdef SQLITE_ENABLE_API_ARMOR
1611 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
1613 sqlite3_mutex_enter(db
->mutex
);
1614 db
->busyHandler
.xBusyHandler
= xBusy
;
1615 db
->busyHandler
.pBusyArg
= pArg
;
1616 db
->busyHandler
.nBusy
= 0;
1617 db
->busyHandler
.bExtraFileArg
= 0;
1618 db
->busyTimeout
= 0;
1619 sqlite3_mutex_leave(db
->mutex
);
1623 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1625 ** This routine sets the progress callback for an Sqlite database to the
1626 ** given callback function with the given argument. The progress callback will
1627 ** be invoked every nOps opcodes.
1629 void sqlite3_progress_handler(
1632 int (*xProgress
)(void*),
1635 #ifdef SQLITE_ENABLE_API_ARMOR
1636 if( !sqlite3SafetyCheckOk(db
) ){
1637 (void)SQLITE_MISUSE_BKPT
;
1641 sqlite3_mutex_enter(db
->mutex
);
1643 db
->xProgress
= xProgress
;
1644 db
->nProgressOps
= (unsigned)nOps
;
1645 db
->pProgressArg
= pArg
;
1648 db
->nProgressOps
= 0;
1649 db
->pProgressArg
= 0;
1651 sqlite3_mutex_leave(db
->mutex
);
1657 ** This routine installs a default busy handler that waits for the
1658 ** specified number of milliseconds before returning 0.
1660 int sqlite3_busy_timeout(sqlite3
*db
, int ms
){
1661 #ifdef SQLITE_ENABLE_API_ARMOR
1662 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
1665 sqlite3_busy_handler(db
, (int(*)(void*,int))sqliteDefaultBusyCallback
,
1667 db
->busyTimeout
= ms
;
1668 db
->busyHandler
.bExtraFileArg
= 1;
1670 sqlite3_busy_handler(db
, 0, 0);
1676 ** Cause any pending operation to stop at its earliest opportunity.
1678 void sqlite3_interrupt(sqlite3
*db
){
1679 #ifdef SQLITE_ENABLE_API_ARMOR
1680 if( !sqlite3SafetyCheckOk(db
) && (db
==0 || db
->magic
!=SQLITE_MAGIC_ZOMBIE
) ){
1681 (void)SQLITE_MISUSE_BKPT
;
1685 db
->u1
.isInterrupted
= 1;
1690 ** This function is exactly the same as sqlite3_create_function(), except
1691 ** that it is designed to be called by internal code. The difference is
1692 ** that if a malloc() fails in sqlite3_create_function(), an error code
1693 ** is returned and the mallocFailed flag cleared.
1695 int sqlite3CreateFunc(
1697 const char *zFunctionName
,
1701 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**),
1702 void (*xStep
)(sqlite3_context
*,int,sqlite3_value
**),
1703 void (*xFinal
)(sqlite3_context
*),
1704 void (*xValue
)(sqlite3_context
*),
1705 void (*xInverse
)(sqlite3_context
*,int,sqlite3_value
**),
1706 FuncDestructor
*pDestructor
1712 assert( sqlite3_mutex_held(db
->mutex
) );
1713 assert( xValue
==0 || xSFunc
==0 );
1714 if( zFunctionName
==0 /* Must have a valid name */
1715 || (xSFunc
!=0 && xFinal
!=0) /* Not both xSFunc and xFinal */
1716 || ((xFinal
==0)!=(xStep
==0)) /* Both or neither of xFinal and xStep */
1717 || ((xValue
==0)!=(xInverse
==0)) /* Both or neither of xValue, xInverse */
1718 || (nArg
<-1 || nArg
>SQLITE_MAX_FUNCTION_ARG
)
1719 || (255<(nName
= sqlite3Strlen30( zFunctionName
)))
1721 return SQLITE_MISUSE_BKPT
;
1724 assert( SQLITE_FUNC_CONSTANT
==SQLITE_DETERMINISTIC
);
1725 extraFlags
= enc
& SQLITE_DETERMINISTIC
;
1726 enc
&= (SQLITE_FUNC_ENCMASK
|SQLITE_ANY
);
1728 #ifndef SQLITE_OMIT_UTF16
1729 /* If SQLITE_UTF16 is specified as the encoding type, transform this
1730 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
1731 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
1733 ** If SQLITE_ANY is specified, add three versions of the function
1734 ** to the hash table.
1736 if( enc
==SQLITE_UTF16
){
1737 enc
= SQLITE_UTF16NATIVE
;
1738 }else if( enc
==SQLITE_ANY
){
1740 rc
= sqlite3CreateFunc(db
, zFunctionName
, nArg
, SQLITE_UTF8
|extraFlags
,
1741 pUserData
, xSFunc
, xStep
, xFinal
, xValue
, xInverse
, pDestructor
);
1742 if( rc
==SQLITE_OK
){
1743 rc
= sqlite3CreateFunc(db
, zFunctionName
, nArg
, SQLITE_UTF16LE
|extraFlags
,
1744 pUserData
, xSFunc
, xStep
, xFinal
, xValue
, xInverse
, pDestructor
);
1746 if( rc
!=SQLITE_OK
){
1749 enc
= SQLITE_UTF16BE
;
1755 /* Check if an existing function is being overridden or deleted. If so,
1756 ** and there are active VMs, then return SQLITE_BUSY. If a function
1757 ** is being overridden/deleted but there are no active VMs, allow the
1758 ** operation to continue but invalidate all precompiled statements.
1760 p
= sqlite3FindFunction(db
, zFunctionName
, nArg
, (u8
)enc
, 0);
1761 if( p
&& (p
->funcFlags
& SQLITE_FUNC_ENCMASK
)==(u32
)enc
&& p
->nArg
==nArg
){
1762 if( db
->nVdbeActive
){
1763 sqlite3ErrorWithMsg(db
, SQLITE_BUSY
,
1764 "unable to delete/modify user-function due to active statements");
1765 assert( !db
->mallocFailed
);
1768 sqlite3ExpirePreparedStatements(db
, 0);
1772 p
= sqlite3FindFunction(db
, zFunctionName
, nArg
, (u8
)enc
, 1);
1773 assert(p
|| db
->mallocFailed
);
1775 return SQLITE_NOMEM_BKPT
;
1778 /* If an older version of the function with a configured destructor is
1779 ** being replaced invoke the destructor function here. */
1780 functionDestroy(db
, p
);
1783 pDestructor
->nRef
++;
1785 p
->u
.pDestructor
= pDestructor
;
1786 p
->funcFlags
= (p
->funcFlags
& SQLITE_FUNC_ENCMASK
) | extraFlags
;
1787 testcase( p
->funcFlags
& SQLITE_DETERMINISTIC
);
1788 p
->xSFunc
= xSFunc
? xSFunc
: xStep
;
1789 p
->xFinalize
= xFinal
;
1791 p
->xInverse
= xInverse
;
1792 p
->pUserData
= pUserData
;
1793 p
->nArg
= (u16
)nArg
;
1798 ** Worker function used by utf-8 APIs that create new functions:
1800 ** sqlite3_create_function()
1801 ** sqlite3_create_function_v2()
1802 ** sqlite3_create_window_function()
1804 static int createFunctionApi(
1810 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**),
1811 void (*xStep
)(sqlite3_context
*,int,sqlite3_value
**),
1812 void (*xFinal
)(sqlite3_context
*),
1813 void (*xValue
)(sqlite3_context
*),
1814 void (*xInverse
)(sqlite3_context
*,int,sqlite3_value
**),
1815 void(*xDestroy
)(void*)
1817 int rc
= SQLITE_ERROR
;
1818 FuncDestructor
*pArg
= 0;
1820 #ifdef SQLITE_ENABLE_API_ARMOR
1821 if( !sqlite3SafetyCheckOk(db
) ){
1822 return SQLITE_MISUSE_BKPT
;
1825 sqlite3_mutex_enter(db
->mutex
);
1827 pArg
= (FuncDestructor
*)sqlite3Malloc(sizeof(FuncDestructor
));
1829 sqlite3OomFault(db
);
1834 pArg
->xDestroy
= xDestroy
;
1835 pArg
->pUserData
= p
;
1837 rc
= sqlite3CreateFunc(db
, zFunc
, nArg
, enc
, p
,
1838 xSFunc
, xStep
, xFinal
, xValue
, xInverse
, pArg
1840 if( pArg
&& pArg
->nRef
==0 ){
1841 assert( rc
!=SQLITE_OK
);
1847 rc
= sqlite3ApiExit(db
, rc
);
1848 sqlite3_mutex_leave(db
->mutex
);
1853 ** Create new user functions.
1855 int sqlite3_create_function(
1861 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**),
1862 void (*xStep
)(sqlite3_context
*,int,sqlite3_value
**),
1863 void (*xFinal
)(sqlite3_context
*)
1865 return createFunctionApi(db
, zFunc
, nArg
, enc
, p
, xSFunc
, xStep
,
1868 int sqlite3_create_function_v2(
1874 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**),
1875 void (*xStep
)(sqlite3_context
*,int,sqlite3_value
**),
1876 void (*xFinal
)(sqlite3_context
*),
1877 void (*xDestroy
)(void *)
1879 return createFunctionApi(db
, zFunc
, nArg
, enc
, p
, xSFunc
, xStep
,
1880 xFinal
, 0, 0, xDestroy
);
1882 int sqlite3_create_window_function(
1888 void (*xStep
)(sqlite3_context
*,int,sqlite3_value
**),
1889 void (*xFinal
)(sqlite3_context
*),
1890 void (*xValue
)(sqlite3_context
*),
1891 void (*xInverse
)(sqlite3_context
*,int,sqlite3_value
**),
1892 void (*xDestroy
)(void *)
1894 return createFunctionApi(db
, zFunc
, nArg
, enc
, p
, 0, xStep
,
1895 xFinal
, xValue
, xInverse
, xDestroy
);
1898 #ifndef SQLITE_OMIT_UTF16
1899 int sqlite3_create_function16(
1901 const void *zFunctionName
,
1905 void (*xSFunc
)(sqlite3_context
*,int,sqlite3_value
**),
1906 void (*xStep
)(sqlite3_context
*,int,sqlite3_value
**),
1907 void (*xFinal
)(sqlite3_context
*)
1912 #ifdef SQLITE_ENABLE_API_ARMOR
1913 if( !sqlite3SafetyCheckOk(db
) || zFunctionName
==0 ) return SQLITE_MISUSE_BKPT
;
1915 sqlite3_mutex_enter(db
->mutex
);
1916 assert( !db
->mallocFailed
);
1917 zFunc8
= sqlite3Utf16to8(db
, zFunctionName
, -1, SQLITE_UTF16NATIVE
);
1918 rc
= sqlite3CreateFunc(db
, zFunc8
, nArg
, eTextRep
, p
, xSFunc
,xStep
,xFinal
,0,0,0);
1919 sqlite3DbFree(db
, zFunc8
);
1920 rc
= sqlite3ApiExit(db
, rc
);
1921 sqlite3_mutex_leave(db
->mutex
);
1928 ** The following is the implementation of an SQL function that always
1929 ** fails with an error message stating that the function is used in the
1930 ** wrong context. The sqlite3_overload_function() API might construct
1931 ** SQL function that use this routine so that the functions will exist
1932 ** for name resolution but are actually overloaded by the xFindFunction
1933 ** method of virtual tables.
1935 static void sqlite3InvalidFunction(
1936 sqlite3_context
*context
, /* The function calling context */
1937 int NotUsed
, /* Number of arguments to the function */
1938 sqlite3_value
**NotUsed2
/* Value of each argument */
1940 const char *zName
= (const char*)sqlite3_user_data(context
);
1942 UNUSED_PARAMETER2(NotUsed
, NotUsed2
);
1943 zErr
= sqlite3_mprintf(
1944 "unable to use function %s in the requested context", zName
);
1945 sqlite3_result_error(context
, zErr
, -1);
1950 ** Declare that a function has been overloaded by a virtual table.
1952 ** If the function already exists as a regular global function, then
1953 ** this routine is a no-op. If the function does not exist, then create
1954 ** a new one that always throws a run-time error.
1956 ** When virtual tables intend to provide an overloaded function, they
1957 ** should call this routine to make sure the global function exists.
1958 ** A global function must exist in order for name resolution to work
1961 int sqlite3_overload_function(
1969 #ifdef SQLITE_ENABLE_API_ARMOR
1970 if( !sqlite3SafetyCheckOk(db
) || zName
==0 || nArg
<-2 ){
1971 return SQLITE_MISUSE_BKPT
;
1974 sqlite3_mutex_enter(db
->mutex
);
1975 rc
= sqlite3FindFunction(db
, zName
, nArg
, SQLITE_UTF8
, 0)!=0;
1976 sqlite3_mutex_leave(db
->mutex
);
1977 if( rc
) return SQLITE_OK
;
1978 zCopy
= sqlite3_mprintf(zName
);
1979 if( zCopy
==0 ) return SQLITE_NOMEM
;
1980 return sqlite3_create_function_v2(db
, zName
, nArg
, SQLITE_UTF8
,
1981 zCopy
, sqlite3InvalidFunction
, 0, 0, sqlite3_free
);
1984 #ifndef SQLITE_OMIT_TRACE
1986 ** Register a trace function. The pArg from the previously registered trace
1989 ** A NULL trace function means that no tracing is executes. A non-NULL
1990 ** trace is a pointer to a function that is invoked at the start of each
1993 #ifndef SQLITE_OMIT_DEPRECATED
1994 void *sqlite3_trace(sqlite3
*db
, void(*xTrace
)(void*,const char*), void *pArg
){
1997 #ifdef SQLITE_ENABLE_API_ARMOR
1998 if( !sqlite3SafetyCheckOk(db
) ){
1999 (void)SQLITE_MISUSE_BKPT
;
2003 sqlite3_mutex_enter(db
->mutex
);
2004 pOld
= db
->pTraceArg
;
2005 db
->mTrace
= xTrace
? SQLITE_TRACE_LEGACY
: 0;
2006 db
->xTrace
= (int(*)(u32
,void*,void*,void*))xTrace
;
2007 db
->pTraceArg
= pArg
;
2008 sqlite3_mutex_leave(db
->mutex
);
2011 #endif /* SQLITE_OMIT_DEPRECATED */
2013 /* Register a trace callback using the version-2 interface.
2015 int sqlite3_trace_v2(
2016 sqlite3
*db
, /* Trace this connection */
2017 unsigned mTrace
, /* Mask of events to be traced */
2018 int(*xTrace
)(unsigned,void*,void*,void*), /* Callback to invoke */
2019 void *pArg
/* Context */
2021 #ifdef SQLITE_ENABLE_API_ARMOR
2022 if( !sqlite3SafetyCheckOk(db
) ){
2023 return SQLITE_MISUSE_BKPT
;
2026 sqlite3_mutex_enter(db
->mutex
);
2027 if( mTrace
==0 ) xTrace
= 0;
2028 if( xTrace
==0 ) mTrace
= 0;
2029 db
->mTrace
= mTrace
;
2030 db
->xTrace
= xTrace
;
2031 db
->pTraceArg
= pArg
;
2032 sqlite3_mutex_leave(db
->mutex
);
2036 #ifndef SQLITE_OMIT_DEPRECATED
2038 ** Register a profile function. The pArg from the previously registered
2039 ** profile function is returned.
2041 ** A NULL profile function means that no profiling is executes. A non-NULL
2042 ** profile is a pointer to a function that is invoked at the conclusion of
2043 ** each SQL statement that is run.
2045 void *sqlite3_profile(
2047 void (*xProfile
)(void*,const char*,sqlite_uint64
),
2052 #ifdef SQLITE_ENABLE_API_ARMOR
2053 if( !sqlite3SafetyCheckOk(db
) ){
2054 (void)SQLITE_MISUSE_BKPT
;
2058 sqlite3_mutex_enter(db
->mutex
);
2059 pOld
= db
->pProfileArg
;
2060 db
->xProfile
= xProfile
;
2061 db
->pProfileArg
= pArg
;
2062 db
->mTrace
&= SQLITE_TRACE_NONLEGACY_MASK
;
2063 if( db
->xProfile
) db
->mTrace
|= SQLITE_TRACE_XPROFILE
;
2064 sqlite3_mutex_leave(db
->mutex
);
2067 #endif /* SQLITE_OMIT_DEPRECATED */
2068 #endif /* SQLITE_OMIT_TRACE */
2071 ** Register a function to be invoked when a transaction commits.
2072 ** If the invoked function returns non-zero, then the commit becomes a
2075 void *sqlite3_commit_hook(
2076 sqlite3
*db
, /* Attach the hook to this database */
2077 int (*xCallback
)(void*), /* Function to invoke on each commit */
2078 void *pArg
/* Argument to the function */
2082 #ifdef SQLITE_ENABLE_API_ARMOR
2083 if( !sqlite3SafetyCheckOk(db
) ){
2084 (void)SQLITE_MISUSE_BKPT
;
2088 sqlite3_mutex_enter(db
->mutex
);
2089 pOld
= db
->pCommitArg
;
2090 db
->xCommitCallback
= xCallback
;
2091 db
->pCommitArg
= pArg
;
2092 sqlite3_mutex_leave(db
->mutex
);
2097 ** Register a callback to be invoked each time a row is updated,
2098 ** inserted or deleted using this database connection.
2100 void *sqlite3_update_hook(
2101 sqlite3
*db
, /* Attach the hook to this database */
2102 void (*xCallback
)(void*,int,char const *,char const *,sqlite_int64
),
2103 void *pArg
/* Argument to the function */
2107 #ifdef SQLITE_ENABLE_API_ARMOR
2108 if( !sqlite3SafetyCheckOk(db
) ){
2109 (void)SQLITE_MISUSE_BKPT
;
2113 sqlite3_mutex_enter(db
->mutex
);
2114 pRet
= db
->pUpdateArg
;
2115 db
->xUpdateCallback
= xCallback
;
2116 db
->pUpdateArg
= pArg
;
2117 sqlite3_mutex_leave(db
->mutex
);
2122 ** Register a callback to be invoked each time a transaction is rolled
2123 ** back by this database connection.
2125 void *sqlite3_rollback_hook(
2126 sqlite3
*db
, /* Attach the hook to this database */
2127 void (*xCallback
)(void*), /* Callback function */
2128 void *pArg
/* Argument to the function */
2132 #ifdef SQLITE_ENABLE_API_ARMOR
2133 if( !sqlite3SafetyCheckOk(db
) ){
2134 (void)SQLITE_MISUSE_BKPT
;
2138 sqlite3_mutex_enter(db
->mutex
);
2139 pRet
= db
->pRollbackArg
;
2140 db
->xRollbackCallback
= xCallback
;
2141 db
->pRollbackArg
= pArg
;
2142 sqlite3_mutex_leave(db
->mutex
);
2146 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2148 ** Register a callback to be invoked each time a row is updated,
2149 ** inserted or deleted using this database connection.
2151 void *sqlite3_preupdate_hook(
2152 sqlite3
*db
, /* Attach the hook to this database */
2153 void(*xCallback
)( /* Callback function */
2154 void*,sqlite3
*,int,char const*,char const*,sqlite3_int64
,sqlite3_int64
),
2155 void *pArg
/* First callback argument */
2158 sqlite3_mutex_enter(db
->mutex
);
2159 pRet
= db
->pPreUpdateArg
;
2160 db
->xPreUpdateCallback
= xCallback
;
2161 db
->pPreUpdateArg
= pArg
;
2162 sqlite3_mutex_leave(db
->mutex
);
2165 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
2167 #ifndef SQLITE_OMIT_WAL
2169 ** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint().
2170 ** Invoke sqlite3_wal_checkpoint if the number of frames in the log file
2171 ** is greater than sqlite3.pWalArg cast to an integer (the value configured by
2172 ** wal_autocheckpoint()).
2174 int sqlite3WalDefaultHook(
2175 void *pClientData
, /* Argument */
2176 sqlite3
*db
, /* Connection */
2177 const char *zDb
, /* Database */
2178 int nFrame
/* Size of WAL */
2180 if( nFrame
>=SQLITE_PTR_TO_INT(pClientData
) ){
2181 sqlite3BeginBenignMalloc();
2182 sqlite3_wal_checkpoint(db
, zDb
);
2183 sqlite3EndBenignMalloc();
2187 #endif /* SQLITE_OMIT_WAL */
2190 ** Configure an sqlite3_wal_hook() callback to automatically checkpoint
2191 ** a database after committing a transaction if there are nFrame or
2192 ** more frames in the log file. Passing zero or a negative value as the
2193 ** nFrame parameter disables automatic checkpoints entirely.
2195 ** The callback registered by this function replaces any existing callback
2196 ** registered using sqlite3_wal_hook(). Likewise, registering a callback
2197 ** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
2198 ** configured by this function.
2200 int sqlite3_wal_autocheckpoint(sqlite3
*db
, int nFrame
){
2201 #ifdef SQLITE_OMIT_WAL
2202 UNUSED_PARAMETER(db
);
2203 UNUSED_PARAMETER(nFrame
);
2205 #ifdef SQLITE_ENABLE_API_ARMOR
2206 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
2209 sqlite3_wal_hook(db
, sqlite3WalDefaultHook
, SQLITE_INT_TO_PTR(nFrame
));
2211 sqlite3_wal_hook(db
, 0, 0);
2218 ** Register a callback to be invoked each time a transaction is written
2219 ** into the write-ahead-log by this database connection.
2221 void *sqlite3_wal_hook(
2222 sqlite3
*db
, /* Attach the hook to this db handle */
2223 int(*xCallback
)(void *, sqlite3
*, const char*, int),
2224 void *pArg
/* First argument passed to xCallback() */
2226 #ifndef SQLITE_OMIT_WAL
2228 #ifdef SQLITE_ENABLE_API_ARMOR
2229 if( !sqlite3SafetyCheckOk(db
) ){
2230 (void)SQLITE_MISUSE_BKPT
;
2234 sqlite3_mutex_enter(db
->mutex
);
2236 db
->xWalCallback
= xCallback
;
2238 sqlite3_mutex_leave(db
->mutex
);
2246 ** Checkpoint database zDb.
2248 int sqlite3_wal_checkpoint_v2(
2249 sqlite3
*db
, /* Database handle */
2250 const char *zDb
, /* Name of attached database (or NULL) */
2251 int eMode
, /* SQLITE_CHECKPOINT_* value */
2252 int *pnLog
, /* OUT: Size of WAL log in frames */
2253 int *pnCkpt
/* OUT: Total number of frames checkpointed */
2255 #ifdef SQLITE_OMIT_WAL
2258 int rc
; /* Return code */
2259 int iDb
= SQLITE_MAX_ATTACHED
; /* sqlite3.aDb[] index of db to checkpoint */
2261 #ifdef SQLITE_ENABLE_API_ARMOR
2262 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
2265 /* Initialize the output variables to -1 in case an error occurs. */
2266 if( pnLog
) *pnLog
= -1;
2267 if( pnCkpt
) *pnCkpt
= -1;
2269 assert( SQLITE_CHECKPOINT_PASSIVE
==0 );
2270 assert( SQLITE_CHECKPOINT_FULL
==1 );
2271 assert( SQLITE_CHECKPOINT_RESTART
==2 );
2272 assert( SQLITE_CHECKPOINT_TRUNCATE
==3 );
2273 if( eMode
<SQLITE_CHECKPOINT_PASSIVE
|| eMode
>SQLITE_CHECKPOINT_TRUNCATE
){
2274 /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
2276 return SQLITE_MISUSE
;
2279 sqlite3_mutex_enter(db
->mutex
);
2280 if( zDb
&& zDb
[0] ){
2281 iDb
= sqlite3FindDbName(db
, zDb
);
2285 sqlite3ErrorWithMsg(db
, SQLITE_ERROR
, "unknown database: %s", zDb
);
2287 db
->busyHandler
.nBusy
= 0;
2288 rc
= sqlite3Checkpoint(db
, iDb
, eMode
, pnLog
, pnCkpt
);
2289 sqlite3Error(db
, rc
);
2291 rc
= sqlite3ApiExit(db
, rc
);
2293 /* If there are no active statements, clear the interrupt flag at this
2295 if( db
->nVdbeActive
==0 ){
2296 db
->u1
.isInterrupted
= 0;
2299 sqlite3_mutex_leave(db
->mutex
);
2306 ** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
2307 ** to contains a zero-length string, all attached databases are
2310 int sqlite3_wal_checkpoint(sqlite3
*db
, const char *zDb
){
2311 /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to
2312 ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */
2313 return sqlite3_wal_checkpoint_v2(db
,zDb
,SQLITE_CHECKPOINT_PASSIVE
,0,0);
2316 #ifndef SQLITE_OMIT_WAL
2318 ** Run a checkpoint on database iDb. This is a no-op if database iDb is
2319 ** not currently open in WAL mode.
2321 ** If a transaction is open on the database being checkpointed, this
2322 ** function returns SQLITE_LOCKED and a checkpoint is not attempted. If
2323 ** an error occurs while running the checkpoint, an SQLite error code is
2324 ** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
2326 ** The mutex on database handle db should be held by the caller. The mutex
2327 ** associated with the specific b-tree being checkpointed is taken by
2328 ** this function while the checkpoint is running.
2330 ** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
2331 ** checkpointed. If an error is encountered it is returned immediately -
2332 ** no attempt is made to checkpoint any remaining databases.
2334 ** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL, RESTART
2337 int sqlite3Checkpoint(sqlite3
*db
, int iDb
, int eMode
, int *pnLog
, int *pnCkpt
){
2338 int rc
= SQLITE_OK
; /* Return code */
2339 int i
; /* Used to iterate through attached dbs */
2340 int bBusy
= 0; /* True if SQLITE_BUSY has been encountered */
2342 assert( sqlite3_mutex_held(db
->mutex
) );
2343 assert( !pnLog
|| *pnLog
==-1 );
2344 assert( !pnCkpt
|| *pnCkpt
==-1 );
2346 for(i
=0; i
<db
->nDb
&& rc
==SQLITE_OK
; i
++){
2347 if( i
==iDb
|| iDb
==SQLITE_MAX_ATTACHED
){
2348 rc
= sqlite3BtreeCheckpoint(db
->aDb
[i
].pBt
, eMode
, pnLog
, pnCkpt
);
2351 if( rc
==SQLITE_BUSY
){
2358 return (rc
==SQLITE_OK
&& bBusy
) ? SQLITE_BUSY
: rc
;
2360 #endif /* SQLITE_OMIT_WAL */
2363 ** This function returns true if main-memory should be used instead of
2364 ** a temporary file for transient pager files and statement journals.
2365 ** The value returned depends on the value of db->temp_store (runtime
2366 ** parameter) and the compile time value of SQLITE_TEMP_STORE. The
2367 ** following table describes the relationship between these two values
2368 ** and this functions return value.
2370 ** SQLITE_TEMP_STORE db->temp_store Location of temporary database
2371 ** ----------------- -------------- ------------------------------
2372 ** 0 any file (return 0)
2373 ** 1 1 file (return 0)
2374 ** 1 2 memory (return 1)
2375 ** 1 0 file (return 0)
2376 ** 2 1 file (return 0)
2377 ** 2 2 memory (return 1)
2378 ** 2 0 memory (return 1)
2379 ** 3 any memory (return 1)
2381 int sqlite3TempInMemory(const sqlite3
*db
){
2382 #if SQLITE_TEMP_STORE==1
2383 return ( db
->temp_store
==2 );
2385 #if SQLITE_TEMP_STORE==2
2386 return ( db
->temp_store
!=1 );
2388 #if SQLITE_TEMP_STORE==3
2389 UNUSED_PARAMETER(db
);
2392 #if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3
2393 UNUSED_PARAMETER(db
);
2399 ** Return UTF-8 encoded English language explanation of the most recent
2402 const char *sqlite3_errmsg(sqlite3
*db
){
2405 return sqlite3ErrStr(SQLITE_NOMEM_BKPT
);
2407 if( !sqlite3SafetyCheckSickOrOk(db
) ){
2408 return sqlite3ErrStr(SQLITE_MISUSE_BKPT
);
2410 sqlite3_mutex_enter(db
->mutex
);
2411 if( db
->mallocFailed
){
2412 z
= sqlite3ErrStr(SQLITE_NOMEM_BKPT
);
2414 testcase( db
->pErr
==0 );
2415 z
= db
->errCode
? (char*)sqlite3_value_text(db
->pErr
) : 0;
2416 assert( !db
->mallocFailed
);
2418 z
= sqlite3ErrStr(db
->errCode
);
2421 sqlite3_mutex_leave(db
->mutex
);
2425 #ifndef SQLITE_OMIT_UTF16
2427 ** Return UTF-16 encoded English language explanation of the most recent
2430 const void *sqlite3_errmsg16(sqlite3
*db
){
2431 static const u16 outOfMem
[] = {
2432 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
2434 static const u16 misuse
[] = {
2435 'b', 'a', 'd', ' ', 'p', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', ' ',
2436 'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ',
2437 'm', 'i', 's', 'u', 's', 'e', 0
2442 return (void *)outOfMem
;
2444 if( !sqlite3SafetyCheckSickOrOk(db
) ){
2445 return (void *)misuse
;
2447 sqlite3_mutex_enter(db
->mutex
);
2448 if( db
->mallocFailed
){
2449 z
= (void *)outOfMem
;
2451 z
= sqlite3_value_text16(db
->pErr
);
2453 sqlite3ErrorWithMsg(db
, db
->errCode
, sqlite3ErrStr(db
->errCode
));
2454 z
= sqlite3_value_text16(db
->pErr
);
2456 /* A malloc() may have failed within the call to sqlite3_value_text16()
2457 ** above. If this is the case, then the db->mallocFailed flag needs to
2458 ** be cleared before returning. Do this directly, instead of via
2459 ** sqlite3ApiExit(), to avoid setting the database handle error message.
2461 sqlite3OomClear(db
);
2463 sqlite3_mutex_leave(db
->mutex
);
2466 #endif /* SQLITE_OMIT_UTF16 */
2469 ** Return the most recent error code generated by an SQLite routine. If NULL is
2470 ** passed to this function, we assume a malloc() failed during sqlite3_open().
2472 int sqlite3_errcode(sqlite3
*db
){
2473 if( db
&& !sqlite3SafetyCheckSickOrOk(db
) ){
2474 return SQLITE_MISUSE_BKPT
;
2476 if( !db
|| db
->mallocFailed
){
2477 return SQLITE_NOMEM_BKPT
;
2479 return db
->errCode
& db
->errMask
;
2481 int sqlite3_extended_errcode(sqlite3
*db
){
2482 if( db
&& !sqlite3SafetyCheckSickOrOk(db
) ){
2483 return SQLITE_MISUSE_BKPT
;
2485 if( !db
|| db
->mallocFailed
){
2486 return SQLITE_NOMEM_BKPT
;
2490 int sqlite3_system_errno(sqlite3
*db
){
2491 return db
? db
->iSysErrno
: 0;
2495 ** Return a string that describes the kind of error specified in the
2496 ** argument. For now, this simply calls the internal sqlite3ErrStr()
2499 const char *sqlite3_errstr(int rc
){
2500 return sqlite3ErrStr(rc
);
2504 ** Create a new collating function for database "db". The name is zName
2505 ** and the encoding is enc.
2507 static int createCollation(
2512 int(*xCompare
)(void*,int,const void*,int,const void*),
2518 assert( sqlite3_mutex_held(db
->mutex
) );
2520 /* If SQLITE_UTF16 is specified as the encoding type, transform this
2521 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
2522 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
2525 testcase( enc2
==SQLITE_UTF16
);
2526 testcase( enc2
==SQLITE_UTF16_ALIGNED
);
2527 if( enc2
==SQLITE_UTF16
|| enc2
==SQLITE_UTF16_ALIGNED
){
2528 enc2
= SQLITE_UTF16NATIVE
;
2530 if( enc2
<SQLITE_UTF8
|| enc2
>SQLITE_UTF16BE
){
2531 return SQLITE_MISUSE_BKPT
;
2534 /* Check if this call is removing or replacing an existing collation
2535 ** sequence. If so, and there are active VMs, return busy. If there
2536 ** are no active VMs, invalidate any pre-compiled statements.
2538 pColl
= sqlite3FindCollSeq(db
, (u8
)enc2
, zName
, 0);
2539 if( pColl
&& pColl
->xCmp
){
2540 if( db
->nVdbeActive
){
2541 sqlite3ErrorWithMsg(db
, SQLITE_BUSY
,
2542 "unable to delete/modify collation sequence due to active statements");
2545 sqlite3ExpirePreparedStatements(db
, 0);
2547 /* If collation sequence pColl was created directly by a call to
2548 ** sqlite3_create_collation, and not generated by synthCollSeq(),
2549 ** then any copies made by synthCollSeq() need to be invalidated.
2550 ** Also, collation destructor - CollSeq.xDel() - function may need
2553 if( (pColl
->enc
& ~SQLITE_UTF16_ALIGNED
)==enc2
){
2554 CollSeq
*aColl
= sqlite3HashFind(&db
->aCollSeq
, zName
);
2557 CollSeq
*p
= &aColl
[j
];
2558 if( p
->enc
==pColl
->enc
){
2568 pColl
= sqlite3FindCollSeq(db
, (u8
)enc2
, zName
, 1);
2569 if( pColl
==0 ) return SQLITE_NOMEM_BKPT
;
2570 pColl
->xCmp
= xCompare
;
2571 pColl
->pUser
= pCtx
;
2573 pColl
->enc
= (u8
)(enc2
| (enc
& SQLITE_UTF16_ALIGNED
));
2574 sqlite3Error(db
, SQLITE_OK
);
2580 ** This array defines hard upper bounds on limit values. The
2581 ** initializer must be kept in sync with the SQLITE_LIMIT_*
2582 ** #defines in sqlite3.h.
2584 static const int aHardLimit
[] = {
2586 SQLITE_MAX_SQL_LENGTH
,
2588 SQLITE_MAX_EXPR_DEPTH
,
2589 SQLITE_MAX_COMPOUND_SELECT
,
2591 SQLITE_MAX_FUNCTION_ARG
,
2592 SQLITE_MAX_ATTACHED
,
2593 SQLITE_MAX_LIKE_PATTERN_LENGTH
,
2594 SQLITE_MAX_VARIABLE_NUMBER
, /* IMP: R-38091-32352 */
2595 SQLITE_MAX_TRIGGER_DEPTH
,
2596 SQLITE_MAX_WORKER_THREADS
,
2600 ** Make sure the hard limits are set to reasonable values
2602 #if SQLITE_MAX_LENGTH<100
2603 # error SQLITE_MAX_LENGTH must be at least 100
2605 #if SQLITE_MAX_SQL_LENGTH<100
2606 # error SQLITE_MAX_SQL_LENGTH must be at least 100
2608 #if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
2609 # error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
2611 #if SQLITE_MAX_COMPOUND_SELECT<2
2612 # error SQLITE_MAX_COMPOUND_SELECT must be at least 2
2614 #if SQLITE_MAX_VDBE_OP<40
2615 # error SQLITE_MAX_VDBE_OP must be at least 40
2617 #if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>127
2618 # error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
2620 #if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>125
2621 # error SQLITE_MAX_ATTACHED must be between 0 and 125
2623 #if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
2624 # error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
2626 #if SQLITE_MAX_COLUMN>32767
2627 # error SQLITE_MAX_COLUMN must not exceed 32767
2629 #if SQLITE_MAX_TRIGGER_DEPTH<1
2630 # error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
2632 #if SQLITE_MAX_WORKER_THREADS<0 || SQLITE_MAX_WORKER_THREADS>50
2633 # error SQLITE_MAX_WORKER_THREADS must be between 0 and 50
2638 ** Change the value of a limit. Report the old value.
2639 ** If an invalid limit index is supplied, report -1.
2640 ** Make no changes but still report the old value if the
2641 ** new limit is negative.
2643 ** A new lower limit does not shrink existing constructs.
2644 ** It merely prevents new constructs that exceed the limit
2647 int sqlite3_limit(sqlite3
*db
, int limitId
, int newLimit
){
2650 #ifdef SQLITE_ENABLE_API_ARMOR
2651 if( !sqlite3SafetyCheckOk(db
) ){
2652 (void)SQLITE_MISUSE_BKPT
;
2657 /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
2658 ** there is a hard upper bound set at compile-time by a C preprocessor
2659 ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
2662 assert( aHardLimit
[SQLITE_LIMIT_LENGTH
]==SQLITE_MAX_LENGTH
);
2663 assert( aHardLimit
[SQLITE_LIMIT_SQL_LENGTH
]==SQLITE_MAX_SQL_LENGTH
);
2664 assert( aHardLimit
[SQLITE_LIMIT_COLUMN
]==SQLITE_MAX_COLUMN
);
2665 assert( aHardLimit
[SQLITE_LIMIT_EXPR_DEPTH
]==SQLITE_MAX_EXPR_DEPTH
);
2666 assert( aHardLimit
[SQLITE_LIMIT_COMPOUND_SELECT
]==SQLITE_MAX_COMPOUND_SELECT
);
2667 assert( aHardLimit
[SQLITE_LIMIT_VDBE_OP
]==SQLITE_MAX_VDBE_OP
);
2668 assert( aHardLimit
[SQLITE_LIMIT_FUNCTION_ARG
]==SQLITE_MAX_FUNCTION_ARG
);
2669 assert( aHardLimit
[SQLITE_LIMIT_ATTACHED
]==SQLITE_MAX_ATTACHED
);
2670 assert( aHardLimit
[SQLITE_LIMIT_LIKE_PATTERN_LENGTH
]==
2671 SQLITE_MAX_LIKE_PATTERN_LENGTH
);
2672 assert( aHardLimit
[SQLITE_LIMIT_VARIABLE_NUMBER
]==SQLITE_MAX_VARIABLE_NUMBER
);
2673 assert( aHardLimit
[SQLITE_LIMIT_TRIGGER_DEPTH
]==SQLITE_MAX_TRIGGER_DEPTH
);
2674 assert( aHardLimit
[SQLITE_LIMIT_WORKER_THREADS
]==SQLITE_MAX_WORKER_THREADS
);
2675 assert( SQLITE_LIMIT_WORKER_THREADS
==(SQLITE_N_LIMIT
-1) );
2678 if( limitId
<0 || limitId
>=SQLITE_N_LIMIT
){
2681 oldLimit
= db
->aLimit
[limitId
];
2682 if( newLimit
>=0 ){ /* IMP: R-52476-28732 */
2683 if( newLimit
>aHardLimit
[limitId
] ){
2684 newLimit
= aHardLimit
[limitId
]; /* IMP: R-51463-25634 */
2686 db
->aLimit
[limitId
] = newLimit
;
2688 return oldLimit
; /* IMP: R-53341-35419 */
2692 ** This function is used to parse both URIs and non-URI filenames passed by the
2693 ** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database
2694 ** URIs specified as part of ATTACH statements.
2696 ** The first argument to this function is the name of the VFS to use (or
2697 ** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
2698 ** query parameter. The second argument contains the URI (or non-URI filename)
2699 ** itself. When this function is called the *pFlags variable should contain
2700 ** the default flags to open the database handle with. The value stored in
2701 ** *pFlags may be updated before returning if the URI filename contains
2702 ** "cache=xxx" or "mode=xxx" query parameters.
2704 ** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
2705 ** the VFS that should be used to open the database file. *pzFile is set to
2706 ** point to a buffer containing the name of the file to open. It is the
2707 ** responsibility of the caller to eventually call sqlite3_free() to release
2710 ** If an error occurs, then an SQLite error code is returned and *pzErrMsg
2711 ** may be set to point to a buffer containing an English language error
2712 ** message. It is the responsibility of the caller to eventually release
2713 ** this buffer by calling sqlite3_free().
2715 int sqlite3ParseUri(
2716 const char *zDefaultVfs
, /* VFS to use if no "vfs=xxx" query option */
2717 const char *zUri
, /* Nul-terminated URI to parse */
2718 unsigned int *pFlags
, /* IN/OUT: SQLITE_OPEN_XXX flags */
2719 sqlite3_vfs
**ppVfs
, /* OUT: VFS to use */
2720 char **pzFile
, /* OUT: Filename component of URI */
2721 char **pzErrMsg
/* OUT: Error message (if rc!=SQLITE_OK) */
2724 unsigned int flags
= *pFlags
;
2725 const char *zVfs
= zDefaultVfs
;
2728 int nUri
= sqlite3Strlen30(zUri
);
2730 assert( *pzErrMsg
==0 );
2732 if( ((flags
& SQLITE_OPEN_URI
) /* IMP: R-48725-32206 */
2733 || sqlite3GlobalConfig
.bOpenUri
) /* IMP: R-51689-46548 */
2734 && nUri
>=5 && memcmp(zUri
, "file:", 5)==0 /* IMP: R-57884-37496 */
2737 int eState
; /* Parser state when parsing URI */
2738 int iIn
; /* Input character index */
2739 int iOut
= 0; /* Output character index */
2740 u64 nByte
= nUri
+2; /* Bytes of space to allocate */
2742 /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
2743 ** method that there may be extra parameters following the file-name. */
2744 flags
|= SQLITE_OPEN_URI
;
2746 for(iIn
=0; iIn
<nUri
; iIn
++) nByte
+= (zUri
[iIn
]=='&');
2747 zFile
= sqlite3_malloc64(nByte
);
2748 if( !zFile
) return SQLITE_NOMEM_BKPT
;
2751 #ifdef SQLITE_ALLOW_URI_AUTHORITY
2752 if( strncmp(zUri
+5, "///", 3)==0 ){
2754 /* The following condition causes URIs with five leading / characters
2755 ** like file://///host/path to be converted into UNCs like //host/path.
2756 ** The correct URI for that UNC has only two or four leading / characters
2757 ** file://host/path or file:////host/path. But 5 leading slashes is a
2758 ** common error, we are told, so we handle it as a special case. */
2759 if( strncmp(zUri
+7, "///", 3)==0 ){ iIn
++; }
2760 }else if( strncmp(zUri
+5, "//localhost/", 12)==0 ){
2764 /* Discard the scheme and authority segments of the URI. */
2765 if( zUri
[5]=='/' && zUri
[6]=='/' ){
2767 while( zUri
[iIn
] && zUri
[iIn
]!='/' ) iIn
++;
2768 if( iIn
!=7 && (iIn
!=16 || memcmp("localhost", &zUri
[7], 9)) ){
2769 *pzErrMsg
= sqlite3_mprintf("invalid uri authority: %.*s",
2777 /* Copy the filename and any query parameters into the zFile buffer.
2778 ** Decode %HH escape codes along the way.
2780 ** Within this loop, variable eState may be set to 0, 1 or 2, depending
2781 ** on the parsing context. As follows:
2783 ** 0: Parsing file-name.
2784 ** 1: Parsing name section of a name=value query parameter.
2785 ** 2: Parsing value section of a name=value query parameter.
2788 while( (c
= zUri
[iIn
])!=0 && c
!='#' ){
2791 && sqlite3Isxdigit(zUri
[iIn
])
2792 && sqlite3Isxdigit(zUri
[iIn
+1])
2794 int octet
= (sqlite3HexToInt(zUri
[iIn
++]) << 4);
2795 octet
+= sqlite3HexToInt(zUri
[iIn
++]);
2797 assert( octet
>=0 && octet
<256 );
2799 #ifndef SQLITE_ENABLE_URI_00_ERROR
2800 /* This branch is taken when "%00" appears within the URI. In this
2801 ** case we ignore all text in the remainder of the path, name or
2802 ** value currently being parsed. So ignore the current character
2803 ** and skip to the next "?", "=" or "&", as appropriate. */
2804 while( (c
= zUri
[iIn
])!=0 && c
!='#'
2805 && (eState
!=0 || c
!='?')
2806 && (eState
!=1 || (c
!='=' && c
!='&'))
2807 && (eState
!=2 || c
!='&')
2813 /* If ENABLE_URI_00_ERROR is defined, "%00" in a URI is an error. */
2814 *pzErrMsg
= sqlite3_mprintf("unexpected %%00 in uri");
2820 }else if( eState
==1 && (c
=='&' || c
=='=') ){
2821 if( zFile
[iOut
-1]==0 ){
2822 /* An empty option name. Ignore this option altogether. */
2823 while( zUri
[iIn
] && zUri
[iIn
]!='#' && zUri
[iIn
-1]!='&' ) iIn
++;
2827 zFile
[iOut
++] = '\0';
2832 }else if( (eState
==0 && c
=='?') || (eState
==2 && c
=='&') ){
2838 if( eState
==1 ) zFile
[iOut
++] = '\0';
2839 zFile
[iOut
++] = '\0';
2840 zFile
[iOut
++] = '\0';
2842 /* Check if there were any options specified that should be interpreted
2843 ** here. Options that are interpreted here include "vfs" and those that
2844 ** correspond to flags that may be passed to the sqlite3_open_v2()
2846 zOpt
= &zFile
[sqlite3Strlen30(zFile
)+1];
2848 int nOpt
= sqlite3Strlen30(zOpt
);
2849 char *zVal
= &zOpt
[nOpt
+1];
2850 int nVal
= sqlite3Strlen30(zVal
);
2852 if( nOpt
==3 && memcmp("vfs", zOpt
, 3)==0 ){
2859 char *zModeType
= 0;
2863 if( nOpt
==5 && memcmp("cache", zOpt
, 5)==0 ){
2864 static struct OpenMode aCacheMode
[] = {
2865 { "shared", SQLITE_OPEN_SHAREDCACHE
},
2866 { "private", SQLITE_OPEN_PRIVATECACHE
},
2870 mask
= SQLITE_OPEN_SHAREDCACHE
|SQLITE_OPEN_PRIVATECACHE
;
2873 zModeType
= "cache";
2875 if( nOpt
==4 && memcmp("mode", zOpt
, 4)==0 ){
2876 static struct OpenMode aOpenMode
[] = {
2877 { "ro", SQLITE_OPEN_READONLY
},
2878 { "rw", SQLITE_OPEN_READWRITE
},
2879 { "rwc", SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
},
2880 { "memory", SQLITE_OPEN_MEMORY
},
2884 mask
= SQLITE_OPEN_READONLY
| SQLITE_OPEN_READWRITE
2885 | SQLITE_OPEN_CREATE
| SQLITE_OPEN_MEMORY
;
2887 limit
= mask
& flags
;
2888 zModeType
= "access";
2894 for(i
=0; aMode
[i
].z
; i
++){
2895 const char *z
= aMode
[i
].z
;
2896 if( nVal
==sqlite3Strlen30(z
) && 0==memcmp(zVal
, z
, nVal
) ){
2897 mode
= aMode
[i
].mode
;
2902 *pzErrMsg
= sqlite3_mprintf("no such %s mode: %s", zModeType
, zVal
);
2906 if( (mode
& ~SQLITE_OPEN_MEMORY
)>limit
){
2907 *pzErrMsg
= sqlite3_mprintf("%s mode not allowed: %s",
2912 flags
= (flags
& ~mask
) | mode
;
2916 zOpt
= &zVal
[nVal
+1];
2920 zFile
= sqlite3_malloc64(nUri
+2);
2921 if( !zFile
) return SQLITE_NOMEM_BKPT
;
2923 memcpy(zFile
, zUri
, nUri
);
2926 zFile
[nUri
+1] = '\0';
2927 flags
&= ~SQLITE_OPEN_URI
;
2930 *ppVfs
= sqlite3_vfs_find(zVfs
);
2932 *pzErrMsg
= sqlite3_mprintf("no such vfs: %s", zVfs
);
2936 if( rc
!=SQLITE_OK
){
2937 sqlite3_free(zFile
);
2945 #if defined(SQLITE_HAS_CODEC)
2947 ** Process URI filename query parameters relevant to the SQLite Encryption
2948 ** Extension. Return true if any of the relevant query parameters are
2949 ** seen and return false if not.
2951 int sqlite3CodecQueryParameters(
2952 sqlite3
*db
, /* Database connection */
2953 const char *zDb
, /* Which schema is being created/attached */
2954 const char *zUri
/* URI filename */
2957 if( (zKey
= sqlite3_uri_parameter(zUri
, "hexkey"))!=0 && zKey
[0] ){
2961 for(i
=0, iByte
=0; i
<sizeof(zDecoded
)*2 && sqlite3Isxdigit(zKey
[i
]); i
++){
2962 iByte
= (iByte
<<4) + sqlite3HexToInt(zKey
[i
]);
2963 if( (i
&1)!=0 ) zDecoded
[i
/2] = iByte
;
2965 sqlite3_key_v2(db
, zDb
, zDecoded
, i
/2);
2967 }else if( (zKey
= sqlite3_uri_parameter(zUri
, "key"))!=0 ){
2968 sqlite3_key_v2(db
, zDb
, zKey
, sqlite3Strlen30(zKey
));
2970 }else if( (zKey
= sqlite3_uri_parameter(zUri
, "textkey"))!=0 ){
2971 sqlite3_key_v2(db
, zDb
, zKey
, -1);
2981 ** This routine does the work of opening a database on behalf of
2982 ** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
2983 ** is UTF-8 encoded.
2985 static int openDatabase(
2986 const char *zFilename
, /* Database filename UTF-8 encoded */
2987 sqlite3
**ppDb
, /* OUT: Returned database handle */
2988 unsigned int flags
, /* Operational flags */
2989 const char *zVfs
/* Name of the VFS to use */
2991 sqlite3
*db
; /* Store allocated handle here */
2992 int rc
; /* Return code */
2993 int isThreadsafe
; /* True for threadsafe connections */
2994 char *zOpen
= 0; /* Filename argument to pass to BtreeOpen() */
2995 char *zErrMsg
= 0; /* Error message from sqlite3ParseUri() */
2997 #ifdef SQLITE_ENABLE_API_ARMOR
2998 if( ppDb
==0 ) return SQLITE_MISUSE_BKPT
;
3001 #ifndef SQLITE_OMIT_AUTOINIT
3002 rc
= sqlite3_initialize();
3006 if( sqlite3GlobalConfig
.bCoreMutex
==0 ){
3008 }else if( flags
& SQLITE_OPEN_NOMUTEX
){
3010 }else if( flags
& SQLITE_OPEN_FULLMUTEX
){
3013 isThreadsafe
= sqlite3GlobalConfig
.bFullMutex
;
3016 if( flags
& SQLITE_OPEN_PRIVATECACHE
){
3017 flags
&= ~SQLITE_OPEN_SHAREDCACHE
;
3018 }else if( sqlite3GlobalConfig
.sharedCacheEnabled
){
3019 flags
|= SQLITE_OPEN_SHAREDCACHE
;
3022 /* Remove harmful bits from the flags parameter
3024 ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
3025 ** dealt with in the previous code block. Besides these, the only
3026 ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
3027 ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
3028 ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits. Silently mask
3029 ** off all other flags.
3031 flags
&= ~( SQLITE_OPEN_DELETEONCLOSE
|
3032 SQLITE_OPEN_EXCLUSIVE
|
3033 SQLITE_OPEN_MAIN_DB
|
3034 SQLITE_OPEN_TEMP_DB
|
3035 SQLITE_OPEN_TRANSIENT_DB
|
3036 SQLITE_OPEN_MAIN_JOURNAL
|
3037 SQLITE_OPEN_TEMP_JOURNAL
|
3038 SQLITE_OPEN_SUBJOURNAL
|
3039 SQLITE_OPEN_MASTER_JOURNAL
|
3040 SQLITE_OPEN_NOMUTEX
|
3041 SQLITE_OPEN_FULLMUTEX
|
3045 /* Allocate the sqlite data structure */
3046 db
= sqlite3MallocZero( sizeof(sqlite3
) );
3047 if( db
==0 ) goto opendb_out
;
3049 #ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS
3050 || sqlite3GlobalConfig
.bCoreMutex
3053 db
->mutex
= sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE
);
3059 if( isThreadsafe
==0 ){
3060 sqlite3MutexWarnOnContention(db
->mutex
);
3063 sqlite3_mutex_enter(db
->mutex
);
3066 db
->magic
= SQLITE_MAGIC_BUSY
;
3067 db
->aDb
= db
->aDbStatic
;
3068 db
->lookaside
.bDisable
= 1;
3070 assert( sizeof(db
->aLimit
)==sizeof(aHardLimit
) );
3071 memcpy(db
->aLimit
, aHardLimit
, sizeof(db
->aLimit
));
3072 db
->aLimit
[SQLITE_LIMIT_WORKER_THREADS
] = SQLITE_DEFAULT_WORKER_THREADS
;
3074 db
->nextAutovac
= -1;
3075 db
->szMmap
= sqlite3GlobalConfig
.szMmap
;
3076 db
->nextPagesize
= 0;
3077 db
->nMaxSorterMmap
= 0x7FFFFFFF;
3078 db
->flags
|= SQLITE_ShortColNames
| SQLITE_EnableTrigger
| SQLITE_CacheSpill
3079 #if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX
3082 #if SQLITE_DEFAULT_CKPTFULLFSYNC
3083 | SQLITE_CkptFullFSync
3085 #if SQLITE_DEFAULT_FILE_FORMAT<4
3086 | SQLITE_LegacyFileFmt
3088 #ifdef SQLITE_ENABLE_LOAD_EXTENSION
3089 | SQLITE_LoadExtension
3091 #if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
3092 | SQLITE_RecTriggers
3094 #if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS
3095 | SQLITE_ForeignKeys
3097 #if defined(SQLITE_REVERSE_UNORDERED_SELECTS)
3098 | SQLITE_ReverseOrder
3100 #if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
3103 #if defined(SQLITE_ENABLE_FTS3_TOKENIZER)
3104 | SQLITE_Fts3Tokenizer
3106 #if defined(SQLITE_ENABLE_QPSG)
3109 #if defined(SQLITE_DEFAULT_DEFENSIVE)
3113 sqlite3HashInit(&db
->aCollSeq
);
3114 #ifndef SQLITE_OMIT_VIRTUALTABLE
3115 sqlite3HashInit(&db
->aModule
);
3118 /* Add the default collation sequence BINARY. BINARY works for both UTF-8
3119 ** and UTF-16, so add a version for each to avoid any unnecessary
3120 ** conversions. The only error that can occur here is a malloc() failure.
3122 ** EVIDENCE-OF: R-52786-44878 SQLite defines three built-in collating
3125 createCollation(db
, sqlite3StrBINARY
, SQLITE_UTF8
, 0, binCollFunc
, 0);
3126 createCollation(db
, sqlite3StrBINARY
, SQLITE_UTF16BE
, 0, binCollFunc
, 0);
3127 createCollation(db
, sqlite3StrBINARY
, SQLITE_UTF16LE
, 0, binCollFunc
, 0);
3128 createCollation(db
, "NOCASE", SQLITE_UTF8
, 0, nocaseCollatingFunc
, 0);
3129 createCollation(db
, "RTRIM", SQLITE_UTF8
, (void*)1, binCollFunc
, 0);
3130 if( db
->mallocFailed
){
3133 /* EVIDENCE-OF: R-08308-17224 The default collating function for all
3134 ** strings is BINARY.
3136 db
->pDfltColl
= sqlite3FindCollSeq(db
, SQLITE_UTF8
, sqlite3StrBINARY
, 0);
3137 assert( db
->pDfltColl
!=0 );
3139 /* Parse the filename/URI argument
3141 ** Only allow sensible combinations of bits in the flags argument.
3142 ** Throw an error if any non-sense combination is used. If we
3143 ** do not block illegal combinations here, it could trigger
3144 ** assert() statements in deeper layers. Sensible combinations
3147 ** 1: SQLITE_OPEN_READONLY
3148 ** 2: SQLITE_OPEN_READWRITE
3149 ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
3151 db
->openFlags
= flags
;
3152 assert( SQLITE_OPEN_READONLY
== 0x01 );
3153 assert( SQLITE_OPEN_READWRITE
== 0x02 );
3154 assert( SQLITE_OPEN_CREATE
== 0x04 );
3155 testcase( (1<<(flags
&7))==0x02 ); /* READONLY */
3156 testcase( (1<<(flags
&7))==0x04 ); /* READWRITE */
3157 testcase( (1<<(flags
&7))==0x40 ); /* READWRITE | CREATE */
3158 if( ((1<<(flags
&7)) & 0x46)==0 ){
3159 rc
= SQLITE_MISUSE_BKPT
; /* IMP: R-65497-44594 */
3161 rc
= sqlite3ParseUri(zVfs
, zFilename
, &flags
, &db
->pVfs
, &zOpen
, &zErrMsg
);
3163 if( rc
!=SQLITE_OK
){
3164 if( rc
==SQLITE_NOMEM
) sqlite3OomFault(db
);
3165 sqlite3ErrorWithMsg(db
, rc
, zErrMsg
? "%s" : 0, zErrMsg
);
3166 sqlite3_free(zErrMsg
);
3170 /* Open the backend database driver */
3171 rc
= sqlite3BtreeOpen(db
->pVfs
, zOpen
, db
, &db
->aDb
[0].pBt
, 0,
3172 flags
| SQLITE_OPEN_MAIN_DB
);
3173 if( rc
!=SQLITE_OK
){
3174 if( rc
==SQLITE_IOERR_NOMEM
){
3175 rc
= SQLITE_NOMEM_BKPT
;
3177 sqlite3Error(db
, rc
);
3180 sqlite3BtreeEnter(db
->aDb
[0].pBt
);
3181 db
->aDb
[0].pSchema
= sqlite3SchemaGet(db
, db
->aDb
[0].pBt
);
3182 if( !db
->mallocFailed
) ENC(db
) = SCHEMA_ENC(db
);
3183 sqlite3BtreeLeave(db
->aDb
[0].pBt
);
3184 db
->aDb
[1].pSchema
= sqlite3SchemaGet(db
, 0);
3186 /* The default safety_level for the main database is FULL; for the temp
3187 ** database it is OFF. This matches the pager layer defaults.
3189 db
->aDb
[0].zDbSName
= "main";
3190 db
->aDb
[0].safety_level
= SQLITE_DEFAULT_SYNCHRONOUS
+1;
3191 db
->aDb
[1].zDbSName
= "temp";
3192 db
->aDb
[1].safety_level
= PAGER_SYNCHRONOUS_OFF
;
3194 db
->magic
= SQLITE_MAGIC_OPEN
;
3195 if( db
->mallocFailed
){
3199 /* Register all built-in functions, but do not attempt to read the
3200 ** database schema yet. This is delayed until the first time the database
3203 sqlite3Error(db
, SQLITE_OK
);
3204 sqlite3RegisterPerConnectionBuiltinFunctions(db
);
3205 rc
= sqlite3_errcode(db
);
3207 #ifdef SQLITE_ENABLE_FTS5
3208 /* Register any built-in FTS5 module before loading the automatic
3209 ** extensions. This allows automatic extensions to register FTS5
3210 ** tokenizers and auxiliary functions. */
3211 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3212 rc
= sqlite3Fts5Init(db
);
3216 /* Load automatic extensions - extensions that have been registered
3217 ** using the sqlite3_automatic_extension() API.
3219 if( rc
==SQLITE_OK
){
3220 sqlite3AutoLoadExtensions(db
);
3221 rc
= sqlite3_errcode(db
);
3222 if( rc
!=SQLITE_OK
){
3227 #ifdef SQLITE_ENABLE_FTS1
3228 if( !db
->mallocFailed
){
3229 extern int sqlite3Fts1Init(sqlite3
*);
3230 rc
= sqlite3Fts1Init(db
);
3234 #ifdef SQLITE_ENABLE_FTS2
3235 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3236 extern int sqlite3Fts2Init(sqlite3
*);
3237 rc
= sqlite3Fts2Init(db
);
3241 #ifdef SQLITE_ENABLE_FTS3 /* automatically defined by SQLITE_ENABLE_FTS4 */
3242 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3243 rc
= sqlite3Fts3Init(db
);
3247 #if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS)
3248 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3249 rc
= sqlite3IcuInit(db
);
3253 #ifdef SQLITE_ENABLE_RTREE
3254 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3255 rc
= sqlite3RtreeInit(db
);
3259 #ifdef SQLITE_ENABLE_DBPAGE_VTAB
3260 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3261 rc
= sqlite3DbpageRegister(db
);
3265 #ifdef SQLITE_ENABLE_DBSTAT_VTAB
3266 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3267 rc
= sqlite3DbstatRegister(db
);
3271 #ifdef SQLITE_ENABLE_JSON1
3272 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3273 rc
= sqlite3Json1Init(db
);
3277 #ifdef SQLITE_ENABLE_STMTVTAB
3278 if( !db
->mallocFailed
&& rc
==SQLITE_OK
){
3279 rc
= sqlite3StmtVtabInit(db
);
3283 /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
3284 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
3285 ** mode. Doing nothing at all also makes NORMAL the default.
3287 #ifdef SQLITE_DEFAULT_LOCKING_MODE
3288 db
->dfltLockMode
= SQLITE_DEFAULT_LOCKING_MODE
;
3289 sqlite3PagerLockingMode(sqlite3BtreePager(db
->aDb
[0].pBt
),
3290 SQLITE_DEFAULT_LOCKING_MODE
);
3293 if( rc
) sqlite3Error(db
, rc
);
3295 /* Enable the lookaside-malloc subsystem */
3296 setupLookaside(db
, 0, sqlite3GlobalConfig
.szLookaside
,
3297 sqlite3GlobalConfig
.nLookaside
);
3299 sqlite3_wal_autocheckpoint(db
, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT
);
3303 assert( db
->mutex
!=0 || isThreadsafe
==0
3304 || sqlite3GlobalConfig
.bFullMutex
==0 );
3305 sqlite3_mutex_leave(db
->mutex
);
3307 rc
= sqlite3_errcode(db
);
3308 assert( db
!=0 || rc
==SQLITE_NOMEM
);
3309 if( rc
==SQLITE_NOMEM
){
3312 }else if( rc
!=SQLITE_OK
){
3313 db
->magic
= SQLITE_MAGIC_SICK
;
3316 #ifdef SQLITE_ENABLE_SQLLOG
3317 if( sqlite3GlobalConfig
.xSqllog
){
3318 /* Opening a db handle. Fourth parameter is passed 0. */
3319 void *pArg
= sqlite3GlobalConfig
.pSqllogArg
;
3320 sqlite3GlobalConfig
.xSqllog(pArg
, db
, zFilename
, 0);
3323 #if defined(SQLITE_HAS_CODEC)
3324 if( rc
==SQLITE_OK
) sqlite3CodecQueryParameters(db
, 0, zOpen
);
3326 sqlite3_free(zOpen
);
3332 ** Open a new database handle.
3335 const char *zFilename
,
3338 return openDatabase(zFilename
, ppDb
,
3339 SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
, 0);
3341 int sqlite3_open_v2(
3342 const char *filename
, /* Database filename (UTF-8) */
3343 sqlite3
**ppDb
, /* OUT: SQLite db handle */
3344 int flags
, /* Flags */
3345 const char *zVfs
/* Name of VFS module to use */
3347 return openDatabase(filename
, ppDb
, (unsigned int)flags
, zVfs
);
3350 #ifndef SQLITE_OMIT_UTF16
3352 ** Open a new database handle.
3355 const void *zFilename
,
3358 char const *zFilename8
; /* zFilename encoded in UTF-8 instead of UTF-16 */
3359 sqlite3_value
*pVal
;
3362 #ifdef SQLITE_ENABLE_API_ARMOR
3363 if( ppDb
==0 ) return SQLITE_MISUSE_BKPT
;
3366 #ifndef SQLITE_OMIT_AUTOINIT
3367 rc
= sqlite3_initialize();
3370 if( zFilename
==0 ) zFilename
= "\000\000";
3371 pVal
= sqlite3ValueNew(0);
3372 sqlite3ValueSetStr(pVal
, -1, zFilename
, SQLITE_UTF16NATIVE
, SQLITE_STATIC
);
3373 zFilename8
= sqlite3ValueText(pVal
, SQLITE_UTF8
);
3375 rc
= openDatabase(zFilename8
, ppDb
,
3376 SQLITE_OPEN_READWRITE
| SQLITE_OPEN_CREATE
, 0);
3377 assert( *ppDb
|| rc
==SQLITE_NOMEM
);
3378 if( rc
==SQLITE_OK
&& !DbHasProperty(*ppDb
, 0, DB_SchemaLoaded
) ){
3379 SCHEMA_ENC(*ppDb
) = ENC(*ppDb
) = SQLITE_UTF16NATIVE
;
3382 rc
= SQLITE_NOMEM_BKPT
;
3384 sqlite3ValueFree(pVal
);
3388 #endif /* SQLITE_OMIT_UTF16 */
3391 ** Register a new collation sequence with the database handle db.
3393 int sqlite3_create_collation(
3398 int(*xCompare
)(void*,int,const void*,int,const void*)
3400 return sqlite3_create_collation_v2(db
, zName
, enc
, pCtx
, xCompare
, 0);
3404 ** Register a new collation sequence with the database handle db.
3406 int sqlite3_create_collation_v2(
3411 int(*xCompare
)(void*,int,const void*,int,const void*),
3416 #ifdef SQLITE_ENABLE_API_ARMOR
3417 if( !sqlite3SafetyCheckOk(db
) || zName
==0 ) return SQLITE_MISUSE_BKPT
;
3419 sqlite3_mutex_enter(db
->mutex
);
3420 assert( !db
->mallocFailed
);
3421 rc
= createCollation(db
, zName
, (u8
)enc
, pCtx
, xCompare
, xDel
);
3422 rc
= sqlite3ApiExit(db
, rc
);
3423 sqlite3_mutex_leave(db
->mutex
);
3427 #ifndef SQLITE_OMIT_UTF16
3429 ** Register a new collation sequence with the database handle db.
3431 int sqlite3_create_collation16(
3436 int(*xCompare
)(void*,int,const void*,int,const void*)
3441 #ifdef SQLITE_ENABLE_API_ARMOR
3442 if( !sqlite3SafetyCheckOk(db
) || zName
==0 ) return SQLITE_MISUSE_BKPT
;
3444 sqlite3_mutex_enter(db
->mutex
);
3445 assert( !db
->mallocFailed
);
3446 zName8
= sqlite3Utf16to8(db
, zName
, -1, SQLITE_UTF16NATIVE
);
3448 rc
= createCollation(db
, zName8
, (u8
)enc
, pCtx
, xCompare
, 0);
3449 sqlite3DbFree(db
, zName8
);
3451 rc
= sqlite3ApiExit(db
, rc
);
3452 sqlite3_mutex_leave(db
->mutex
);
3455 #endif /* SQLITE_OMIT_UTF16 */
3458 ** Register a collation sequence factory callback with the database handle
3459 ** db. Replace any previously installed collation sequence factory.
3461 int sqlite3_collation_needed(
3463 void *pCollNeededArg
,
3464 void(*xCollNeeded
)(void*,sqlite3
*,int eTextRep
,const char*)
3466 #ifdef SQLITE_ENABLE_API_ARMOR
3467 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
3469 sqlite3_mutex_enter(db
->mutex
);
3470 db
->xCollNeeded
= xCollNeeded
;
3471 db
->xCollNeeded16
= 0;
3472 db
->pCollNeededArg
= pCollNeededArg
;
3473 sqlite3_mutex_leave(db
->mutex
);
3477 #ifndef SQLITE_OMIT_UTF16
3479 ** Register a collation sequence factory callback with the database handle
3480 ** db. Replace any previously installed collation sequence factory.
3482 int sqlite3_collation_needed16(
3484 void *pCollNeededArg
,
3485 void(*xCollNeeded16
)(void*,sqlite3
*,int eTextRep
,const void*)
3487 #ifdef SQLITE_ENABLE_API_ARMOR
3488 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
3490 sqlite3_mutex_enter(db
->mutex
);
3491 db
->xCollNeeded
= 0;
3492 db
->xCollNeeded16
= xCollNeeded16
;
3493 db
->pCollNeededArg
= pCollNeededArg
;
3494 sqlite3_mutex_leave(db
->mutex
);
3497 #endif /* SQLITE_OMIT_UTF16 */
3499 #ifndef SQLITE_OMIT_DEPRECATED
3501 ** This function is now an anachronism. It used to be used to recover from a
3502 ** malloc() failure, but SQLite now does this automatically.
3504 int sqlite3_global_recover(void){
3510 ** Test to see whether or not the database connection is in autocommit
3511 ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
3512 ** by default. Autocommit is disabled by a BEGIN statement and reenabled
3513 ** by the next COMMIT or ROLLBACK.
3515 int sqlite3_get_autocommit(sqlite3
*db
){
3516 #ifdef SQLITE_ENABLE_API_ARMOR
3517 if( !sqlite3SafetyCheckOk(db
) ){
3518 (void)SQLITE_MISUSE_BKPT
;
3522 return db
->autoCommit
;
3526 ** The following routines are substitutes for constants SQLITE_CORRUPT,
3527 ** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_NOMEM and possibly other error
3528 ** constants. They serve two purposes:
3530 ** 1. Serve as a convenient place to set a breakpoint in a debugger
3531 ** to detect when version error conditions occurs.
3533 ** 2. Invoke sqlite3_log() to provide the source code location where
3534 ** a low-level error is first detected.
3536 int sqlite3ReportError(int iErr
, int lineno
, const char *zType
){
3537 sqlite3_log(iErr
, "%s at line %d of [%.10s]",
3538 zType
, lineno
, 20+sqlite3_sourceid());
3541 int sqlite3CorruptError(int lineno
){
3542 testcase( sqlite3GlobalConfig
.xLog
!=0 );
3543 return sqlite3ReportError(SQLITE_CORRUPT
, lineno
, "database corruption");
3545 int sqlite3MisuseError(int lineno
){
3546 testcase( sqlite3GlobalConfig
.xLog
!=0 );
3547 return sqlite3ReportError(SQLITE_MISUSE
, lineno
, "misuse");
3549 int sqlite3CantopenError(int lineno
){
3550 testcase( sqlite3GlobalConfig
.xLog
!=0 );
3551 return sqlite3ReportError(SQLITE_CANTOPEN
, lineno
, "cannot open file");
3554 int sqlite3CorruptPgnoError(int lineno
, Pgno pgno
){
3556 sqlite3_snprintf(sizeof(zMsg
), zMsg
, "database corruption page %d", pgno
);
3557 testcase( sqlite3GlobalConfig
.xLog
!=0 );
3558 return sqlite3ReportError(SQLITE_CORRUPT
, lineno
, zMsg
);
3560 int sqlite3NomemError(int lineno
){
3561 testcase( sqlite3GlobalConfig
.xLog
!=0 );
3562 return sqlite3ReportError(SQLITE_NOMEM
, lineno
, "OOM");
3564 int sqlite3IoerrnomemError(int lineno
){
3565 testcase( sqlite3GlobalConfig
.xLog
!=0 );
3566 return sqlite3ReportError(SQLITE_IOERR_NOMEM
, lineno
, "I/O OOM error");
3570 #ifndef SQLITE_OMIT_DEPRECATED
3572 ** This is a convenience routine that makes sure that all thread-specific
3573 ** data for this thread has been deallocated.
3575 ** SQLite no longer uses thread-specific data so this routine is now a
3576 ** no-op. It is retained for historical compatibility.
3578 void sqlite3_thread_cleanup(void){
3583 ** Return meta information about a specific column of a database table.
3584 ** See comment in sqlite3.h (sqlite.h.in) for details.
3586 int sqlite3_table_column_metadata(
3587 sqlite3
*db
, /* Connection handle */
3588 const char *zDbName
, /* Database name or NULL */
3589 const char *zTableName
, /* Table name */
3590 const char *zColumnName
, /* Column name */
3591 char const **pzDataType
, /* OUTPUT: Declared data type */
3592 char const **pzCollSeq
, /* OUTPUT: Collation sequence name */
3593 int *pNotNull
, /* OUTPUT: True if NOT NULL constraint exists */
3594 int *pPrimaryKey
, /* OUTPUT: True if column part of PK */
3595 int *pAutoinc
/* OUTPUT: True if column is auto-increment */
3602 char const *zDataType
= 0;
3603 char const *zCollSeq
= 0;
3609 #ifdef SQLITE_ENABLE_API_ARMOR
3610 if( !sqlite3SafetyCheckOk(db
) || zTableName
==0 ){
3611 return SQLITE_MISUSE_BKPT
;
3615 /* Ensure the database schema has been loaded */
3616 sqlite3_mutex_enter(db
->mutex
);
3617 sqlite3BtreeEnterAll(db
);
3618 rc
= sqlite3Init(db
, &zErrMsg
);
3619 if( SQLITE_OK
!=rc
){
3623 /* Locate the table in question */
3624 pTab
= sqlite3FindTable(db
, zTableName
, zDbName
);
3625 if( !pTab
|| pTab
->pSelect
){
3630 /* Find the column for which info is requested */
3631 if( zColumnName
==0 ){
3632 /* Query for existance of table only */
3634 for(iCol
=0; iCol
<pTab
->nCol
; iCol
++){
3635 pCol
= &pTab
->aCol
[iCol
];
3636 if( 0==sqlite3StrICmp(pCol
->zName
, zColumnName
) ){
3640 if( iCol
==pTab
->nCol
){
3641 if( HasRowid(pTab
) && sqlite3IsRowid(zColumnName
) ){
3643 pCol
= iCol
>=0 ? &pTab
->aCol
[iCol
] : 0;
3651 /* The following block stores the meta information that will be returned
3652 ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
3653 ** and autoinc. At this point there are two possibilities:
3655 ** 1. The specified column name was rowid", "oid" or "_rowid_"
3656 ** and there is no explicitly declared IPK column.
3658 ** 2. The table is not a view and the column name identified an
3659 ** explicitly declared column. Copy meta information from *pCol.
3662 zDataType
= sqlite3ColumnType(pCol
,0);
3663 zCollSeq
= pCol
->zColl
;
3664 notnull
= pCol
->notNull
!=0;
3665 primarykey
= (pCol
->colFlags
& COLFLAG_PRIMKEY
)!=0;
3666 autoinc
= pTab
->iPKey
==iCol
&& (pTab
->tabFlags
& TF_Autoincrement
)!=0;
3668 zDataType
= "INTEGER";
3672 zCollSeq
= sqlite3StrBINARY
;
3676 sqlite3BtreeLeaveAll(db
);
3678 /* Whether the function call succeeded or failed, set the output parameters
3679 ** to whatever their local counterparts contain. If an error did occur,
3680 ** this has the effect of zeroing all output parameters.
3682 if( pzDataType
) *pzDataType
= zDataType
;
3683 if( pzCollSeq
) *pzCollSeq
= zCollSeq
;
3684 if( pNotNull
) *pNotNull
= notnull
;
3685 if( pPrimaryKey
) *pPrimaryKey
= primarykey
;
3686 if( pAutoinc
) *pAutoinc
= autoinc
;
3688 if( SQLITE_OK
==rc
&& !pTab
){
3689 sqlite3DbFree(db
, zErrMsg
);
3690 zErrMsg
= sqlite3MPrintf(db
, "no such table column: %s.%s", zTableName
,
3694 sqlite3ErrorWithMsg(db
, rc
, (zErrMsg
?"%s":0), zErrMsg
);
3695 sqlite3DbFree(db
, zErrMsg
);
3696 rc
= sqlite3ApiExit(db
, rc
);
3697 sqlite3_mutex_leave(db
->mutex
);
3702 ** Sleep for a little while. Return the amount of time slept.
3704 int sqlite3_sleep(int ms
){
3707 pVfs
= sqlite3_vfs_find(0);
3708 if( pVfs
==0 ) return 0;
3710 /* This function works in milliseconds, but the underlying OsSleep()
3711 ** API uses microseconds. Hence the 1000's.
3713 rc
= (sqlite3OsSleep(pVfs
, 1000*ms
)/1000);
3718 ** Enable or disable the extended result codes.
3720 int sqlite3_extended_result_codes(sqlite3
*db
, int onoff
){
3721 #ifdef SQLITE_ENABLE_API_ARMOR
3722 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
3724 sqlite3_mutex_enter(db
->mutex
);
3725 db
->errMask
= onoff
? 0xffffffff : 0xff;
3726 sqlite3_mutex_leave(db
->mutex
);
3731 ** Invoke the xFileControl method on a particular database.
3733 int sqlite3_file_control(sqlite3
*db
, const char *zDbName
, int op
, void *pArg
){
3734 int rc
= SQLITE_ERROR
;
3737 #ifdef SQLITE_ENABLE_API_ARMOR
3738 if( !sqlite3SafetyCheckOk(db
) ) return SQLITE_MISUSE_BKPT
;
3740 sqlite3_mutex_enter(db
->mutex
);
3741 pBtree
= sqlite3DbNameToBtree(db
, zDbName
);
3745 sqlite3BtreeEnter(pBtree
);
3746 pPager
= sqlite3BtreePager(pBtree
);
3747 assert( pPager
!=0 );
3748 fd
= sqlite3PagerFile(pPager
);
3750 if( op
==SQLITE_FCNTL_FILE_POINTER
){
3751 *(sqlite3_file
**)pArg
= fd
;
3753 }else if( op
==SQLITE_FCNTL_VFS_POINTER
){
3754 *(sqlite3_vfs
**)pArg
= sqlite3PagerVfs(pPager
);
3756 }else if( op
==SQLITE_FCNTL_JOURNAL_POINTER
){
3757 *(sqlite3_file
**)pArg
= sqlite3PagerJrnlFile(pPager
);
3759 }else if( op
==SQLITE_FCNTL_DATA_VERSION
){
3760 *(unsigned int*)pArg
= sqlite3PagerDataVersion(pPager
);
3763 rc
= sqlite3OsFileControl(fd
, op
, pArg
);
3765 sqlite3BtreeLeave(pBtree
);
3767 sqlite3_mutex_leave(db
->mutex
);
3772 ** Interface to the testing logic.
3774 int sqlite3_test_control(int op
, ...){
3776 #ifdef SQLITE_UNTESTABLE
3777 UNUSED_PARAMETER(op
);
3784 ** Save the current state of the PRNG.
3786 case SQLITE_TESTCTRL_PRNG_SAVE
: {
3787 sqlite3PrngSaveState();
3792 ** Restore the state of the PRNG to the last state saved using
3793 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
3794 ** this verb acts like PRNG_RESET.
3796 case SQLITE_TESTCTRL_PRNG_RESTORE
: {
3797 sqlite3PrngRestoreState();
3802 ** Reset the PRNG back to its uninitialized state. The next call
3803 ** to sqlite3_randomness() will reseed the PRNG using a single call
3804 ** to the xRandomness method of the default VFS.
3806 case SQLITE_TESTCTRL_PRNG_RESET
: {
3807 sqlite3_randomness(0,0);
3812 ** sqlite3_test_control(BITVEC_TEST, size, program)
3814 ** Run a test against a Bitvec object of size. The program argument
3815 ** is an array of integers that defines the test. Return -1 on a
3816 ** memory allocation error, 0 on success, or non-zero for an error.
3817 ** See the sqlite3BitvecBuiltinTest() for additional information.
3819 case SQLITE_TESTCTRL_BITVEC_TEST
: {
3820 int sz
= va_arg(ap
, int);
3821 int *aProg
= va_arg(ap
, int*);
3822 rc
= sqlite3BitvecBuiltinTest(sz
, aProg
);
3827 ** sqlite3_test_control(FAULT_INSTALL, xCallback)
3829 ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called,
3830 ** if xCallback is not NULL.
3832 ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0)
3833 ** is called immediately after installing the new callback and the return
3834 ** value from sqlite3FaultSim(0) becomes the return from
3835 ** sqlite3_test_control().
3837 case SQLITE_TESTCTRL_FAULT_INSTALL
: {
3838 /* MSVC is picky about pulling func ptrs from va lists.
3839 ** http://support.microsoft.com/kb/47961
3840 ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
3842 typedef int(*TESTCALLBACKFUNC_t
)(int);
3843 sqlite3GlobalConfig
.xTestCallback
= va_arg(ap
, TESTCALLBACKFUNC_t
);
3844 rc
= sqlite3FaultSim(0);
3849 ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
3851 ** Register hooks to call to indicate which malloc() failures
3854 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS
: {
3855 typedef void (*void_function
)(void);
3856 void_function xBenignBegin
;
3857 void_function xBenignEnd
;
3858 xBenignBegin
= va_arg(ap
, void_function
);
3859 xBenignEnd
= va_arg(ap
, void_function
);
3860 sqlite3BenignMallocHooks(xBenignBegin
, xBenignEnd
);
3865 ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
3867 ** Set the PENDING byte to the value in the argument, if X>0.
3868 ** Make no changes if X==0. Return the value of the pending byte
3869 ** as it existing before this routine was called.
3871 ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in
3872 ** an incompatible database file format. Changing the PENDING byte
3873 ** while any database connection is open results in undefined and
3874 ** deleterious behavior.
3876 case SQLITE_TESTCTRL_PENDING_BYTE
: {
3878 #ifndef SQLITE_OMIT_WSD
3880 unsigned int newVal
= va_arg(ap
, unsigned int);
3881 if( newVal
) sqlite3PendingByte
= newVal
;
3888 ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
3890 ** This action provides a run-time test to see whether or not
3891 ** assert() was enabled at compile-time. If X is true and assert()
3892 ** is enabled, then the return value is true. If X is true and
3893 ** assert() is disabled, then the return value is zero. If X is
3894 ** false and assert() is enabled, then the assertion fires and the
3895 ** process aborts. If X is false and assert() is disabled, then the
3896 ** return value is zero.
3898 case SQLITE_TESTCTRL_ASSERT
: {
3900 assert( /*side-effects-ok*/ (x
= va_arg(ap
,int))!=0 );
3907 ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
3909 ** This action provides a run-time test to see how the ALWAYS and
3910 ** NEVER macros were defined at compile-time.
3912 ** The return value is ALWAYS(X) if X is true, or 0 if X is false.
3914 ** The recommended test is X==2. If the return value is 2, that means
3915 ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
3916 ** default setting. If the return value is 1, then ALWAYS() is either
3917 ** hard-coded to true or else it asserts if its argument is false.
3918 ** The first behavior (hard-coded to true) is the case if
3919 ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
3920 ** behavior (assert if the argument to ALWAYS() is false) is the case if
3921 ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
3923 ** The run-time test procedure might look something like this:
3925 ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
3926 ** // ALWAYS() and NEVER() are no-op pass-through macros
3927 ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
3928 ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
3930 ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0.
3933 case SQLITE_TESTCTRL_ALWAYS
: {
3934 int x
= va_arg(ap
,int);
3935 rc
= x
? ALWAYS(x
) : 0;
3940 ** sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER);
3942 ** The integer returned reveals the byte-order of the computer on which
3943 ** SQLite is running:
3945 ** 1 big-endian, determined at run-time
3946 ** 10 little-endian, determined at run-time
3947 ** 432101 big-endian, determined at compile-time
3948 ** 123410 little-endian, determined at compile-time
3950 case SQLITE_TESTCTRL_BYTEORDER
: {
3951 rc
= SQLITE_BYTEORDER
*100 + SQLITE_LITTLEENDIAN
*10 + SQLITE_BIGENDIAN
;
3955 /* sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N)
3957 ** Set the nReserve size to N for the main database on the database
3960 case SQLITE_TESTCTRL_RESERVE
: {
3961 sqlite3
*db
= va_arg(ap
, sqlite3
*);
3962 int x
= va_arg(ap
,int);
3963 sqlite3_mutex_enter(db
->mutex
);
3964 sqlite3BtreeSetPageSize(db
->aDb
[0].pBt
, 0, x
, 0);
3965 sqlite3_mutex_leave(db
->mutex
);
3969 /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
3971 ** Enable or disable various optimizations for testing purposes. The
3972 ** argument N is a bitmask of optimizations to be disabled. For normal
3973 ** operation N should be 0. The idea is that a test program (like the
3974 ** SQL Logic Test or SLT test module) can run the same SQL multiple times
3975 ** with various optimizations disabled to verify that the same answer
3976 ** is obtained in every case.
3978 case SQLITE_TESTCTRL_OPTIMIZATIONS
: {
3979 sqlite3
*db
= va_arg(ap
, sqlite3
*);
3980 db
->dbOptFlags
= (u16
)(va_arg(ap
, int) & 0xffff);
3984 /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
3986 ** If parameter onoff is non-zero, subsequent calls to localtime()
3987 ** and its variants fail. If onoff is zero, undo this setting.
3989 case SQLITE_TESTCTRL_LOCALTIME_FAULT
: {
3990 sqlite3GlobalConfig
.bLocaltimeFault
= va_arg(ap
, int);
3994 /* sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCS, int onoff);
3996 ** If parameter onoff is non-zero, internal-use-only SQL functions
3997 ** are visible to ordinary SQL. This is useful for testing but is
3998 ** unsafe because invalid parameters to those internal-use-only functions
3999 ** can result in crashes or segfaults.
4001 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS
: {
4002 sqlite3GlobalConfig
.bInternalFunctions
= va_arg(ap
, int);
4006 /* sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
4008 ** Set or clear a flag that indicates that the database file is always well-
4009 ** formed and never corrupt. This flag is clear by default, indicating that
4010 ** database files might have arbitrary corruption. Setting the flag during
4011 ** testing causes certain assert() statements in the code to be activated
4012 ** that demonstrat invariants on well-formed database files.
4014 case SQLITE_TESTCTRL_NEVER_CORRUPT
: {
4015 sqlite3GlobalConfig
.neverCorrupt
= va_arg(ap
, int);
4019 /* Set the threshold at which OP_Once counters reset back to zero.
4020 ** By default this is 0x7ffffffe (over 2 billion), but that value is
4021 ** too big to test in a reasonable amount of time, so this control is
4022 ** provided to set a small and easily reachable reset value.
4024 case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD
: {
4025 sqlite3GlobalConfig
.iOnceResetThreshold
= va_arg(ap
, int);
4029 /* sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
4031 ** Set the VDBE coverage callback function to xCallback with context
4034 case SQLITE_TESTCTRL_VDBE_COVERAGE
: {
4035 #ifdef SQLITE_VDBE_COVERAGE
4036 typedef void (*branch_callback
)(void*,unsigned int,
4037 unsigned char,unsigned char);
4038 sqlite3GlobalConfig
.xVdbeBranch
= va_arg(ap
,branch_callback
);
4039 sqlite3GlobalConfig
.pVdbeBranchArg
= va_arg(ap
,void*);
4044 /* sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
4045 case SQLITE_TESTCTRL_SORTER_MMAP
: {
4046 sqlite3
*db
= va_arg(ap
, sqlite3
*);
4047 db
->nMaxSorterMmap
= va_arg(ap
, int);
4051 /* sqlite3_test_control(SQLITE_TESTCTRL_ISINIT);
4053 ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
4056 case SQLITE_TESTCTRL_ISINIT
: {
4057 if( sqlite3GlobalConfig
.isInit
==0 ) rc
= SQLITE_ERROR
;
4061 /* sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
4063 ** This test control is used to create imposter tables. "db" is a pointer
4064 ** to the database connection. dbName is the database name (ex: "main" or
4065 ** "temp") which will receive the imposter. "onOff" turns imposter mode on
4066 ** or off. "tnum" is the root page of the b-tree to which the imposter
4067 ** table should connect.
4069 ** Enable imposter mode only when the schema has already been parsed. Then
4070 ** run a single CREATE TABLE statement to construct the imposter table in
4071 ** the parsed schema. Then turn imposter mode back off again.
4073 ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
4074 ** the schema to be reparsed the next time it is needed. This has the
4075 ** effect of erasing all imposter tables.
4077 case SQLITE_TESTCTRL_IMPOSTER
: {
4078 sqlite3
*db
= va_arg(ap
, sqlite3
*);
4079 sqlite3_mutex_enter(db
->mutex
);
4080 db
->init
.iDb
= sqlite3FindDbName(db
, va_arg(ap
,const char*));
4081 db
->init
.busy
= db
->init
.imposterTable
= va_arg(ap
,int);
4082 db
->init
.newTnum
= va_arg(ap
,int);
4083 if( db
->init
.busy
==0 && db
->init
.newTnum
>0 ){
4084 sqlite3ResetAllSchemasOfConnection(db
);
4086 sqlite3_mutex_leave(db
->mutex
);
4090 #if defined(YYCOVERAGE)
4091 /* sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out)
4093 ** This test control (only available when SQLite is compiled with
4094 ** -DYYCOVERAGE) writes a report onto "out" that shows all
4095 ** state/lookahead combinations in the parser state machine
4096 ** which are never exercised. If any state is missed, make the
4097 ** return code SQLITE_ERROR.
4099 case SQLITE_TESTCTRL_PARSER_COVERAGE
: {
4100 FILE *out
= va_arg(ap
, FILE*);
4101 if( sqlite3ParserCoverage(out
) ) rc
= SQLITE_ERROR
;
4104 #endif /* defined(YYCOVERAGE) */
4107 #endif /* SQLITE_UNTESTABLE */
4112 ** This is a utility routine, useful to VFS implementations, that checks
4113 ** to see if a database file was a URI that contained a specific query
4114 ** parameter, and if so obtains the value of the query parameter.
4116 ** The zFilename argument is the filename pointer passed into the xOpen()
4117 ** method of a VFS implementation. The zParam argument is the name of the
4118 ** query parameter we seek. This routine returns the value of the zParam
4119 ** parameter if it exists. If the parameter does not exist, this routine
4120 ** returns a NULL pointer.
4122 const char *sqlite3_uri_parameter(const char *zFilename
, const char *zParam
){
4123 if( zFilename
==0 || zParam
==0 ) return 0;
4124 zFilename
+= sqlite3Strlen30(zFilename
) + 1;
4125 while( zFilename
[0] ){
4126 int x
= strcmp(zFilename
, zParam
);
4127 zFilename
+= sqlite3Strlen30(zFilename
) + 1;
4128 if( x
==0 ) return zFilename
;
4129 zFilename
+= sqlite3Strlen30(zFilename
) + 1;
4135 ** Return a boolean value for a query parameter.
4137 int sqlite3_uri_boolean(const char *zFilename
, const char *zParam
, int bDflt
){
4138 const char *z
= sqlite3_uri_parameter(zFilename
, zParam
);
4140 return z
? sqlite3GetBoolean(z
, bDflt
) : bDflt
;
4144 ** Return a 64-bit integer value for a query parameter.
4146 sqlite3_int64
sqlite3_uri_int64(
4147 const char *zFilename
, /* Filename as passed to xOpen */
4148 const char *zParam
, /* URI parameter sought */
4149 sqlite3_int64 bDflt
/* return if parameter is missing */
4151 const char *z
= sqlite3_uri_parameter(zFilename
, zParam
);
4153 if( z
&& sqlite3DecOrHexToI64(z
, &v
)==0 ){
4160 ** Return the Btree pointer identified by zDbName. Return NULL if not found.
4162 Btree
*sqlite3DbNameToBtree(sqlite3
*db
, const char *zDbName
){
4163 int iDb
= zDbName
? sqlite3FindDbName(db
, zDbName
) : 0;
4164 return iDb
<0 ? 0 : db
->aDb
[iDb
].pBt
;
4168 ** Return the filename of the database associated with a database
4171 const char *sqlite3_db_filename(sqlite3
*db
, const char *zDbName
){
4173 #ifdef SQLITE_ENABLE_API_ARMOR
4174 if( !sqlite3SafetyCheckOk(db
) ){
4175 (void)SQLITE_MISUSE_BKPT
;
4179 pBt
= sqlite3DbNameToBtree(db
, zDbName
);
4180 return pBt
? sqlite3BtreeGetFilename(pBt
) : 0;
4184 ** Return 1 if database is read-only or 0 if read/write. Return -1 if
4185 ** no such database exists.
4187 int sqlite3_db_readonly(sqlite3
*db
, const char *zDbName
){
4189 #ifdef SQLITE_ENABLE_API_ARMOR
4190 if( !sqlite3SafetyCheckOk(db
) ){
4191 (void)SQLITE_MISUSE_BKPT
;
4195 pBt
= sqlite3DbNameToBtree(db
, zDbName
);
4196 return pBt
? sqlite3BtreeIsReadonly(pBt
) : -1;
4199 #ifdef SQLITE_ENABLE_SNAPSHOT
4201 ** Obtain a snapshot handle for the snapshot of database zDb currently
4202 ** being read by handle db.
4204 int sqlite3_snapshot_get(
4207 sqlite3_snapshot
**ppSnapshot
4209 int rc
= SQLITE_ERROR
;
4210 #ifndef SQLITE_OMIT_WAL
4212 #ifdef SQLITE_ENABLE_API_ARMOR
4213 if( !sqlite3SafetyCheckOk(db
) ){
4214 return SQLITE_MISUSE_BKPT
;
4217 sqlite3_mutex_enter(db
->mutex
);
4219 if( db
->autoCommit
==0 ){
4220 int iDb
= sqlite3FindDbName(db
, zDb
);
4221 if( iDb
==0 || iDb
>1 ){
4222 Btree
*pBt
= db
->aDb
[iDb
].pBt
;
4223 if( 0==sqlite3BtreeIsInTrans(pBt
) ){
4224 rc
= sqlite3BtreeBeginTrans(pBt
, 0, 0);
4225 if( rc
==SQLITE_OK
){
4226 rc
= sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt
), ppSnapshot
);
4232 sqlite3_mutex_leave(db
->mutex
);
4233 #endif /* SQLITE_OMIT_WAL */
4238 ** Open a read-transaction on the snapshot idendified by pSnapshot.
4240 int sqlite3_snapshot_open(
4243 sqlite3_snapshot
*pSnapshot
4245 int rc
= SQLITE_ERROR
;
4246 #ifndef SQLITE_OMIT_WAL
4248 #ifdef SQLITE_ENABLE_API_ARMOR
4249 if( !sqlite3SafetyCheckOk(db
) ){
4250 return SQLITE_MISUSE_BKPT
;
4253 sqlite3_mutex_enter(db
->mutex
);
4254 if( db
->autoCommit
==0 ){
4256 iDb
= sqlite3FindDbName(db
, zDb
);
4257 if( iDb
==0 || iDb
>1 ){
4258 Btree
*pBt
= db
->aDb
[iDb
].pBt
;
4259 if( sqlite3BtreeIsInTrans(pBt
)==0 ){
4260 Pager
*pPager
= sqlite3BtreePager(pBt
);
4262 if( sqlite3BtreeIsInReadTrans(pBt
) ){
4263 if( db
->nVdbeActive
==0 ){
4264 rc
= sqlite3PagerSnapshotCheck(pPager
, pSnapshot
);
4265 if( rc
==SQLITE_OK
){
4267 rc
= sqlite3BtreeCommit(pBt
);
4273 if( rc
==SQLITE_OK
){
4274 rc
= sqlite3PagerSnapshotOpen(pPager
, pSnapshot
);
4276 if( rc
==SQLITE_OK
){
4277 rc
= sqlite3BtreeBeginTrans(pBt
, 0, 0);
4278 sqlite3PagerSnapshotOpen(pPager
, 0);
4281 sqlite3PagerSnapshotUnlock(pPager
);
4287 sqlite3_mutex_leave(db
->mutex
);
4288 #endif /* SQLITE_OMIT_WAL */
4293 ** Recover as many snapshots as possible from the wal file associated with
4294 ** schema zDb of database db.
4296 int sqlite3_snapshot_recover(sqlite3
*db
, const char *zDb
){
4297 int rc
= SQLITE_ERROR
;
4299 #ifndef SQLITE_OMIT_WAL
4301 #ifdef SQLITE_ENABLE_API_ARMOR
4302 if( !sqlite3SafetyCheckOk(db
) ){
4303 return SQLITE_MISUSE_BKPT
;
4307 sqlite3_mutex_enter(db
->mutex
);
4308 iDb
= sqlite3FindDbName(db
, zDb
);
4309 if( iDb
==0 || iDb
>1 ){
4310 Btree
*pBt
= db
->aDb
[iDb
].pBt
;
4311 if( 0==sqlite3BtreeIsInReadTrans(pBt
) ){
4312 rc
= sqlite3BtreeBeginTrans(pBt
, 0, 0);
4313 if( rc
==SQLITE_OK
){
4314 rc
= sqlite3PagerSnapshotRecover(sqlite3BtreePager(pBt
));
4315 sqlite3BtreeCommit(pBt
);
4319 sqlite3_mutex_leave(db
->mutex
);
4320 #endif /* SQLITE_OMIT_WAL */
4325 ** Free a snapshot handle obtained from sqlite3_snapshot_get().
4327 void sqlite3_snapshot_free(sqlite3_snapshot
*pSnapshot
){
4328 sqlite3_free(pSnapshot
);
4330 #endif /* SQLITE_ENABLE_SNAPSHOT */
4332 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
4334 ** Given the name of a compile-time option, return true if that option
4335 ** was used and false if not.
4337 ** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix
4338 ** is not required for a match.
4340 int sqlite3_compileoption_used(const char *zOptName
){
4343 const char **azCompileOpt
;
4345 #if SQLITE_ENABLE_API_ARMOR
4347 (void)SQLITE_MISUSE_BKPT
;
4352 azCompileOpt
= sqlite3CompileOptions(&nOpt
);
4354 if( sqlite3StrNICmp(zOptName
, "SQLITE_", 7)==0 ) zOptName
+= 7;
4355 n
= sqlite3Strlen30(zOptName
);
4357 /* Since nOpt is normally in single digits, a linear search is
4358 ** adequate. No need for a binary search. */
4359 for(i
=0; i
<nOpt
; i
++){
4360 if( sqlite3StrNICmp(zOptName
, azCompileOpt
[i
], n
)==0
4361 && sqlite3IsIdChar((unsigned char)azCompileOpt
[i
][n
])==0
4370 ** Return the N-th compile-time option string. If N is out of range,
4371 ** return a NULL pointer.
4373 const char *sqlite3_compileoption_get(int N
){
4375 const char **azCompileOpt
;
4376 azCompileOpt
= sqlite3CompileOptions(&nOpt
);
4377 if( N
>=0 && N
<nOpt
){
4378 return azCompileOpt
[N
];
4382 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */