1/*
2** 2001 September 15
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12** Main file for the SQLite library. The routines in this file
13** implement the programmer interface to the library. Routines in
14** other files are for internal use by SQLite and should not be
15** accessed by users of the library.
16*/
17#include "sqliteInt.h"
18
19#ifdef SQLITE_ENABLE_FTS3
20# include "fts3.h"
21#endif
22#ifdef SQLITE_ENABLE_RTREE
23# include "rtree.h"
24#endif
25#if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS)
26# include "sqliteicu.h"
27#endif
28
29/*
30** This is an extension initializer that is a no-op and always
31** succeeds, except that it fails if the fault-simulation is set
32** to 500.
33*/
34static int sqlite3TestExtInit(sqlite3 *db){
35 (void)db;
36 return sqlite3FaultSim(500);
37}
38
39
40/*
41** Forward declarations of external module initializer functions
42** for modules that need them.
43*/
44#ifdef SQLITE_ENABLE_FTS1
45int sqlite3Fts1Init(sqlite3*);
46#endif
47#ifdef SQLITE_ENABLE_FTS2
48int sqlite3Fts2Init(sqlite3*);
49#endif
50#ifdef SQLITE_ENABLE_FTS5
51int sqlite3Fts5Init(sqlite3*);
52#endif
53#ifdef SQLITE_ENABLE_STMTVTAB
54int sqlite3StmtVtabInit(sqlite3*);
55#endif
56
57/*
58** An array of pointers to extension initializer functions for
59** built-in extensions.
60*/
61static int (*const sqlite3BuiltinExtensions[])(sqlite3*) = {
62#ifdef SQLITE_ENABLE_FTS1
63 sqlite3Fts1Init,
64#endif
65#ifdef SQLITE_ENABLE_FTS2
66 sqlite3Fts2Init,
67#endif
68#ifdef SQLITE_ENABLE_FTS3
69 sqlite3Fts3Init,
70#endif
71#ifdef SQLITE_ENABLE_FTS5
72 sqlite3Fts5Init,
73#endif
74#if defined(SQLITE_ENABLE_ICU) || defined(SQLITE_ENABLE_ICU_COLLATIONS)
75 sqlite3IcuInit,
76#endif
77#ifdef SQLITE_ENABLE_RTREE
78 sqlite3RtreeInit,
79#endif
80#ifdef SQLITE_ENABLE_DBPAGE_VTAB
81 sqlite3DbpageRegister,
82#endif
83#ifdef SQLITE_ENABLE_DBSTAT_VTAB
84 sqlite3DbstatRegister,
85#endif
86 sqlite3TestExtInit,
87#if !defined(SQLITE_OMIT_VIRTUALTABLE) && !defined(SQLITE_OMIT_JSON)
88 sqlite3JsonTableFunctions,
89#endif
90#ifdef SQLITE_ENABLE_STMTVTAB
91 sqlite3StmtVtabInit,
92#endif
93#ifdef SQLITE_ENABLE_BYTECODE_VTAB
94 sqlite3VdbeBytecodeVtabInit,
95#endif
96};
97
98#ifndef SQLITE_AMALGAMATION
99/* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant
100** contains the text of SQLITE_VERSION macro.
101*/
102const char sqlite3_version[] = SQLITE_VERSION;
103#endif
104
105/* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns
106** a pointer to the to the sqlite3_version[] string constant.
107*/
108const char *sqlite3_libversion(void){ return sqlite3_version; }
109
110/* IMPLEMENTATION-OF: R-25063-23286 The sqlite3_sourceid() function returns a
111** pointer to a string constant whose value is the same as the
112** SQLITE_SOURCE_ID C preprocessor macro. Except if SQLite is built using
113** an edited copy of the amalgamation, then the last four characters of
114** the hash might be different from SQLITE_SOURCE_ID.
115*/
116const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
117
118/* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function
119** returns an integer equal to SQLITE_VERSION_NUMBER.
120*/
121int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
122
123/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
124** zero if and only if SQLite was compiled with mutexing code omitted due to
125** the SQLITE_THREADSAFE compile-time option being set to 0.
126*/
127int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
128
129/*
130** When compiling the test fixture or with debugging enabled (on Win32),
131** this variable being set to non-zero will cause OSTRACE macros to emit
132** extra diagnostic information.
133*/
134#ifdef SQLITE_HAVE_OS_TRACE
135# ifndef SQLITE_DEBUG_OS_TRACE
136# define SQLITE_DEBUG_OS_TRACE 0
137# endif
138 int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;
139#endif
140
141#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
142/*
143** If the following function pointer is not NULL and if
144** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
145** I/O active are written using this function. These messages
146** are intended for debugging activity only.
147*/
148SQLITE_API void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...) = 0;
149#endif
150
151/*
152** If the following global variable points to a string which is the
153** name of a directory, then that directory will be used to store
154** temporary files.
155**
156** See also the "PRAGMA temp_store_directory" SQL command.
157*/
158char *sqlite3_temp_directory = 0;
159
160/*
161** If the following global variable points to a string which is the
162** name of a directory, then that directory will be used to store
163** all database files specified with a relative pathname.
164**
165** See also the "PRAGMA data_store_directory" SQL command.
166*/
167char *sqlite3_data_directory = 0;
168
169/*
170** Initialize SQLite.
171**
172** This routine must be called to initialize the memory allocation,
173** VFS, and mutex subsystems prior to doing any serious work with
174** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
175** this routine will be called automatically by key routines such as
176** sqlite3_open().
177**
178** This routine is a no-op except on its very first call for the process,
179** or for the first call after a call to sqlite3_shutdown.
180**
181** The first thread to call this routine runs the initialization to
182** completion. If subsequent threads call this routine before the first
183** thread has finished the initialization process, then the subsequent
184** threads must block until the first thread finishes with the initialization.
185**
186** The first thread might call this routine recursively. Recursive
187** calls to this routine should not block, of course. Otherwise the
188** initialization process would never complete.
189**
190** Let X be the first thread to enter this routine. Let Y be some other
191** thread. Then while the initial invocation of this routine by X is
192** incomplete, it is required that:
193**
194** * Calls to this routine from Y must block until the outer-most
195** call by X completes.
196**
197** * Recursive calls to this routine from thread X return immediately
198** without blocking.
199*/
200int sqlite3_initialize(void){
201 MUTEX_LOGIC( sqlite3_mutex *pMainMtx; ) /* The main static mutex */
202 int rc; /* Result code */
203#ifdef SQLITE_EXTRA_INIT
204 int bRunExtraInit = 0; /* Extra initialization needed */
205#endif
206
207#ifdef SQLITE_OMIT_WSD
208 rc = sqlite3_wsd_init(4096, 24);
209 if( rc!=SQLITE_OK ){
210 return rc;
211 }
212#endif
213
214 /* If the following assert() fails on some obscure processor/compiler
215 ** combination, the work-around is to set the correct pointer
216 ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
217 assert( SQLITE_PTRSIZE==sizeof(char*) );
218
219 /* If SQLite is already completely initialized, then this call
220 ** to sqlite3_initialize() should be a no-op. But the initialization
221 ** must be complete. So isInit must not be set until the very end
222 ** of this routine.
223 */
224 if( sqlite3GlobalConfig.isInit ){
225 sqlite3MemoryBarrier();
226 return SQLITE_OK;
227 }
228
229 /* Make sure the mutex subsystem is initialized. If unable to
230 ** initialize the mutex subsystem, return early with the error.
231 ** If the system is so sick that we are unable to allocate a mutex,
232 ** there is not much SQLite is going to be able to do.
233 **
234 ** The mutex subsystem must take care of serializing its own
235 ** initialization.
236 */
237 rc = sqlite3MutexInit();
238 if( rc ) return rc;
239
240 /* Initialize the malloc() system and the recursive pInitMutex mutex.
241 ** This operation is protected by the STATIC_MAIN mutex. Note that
242 ** MutexAlloc() is called for a static mutex prior to initializing the
243 ** malloc subsystem - this implies that the allocation of a static
244 ** mutex must not require support from the malloc subsystem.
245 */
246 MUTEX_LOGIC( pMainMtx = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MAIN); )
247 sqlite3_mutex_enter(pMainMtx);
248 sqlite3GlobalConfig.isMutexInit = 1;
249 if( !sqlite3GlobalConfig.isMallocInit ){
250 rc = sqlite3MallocInit();
251 }
252 if( rc==SQLITE_OK ){
253 sqlite3GlobalConfig.isMallocInit = 1;
254 if( !sqlite3GlobalConfig.pInitMutex ){
255 sqlite3GlobalConfig.pInitMutex =
256 sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
257 if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
258 rc = SQLITE_NOMEM_BKPT;
259 }
260 }
261 }
262 if( rc==SQLITE_OK ){
263 sqlite3GlobalConfig.nRefInitMutex++;
264 }
265 sqlite3_mutex_leave(pMainMtx);
266
267 /* If rc is not SQLITE_OK at this point, then either the malloc
268 ** subsystem could not be initialized or the system failed to allocate
269 ** the pInitMutex mutex. Return an error in either case. */
270 if( rc!=SQLITE_OK ){
271 return rc;
272 }
273
274 /* Do the rest of the initialization under the recursive mutex so
275 ** that we will be able to handle recursive calls into
276 ** sqlite3_initialize(). The recursive calls normally come through
277 ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
278 ** recursive calls might also be possible.
279 **
280 ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
281 ** to the xInit method, so the xInit method need not be threadsafe.
282 **
283 ** The following mutex is what serializes access to the appdef pcache xInit
284 ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the
285 ** call to sqlite3PcacheInitialize().
286 */
287 sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
288 if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
289 sqlite3GlobalConfig.inProgress = 1;
290#ifdef SQLITE_ENABLE_SQLLOG
291 {
292 extern void sqlite3_init_sqllog(void);
293 sqlite3_init_sqllog();
294 }
295#endif
296 memset(&sqlite3BuiltinFunctions, 0, sizeof(sqlite3BuiltinFunctions));
297 sqlite3RegisterBuiltinFunctions();
298 if( sqlite3GlobalConfig.isPCacheInit==0 ){
299 rc = sqlite3PcacheInitialize();
300 }
301 if( rc==SQLITE_OK ){
302 sqlite3GlobalConfig.isPCacheInit = 1;
303 rc = sqlite3OsInit();
304 }
305#ifndef SQLITE_OMIT_DESERIALIZE
306 if( rc==SQLITE_OK ){
307 rc = sqlite3MemdbInit();
308 }
309#endif
310 if( rc==SQLITE_OK ){
311 sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
312 sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
313 sqlite3MemoryBarrier();
314 sqlite3GlobalConfig.isInit = 1;
315#ifdef SQLITE_EXTRA_INIT
316 bRunExtraInit = 1;
317#endif
318 }
319 sqlite3GlobalConfig.inProgress = 0;
320 }
321 sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
322
323 /* Go back under the static mutex and clean up the recursive
324 ** mutex to prevent a resource leak.
325 */
326 sqlite3_mutex_enter(pMainMtx);
327 sqlite3GlobalConfig.nRefInitMutex--;
328 if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
329 assert( sqlite3GlobalConfig.nRefInitMutex==0 );
330 sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
331 sqlite3GlobalConfig.pInitMutex = 0;
332 }
333 sqlite3_mutex_leave(pMainMtx);
334
335 /* The following is just a sanity check to make sure SQLite has
336 ** been compiled correctly. It is important to run this code, but
337 ** we don't want to run it too often and soak up CPU cycles for no
338 ** reason. So we run it once during initialization.
339 */
340#ifndef NDEBUG
341#ifndef SQLITE_OMIT_FLOATING_POINT
342 /* This section of code's only "output" is via assert() statements. */
343 if( rc==SQLITE_OK ){
344 u64 x = (((u64)1)<<63)-1;
345 double y;
346 assert(sizeof(x)==8);
347 assert(sizeof(x)==sizeof(y));
348 memcpy(&y, &x, 8);
349 assert( sqlite3IsNaN(y) );
350 }
351#endif
352#endif
353
354 /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
355 ** compile-time option.
356 */
357#ifdef SQLITE_EXTRA_INIT
358 if( bRunExtraInit ){
359 int SQLITE_EXTRA_INIT(const char*);
360 rc = SQLITE_EXTRA_INIT(0);
361 }
362#endif
363
364 return rc;
365}
366
367/*
368** Undo the effects of sqlite3_initialize(). Must not be called while
369** there are outstanding database connections or memory allocations or
370** while any part of SQLite is otherwise in use in any thread. This
371** routine is not threadsafe. But it is safe to invoke this routine
372** on when SQLite is already shut down. If SQLite is already shut down
373** when this routine is invoked, then this routine is a harmless no-op.
374*/
375int sqlite3_shutdown(void){
376#ifdef SQLITE_OMIT_WSD
377 int rc = sqlite3_wsd_init(4096, 24);
378 if( rc!=SQLITE_OK ){
379 return rc;
380 }
381#endif
382
383 if( sqlite3GlobalConfig.isInit ){
384#ifdef SQLITE_EXTRA_SHUTDOWN
385 void SQLITE_EXTRA_SHUTDOWN(void);
386 SQLITE_EXTRA_SHUTDOWN();
387#endif
388 sqlite3_os_end();
389 sqlite3_reset_auto_extension();
390 sqlite3GlobalConfig.isInit = 0;
391 }
392 if( sqlite3GlobalConfig.isPCacheInit ){
393 sqlite3PcacheShutdown();
394 sqlite3GlobalConfig.isPCacheInit = 0;
395 }
396 if( sqlite3GlobalConfig.isMallocInit ){
397 sqlite3MallocEnd();
398 sqlite3GlobalConfig.isMallocInit = 0;
399
400#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
401 /* The heap subsystem has now been shutdown and these values are supposed
402 ** to be NULL or point to memory that was obtained from sqlite3_malloc(),
403 ** which would rely on that heap subsystem; therefore, make sure these
404 ** values cannot refer to heap memory that was just invalidated when the
405 ** heap subsystem was shutdown. This is only done if the current call to
406 ** this function resulted in the heap subsystem actually being shutdown.
407 */
408 sqlite3_data_directory = 0;
409 sqlite3_temp_directory = 0;
410#endif
411 }
412 if( sqlite3GlobalConfig.isMutexInit ){
413 sqlite3MutexEnd();
414 sqlite3GlobalConfig.isMutexInit = 0;
415 }
416
417 return SQLITE_OK;
418}
419
420/*
421** This API allows applications to modify the global configuration of
422** the SQLite library at run-time.
423**
424** This routine should only be called when there are no outstanding
425** database connections or memory allocations. This routine is not
426** threadsafe. Failure to heed these warnings can lead to unpredictable
427** behavior.
428*/
429int sqlite3_config(int op, ...){
430 va_list ap;
431 int rc = SQLITE_OK;
432
433 /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
434 ** the SQLite library is in use. */
435 if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;
436
437 va_start(ap, op);
438 switch( op ){
439
440 /* Mutex configuration options are only available in a threadsafe
441 ** compile.
442 */
443#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */
444 case SQLITE_CONFIG_SINGLETHREAD: {
445 /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
446 ** Single-thread. */
447 sqlite3GlobalConfig.bCoreMutex = 0; /* Disable mutex on core */
448 sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */
449 break;
450 }
451#endif
452#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
453 case SQLITE_CONFIG_MULTITHREAD: {
454 /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
455 ** Multi-thread. */
456 sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */
457 sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */
458 break;
459 }
460#endif
461#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
462 case SQLITE_CONFIG_SERIALIZED: {
463 /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
464 ** Serialized. */
465 sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */
466 sqlite3GlobalConfig.bFullMutex = 1; /* Enable mutex on connections */
467 break;
468 }
469#endif
470#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
471 case SQLITE_CONFIG_MUTEX: {
472 /* Specify an alternative mutex implementation */
473 sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
474 break;
475 }
476#endif
477#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
478 case SQLITE_CONFIG_GETMUTEX: {
479 /* Retrieve the current mutex implementation */
480 *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
481 break;
482 }
483#endif
484
485 case SQLITE_CONFIG_MALLOC: {
486 /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
487 ** single argument which is a pointer to an instance of the
488 ** sqlite3_mem_methods structure. The argument specifies alternative
489 ** low-level memory allocation routines to be used in place of the memory
490 ** allocation routines built into SQLite. */
491 sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
492 break;
493 }
494 case SQLITE_CONFIG_GETMALLOC: {
495 /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
496 ** single argument which is a pointer to an instance of the
497 ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
498 ** filled with the currently defined memory allocation routines. */
499 if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
500 *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
501 break;
502 }
503 case SQLITE_CONFIG_MEMSTATUS: {
504 /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
505 ** single argument of type int, interpreted as a boolean, which enables
506 ** or disables the collection of memory allocation statistics. */
507 sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
508 break;
509 }
510 case SQLITE_CONFIG_SMALL_MALLOC: {
511 sqlite3GlobalConfig.bSmallMalloc = va_arg(ap, int);
512 break;
513 }
514 case SQLITE_CONFIG_PAGECACHE: {
515 /* EVIDENCE-OF: R-18761-36601 There are three arguments to
516 ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem),
517 ** the size of each page cache line (sz), and the number of cache lines
518 ** (N). */
519 sqlite3GlobalConfig.pPage = va_arg(ap, void*);
520 sqlite3GlobalConfig.szPage = va_arg(ap, int);
521 sqlite3GlobalConfig.nPage = va_arg(ap, int);
522 break;
523 }
524 case SQLITE_CONFIG_PCACHE_HDRSZ: {
525 /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes
526 ** a single parameter which is a pointer to an integer and writes into
527 ** that integer the number of extra bytes per page required for each page
528 ** in SQLITE_CONFIG_PAGECACHE. */
529 *va_arg(ap, int*) =
530 sqlite3HeaderSizeBtree() +
531 sqlite3HeaderSizePcache() +
532 sqlite3HeaderSizePcache1();
533 break;
534 }
535
536 case SQLITE_CONFIG_PCACHE: {
537 /* no-op */
538 break;
539 }
540 case SQLITE_CONFIG_GETPCACHE: {
541 /* now an error */
542 rc = SQLITE_ERROR;
543 break;
544 }
545
546 case SQLITE_CONFIG_PCACHE2: {
547 /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a
548 ** single argument which is a pointer to an sqlite3_pcache_methods2
549 ** object. This object specifies the interface to a custom page cache
550 ** implementation. */
551 sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
552 break;
553 }
554 case SQLITE_CONFIG_GETPCACHE2: {
555 /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a
556 ** single argument which is a pointer to an sqlite3_pcache_methods2
557 ** object. SQLite copies of the current page cache implementation into
558 ** that object. */
559 if( sqlite3GlobalConfig.pcache2.xInit==0 ){
560 sqlite3PCacheSetDefault();
561 }
562 *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
563 break;
564 }
565
566/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
567** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
568** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */
569#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
570 case SQLITE_CONFIG_HEAP: {
571 /* EVIDENCE-OF: R-19854-42126 There are three arguments to
572 ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
573 ** number of bytes in the memory buffer, and the minimum allocation size.
574 */
575 sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
576 sqlite3GlobalConfig.nHeap = va_arg(ap, int);
577 sqlite3GlobalConfig.mnReq = va_arg(ap, int);
578
579 if( sqlite3GlobalConfig.mnReq<1 ){
580 sqlite3GlobalConfig.mnReq = 1;
581 }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
582 /* cap min request size at 2^12 */
583 sqlite3GlobalConfig.mnReq = (1<<12);
584 }
585
586 if( sqlite3GlobalConfig.pHeap==0 ){
587 /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
588 ** is NULL, then SQLite reverts to using its default memory allocator
589 ** (the system malloc() implementation), undoing any prior invocation of
590 ** SQLITE_CONFIG_MALLOC.
591 **
592 ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
593 ** revert to its default implementation when sqlite3_initialize() is run
594 */
595 memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
596 }else{
597 /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
598 ** alternative memory allocator is engaged to handle all of SQLites
599 ** memory allocation needs. */
600#ifdef SQLITE_ENABLE_MEMSYS3
601 sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
602#endif
603#ifdef SQLITE_ENABLE_MEMSYS5
604 sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
605#endif
606 }
607 break;
608 }
609#endif
610
611 case SQLITE_CONFIG_LOOKASIDE: {
612 sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
613 sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
614 break;
615 }
616
617 /* Record a pointer to the logger function and its first argument.
618 ** The default is NULL. Logging is disabled if the function pointer is
619 ** NULL.
620 */
621 case SQLITE_CONFIG_LOG: {
622 /* MSVC is picky about pulling func ptrs from va lists.
623 ** http://support.microsoft.com/kb/47961
624 ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
625 */
626 typedef void(*LOGFUNC_t)(void*,int,const char*);
627 sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
628 sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
629 break;
630 }
631
632 /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
633 ** can be changed at start-time using the
634 ** sqlite3_config(SQLITE_CONFIG_URI,1) or
635 ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.
636 */
637 case SQLITE_CONFIG_URI: {
638 /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
639 ** argument of type int. If non-zero, then URI handling is globally
640 ** enabled. If the parameter is zero, then URI handling is globally
641 ** disabled. */
642 sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
643 break;
644 }
645
646 case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
647 /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN
648 ** option takes a single integer argument which is interpreted as a
649 ** boolean in order to enable or disable the use of covering indices for
650 ** full table scans in the query optimizer. */
651 sqlite3GlobalConfig.bUseCis = va_arg(ap, int);
652 break;
653 }
654
655#ifdef SQLITE_ENABLE_SQLLOG
656 case SQLITE_CONFIG_SQLLOG: {
657 typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int);
658 sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);
659 sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);
660 break;
661 }
662#endif
663
664 case SQLITE_CONFIG_MMAP_SIZE: {
665 /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit
666 ** integer (sqlite3_int64) values that are the default mmap size limit
667 ** (the default setting for PRAGMA mmap_size) and the maximum allowed
668 ** mmap size limit. */
669 sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
670 sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
671 /* EVIDENCE-OF: R-53367-43190 If either argument to this option is
672 ** negative, then that argument is changed to its compile-time default.
673 **
674 ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
675 ** silently truncated if necessary so that it does not exceed the
676 ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
677 ** compile-time option.
678 */
679 if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
680 mxMmap = SQLITE_MAX_MMAP_SIZE;
681 }
682 if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
683 if( szMmap>mxMmap) szMmap = mxMmap;
684 sqlite3GlobalConfig.mxMmap = mxMmap;
685 sqlite3GlobalConfig.szMmap = szMmap;
686 break;
687 }
688
689#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */
690 case SQLITE_CONFIG_WIN32_HEAPSIZE: {
691 /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit
692 ** unsigned integer value that specifies the maximum size of the created
693 ** heap. */
694 sqlite3GlobalConfig.nHeap = va_arg(ap, int);
695 break;
696 }
697#endif
698
699 case SQLITE_CONFIG_PMASZ: {
700 sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int);
701 break;
702 }
703
704 case SQLITE_CONFIG_STMTJRNL_SPILL: {
705 sqlite3GlobalConfig.nStmtSpill = va_arg(ap, int);
706 break;
707 }
708
709#ifdef SQLITE_ENABLE_SORTER_REFERENCES
710 case SQLITE_CONFIG_SORTERREF_SIZE: {
711 int iVal = va_arg(ap, int);
712 if( iVal<0 ){
713 iVal = SQLITE_DEFAULT_SORTERREF_SIZE;
714 }
715 sqlite3GlobalConfig.szSorterRef = (u32)iVal;
716 break;
717 }
718#endif /* SQLITE_ENABLE_SORTER_REFERENCES */
719
720#ifndef SQLITE_OMIT_DESERIALIZE
721 case SQLITE_CONFIG_MEMDB_MAXSIZE: {
722 sqlite3GlobalConfig.mxMemdbSize = va_arg(ap, sqlite3_int64);
723 break;
724 }
725#endif /* SQLITE_OMIT_DESERIALIZE */
726
727 default: {
728 rc = SQLITE_ERROR;
729 break;
730 }
731 }
732 va_end(ap);
733 return rc;
734}
735
736/*
737** Set up the lookaside buffers for a database connection.
738** Return SQLITE_OK on success.
739** If lookaside is already active, return SQLITE_BUSY.
740**
741** The sz parameter is the number of bytes in each lookaside slot.
742** The cnt parameter is the number of slots. If pStart is NULL the
743** space for the lookaside memory is obtained from sqlite3_malloc().
744** If pStart is not NULL then it is sz*cnt bytes of memory to use for
745** the lookaside memory.
746*/
747static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
748#ifndef SQLITE_OMIT_LOOKASIDE
749 void *pStart;
750 sqlite3_int64 szAlloc = sz*(sqlite3_int64)cnt;
751 int nBig; /* Number of full-size slots */
752 int nSm; /* Number smaller LOOKASIDE_SMALL-byte slots */
753
754 if( sqlite3LookasideUsed(db,0)>0 ){
755 return SQLITE_BUSY;
756 }
757 /* Free any existing lookaside buffer for this handle before
758 ** allocating a new one so we don't have to have space for
759 ** both at the same time.
760 */
761 if( db->lookaside.bMalloced ){
762 sqlite3_free(db->lookaside.pStart);
763 }
764 /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger
765 ** than a pointer to be useful.
766 */
767 sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */
768 if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
769 if( cnt<0 ) cnt = 0;
770 if( sz==0 || cnt==0 ){
771 sz = 0;
772 pStart = 0;
773 }else if( pBuf==0 ){
774 sqlite3BeginBenignMalloc();
775 pStart = sqlite3Malloc( szAlloc ); /* IMP: R-61949-35727 */
776 sqlite3EndBenignMalloc();
777 if( pStart ) szAlloc = sqlite3MallocSize(pStart);
778 }else{
779 pStart = pBuf;
780 }
781#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
782 if( sz>=LOOKASIDE_SMALL*3 ){
783 nBig = szAlloc/(3*LOOKASIDE_SMALL+sz);
784 nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL;
785 }else if( sz>=LOOKASIDE_SMALL*2 ){
786 nBig = szAlloc/(LOOKASIDE_SMALL+sz);
787 nSm = (szAlloc - sz*nBig)/LOOKASIDE_SMALL;
788 }else
789#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
790 if( sz>0 ){
791 nBig = szAlloc/sz;
792 nSm = 0;
793 }else{
794 nBig = nSm = 0;
795 }
796 db->lookaside.pStart = pStart;
797 db->lookaside.pInit = 0;
798 db->lookaside.pFree = 0;
799 db->lookaside.sz = (u16)sz;
800 db->lookaside.szTrue = (u16)sz;
801 if( pStart ){
802 int i;
803 LookasideSlot *p;
804 assert( sz > (int)sizeof(LookasideSlot*) );
805 p = (LookasideSlot*)pStart;
806 for(i=0; i<nBig; i++){
807 p->pNext = db->lookaside.pInit;
808 db->lookaside.pInit = p;
809 p = (LookasideSlot*)&((u8*)p)[sz];
810 }
811#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
812 db->lookaside.pSmallInit = 0;
813 db->lookaside.pSmallFree = 0;
814 db->lookaside.pMiddle = p;
815 for(i=0; i<nSm; i++){
816 p->pNext = db->lookaside.pSmallInit;
817 db->lookaside.pSmallInit = p;
818 p = (LookasideSlot*)&((u8*)p)[LOOKASIDE_SMALL];
819 }
820#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
821 assert( ((uptr)p)<=szAlloc + (uptr)pStart );
822 db->lookaside.pEnd = p;
823 db->lookaside.bDisable = 0;
824 db->lookaside.bMalloced = pBuf==0 ?1:0;
825 db->lookaside.nSlot = nBig+nSm;
826 }else{
827 db->lookaside.pStart = 0;
828#ifndef SQLITE_OMIT_TWOSIZE_LOOKASIDE
829 db->lookaside.pSmallInit = 0;
830 db->lookaside.pSmallFree = 0;
831 db->lookaside.pMiddle = 0;
832#endif /* SQLITE_OMIT_TWOSIZE_LOOKASIDE */
833 db->lookaside.pEnd = 0;
834 db->lookaside.bDisable = 1;
835 db->lookaside.sz = 0;
836 db->lookaside.bMalloced = 0;
837 db->lookaside.nSlot = 0;
838 }
839 db->lookaside.pTrueEnd = db->lookaside.pEnd;
840 assert( sqlite3LookasideUsed(db,0)==0 );
841#endif /* SQLITE_OMIT_LOOKASIDE */
842 return SQLITE_OK;
843}
844
845/*
846** Return the mutex associated with a database connection.
847*/
848sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){
849#ifdef SQLITE_ENABLE_API_ARMOR
850 if( !sqlite3SafetyCheckOk(db) ){
851 (void)SQLITE_MISUSE_BKPT;
852 return 0;
853 }
854#endif
855 return db->mutex;
856}
857
858/*
859** Free up as much memory as we can from the given database
860** connection.
861*/
862int sqlite3_db_release_memory(sqlite3 *db){
863 int i;
864
865#ifdef SQLITE_ENABLE_API_ARMOR
866 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
867#endif
868 sqlite3_mutex_enter(db->mutex);
869 sqlite3BtreeEnterAll(db);
870 for(i=0; i<db->nDb; i++){
871 Btree *pBt = db->aDb[i].pBt;
872 if( pBt ){
873 Pager *pPager = sqlite3BtreePager(pBt);
874 sqlite3PagerShrink(pPager);
875 }
876 }
877 sqlite3BtreeLeaveAll(db);
878 sqlite3_mutex_leave(db->mutex);
879 return SQLITE_OK;
880}
881
882/*
883** Flush any dirty pages in the pager-cache for any attached database
884** to disk.
885*/
886int sqlite3_db_cacheflush(sqlite3 *db){
887 int i;
888 int rc = SQLITE_OK;
889 int bSeenBusy = 0;
890
891#ifdef SQLITE_ENABLE_API_ARMOR
892 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
893#endif
894 sqlite3_mutex_enter(db->mutex);
895 sqlite3BtreeEnterAll(db);
896 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
897 Btree *pBt = db->aDb[i].pBt;
898 if( pBt && sqlite3BtreeTxnState(pBt)==SQLITE_TXN_WRITE ){
899 Pager *pPager = sqlite3BtreePager(pBt);
900 rc = sqlite3PagerFlush(pPager);
901 if( rc==SQLITE_BUSY ){
902 bSeenBusy = 1;
903 rc = SQLITE_OK;
904 }
905 }
906 }
907 sqlite3BtreeLeaveAll(db);
908 sqlite3_mutex_leave(db->mutex);
909 return ((rc==SQLITE_OK && bSeenBusy) ? SQLITE_BUSY : rc);
910}
911
912/*
913** Configuration settings for an individual database connection
914*/
915int sqlite3_db_config(sqlite3 *db, int op, ...){
916 va_list ap;
917 int rc;
918 sqlite3_mutex_enter(db->mutex);
919 va_start(ap, op);
920 switch( op ){
921 case SQLITE_DBCONFIG_MAINDBNAME: {
922 /* IMP: R-06824-28531 */
923 /* IMP: R-36257-52125 */
924 db->aDb[0].zDbSName = va_arg(ap,char*);
925 rc = SQLITE_OK;
926 break;
927 }
928 case SQLITE_DBCONFIG_LOOKASIDE: {
929 void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
930 int sz = va_arg(ap, int); /* IMP: R-47871-25994 */
931 int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */
932 rc = setupLookaside(db, pBuf, sz, cnt);
933 break;
934 }
935 default: {
936 static const struct {
937 int op; /* The opcode */
938 u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
939 } aFlagOp[] = {
940 { SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys },
941 { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger },
942 { SQLITE_DBCONFIG_ENABLE_VIEW, SQLITE_EnableView },
943 { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer },
944 { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension },
945 { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_NoCkptOnClose },
946 { SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_EnableQPSG },
947 { SQLITE_DBCONFIG_TRIGGER_EQP, SQLITE_TriggerEQP },
948 { SQLITE_DBCONFIG_RESET_DATABASE, SQLITE_ResetDatabase },
949 { SQLITE_DBCONFIG_DEFENSIVE, SQLITE_Defensive },
950 { SQLITE_DBCONFIG_WRITABLE_SCHEMA, SQLITE_WriteSchema|
951 SQLITE_NoSchemaError },
952 { SQLITE_DBCONFIG_LEGACY_ALTER_TABLE, SQLITE_LegacyAlter },
953 { SQLITE_DBCONFIG_DQS_DDL, SQLITE_DqsDDL },
954 { SQLITE_DBCONFIG_DQS_DML, SQLITE_DqsDML },
955 { SQLITE_DBCONFIG_LEGACY_FILE_FORMAT, SQLITE_LegacyFileFmt },
956 { SQLITE_DBCONFIG_TRUSTED_SCHEMA, SQLITE_TrustedSchema },
957 };
958 unsigned int i;
959 rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
960 for(i=0; i<ArraySize(aFlagOp); i++){
961 if( aFlagOp[i].op==op ){
962 int onoff = va_arg(ap, int);
963 int *pRes = va_arg(ap, int*);
964 u64 oldFlags = db->flags;
965 if( onoff>0 ){
966 db->flags |= aFlagOp[i].mask;
967 }else if( onoff==0 ){
968 db->flags &= ~(u64)aFlagOp[i].mask;
969 }
970 if( oldFlags!=db->flags ){
971 sqlite3ExpirePreparedStatements(db, 0);
972 }
973 if( pRes ){
974 *pRes = (db->flags & aFlagOp[i].mask)!=0;
975 }
976 rc = SQLITE_OK;
977 break;
978 }
979 }
980 break;
981 }
982 }
983 va_end(ap);
984 sqlite3_mutex_leave(db->mutex);
985 return rc;
986}
987
988/*
989** This is the default collating function named "BINARY" which is always
990** available.
991*/
992static int binCollFunc(
993 void *NotUsed,
994 int nKey1, const void *pKey1,
995 int nKey2, const void *pKey2
996){
997 int rc, n;
998 UNUSED_PARAMETER(NotUsed);
999 n = nKey1<nKey2 ? nKey1 : nKey2;
1000 /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
1001 ** strings byte by byte using the memcmp() function from the standard C
1002 ** library. */
1003 assert( pKey1 && pKey2 );
1004 rc = memcmp(pKey1, pKey2, n);
1005 if( rc==0 ){
1006 rc = nKey1 - nKey2;
1007 }
1008 return rc;
1009}
1010
1011/*
1012** This is the collating function named "RTRIM" which is always
1013** available. Ignore trailing spaces.
1014*/
1015static int rtrimCollFunc(
1016 void *pUser,
1017 int nKey1, const void *pKey1,
1018 int nKey2, const void *pKey2
1019){
1020 const u8 *pK1 = (const u8*)pKey1;
1021 const u8 *pK2 = (const u8*)pKey2;
1022 while( nKey1 && pK1[nKey1-1]==' ' ) nKey1--;
1023 while( nKey2 && pK2[nKey2-1]==' ' ) nKey2--;
1024 return binCollFunc(pUser, nKey1, pKey1, nKey2, pKey2);
1025}
1026
1027/*
1028** Return true if CollSeq is the default built-in BINARY.
1029*/
1030int sqlite3IsBinary(const CollSeq *p){
1031 assert( p==0 || p->xCmp!=binCollFunc || strcmp(p->zName,"BINARY")==0 );
1032 return p==0 || p->xCmp==binCollFunc;
1033}
1034
1035/*
1036** Another built-in collating sequence: NOCASE.
1037**
1038** This collating sequence is intended to be used for "case independent
1039** comparison". SQLite's knowledge of upper and lower case equivalents
1040** extends only to the 26 characters used in the English language.
1041**
1042** At the moment there is only a UTF-8 implementation.
1043*/
1044static int nocaseCollatingFunc(
1045 void *NotUsed,
1046 int nKey1, const void *pKey1,
1047 int nKey2, const void *pKey2
1048){
1049 int r = sqlite3StrNICmp(
1050 (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
1051 UNUSED_PARAMETER(NotUsed);
1052 if( 0==r ){
1053 r = nKey1-nKey2;
1054 }
1055 return r;
1056}
1057
1058/*
1059** Return the ROWID of the most recent insert
1060*/
1061sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
1062#ifdef SQLITE_ENABLE_API_ARMOR
1063 if( !sqlite3SafetyCheckOk(db) ){
1064 (void)SQLITE_MISUSE_BKPT;
1065 return 0;
1066 }
1067#endif
1068 return db->lastRowid;
1069}
1070
1071/*
1072** Set the value returned by the sqlite3_last_insert_rowid() API function.
1073*/
1074void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){
1075#ifdef SQLITE_ENABLE_API_ARMOR
1076 if( !sqlite3SafetyCheckOk(db) ){
1077 (void)SQLITE_MISUSE_BKPT;
1078 return;
1079 }
1080#endif
1081 sqlite3_mutex_enter(db->mutex);
1082 db->lastRowid = iRowid;
1083 sqlite3_mutex_leave(db->mutex);
1084}
1085
1086/*
1087** Return the number of changes in the most recent call to sqlite3_exec().
1088*/
1089sqlite3_int64 sqlite3_changes64(sqlite3 *db){
1090#ifdef SQLITE_ENABLE_API_ARMOR
1091 if( !sqlite3SafetyCheckOk(db) ){
1092 (void)SQLITE_MISUSE_BKPT;
1093 return 0;
1094 }
1095#endif
1096 return db->nChange;
1097}
1098int sqlite3_changes(sqlite3 *db){
1099 return (int)sqlite3_changes64(db);
1100}
1101
1102/*
1103** Return the number of changes since the database handle was opened.
1104*/
1105sqlite3_int64 sqlite3_total_changes64(sqlite3 *db){
1106#ifdef SQLITE_ENABLE_API_ARMOR
1107 if( !sqlite3SafetyCheckOk(db) ){
1108 (void)SQLITE_MISUSE_BKPT;
1109 return 0;
1110 }
1111#endif
1112 return db->nTotalChange;
1113}
1114int sqlite3_total_changes(sqlite3 *db){
1115 return (int)sqlite3_total_changes64(db);
1116}
1117
1118/*
1119** Close all open savepoints. This function only manipulates fields of the
1120** database handle object, it does not close any savepoints that may be open
1121** at the b-tree/pager level.
1122*/
1123void sqlite3CloseSavepoints(sqlite3 *db){
1124 while( db->pSavepoint ){
1125 Savepoint *pTmp = db->pSavepoint;
1126 db->pSavepoint = pTmp->pNext;
1127 sqlite3DbFree(db, pTmp);
1128 }
1129 db->nSavepoint = 0;
1130 db->nStatement = 0;
1131 db->isTransactionSavepoint = 0;
1132}
1133
1134/*
1135** Invoke the destructor function associated with FuncDef p, if any. Except,
1136** if this is not the last copy of the function, do not invoke it. Multiple
1137** copies of a single function are created when create_function() is called
1138** with SQLITE_ANY as the encoding.
1139*/
1140static void functionDestroy(sqlite3 *db, FuncDef *p){
1141 FuncDestructor *pDestructor;
1142 assert( (p->funcFlags & SQLITE_FUNC_BUILTIN)==0 );
1143 pDestructor = p->u.pDestructor;
1144 if( pDestructor ){
1145 pDestructor->nRef--;
1146 if( pDestructor->nRef==0 ){
1147 pDestructor->xDestroy(pDestructor->pUserData);
1148 sqlite3DbFree(db, pDestructor);
1149 }
1150 }
1151}
1152
1153/*
1154** Disconnect all sqlite3_vtab objects that belong to database connection
1155** db. This is called when db is being closed.
1156*/
1157static void disconnectAllVtab(sqlite3 *db){
1158#ifndef SQLITE_OMIT_VIRTUALTABLE
1159 int i;
1160 HashElem *p;
1161 sqlite3BtreeEnterAll(db);
1162 for(i=0; i<db->nDb; i++){
1163 Schema *pSchema = db->aDb[i].pSchema;
1164 if( pSchema ){
1165 for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
1166 Table *pTab = (Table *)sqliteHashData(p);
1167 if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
1168 }
1169 }
1170 }
1171 for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){
1172 Module *pMod = (Module *)sqliteHashData(p);
1173 if( pMod->pEpoTab ){
1174 sqlite3VtabDisconnect(db, pMod->pEpoTab);
1175 }
1176 }
1177 sqlite3VtabUnlockList(db);
1178 sqlite3BtreeLeaveAll(db);
1179#else
1180 UNUSED_PARAMETER(db);
1181#endif
1182}
1183
1184/*
1185** Return TRUE if database connection db has unfinalized prepared
1186** statements or unfinished sqlite3_backup objects.
1187*/
1188static int connectionIsBusy(sqlite3 *db){
1189 int j;
1190 assert( sqlite3_mutex_held(db->mutex) );
1191 if( db->pVdbe ) return 1;
1192 for(j=0; j<db->nDb; j++){
1193 Btree *pBt = db->aDb[j].pBt;
1194 if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1;
1195 }
1196 return 0;
1197}
1198
1199/*
1200** Close an existing SQLite database
1201*/
1202static int sqlite3Close(sqlite3 *db, int forceZombie){
1203 if( !db ){
1204 /* EVIDENCE-OF: R-63257-11740 Calling sqlite3_close() or
1205 ** sqlite3_close_v2() with a NULL pointer argument is a harmless no-op. */
1206 return SQLITE_OK;
1207 }
1208 if( !sqlite3SafetyCheckSickOrOk(db) ){
1209 return SQLITE_MISUSE_BKPT;
1210 }
1211 sqlite3_mutex_enter(db->mutex);
1212 if( db->mTrace & SQLITE_TRACE_CLOSE ){
1213 db->trace.xV2(SQLITE_TRACE_CLOSE, db->pTraceArg, db, 0);
1214 }
1215
1216 /* Force xDisconnect calls on all virtual tables */
1217 disconnectAllVtab(db);
1218
1219 /* If a transaction is open, the disconnectAllVtab() call above
1220 ** will not have called the xDisconnect() method on any virtual
1221 ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
1222 ** call will do so. We need to do this before the check for active
1223 ** SQL statements below, as the v-table implementation may be storing
1224 ** some prepared statements internally.
1225 */
1226 sqlite3VtabRollback(db);
1227
1228 /* Legacy behavior (sqlite3_close() behavior) is to return
1229 ** SQLITE_BUSY if the connection can not be closed immediately.
1230 */
1231 if( !forceZombie && connectionIsBusy(db) ){
1232 sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized "
1233 "statements or unfinished backups");
1234 sqlite3_mutex_leave(db->mutex);
1235 return SQLITE_BUSY;
1236 }
1237
1238#ifdef SQLITE_ENABLE_SQLLOG
1239 if( sqlite3GlobalConfig.xSqllog ){
1240 /* Closing the handle. Fourth parameter is passed the value 2. */
1241 sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2);
1242 }
1243#endif
1244
1245 /* Convert the connection into a zombie and then close it.
1246 */
1247 db->eOpenState = SQLITE_STATE_ZOMBIE;
1248 sqlite3LeaveMutexAndCloseZombie(db);
1249 return SQLITE_OK;
1250}
1251
1252/*
1253** Return the transaction state for a single databse, or the maximum
1254** transaction state over all attached databases if zSchema is null.
1255*/
1256int sqlite3_txn_state(sqlite3 *db, const char *zSchema){
1257 int iDb, nDb;
1258 int iTxn = -1;
1259#ifdef SQLITE_ENABLE_API_ARMOR
1260 if( !sqlite3SafetyCheckOk(db) ){
1261 (void)SQLITE_MISUSE_BKPT;
1262 return -1;
1263 }
1264#endif
1265 sqlite3_mutex_enter(db->mutex);
1266 if( zSchema ){
1267 nDb = iDb = sqlite3FindDbName(db, zSchema);
1268 if( iDb<0 ) nDb--;
1269 }else{
1270 iDb = 0;
1271 nDb = db->nDb-1;
1272 }
1273 for(; iDb<=nDb; iDb++){
1274 Btree *pBt = db->aDb[iDb].pBt;
1275 int x = pBt!=0 ? sqlite3BtreeTxnState(pBt) : SQLITE_TXN_NONE;
1276 if( x>iTxn ) iTxn = x;
1277 }
1278 sqlite3_mutex_leave(db->mutex);
1279 return iTxn;
1280}
1281
1282/*
1283** Two variations on the public interface for closing a database
1284** connection. The sqlite3_close() version returns SQLITE_BUSY and
1285** leaves the connection open if there are unfinalized prepared
1286** statements or unfinished sqlite3_backups. The sqlite3_close_v2()
1287** version forces the connection to become a zombie if there are
1288** unclosed resources, and arranges for deallocation when the last
1289** prepare statement or sqlite3_backup closes.
1290*/
1291int sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); }
1292int sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); }
1293
1294
1295/*
1296** Close the mutex on database connection db.
1297**
1298** Furthermore, if database connection db is a zombie (meaning that there
1299** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and
1300** every sqlite3_stmt has now been finalized and every sqlite3_backup has
1301** finished, then free all resources.
1302*/
1303void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
1304 HashElem *i; /* Hash table iterator */
1305 int j;
1306
1307 /* If there are outstanding sqlite3_stmt or sqlite3_backup objects
1308 ** or if the connection has not yet been closed by sqlite3_close_v2(),
1309 ** then just leave the mutex and return.
1310 */
1311 if( db->eOpenState!=SQLITE_STATE_ZOMBIE || connectionIsBusy(db) ){
1312 sqlite3_mutex_leave(db->mutex);
1313 return;
1314 }
1315
1316 /* If we reach this point, it means that the database connection has
1317 ** closed all sqlite3_stmt and sqlite3_backup objects and has been
1318 ** passed to sqlite3_close (meaning that it is a zombie). Therefore,
1319 ** go ahead and free all resources.
1320 */
1321
1322 /* If a transaction is open, roll it back. This also ensures that if
1323 ** any database schemas have been modified by an uncommitted transaction
1324 ** they are reset. And that the required b-tree mutex is held to make
1325 ** the pager rollback and schema reset an atomic operation. */
1326 sqlite3RollbackAll(db, SQLITE_OK);
1327
1328 /* Free any outstanding Savepoint structures. */
1329 sqlite3CloseSavepoints(db);
1330
1331 /* Close all database connections */
1332 for(j=0; j<db->nDb; j++){
1333 struct Db *pDb = &db->aDb[j];
1334 if( pDb->pBt ){
1335 sqlite3BtreeClose(pDb->pBt);
1336 pDb->pBt = 0;
1337 if( j!=1 ){
1338 pDb->pSchema = 0;
1339 }
1340 }
1341 }
1342 /* Clear the TEMP schema separately and last */
1343 if( db->aDb[1].pSchema ){
1344 sqlite3SchemaClear(db->aDb[1].pSchema);
1345 }
1346 sqlite3VtabUnlockList(db);
1347
1348 /* Free up the array of auxiliary databases */
1349 sqlite3CollapseDatabaseArray(db);
1350 assert( db->nDb<=2 );
1351 assert( db->aDb==db->aDbStatic );
1352
1353 /* Tell the code in notify.c that the connection no longer holds any
1354 ** locks and does not require any further unlock-notify callbacks.
1355 */
1356 sqlite3ConnectionClosed(db);
1357
1358 for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
1359 FuncDef *pNext, *p;
1360 p = sqliteHashData(i);
1361 do{
1362 functionDestroy(db, p);
1363 pNext = p->pNext;
1364 sqlite3DbFree(db, p);
1365 p = pNext;
1366 }while( p );
1367 }
1368 sqlite3HashClear(&db->aFunc);
1369 for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
1370 CollSeq *pColl = (CollSeq *)sqliteHashData(i);
1371 /* Invoke any destructors registered for collation sequence user data. */
1372 for(j=0; j<3; j++){
1373 if( pColl[j].xDel ){
1374 pColl[j].xDel(pColl[j].pUser);
1375 }
1376 }
1377 sqlite3DbFree(db, pColl);
1378 }
1379 sqlite3HashClear(&db->aCollSeq);
1380#ifndef SQLITE_OMIT_VIRTUALTABLE
1381 for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
1382 Module *pMod = (Module *)sqliteHashData(i);
1383 sqlite3VtabEponymousTableClear(db, pMod);
1384 sqlite3VtabModuleUnref(db, pMod);
1385 }
1386 sqlite3HashClear(&db->aModule);
1387#endif
1388
1389 sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */
1390 sqlite3ValueFree(db->pErr);
1391 sqlite3CloseExtensions(db);
1392#if SQLITE_USER_AUTHENTICATION
1393 sqlite3_free(db->auth.zAuthUser);
1394 sqlite3_free(db->auth.zAuthPW);
1395#endif
1396
1397 db->eOpenState = SQLITE_STATE_ERROR;
1398
1399 /* The temp-database schema is allocated differently from the other schema
1400 ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
1401 ** So it needs to be freed here. Todo: Why not roll the temp schema into
1402 ** the same sqliteMalloc() as the one that allocates the database
1403 ** structure?
1404 */
1405 sqlite3DbFree(db, db->aDb[1].pSchema);
1406 if( db->xAutovacDestr ){
1407 db->xAutovacDestr(db->pAutovacPagesArg);
1408 }
1409 sqlite3_mutex_leave(db->mutex);
1410 db->eOpenState = SQLITE_STATE_CLOSED;
1411 sqlite3_mutex_free(db->mutex);
1412 assert( sqlite3LookasideUsed(db,0)==0 );
1413 if( db->lookaside.bMalloced ){
1414 sqlite3_free(db->lookaside.pStart);
1415 }
1416 sqlite3_free(db);
1417}
1418
1419/*
1420** Rollback all database files. If tripCode is not SQLITE_OK, then
1421** any write cursors are invalidated ("tripped" - as in "tripping a circuit
1422** breaker") and made to return tripCode if there are any further
1423** attempts to use that cursor. Read cursors remain open and valid
1424** but are "saved" in case the table pages are moved around.
1425*/
1426void sqlite3RollbackAll(sqlite3 *db, int tripCode){
1427 int i;
1428 int inTrans = 0;
1429 int schemaChange;
1430 assert( sqlite3_mutex_held(db->mutex) );
1431 sqlite3BeginBenignMalloc();
1432
1433 /* Obtain all b-tree mutexes before making any calls to BtreeRollback().
1434 ** This is important in case the transaction being rolled back has
1435 ** modified the database schema. If the b-tree mutexes are not taken
1436 ** here, then another shared-cache connection might sneak in between
1437 ** the database rollback and schema reset, which can cause false
1438 ** corruption reports in some cases. */
1439 sqlite3BtreeEnterAll(db);
1440 schemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0 && db->init.busy==0;
1441
1442 for(i=0; i<db->nDb; i++){
1443 Btree *p = db->aDb[i].pBt;
1444 if( p ){
1445 if( sqlite3BtreeTxnState(p)==SQLITE_TXN_WRITE ){
1446 inTrans = 1;
1447 }
1448 sqlite3BtreeRollback(p, tripCode, !schemaChange);
1449 }
1450 }
1451 sqlite3VtabRollback(db);
1452 sqlite3EndBenignMalloc();
1453
1454 if( schemaChange ){
1455 sqlite3ExpirePreparedStatements(db, 0);
1456 sqlite3ResetAllSchemasOfConnection(db);
1457 }
1458 sqlite3BtreeLeaveAll(db);
1459
1460 /* Any deferred constraint violations have now been resolved. */
1461 db->nDeferredCons = 0;
1462 db->nDeferredImmCons = 0;
1463 db->flags &= ~(u64)(SQLITE_DeferFKs|SQLITE_CorruptRdOnly);
1464
1465 /* If one has been configured, invoke the rollback-hook callback */
1466 if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
1467 db->xRollbackCallback(db->pRollbackArg);
1468 }
1469}
1470
1471/*
1472** Return a static string containing the name corresponding to the error code
1473** specified in the argument.
1474*/
1475#if defined(SQLITE_NEED_ERR_NAME)
1476const char *sqlite3ErrName(int rc){
1477 const char *zName = 0;
1478 int i, origRc = rc;
1479 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
1480 switch( rc ){
1481 case SQLITE_OK: zName = "SQLITE_OK"; break;
1482 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
1483 case SQLITE_ERROR_SNAPSHOT: zName = "SQLITE_ERROR_SNAPSHOT"; break;
1484 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
1485 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
1486 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
1487 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
1488 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
1489 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
1490 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
1491 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
1492 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
1493 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
1494 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
1495 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
1496 case SQLITE_READONLY_CANTINIT: zName = "SQLITE_READONLY_CANTINIT"; break;
1497 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
1498 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
1499 case SQLITE_READONLY_DIRECTORY: zName = "SQLITE_READONLY_DIRECTORY";break;
1500 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
1501 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
1502 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
1503 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
1504 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
1505 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
1506 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
1507 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
1508 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
1509 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
1510 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
1511 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
1512 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
1513 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
1514 case SQLITE_IOERR_CHECKRESERVEDLOCK:
1515 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
1516 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
1517 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
1518 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
1519 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
1520 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
1521 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
1522 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
1523 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
1524 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
1525 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
1526 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
1527 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
1528 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
1529 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
1530 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
1531 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
1532 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
1533 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
1534 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
1535 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
1536 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
1537 case SQLITE_CANTOPEN_SYMLINK: zName = "SQLITE_CANTOPEN_SYMLINK"; break;
1538 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
1539 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
1540 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
1541 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
1542 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
1543 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
1544 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
1545 case SQLITE_CONSTRAINT_FOREIGNKEY:
1546 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
1547 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
1548 case SQLITE_CONSTRAINT_PRIMARYKEY:
1549 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
1550 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
1551 case SQLITE_CONSTRAINT_COMMITHOOK:
1552 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
1553 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
1554 case SQLITE_CONSTRAINT_FUNCTION:
1555 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
1556 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
1557 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
1558 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
1559 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
1560 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
1561 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
1562 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
1563 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
1564 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
1565 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
1566 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
1567 case SQLITE_NOTICE_RECOVER_ROLLBACK:
1568 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
1569 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
1570 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
1571 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
1572 }
1573 }
1574 if( zName==0 ){
1575 static char zBuf[50];
1576 sqlite3_snprintf(sizeof(zBuf), zBuf, "SQLITE_UNKNOWN(%d)", origRc);
1577 zName = zBuf;
1578 }
1579 return zName;
1580}
1581#endif
1582
1583/*
1584** Return a static string that describes the kind of error specified in the
1585** argument.
1586*/
1587const char *sqlite3ErrStr(int rc){
1588 static const char* const aMsg[] = {
1589 /* SQLITE_OK */ "not an error",
1590 /* SQLITE_ERROR */ "SQL logic error",
1591 /* SQLITE_INTERNAL */ 0,
1592 /* SQLITE_PERM */ "access permission denied",
1593 /* SQLITE_ABORT */ "query aborted",
1594 /* SQLITE_BUSY */ "database is locked",
1595 /* SQLITE_LOCKED */ "database table is locked",
1596 /* SQLITE_NOMEM */ "out of memory",
1597 /* SQLITE_READONLY */ "attempt to write a readonly database",
1598 /* SQLITE_INTERRUPT */ "interrupted",
1599 /* SQLITE_IOERR */ "disk I/O error",
1600 /* SQLITE_CORRUPT */ "database disk image is malformed",
1601 /* SQLITE_NOTFOUND */ "unknown operation",
1602 /* SQLITE_FULL */ "database or disk is full",
1603 /* SQLITE_CANTOPEN */ "unable to open database file",
1604 /* SQLITE_PROTOCOL */ "locking protocol",
1605 /* SQLITE_EMPTY */ 0,
1606 /* SQLITE_SCHEMA */ "database schema has changed",
1607 /* SQLITE_TOOBIG */ "string or blob too big",
1608 /* SQLITE_CONSTRAINT */ "constraint failed",
1609 /* SQLITE_MISMATCH */ "datatype mismatch",
1610 /* SQLITE_MISUSE */ "bad parameter or other API misuse",
1611#ifdef SQLITE_DISABLE_LFS
1612 /* SQLITE_NOLFS */ "large file support is disabled",
1613#else
1614 /* SQLITE_NOLFS */ 0,
1615#endif
1616 /* SQLITE_AUTH */ "authorization denied",
1617 /* SQLITE_FORMAT */ 0,
1618 /* SQLITE_RANGE */ "column index out of range",
1619 /* SQLITE_NOTADB */ "file is not a database",
1620 /* SQLITE_NOTICE */ "notification message",
1621 /* SQLITE_WARNING */ "warning message",
1622 };
1623 const char *zErr = "unknown error";
1624 switch( rc ){
1625 case SQLITE_ABORT_ROLLBACK: {
1626 zErr = "abort due to ROLLBACK";
1627 break;
1628 }
1629 case SQLITE_ROW: {
1630 zErr = "another row available";
1631 break;
1632 }
1633 case SQLITE_DONE: {
1634 zErr = "no more rows available";
1635 break;
1636 }
1637 default: {
1638 rc &= 0xff;
1639 if( ALWAYS(rc>=0) && rc<ArraySize(aMsg) && aMsg[rc]!=0 ){
1640 zErr = aMsg[rc];
1641 }
1642 break;
1643 }
1644 }
1645 return zErr;
1646}
1647
1648/*
1649** This routine implements a busy callback that sleeps and tries
1650** again until a timeout value is reached. The timeout value is
1651** an integer number of milliseconds passed in as the first
1652** argument.
1653**
1654** Return non-zero to retry the lock. Return zero to stop trying
1655** and cause SQLite to return SQLITE_BUSY.
1656*/
1657static int sqliteDefaultBusyCallback(
1658 void *ptr, /* Database connection */
1659 int count /* Number of times table has been busy */
1660){
1661#if SQLITE_OS_WIN || HAVE_USLEEP
1662 /* This case is for systems that have support for sleeping for fractions of
1663 ** a second. Examples: All windows systems, unix systems with usleep() */
1664 static const u8 delays[] =
1665 { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
1666 static const u8 totals[] =
1667 { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
1668# define NDELAY ArraySize(delays)
1669 sqlite3 *db = (sqlite3 *)ptr;
1670 int tmout = db->busyTimeout;
1671 int delay, prior;
1672
1673 assert( count>=0 );
1674 if( count < NDELAY ){
1675 delay = delays[count];
1676 prior = totals[count];
1677 }else{
1678 delay = delays[NDELAY-1];
1679 prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
1680 }
1681 if( prior + delay > tmout ){
1682 delay = tmout - prior;
1683 if( delay<=0 ) return 0;
1684 }
1685 sqlite3OsSleep(db->pVfs, delay*1000);
1686 return 1;
1687#else
1688 /* This case for unix systems that lack usleep() support. Sleeping
1689 ** must be done in increments of whole seconds */
1690 sqlite3 *db = (sqlite3 *)ptr;
1691 int tmout = ((sqlite3 *)ptr)->busyTimeout;
1692 if( (count+1)*1000 > tmout ){
1693 return 0;
1694 }
1695 sqlite3OsSleep(db->pVfs, 1000000);
1696 return 1;
1697#endif
1698}
1699
1700/*
1701** Invoke the given busy handler.
1702**
1703** This routine is called when an operation failed to acquire a
1704** lock on VFS file pFile.
1705**
1706** If this routine returns non-zero, the lock is retried. If it
1707** returns 0, the operation aborts with an SQLITE_BUSY error.
1708*/
1709int sqlite3InvokeBusyHandler(BusyHandler *p){
1710 int rc;
1711 if( p->xBusyHandler==0 || p->nBusy<0 ) return 0;
1712 rc = p->xBusyHandler(p->pBusyArg, p->nBusy);
1713 if( rc==0 ){
1714 p->nBusy = -1;
1715 }else{
1716 p->nBusy++;
1717 }
1718 return rc;
1719}
1720
1721/*
1722** This routine sets the busy callback for an Sqlite database to the
1723** given callback function with the given argument.
1724*/
1725int sqlite3_busy_handler(
1726 sqlite3 *db,
1727 int (*xBusy)(void*,int),
1728 void *pArg
1729){
1730#ifdef SQLITE_ENABLE_API_ARMOR
1731 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
1732#endif
1733 sqlite3_mutex_enter(db->mutex);
1734 db->busyHandler.xBusyHandler = xBusy;
1735 db->busyHandler.pBusyArg = pArg;
1736 db->busyHandler.nBusy = 0;
1737 db->busyTimeout = 0;
1738 sqlite3_mutex_leave(db->mutex);
1739 return SQLITE_OK;
1740}
1741
1742#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1743/*
1744** This routine sets the progress callback for an Sqlite database to the
1745** given callback function with the given argument. The progress callback will
1746** be invoked every nOps opcodes.
1747*/
1748void sqlite3_progress_handler(
1749 sqlite3 *db,
1750 int nOps,
1751 int (*xProgress)(void*),
1752 void *pArg
1753){
1754#ifdef SQLITE_ENABLE_API_ARMOR
1755 if( !sqlite3SafetyCheckOk(db) ){
1756 (void)SQLITE_MISUSE_BKPT;
1757 return;
1758 }
1759#endif
1760 sqlite3_mutex_enter(db->mutex);
1761 if( nOps>0 ){
1762 db->xProgress = xProgress;
1763 db->nProgressOps = (unsigned)nOps;
1764 db->pProgressArg = pArg;
1765 }else{
1766 db->xProgress = 0;
1767 db->nProgressOps = 0;
1768 db->pProgressArg = 0;
1769 }
1770 sqlite3_mutex_leave(db->mutex);
1771}
1772#endif
1773
1774
1775/*
1776** This routine installs a default busy handler that waits for the
1777** specified number of milliseconds before returning 0.
1778*/
1779int sqlite3_busy_timeout(sqlite3 *db, int ms){
1780#ifdef SQLITE_ENABLE_API_ARMOR
1781 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
1782#endif
1783 if( ms>0 ){
1784 sqlite3_busy_handler(db, (int(*)(void*,int))sqliteDefaultBusyCallback,
1785 (void*)db);
1786 db->busyTimeout = ms;
1787 }else{
1788 sqlite3_busy_handler(db, 0, 0);
1789 }
1790 return SQLITE_OK;
1791}
1792
1793/*
1794** Cause any pending operation to stop at its earliest opportunity.
1795*/
1796void sqlite3_interrupt(sqlite3 *db){
1797#ifdef SQLITE_ENABLE_API_ARMOR
1798 if( !sqlite3SafetyCheckOk(db) && (db==0 || db->eOpenState!=SQLITE_STATE_ZOMBIE) ){
1799 (void)SQLITE_MISUSE_BKPT;
1800 return;
1801 }
1802#endif
1803 AtomicStore(&db->u1.isInterrupted, 1);
1804}
1805
1806
1807/*
1808** This function is exactly the same as sqlite3_create_function(), except
1809** that it is designed to be called by internal code. The difference is
1810** that if a malloc() fails in sqlite3_create_function(), an error code
1811** is returned and the mallocFailed flag cleared.
1812*/
1813int sqlite3CreateFunc(
1814 sqlite3 *db,
1815 const char *zFunctionName,
1816 int nArg,
1817 int enc,
1818 void *pUserData,
1819 void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
1820 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
1821 void (*xFinal)(sqlite3_context*),
1822 void (*xValue)(sqlite3_context*),
1823 void (*xInverse)(sqlite3_context*,int,sqlite3_value **),
1824 FuncDestructor *pDestructor
1825){
1826 FuncDef *p;
1827 int extraFlags;
1828
1829 assert( sqlite3_mutex_held(db->mutex) );
1830 assert( xValue==0 || xSFunc==0 );
1831 if( zFunctionName==0 /* Must have a valid name */
1832 || (xSFunc!=0 && xFinal!=0) /* Not both xSFunc and xFinal */
1833 || ((xFinal==0)!=(xStep==0)) /* Both or neither of xFinal and xStep */
1834 || ((xValue==0)!=(xInverse==0)) /* Both or neither of xValue, xInverse */
1835 || (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG)
1836 || (255<sqlite3Strlen30(zFunctionName))
1837 ){
1838 return SQLITE_MISUSE_BKPT;
1839 }
1840
1841 assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
1842 assert( SQLITE_FUNC_DIRECT==SQLITE_DIRECTONLY );
1843 extraFlags = enc & (SQLITE_DETERMINISTIC|SQLITE_DIRECTONLY|
1844 SQLITE_SUBTYPE|SQLITE_INNOCUOUS);
1845 enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
1846
1847 /* The SQLITE_INNOCUOUS flag is the same bit as SQLITE_FUNC_UNSAFE. But
1848 ** the meaning is inverted. So flip the bit. */
1849 assert( SQLITE_FUNC_UNSAFE==SQLITE_INNOCUOUS );
1850 extraFlags ^= SQLITE_FUNC_UNSAFE;
1851
1852
1853#ifndef SQLITE_OMIT_UTF16
1854 /* If SQLITE_UTF16 is specified as the encoding type, transform this
1855 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
1856 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
1857 **
1858 ** If SQLITE_ANY is specified, add three versions of the function
1859 ** to the hash table.
1860 */
1861 switch( enc ){
1862 case SQLITE_UTF16:
1863 enc = SQLITE_UTF16NATIVE;
1864 break;
1865 case SQLITE_ANY: {
1866 int rc;
1867 rc = sqlite3CreateFunc(db, zFunctionName, nArg,
1868 (SQLITE_UTF8|extraFlags)^SQLITE_FUNC_UNSAFE,
1869 pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
1870 if( rc==SQLITE_OK ){
1871 rc = sqlite3CreateFunc(db, zFunctionName, nArg,
1872 (SQLITE_UTF16LE|extraFlags)^SQLITE_FUNC_UNSAFE,
1873 pUserData, xSFunc, xStep, xFinal, xValue, xInverse, pDestructor);
1874 }
1875 if( rc!=SQLITE_OK ){
1876 return rc;
1877 }
1878 enc = SQLITE_UTF16BE;
1879 break;
1880 }
1881 case SQLITE_UTF8:
1882 case SQLITE_UTF16LE:
1883 case SQLITE_UTF16BE:
1884 break;
1885 default:
1886 enc = SQLITE_UTF8;
1887 break;
1888 }
1889#else
1890 enc = SQLITE_UTF8;
1891#endif
1892
1893 /* Check if an existing function is being overridden or deleted. If so,
1894 ** and there are active VMs, then return SQLITE_BUSY. If a function
1895 ** is being overridden/deleted but there are no active VMs, allow the
1896 ** operation to continue but invalidate all precompiled statements.
1897 */
1898 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0);
1899 if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==(u32)enc && p->nArg==nArg ){
1900 if( db->nVdbeActive ){
1901 sqlite3ErrorWithMsg(db, SQLITE_BUSY,
1902 "unable to delete/modify user-function due to active statements");
1903 assert( !db->mallocFailed );
1904 return SQLITE_BUSY;
1905 }else{
1906 sqlite3ExpirePreparedStatements(db, 0);
1907 }
1908 }else if( xSFunc==0 && xFinal==0 ){
1909 /* Trying to delete a function that does not exist. This is a no-op.
1910 ** https://sqlite.org/forum/forumpost/726219164b */
1911 return SQLITE_OK;
1912 }
1913
1914 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1);
1915 assert(p || db->mallocFailed);
1916 if( !p ){
1917 return SQLITE_NOMEM_BKPT;
1918 }
1919
1920 /* If an older version of the function with a configured destructor is
1921 ** being replaced invoke the destructor function here. */
1922 functionDestroy(db, p);
1923
1924 if( pDestructor ){
1925 pDestructor->nRef++;
1926 }
1927 p->u.pDestructor = pDestructor;
1928 p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags;
1929 testcase( p->funcFlags & SQLITE_DETERMINISTIC );
1930 testcase( p->funcFlags & SQLITE_DIRECTONLY );
1931 p->xSFunc = xSFunc ? xSFunc : xStep;
1932 p->xFinalize = xFinal;
1933 p->xValue = xValue;
1934 p->xInverse = xInverse;
1935 p->pUserData = pUserData;
1936 p->nArg = (u16)nArg;
1937 return SQLITE_OK;
1938}
1939
1940/*
1941** Worker function used by utf-8 APIs that create new functions:
1942**
1943** sqlite3_create_function()
1944** sqlite3_create_function_v2()
1945** sqlite3_create_window_function()
1946*/
1947static int createFunctionApi(
1948 sqlite3 *db,
1949 const char *zFunc,
1950 int nArg,
1951 int enc,
1952 void *p,
1953 void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
1954 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
1955 void (*xFinal)(sqlite3_context*),
1956 void (*xValue)(sqlite3_context*),
1957 void (*xInverse)(sqlite3_context*,int,sqlite3_value**),
1958 void(*xDestroy)(void*)
1959){
1960 int rc = SQLITE_ERROR;
1961 FuncDestructor *pArg = 0;
1962
1963#ifdef SQLITE_ENABLE_API_ARMOR
1964 if( !sqlite3SafetyCheckOk(db) ){
1965 return SQLITE_MISUSE_BKPT;
1966 }
1967#endif
1968 sqlite3_mutex_enter(db->mutex);
1969 if( xDestroy ){
1970 pArg = (FuncDestructor *)sqlite3Malloc(sizeof(FuncDestructor));
1971 if( !pArg ){
1972 sqlite3OomFault(db);
1973 xDestroy(p);
1974 goto out;
1975 }
1976 pArg->nRef = 0;
1977 pArg->xDestroy = xDestroy;
1978 pArg->pUserData = p;
1979 }
1980 rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p,
1981 xSFunc, xStep, xFinal, xValue, xInverse, pArg
1982 );
1983 if( pArg && pArg->nRef==0 ){
1984 assert( rc!=SQLITE_OK || (xStep==0 && xFinal==0) );
1985 xDestroy(p);
1986 sqlite3_free(pArg);
1987 }
1988
1989 out:
1990 rc = sqlite3ApiExit(db, rc);
1991 sqlite3_mutex_leave(db->mutex);
1992 return rc;
1993}
1994
1995/*
1996** Create new user functions.
1997*/
1998int sqlite3_create_function(
1999 sqlite3 *db,
2000 const char *zFunc,
2001 int nArg,
2002 int enc,
2003 void *p,
2004 void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
2005 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
2006 void (*xFinal)(sqlite3_context*)
2007){
2008 return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
2009 xFinal, 0, 0, 0);
2010}
2011int sqlite3_create_function_v2(
2012 sqlite3 *db,
2013 const char *zFunc,
2014 int nArg,
2015 int enc,
2016 void *p,
2017 void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
2018 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
2019 void (*xFinal)(sqlite3_context*),
2020 void (*xDestroy)(void *)
2021){
2022 return createFunctionApi(db, zFunc, nArg, enc, p, xSFunc, xStep,
2023 xFinal, 0, 0, xDestroy);
2024}
2025int sqlite3_create_window_function(
2026 sqlite3 *db,
2027 const char *zFunc,
2028 int nArg,
2029 int enc,
2030 void *p,
2031 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
2032 void (*xFinal)(sqlite3_context*),
2033 void (*xValue)(sqlite3_context*),
2034 void (*xInverse)(sqlite3_context*,int,sqlite3_value **),
2035 void (*xDestroy)(void *)
2036){
2037 return createFunctionApi(db, zFunc, nArg, enc, p, 0, xStep,
2038 xFinal, xValue, xInverse, xDestroy);
2039}
2040
2041#ifndef SQLITE_OMIT_UTF16
2042int sqlite3_create_function16(
2043 sqlite3 *db,
2044 const void *zFunctionName,
2045 int nArg,
2046 int eTextRep,
2047 void *p,
2048 void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
2049 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
2050 void (*xFinal)(sqlite3_context*)
2051){
2052 int rc;
2053 char *zFunc8;
2054
2055#ifdef SQLITE_ENABLE_API_ARMOR
2056 if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT;
2057#endif
2058 sqlite3_mutex_enter(db->mutex);
2059 assert( !db->mallocFailed );
2060 zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
2061 rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xSFunc,xStep,xFinal,0,0,0);
2062 sqlite3DbFree(db, zFunc8);
2063 rc = sqlite3ApiExit(db, rc);
2064 sqlite3_mutex_leave(db->mutex);
2065 return rc;
2066}
2067#endif
2068
2069
2070/*
2071** The following is the implementation of an SQL function that always
2072** fails with an error message stating that the function is used in the
2073** wrong context. The sqlite3_overload_function() API might construct
2074** SQL function that use this routine so that the functions will exist
2075** for name resolution but are actually overloaded by the xFindFunction
2076** method of virtual tables.
2077*/
2078static void sqlite3InvalidFunction(
2079 sqlite3_context *context, /* The function calling context */
2080 int NotUsed, /* Number of arguments to the function */
2081 sqlite3_value **NotUsed2 /* Value of each argument */
2082){
2083 const char *zName = (const char*)sqlite3_user_data(context);
2084 char *zErr;
2085 UNUSED_PARAMETER2(NotUsed, NotUsed2);
2086 zErr = sqlite3_mprintf(
2087 "unable to use function %s in the requested context", zName);
2088 sqlite3_result_error(context, zErr, -1);
2089 sqlite3_free(zErr);
2090}
2091
2092/*
2093** Declare that a function has been overloaded by a virtual table.
2094**
2095** If the function already exists as a regular global function, then
2096** this routine is a no-op. If the function does not exist, then create
2097** a new one that always throws a run-time error.
2098**
2099** When virtual tables intend to provide an overloaded function, they
2100** should call this routine to make sure the global function exists.
2101** A global function must exist in order for name resolution to work
2102** properly.
2103*/
2104int sqlite3_overload_function(
2105 sqlite3 *db,
2106 const char *zName,
2107 int nArg
2108){
2109 int rc;
2110 char *zCopy;
2111
2112#ifdef SQLITE_ENABLE_API_ARMOR
2113 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
2114 return SQLITE_MISUSE_BKPT;
2115 }
2116#endif
2117 sqlite3_mutex_enter(db->mutex);
2118 rc = sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)!=0;
2119 sqlite3_mutex_leave(db->mutex);
2120 if( rc ) return SQLITE_OK;
2121 zCopy = sqlite3_mprintf("%s", zName);
2122 if( zCopy==0 ) return SQLITE_NOMEM;
2123 return sqlite3_create_function_v2(db, zName, nArg, SQLITE_UTF8,
2124 zCopy, sqlite3InvalidFunction, 0, 0, sqlite3_free);
2125}
2126
2127#ifndef SQLITE_OMIT_TRACE
2128/*
2129** Register a trace function. The pArg from the previously registered trace
2130** is returned.
2131**
2132** A NULL trace function means that no tracing is executes. A non-NULL
2133** trace is a pointer to a function that is invoked at the start of each
2134** SQL statement.
2135*/
2136#ifndef SQLITE_OMIT_DEPRECATED
2137void *sqlite3_trace(sqlite3 *db, void(*xTrace)(void*,const char*), void *pArg){
2138 void *pOld;
2139
2140#ifdef SQLITE_ENABLE_API_ARMOR
2141 if( !sqlite3SafetyCheckOk(db) ){
2142 (void)SQLITE_MISUSE_BKPT;
2143 return 0;
2144 }
2145#endif
2146 sqlite3_mutex_enter(db->mutex);
2147 pOld = db->pTraceArg;
2148 db->mTrace = xTrace ? SQLITE_TRACE_LEGACY : 0;
2149 db->trace.xLegacy = xTrace;
2150 db->pTraceArg = pArg;
2151 sqlite3_mutex_leave(db->mutex);
2152 return pOld;
2153}
2154#endif /* SQLITE_OMIT_DEPRECATED */
2155
2156/* Register a trace callback using the version-2 interface.
2157*/
2158int sqlite3_trace_v2(
2159 sqlite3 *db, /* Trace this connection */
2160 unsigned mTrace, /* Mask of events to be traced */
2161 int(*xTrace)(unsigned,void*,void*,void*), /* Callback to invoke */
2162 void *pArg /* Context */
2163){
2164#ifdef SQLITE_ENABLE_API_ARMOR
2165 if( !sqlite3SafetyCheckOk(db) ){
2166 return SQLITE_MISUSE_BKPT;
2167 }
2168#endif
2169 sqlite3_mutex_enter(db->mutex);
2170 if( mTrace==0 ) xTrace = 0;
2171 if( xTrace==0 ) mTrace = 0;
2172 db->mTrace = mTrace;
2173 db->trace.xV2 = xTrace;
2174 db->pTraceArg = pArg;
2175 sqlite3_mutex_leave(db->mutex);
2176 return SQLITE_OK;
2177}
2178
2179#ifndef SQLITE_OMIT_DEPRECATED
2180/*
2181** Register a profile function. The pArg from the previously registered
2182** profile function is returned.
2183**
2184** A NULL profile function means that no profiling is executes. A non-NULL
2185** profile is a pointer to a function that is invoked at the conclusion of
2186** each SQL statement that is run.
2187*/
2188void *sqlite3_profile(
2189 sqlite3 *db,
2190 void (*xProfile)(void*,const char*,sqlite_uint64),
2191 void *pArg
2192){
2193 void *pOld;
2194
2195#ifdef SQLITE_ENABLE_API_ARMOR
2196 if( !sqlite3SafetyCheckOk(db) ){
2197 (void)SQLITE_MISUSE_BKPT;
2198 return 0;
2199 }
2200#endif
2201 sqlite3_mutex_enter(db->mutex);
2202 pOld = db->pProfileArg;
2203 db->xProfile = xProfile;
2204 db->pProfileArg = pArg;
2205 db->mTrace &= SQLITE_TRACE_NONLEGACY_MASK;
2206 if( db->xProfile ) db->mTrace |= SQLITE_TRACE_XPROFILE;
2207 sqlite3_mutex_leave(db->mutex);
2208 return pOld;
2209}
2210#endif /* SQLITE_OMIT_DEPRECATED */
2211#endif /* SQLITE_OMIT_TRACE */
2212
2213/*
2214** Register a function to be invoked when a transaction commits.
2215** If the invoked function returns non-zero, then the commit becomes a
2216** rollback.
2217*/
2218void *sqlite3_commit_hook(
2219 sqlite3 *db, /* Attach the hook to this database */
2220 int (*xCallback)(void*), /* Function to invoke on each commit */
2221 void *pArg /* Argument to the function */
2222){
2223 void *pOld;
2224
2225#ifdef SQLITE_ENABLE_API_ARMOR
2226 if( !sqlite3SafetyCheckOk(db) ){
2227 (void)SQLITE_MISUSE_BKPT;
2228 return 0;
2229 }
2230#endif
2231 sqlite3_mutex_enter(db->mutex);
2232 pOld = db->pCommitArg;
2233 db->xCommitCallback = xCallback;
2234 db->pCommitArg = pArg;
2235 sqlite3_mutex_leave(db->mutex);
2236 return pOld;
2237}
2238
2239/*
2240** Register a callback to be invoked each time a row is updated,
2241** inserted or deleted using this database connection.
2242*/
2243void *sqlite3_update_hook(
2244 sqlite3 *db, /* Attach the hook to this database */
2245 void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
2246 void *pArg /* Argument to the function */
2247){
2248 void *pRet;
2249
2250#ifdef SQLITE_ENABLE_API_ARMOR
2251 if( !sqlite3SafetyCheckOk(db) ){
2252 (void)SQLITE_MISUSE_BKPT;
2253 return 0;
2254 }
2255#endif
2256 sqlite3_mutex_enter(db->mutex);
2257 pRet = db->pUpdateArg;
2258 db->xUpdateCallback = xCallback;
2259 db->pUpdateArg = pArg;
2260 sqlite3_mutex_leave(db->mutex);
2261 return pRet;
2262}
2263
2264/*
2265** Register a callback to be invoked each time a transaction is rolled
2266** back by this database connection.
2267*/
2268void *sqlite3_rollback_hook(
2269 sqlite3 *db, /* Attach the hook to this database */
2270 void (*xCallback)(void*), /* Callback function */
2271 void *pArg /* Argument to the function */
2272){
2273 void *pRet;
2274
2275#ifdef SQLITE_ENABLE_API_ARMOR
2276 if( !sqlite3SafetyCheckOk(db) ){
2277 (void)SQLITE_MISUSE_BKPT;
2278 return 0;
2279 }
2280#endif
2281 sqlite3_mutex_enter(db->mutex);
2282 pRet = db->pRollbackArg;
2283 db->xRollbackCallback = xCallback;
2284 db->pRollbackArg = pArg;
2285 sqlite3_mutex_leave(db->mutex);
2286 return pRet;
2287}
2288
2289#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
2290/*
2291** Register a callback to be invoked each time a row is updated,
2292** inserted or deleted using this database connection.
2293*/
2294void *sqlite3_preupdate_hook(
2295 sqlite3 *db, /* Attach the hook to this database */
2296 void(*xCallback)( /* Callback function */
2297 void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64),
2298 void *pArg /* First callback argument */
2299){
2300 void *pRet;
2301 sqlite3_mutex_enter(db->mutex);
2302 pRet = db->pPreUpdateArg;
2303 db->xPreUpdateCallback = xCallback;
2304 db->pPreUpdateArg = pArg;
2305 sqlite3_mutex_leave(db->mutex);
2306 return pRet;
2307}
2308#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
2309
2310/*
2311** Register a function to be invoked prior to each autovacuum that
2312** determines the number of pages to vacuum.
2313*/
2314int sqlite3_autovacuum_pages(
2315 sqlite3 *db, /* Attach the hook to this database */
2316 unsigned int (*xCallback)(void*,const char*,u32,u32,u32),
2317 void *pArg, /* Argument to the function */
2318 void (*xDestructor)(void*) /* Destructor for pArg */
2319){
2320#ifdef SQLITE_ENABLE_API_ARMOR
2321 if( !sqlite3SafetyCheckOk(db) ){
2322 if( xDestructor ) xDestructor(pArg);
2323 return SQLITE_MISUSE_BKPT;
2324 }
2325#endif
2326 sqlite3_mutex_enter(db->mutex);
2327 if( db->xAutovacDestr ){
2328 db->xAutovacDestr(db->pAutovacPagesArg);
2329 }
2330 db->xAutovacPages = xCallback;
2331 db->pAutovacPagesArg = pArg;
2332 db->xAutovacDestr = xDestructor;
2333 sqlite3_mutex_leave(db->mutex);
2334 return SQLITE_OK;
2335}
2336
2337
2338#ifndef SQLITE_OMIT_WAL
2339/*
2340** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint().
2341** Invoke sqlite3_wal_checkpoint if the number of frames in the log file
2342** is greater than sqlite3.pWalArg cast to an integer (the value configured by
2343** wal_autocheckpoint()).
2344*/
2345int sqlite3WalDefaultHook(
2346 void *pClientData, /* Argument */
2347 sqlite3 *db, /* Connection */
2348 const char *zDb, /* Database */
2349 int nFrame /* Size of WAL */
2350){
2351 if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){
2352 sqlite3BeginBenignMalloc();
2353 sqlite3_wal_checkpoint(db, zDb);
2354 sqlite3EndBenignMalloc();
2355 }
2356 return SQLITE_OK;
2357}
2358#endif /* SQLITE_OMIT_WAL */
2359
2360/*
2361** Configure an sqlite3_wal_hook() callback to automatically checkpoint
2362** a database after committing a transaction if there are nFrame or
2363** more frames in the log file. Passing zero or a negative value as the
2364** nFrame parameter disables automatic checkpoints entirely.
2365**
2366** The callback registered by this function replaces any existing callback
2367** registered using sqlite3_wal_hook(). Likewise, registering a callback
2368** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
2369** configured by this function.
2370*/
2371int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
2372#ifdef SQLITE_OMIT_WAL
2373 UNUSED_PARAMETER(db);
2374 UNUSED_PARAMETER(nFrame);
2375#else
2376#ifdef SQLITE_ENABLE_API_ARMOR
2377 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
2378#endif
2379 if( nFrame>0 ){
2380 sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));
2381 }else{
2382 sqlite3_wal_hook(db, 0, 0);
2383 }
2384#endif
2385 return SQLITE_OK;
2386}
2387
2388/*
2389** Register a callback to be invoked each time a transaction is written
2390** into the write-ahead-log by this database connection.
2391*/
2392void *sqlite3_wal_hook(
2393 sqlite3 *db, /* Attach the hook to this db handle */
2394 int(*xCallback)(void *, sqlite3*, const char*, int),
2395 void *pArg /* First argument passed to xCallback() */
2396){
2397#ifndef SQLITE_OMIT_WAL
2398 void *pRet;
2399#ifdef SQLITE_ENABLE_API_ARMOR
2400 if( !sqlite3SafetyCheckOk(db) ){
2401 (void)SQLITE_MISUSE_BKPT;
2402 return 0;
2403 }
2404#endif
2405 sqlite3_mutex_enter(db->mutex);
2406 pRet = db->pWalArg;
2407 db->xWalCallback = xCallback;
2408 db->pWalArg = pArg;
2409 sqlite3_mutex_leave(db->mutex);
2410 return pRet;
2411#else
2412 return 0;
2413#endif
2414}
2415
2416/*
2417** Checkpoint database zDb.
2418*/
2419int sqlite3_wal_checkpoint_v2(
2420 sqlite3 *db, /* Database handle */
2421 const char *zDb, /* Name of attached database (or NULL) */
2422 int eMode, /* SQLITE_CHECKPOINT_* value */
2423 int *pnLog, /* OUT: Size of WAL log in frames */
2424 int *pnCkpt /* OUT: Total number of frames checkpointed */
2425){
2426#ifdef SQLITE_OMIT_WAL
2427 return SQLITE_OK;
2428#else
2429 int rc; /* Return code */
2430 int iDb; /* Schema to checkpoint */
2431
2432#ifdef SQLITE_ENABLE_API_ARMOR
2433 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
2434#endif
2435
2436 /* Initialize the output variables to -1 in case an error occurs. */
2437 if( pnLog ) *pnLog = -1;
2438 if( pnCkpt ) *pnCkpt = -1;
2439
2440 assert( SQLITE_CHECKPOINT_PASSIVE==0 );
2441 assert( SQLITE_CHECKPOINT_FULL==1 );
2442 assert( SQLITE_CHECKPOINT_RESTART==2 );
2443 assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
2444 if( eMode<SQLITE_CHECKPOINT_PASSIVE || eMode>SQLITE_CHECKPOINT_TRUNCATE ){
2445 /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
2446 ** mode: */
2447 return SQLITE_MISUSE;
2448 }
2449
2450 sqlite3_mutex_enter(db->mutex);
2451 if( zDb && zDb[0] ){
2452 iDb = sqlite3FindDbName(db, zDb);
2453 }else{
2454 iDb = SQLITE_MAX_DB; /* This means process all schemas */
2455 }
2456 if( iDb<0 ){
2457 rc = SQLITE_ERROR;
2458 sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb);
2459 }else{
2460 db->busyHandler.nBusy = 0;
2461 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
2462 sqlite3Error(db, rc);
2463 }
2464 rc = sqlite3ApiExit(db, rc);
2465
2466 /* If there are no active statements, clear the interrupt flag at this
2467 ** point. */
2468 if( db->nVdbeActive==0 ){
2469 AtomicStore(&db->u1.isInterrupted, 0);
2470 }
2471
2472 sqlite3_mutex_leave(db->mutex);
2473 return rc;
2474#endif
2475}
2476
2477
2478/*
2479** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
2480** to contains a zero-length string, all attached databases are
2481** checkpointed.
2482*/
2483int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
2484 /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to
2485 ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */
2486 return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0);
2487}
2488
2489#ifndef SQLITE_OMIT_WAL
2490/*
2491** Run a checkpoint on database iDb. This is a no-op if database iDb is
2492** not currently open in WAL mode.
2493**
2494** If a transaction is open on the database being checkpointed, this
2495** function returns SQLITE_LOCKED and a checkpoint is not attempted. If
2496** an error occurs while running the checkpoint, an SQLite error code is
2497** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
2498**
2499** The mutex on database handle db should be held by the caller. The mutex
2500** associated with the specific b-tree being checkpointed is taken by
2501** this function while the checkpoint is running.
2502**
2503** If iDb is passed SQLITE_MAX_DB then all attached databases are
2504** checkpointed. If an error is encountered it is returned immediately -
2505** no attempt is made to checkpoint any remaining databases.
2506**
2507** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL, RESTART
2508** or TRUNCATE.
2509*/
2510int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
2511 int rc = SQLITE_OK; /* Return code */
2512 int i; /* Used to iterate through attached dbs */
2513 int bBusy = 0; /* True if SQLITE_BUSY has been encountered */
2514
2515 assert( sqlite3_mutex_held(db->mutex) );
2516 assert( !pnLog || *pnLog==-1 );
2517 assert( !pnCkpt || *pnCkpt==-1 );
2518 testcase( iDb==SQLITE_MAX_ATTACHED ); /* See forum post a006d86f72 */
2519 testcase( iDb==SQLITE_MAX_DB );
2520
2521 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
2522 if( i==iDb || iDb==SQLITE_MAX_DB ){
2523 rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
2524 pnLog = 0;
2525 pnCkpt = 0;
2526 if( rc==SQLITE_BUSY ){
2527 bBusy = 1;
2528 rc = SQLITE_OK;
2529 }
2530 }
2531 }
2532
2533 return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
2534}
2535#endif /* SQLITE_OMIT_WAL */
2536
2537/*
2538** This function returns true if main-memory should be used instead of
2539** a temporary file for transient pager files and statement journals.
2540** The value returned depends on the value of db->temp_store (runtime
2541** parameter) and the compile time value of SQLITE_TEMP_STORE. The
2542** following table describes the relationship between these two values
2543** and this functions return value.
2544**
2545** SQLITE_TEMP_STORE db->temp_store Location of temporary database
2546** ----------------- -------------- ------------------------------
2547** 0 any file (return 0)
2548** 1 1 file (return 0)
2549** 1 2 memory (return 1)
2550** 1 0 file (return 0)
2551** 2 1 file (return 0)
2552** 2 2 memory (return 1)
2553** 2 0 memory (return 1)
2554** 3 any memory (return 1)
2555*/
2556int sqlite3TempInMemory(const sqlite3 *db){
2557#if SQLITE_TEMP_STORE==1
2558 return ( db->temp_store==2 );
2559#endif
2560#if SQLITE_TEMP_STORE==2
2561 return ( db->temp_store!=1 );
2562#endif
2563#if SQLITE_TEMP_STORE==3
2564 UNUSED_PARAMETER(db);
2565 return 1;
2566#endif
2567#if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3
2568 UNUSED_PARAMETER(db);
2569 return 0;
2570#endif
2571}
2572
2573/*
2574** Return UTF-8 encoded English language explanation of the most recent
2575** error.
2576*/
2577const char *sqlite3_errmsg(sqlite3 *db){
2578 const char *z;
2579 if( !db ){
2580 return sqlite3ErrStr(SQLITE_NOMEM_BKPT);
2581 }
2582 if( !sqlite3SafetyCheckSickOrOk(db) ){
2583 return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
2584 }
2585 sqlite3_mutex_enter(db->mutex);
2586 if( db->mallocFailed ){
2587 z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
2588 }else{
2589 testcase( db->pErr==0 );
2590 z = db->errCode ? (char*)sqlite3_value_text(db->pErr) : 0;
2591 assert( !db->mallocFailed );
2592 if( z==0 ){
2593 z = sqlite3ErrStr(db->errCode);
2594 }
2595 }
2596 sqlite3_mutex_leave(db->mutex);
2597 return z;
2598}
2599
2600/*
2601** Return the byte offset of the most recent error
2602*/
2603int sqlite3_error_offset(sqlite3 *db){
2604 int iOffset = -1;
2605 if( db && sqlite3SafetyCheckSickOrOk(db) && db->errCode ){
2606 sqlite3_mutex_enter(db->mutex);
2607 iOffset = db->errByteOffset;
2608 sqlite3_mutex_leave(db->mutex);
2609 }
2610 return iOffset;
2611}
2612
2613#ifndef SQLITE_OMIT_UTF16
2614/*
2615** Return UTF-16 encoded English language explanation of the most recent
2616** error.
2617*/
2618const void *sqlite3_errmsg16(sqlite3 *db){
2619 static const u16 outOfMem[] = {
2620 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
2621 };
2622 static const u16 misuse[] = {
2623 'b', 'a', 'd', ' ', 'p', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', ' ',
2624 'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ',
2625 'm', 'i', 's', 'u', 's', 'e', 0
2626 };
2627
2628 const void *z;
2629 if( !db ){
2630 return (void *)outOfMem;
2631 }
2632 if( !sqlite3SafetyCheckSickOrOk(db) ){
2633 return (void *)misuse;
2634 }
2635 sqlite3_mutex_enter(db->mutex);
2636 if( db->mallocFailed ){
2637 z = (void *)outOfMem;
2638 }else{
2639 z = sqlite3_value_text16(db->pErr);
2640 if( z==0 ){
2641 sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode));
2642 z = sqlite3_value_text16(db->pErr);
2643 }
2644 /* A malloc() may have failed within the call to sqlite3_value_text16()
2645 ** above. If this is the case, then the db->mallocFailed flag needs to
2646 ** be cleared before returning. Do this directly, instead of via
2647 ** sqlite3ApiExit(), to avoid setting the database handle error message.
2648 */
2649 sqlite3OomClear(db);
2650 }
2651 sqlite3_mutex_leave(db->mutex);
2652 return z;
2653}
2654#endif /* SQLITE_OMIT_UTF16 */
2655
2656/*
2657** Return the most recent error code generated by an SQLite routine. If NULL is
2658** passed to this function, we assume a malloc() failed during sqlite3_open().
2659*/
2660int sqlite3_errcode(sqlite3 *db){
2661 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
2662 return SQLITE_MISUSE_BKPT;
2663 }
2664 if( !db || db->mallocFailed ){
2665 return SQLITE_NOMEM_BKPT;
2666 }
2667 return db->errCode & db->errMask;
2668}
2669int sqlite3_extended_errcode(sqlite3 *db){
2670 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
2671 return SQLITE_MISUSE_BKPT;
2672 }
2673 if( !db || db->mallocFailed ){
2674 return SQLITE_NOMEM_BKPT;
2675 }
2676 return db->errCode;
2677}
2678int sqlite3_system_errno(sqlite3 *db){
2679 return db ? db->iSysErrno : 0;
2680}
2681
2682/*
2683** Return a string that describes the kind of error specified in the
2684** argument. For now, this simply calls the internal sqlite3ErrStr()
2685** function.
2686*/
2687const char *sqlite3_errstr(int rc){
2688 return sqlite3ErrStr(rc);
2689}
2690
2691/*
2692** Create a new collating function for database "db". The name is zName
2693** and the encoding is enc.
2694*/
2695static int createCollation(
2696 sqlite3* db,
2697 const char *zName,
2698 u8 enc,
2699 void* pCtx,
2700 int(*xCompare)(void*,int,const void*,int,const void*),
2701 void(*xDel)(void*)
2702){
2703 CollSeq *pColl;
2704 int enc2;
2705
2706 assert( sqlite3_mutex_held(db->mutex) );
2707
2708 /* If SQLITE_UTF16 is specified as the encoding type, transform this
2709 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
2710 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
2711 */
2712 enc2 = enc;
2713 testcase( enc2==SQLITE_UTF16 );
2714 testcase( enc2==SQLITE_UTF16_ALIGNED );
2715 if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){
2716 enc2 = SQLITE_UTF16NATIVE;
2717 }
2718 if( enc2<SQLITE_UTF8 || enc2>SQLITE_UTF16BE ){
2719 return SQLITE_MISUSE_BKPT;
2720 }
2721
2722 /* Check if this call is removing or replacing an existing collation
2723 ** sequence. If so, and there are active VMs, return busy. If there
2724 ** are no active VMs, invalidate any pre-compiled statements.
2725 */
2726 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
2727 if( pColl && pColl->xCmp ){
2728 if( db->nVdbeActive ){
2729 sqlite3ErrorWithMsg(db, SQLITE_BUSY,
2730 "unable to delete/modify collation sequence due to active statements");
2731 return SQLITE_BUSY;
2732 }
2733 sqlite3ExpirePreparedStatements(db, 0);
2734
2735 /* If collation sequence pColl was created directly by a call to
2736 ** sqlite3_create_collation, and not generated by synthCollSeq(),
2737 ** then any copies made by synthCollSeq() need to be invalidated.
2738 ** Also, collation destructor - CollSeq.xDel() - function may need
2739 ** to be called.
2740 */
2741 if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
2742 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
2743 int j;
2744 for(j=0; j<3; j++){
2745 CollSeq *p = &aColl[j];
2746 if( p->enc==pColl->enc ){
2747 if( p->xDel ){
2748 p->xDel(p->pUser);
2749 }
2750 p->xCmp = 0;
2751 }
2752 }
2753 }
2754 }
2755
2756 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
2757 if( pColl==0 ) return SQLITE_NOMEM_BKPT;
2758 pColl->xCmp = xCompare;
2759 pColl->pUser = pCtx;
2760 pColl->xDel = xDel;
2761 pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
2762 sqlite3Error(db, SQLITE_OK);
2763 return SQLITE_OK;
2764}
2765
2766
2767/*
2768** This array defines hard upper bounds on limit values. The
2769** initializer must be kept in sync with the SQLITE_LIMIT_*
2770** #defines in sqlite3.h.
2771*/
2772static const int aHardLimit[] = {
2773 SQLITE_MAX_LENGTH,
2774 SQLITE_MAX_SQL_LENGTH,
2775 SQLITE_MAX_COLUMN,
2776 SQLITE_MAX_EXPR_DEPTH,
2777 SQLITE_MAX_COMPOUND_SELECT,
2778 SQLITE_MAX_VDBE_OP,
2779 SQLITE_MAX_FUNCTION_ARG,
2780 SQLITE_MAX_ATTACHED,
2781 SQLITE_MAX_LIKE_PATTERN_LENGTH,
2782 SQLITE_MAX_VARIABLE_NUMBER, /* IMP: R-38091-32352 */
2783 SQLITE_MAX_TRIGGER_DEPTH,
2784 SQLITE_MAX_WORKER_THREADS,
2785};
2786
2787/*
2788** Make sure the hard limits are set to reasonable values
2789*/
2790#if SQLITE_MAX_LENGTH<100
2791# error SQLITE_MAX_LENGTH must be at least 100
2792#endif
2793#if SQLITE_MAX_SQL_LENGTH<100
2794# error SQLITE_MAX_SQL_LENGTH must be at least 100
2795#endif
2796#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
2797# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
2798#endif
2799#if SQLITE_MAX_COMPOUND_SELECT<2
2800# error SQLITE_MAX_COMPOUND_SELECT must be at least 2
2801#endif
2802#if SQLITE_MAX_VDBE_OP<40
2803# error SQLITE_MAX_VDBE_OP must be at least 40
2804#endif
2805#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>127
2806# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
2807#endif
2808#if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>125
2809# error SQLITE_MAX_ATTACHED must be between 0 and 125
2810#endif
2811#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
2812# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
2813#endif
2814#if SQLITE_MAX_COLUMN>32767
2815# error SQLITE_MAX_COLUMN must not exceed 32767
2816#endif
2817#if SQLITE_MAX_TRIGGER_DEPTH<1
2818# error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
2819#endif
2820#if SQLITE_MAX_WORKER_THREADS<0 || SQLITE_MAX_WORKER_THREADS>50
2821# error SQLITE_MAX_WORKER_THREADS must be between 0 and 50
2822#endif
2823
2824
2825/*
2826** Change the value of a limit. Report the old value.
2827** If an invalid limit index is supplied, report -1.
2828** Make no changes but still report the old value if the
2829** new limit is negative.
2830**
2831** A new lower limit does not shrink existing constructs.
2832** It merely prevents new constructs that exceed the limit
2833** from forming.
2834*/
2835int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
2836 int oldLimit;
2837
2838#ifdef SQLITE_ENABLE_API_ARMOR
2839 if( !sqlite3SafetyCheckOk(db) ){
2840 (void)SQLITE_MISUSE_BKPT;
2841 return -1;
2842 }
2843#endif
2844
2845 /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
2846 ** there is a hard upper bound set at compile-time by a C preprocessor
2847 ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
2848 ** "_MAX_".)
2849 */
2850 assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
2851 assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
2852 assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
2853 assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
2854 assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
2855 assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
2856 assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
2857 assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
2858 assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
2859 SQLITE_MAX_LIKE_PATTERN_LENGTH );
2860 assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
2861 assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
2862 assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS );
2863 assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) );
2864
2865
2866 if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
2867 return -1;
2868 }
2869 oldLimit = db->aLimit[limitId];
2870 if( newLimit>=0 ){ /* IMP: R-52476-28732 */
2871 if( newLimit>aHardLimit[limitId] ){
2872 newLimit = aHardLimit[limitId]; /* IMP: R-51463-25634 */
2873 }else if( newLimit<1 && limitId==SQLITE_LIMIT_LENGTH ){
2874 newLimit = 1;
2875 }
2876 db->aLimit[limitId] = newLimit;
2877 }
2878 return oldLimit; /* IMP: R-53341-35419 */
2879}
2880
2881/*
2882** This function is used to parse both URIs and non-URI filenames passed by the
2883** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database
2884** URIs specified as part of ATTACH statements.
2885**
2886** The first argument to this function is the name of the VFS to use (or
2887** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
2888** query parameter. The second argument contains the URI (or non-URI filename)
2889** itself. When this function is called the *pFlags variable should contain
2890** the default flags to open the database handle with. The value stored in
2891** *pFlags may be updated before returning if the URI filename contains
2892** "cache=xxx" or "mode=xxx" query parameters.
2893**
2894** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
2895** the VFS that should be used to open the database file. *pzFile is set to
2896** point to a buffer containing the name of the file to open. The value
2897** stored in *pzFile is a database name acceptable to sqlite3_uri_parameter()
2898** and is in the same format as names created using sqlite3_create_filename().
2899** The caller must invoke sqlite3_free_filename() (not sqlite3_free()!) on
2900** the value returned in *pzFile to avoid a memory leak.
2901**
2902** If an error occurs, then an SQLite error code is returned and *pzErrMsg
2903** may be set to point to a buffer containing an English language error
2904** message. It is the responsibility of the caller to eventually release
2905** this buffer by calling sqlite3_free().
2906*/
2907int sqlite3ParseUri(
2908 const char *zDefaultVfs, /* VFS to use if no "vfs=xxx" query option */
2909 const char *zUri, /* Nul-terminated URI to parse */
2910 unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */
2911 sqlite3_vfs **ppVfs, /* OUT: VFS to use */
2912 char **pzFile, /* OUT: Filename component of URI */
2913 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
2914){
2915 int rc = SQLITE_OK;
2916 unsigned int flags = *pFlags;
2917 const char *zVfs = zDefaultVfs;
2918 char *zFile;
2919 char c;
2920 int nUri = sqlite3Strlen30(zUri);
2921
2922 assert( *pzErrMsg==0 );
2923
2924 if( ((flags & SQLITE_OPEN_URI) /* IMP: R-48725-32206 */
2925 || sqlite3GlobalConfig.bOpenUri) /* IMP: R-51689-46548 */
2926 && nUri>=5 && memcmp(zUri, "file:", 5)==0 /* IMP: R-57884-37496 */
2927 ){
2928 char *zOpt;
2929 int eState; /* Parser state when parsing URI */
2930 int iIn; /* Input character index */
2931 int iOut = 0; /* Output character index */
2932 u64 nByte = nUri+8; /* Bytes of space to allocate */
2933
2934 /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
2935 ** method that there may be extra parameters following the file-name. */
2936 flags |= SQLITE_OPEN_URI;
2937
2938 for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
2939 zFile = sqlite3_malloc64(nByte);
2940 if( !zFile ) return SQLITE_NOMEM_BKPT;
2941
2942 memset(zFile, 0, 4); /* 4-byte of 0x00 is the start of DB name marker */
2943 zFile += 4;
2944
2945 iIn = 5;
2946#ifdef SQLITE_ALLOW_URI_AUTHORITY
2947 if( strncmp(zUri+5, "///", 3)==0 ){
2948 iIn = 7;
2949 /* The following condition causes URIs with five leading / characters
2950 ** like file://///host/path to be converted into UNCs like //host/path.
2951 ** The correct URI for that UNC has only two or four leading / characters
2952 ** file://host/path or file:////host/path. But 5 leading slashes is a
2953 ** common error, we are told, so we handle it as a special case. */
2954 if( strncmp(zUri+7, "///", 3)==0 ){ iIn++; }
2955 }else if( strncmp(zUri+5, "//localhost/", 12)==0 ){
2956 iIn = 16;
2957 }
2958#else
2959 /* Discard the scheme and authority segments of the URI. */
2960 if( zUri[5]=='/' && zUri[6]=='/' ){
2961 iIn = 7;
2962 while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
2963 if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
2964 *pzErrMsg = sqlite3_mprintf("invalid uri authority: %.*s",
2965 iIn-7, &zUri[7]);
2966 rc = SQLITE_ERROR;
2967 goto parse_uri_out;
2968 }
2969 }
2970#endif
2971
2972 /* Copy the filename and any query parameters into the zFile buffer.
2973 ** Decode %HH escape codes along the way.
2974 **
2975 ** Within this loop, variable eState may be set to 0, 1 or 2, depending
2976 ** on the parsing context. As follows:
2977 **
2978 ** 0: Parsing file-name.
2979 ** 1: Parsing name section of a name=value query parameter.
2980 ** 2: Parsing value section of a name=value query parameter.
2981 */
2982 eState = 0;
2983 while( (c = zUri[iIn])!=0 && c!='#' ){
2984 iIn++;
2985 if( c=='%'
2986 && sqlite3Isxdigit(zUri[iIn])
2987 && sqlite3Isxdigit(zUri[iIn+1])
2988 ){
2989 int octet = (sqlite3HexToInt(zUri[iIn++]) << 4);
2990 octet += sqlite3HexToInt(zUri[iIn++]);
2991
2992 assert( octet>=0 && octet<256 );
2993 if( octet==0 ){
2994#ifndef SQLITE_ENABLE_URI_00_ERROR
2995 /* This branch is taken when "%00" appears within the URI. In this
2996 ** case we ignore all text in the remainder of the path, name or
2997 ** value currently being parsed. So ignore the current character
2998 ** and skip to the next "?", "=" or "&", as appropriate. */
2999 while( (c = zUri[iIn])!=0 && c!='#'
3000 && (eState!=0 || c!='?')
3001 && (eState!=1 || (c!='=' && c!='&'))
3002 && (eState!=2 || c!='&')
3003 ){
3004 iIn++;
3005 }
3006 continue;
3007#else
3008 /* If ENABLE_URI_00_ERROR is defined, "%00" in a URI is an error. */
3009 *pzErrMsg = sqlite3_mprintf("unexpected %%00 in uri");
3010 rc = SQLITE_ERROR;
3011 goto parse_uri_out;
3012#endif
3013 }
3014 c = octet;
3015 }else if( eState==1 && (c=='&' || c=='=') ){
3016 if( zFile[iOut-1]==0 ){
3017 /* An empty option name. Ignore this option altogether. */
3018 while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++;
3019 continue;
3020 }
3021 if( c=='&' ){
3022 zFile[iOut++] = '\0';
3023 }else{
3024 eState = 2;
3025 }
3026 c = 0;
3027 }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
3028 c = 0;
3029 eState = 1;
3030 }
3031 zFile[iOut++] = c;
3032 }
3033 if( eState==1 ) zFile[iOut++] = '\0';
3034 memset(zFile+iOut, 0, 4); /* end-of-options + empty journal filenames */
3035
3036 /* Check if there were any options specified that should be interpreted
3037 ** here. Options that are interpreted here include "vfs" and those that
3038 ** correspond to flags that may be passed to the sqlite3_open_v2()
3039 ** method. */
3040 zOpt = &zFile[sqlite3Strlen30(zFile)+1];
3041 while( zOpt[0] ){
3042 int nOpt = sqlite3Strlen30(zOpt);
3043 char *zVal = &zOpt[nOpt+1];
3044 int nVal = sqlite3Strlen30(zVal);
3045
3046 if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){
3047 zVfs = zVal;
3048 }else{
3049 struct OpenMode {
3050 const char *z;
3051 int mode;
3052 } *aMode = 0;
3053 char *zModeType = 0;
3054 int mask = 0;
3055 int limit = 0;
3056
3057 if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){
3058 static struct OpenMode aCacheMode[] = {
3059 { "shared", SQLITE_OPEN_SHAREDCACHE },
3060 { "private", SQLITE_OPEN_PRIVATECACHE },
3061 { 0, 0 }
3062 };
3063
3064 mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE;
3065 aMode = aCacheMode;
3066 limit = mask;
3067 zModeType = "cache";
3068 }
3069 if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
3070 static struct OpenMode aOpenMode[] = {
3071 { "ro", SQLITE_OPEN_READONLY },
3072 { "rw", SQLITE_OPEN_READWRITE },
3073 { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE },
3074 { "memory", SQLITE_OPEN_MEMORY },
3075 { 0, 0 }
3076 };
3077
3078 mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE
3079 | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY;
3080 aMode = aOpenMode;
3081 limit = mask & flags;
3082 zModeType = "access";
3083 }
3084
3085 if( aMode ){
3086 int i;
3087 int mode = 0;
3088 for(i=0; aMode[i].z; i++){
3089 const char *z = aMode[i].z;
3090 if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
3091 mode = aMode[i].mode;
3092 break;
3093 }
3094 }
3095 if( mode==0 ){
3096 *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
3097 rc = SQLITE_ERROR;
3098 goto parse_uri_out;
3099 }
3100 if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){
3101 *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
3102 zModeType, zVal);
3103 rc = SQLITE_PERM;
3104 goto parse_uri_out;
3105 }
3106 flags = (flags & ~mask) | mode;
3107 }
3108 }
3109
3110 zOpt = &zVal[nVal+1];
3111 }
3112
3113 }else{
3114 zFile = sqlite3_malloc64(nUri+8);
3115 if( !zFile ) return SQLITE_NOMEM_BKPT;
3116 memset(zFile, 0, 4);
3117 zFile += 4;
3118 if( nUri ){
3119 memcpy(zFile, zUri, nUri);
3120 }
3121 memset(zFile+nUri, 0, 4);
3122 flags &= ~SQLITE_OPEN_URI;
3123 }
3124
3125 *ppVfs = sqlite3_vfs_find(zVfs);
3126 if( *ppVfs==0 ){
3127 *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs);
3128 rc = SQLITE_ERROR;
3129 }
3130 parse_uri_out:
3131 if( rc!=SQLITE_OK ){
3132 sqlite3_free_filename(zFile);
3133 zFile = 0;
3134 }
3135 *pFlags = flags;
3136 *pzFile = zFile;
3137 return rc;
3138}
3139
3140/*
3141** This routine does the core work of extracting URI parameters from a
3142** database filename for the sqlite3_uri_parameter() interface.
3143*/
3144static const char *uriParameter(const char *zFilename, const char *zParam){
3145 zFilename += sqlite3Strlen30(zFilename) + 1;
3146 while( ALWAYS(zFilename!=0) && zFilename[0] ){
3147 int x = strcmp(zFilename, zParam);
3148 zFilename += sqlite3Strlen30(zFilename) + 1;
3149 if( x==0 ) return zFilename;
3150 zFilename += sqlite3Strlen30(zFilename) + 1;
3151 }
3152 return 0;
3153}
3154
3155
3156
3157/*
3158** This routine does the work of opening a database on behalf of
3159** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
3160** is UTF-8 encoded.
3161*/
3162static int openDatabase(
3163 const char *zFilename, /* Database filename UTF-8 encoded */
3164 sqlite3 **ppDb, /* OUT: Returned database handle */
3165 unsigned int flags, /* Operational flags */
3166 const char *zVfs /* Name of the VFS to use */
3167){
3168 sqlite3 *db; /* Store allocated handle here */
3169 int rc; /* Return code */
3170 int isThreadsafe; /* True for threadsafe connections */
3171 char *zOpen = 0; /* Filename argument to pass to BtreeOpen() */
3172 char *zErrMsg = 0; /* Error message from sqlite3ParseUri() */
3173 int i; /* Loop counter */
3174
3175#ifdef SQLITE_ENABLE_API_ARMOR
3176 if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
3177#endif
3178 *ppDb = 0;
3179#ifndef SQLITE_OMIT_AUTOINIT
3180 rc = sqlite3_initialize();
3181 if( rc ) return rc;
3182#endif
3183
3184 if( sqlite3GlobalConfig.bCoreMutex==0 ){
3185 isThreadsafe = 0;
3186 }else if( flags & SQLITE_OPEN_NOMUTEX ){
3187 isThreadsafe = 0;
3188 }else if( flags & SQLITE_OPEN_FULLMUTEX ){
3189 isThreadsafe = 1;
3190 }else{
3191 isThreadsafe = sqlite3GlobalConfig.bFullMutex;
3192 }
3193
3194 if( flags & SQLITE_OPEN_PRIVATECACHE ){
3195 flags &= ~SQLITE_OPEN_SHAREDCACHE;
3196 }else if( sqlite3GlobalConfig.sharedCacheEnabled ){
3197 flags |= SQLITE_OPEN_SHAREDCACHE;
3198 }
3199
3200 /* Remove harmful bits from the flags parameter
3201 **
3202 ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
3203 ** dealt with in the previous code block. Besides these, the only
3204 ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
3205 ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
3206 ** SQLITE_OPEN_PRIVATECACHE, SQLITE_OPEN_EXRESCODE, and some reserved
3207 ** bits. Silently mask off all other flags.
3208 */
3209 flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
3210 SQLITE_OPEN_EXCLUSIVE |
3211 SQLITE_OPEN_MAIN_DB |
3212 SQLITE_OPEN_TEMP_DB |
3213 SQLITE_OPEN_TRANSIENT_DB |
3214 SQLITE_OPEN_MAIN_JOURNAL |
3215 SQLITE_OPEN_TEMP_JOURNAL |
3216 SQLITE_OPEN_SUBJOURNAL |
3217 SQLITE_OPEN_SUPER_JOURNAL |
3218 SQLITE_OPEN_NOMUTEX |
3219 SQLITE_OPEN_FULLMUTEX |
3220 SQLITE_OPEN_WAL
3221 );
3222
3223 /* Allocate the sqlite data structure */
3224 db = sqlite3MallocZero( sizeof(sqlite3) );
3225 if( db==0 ) goto opendb_out;
3226 if( isThreadsafe
3227#ifdef SQLITE_ENABLE_MULTITHREADED_CHECKS
3228 || sqlite3GlobalConfig.bCoreMutex
3229#endif
3230 ){
3231 db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
3232 if( db->mutex==0 ){
3233 sqlite3_free(db);
3234 db = 0;
3235 goto opendb_out;
3236 }
3237 if( isThreadsafe==0 ){
3238 sqlite3MutexWarnOnContention(db->mutex);
3239 }
3240 }
3241 sqlite3_mutex_enter(db->mutex);
3242 db->errMask = (flags & SQLITE_OPEN_EXRESCODE)!=0 ? 0xffffffff : 0xff;
3243 db->nDb = 2;
3244 db->eOpenState = SQLITE_STATE_BUSY;
3245 db->aDb = db->aDbStatic;
3246 db->lookaside.bDisable = 1;
3247 db->lookaside.sz = 0;
3248
3249 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
3250 memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
3251 db->aLimit[SQLITE_LIMIT_WORKER_THREADS] = SQLITE_DEFAULT_WORKER_THREADS;
3252 db->autoCommit = 1;
3253 db->nextAutovac = -1;
3254 db->szMmap = sqlite3GlobalConfig.szMmap;
3255 db->nextPagesize = 0;
3256 db->init.azInit = sqlite3StdType; /* Any array of string ptrs will do */
3257#ifdef SQLITE_ENABLE_SORTER_MMAP
3258 /* Beginning with version 3.37.0, using the VFS xFetch() API to memory-map
3259 ** the temporary files used to do external sorts (see code in vdbesort.c)
3260 ** is disabled. It can still be used either by defining
3261 ** SQLITE_ENABLE_SORTER_MMAP at compile time or by using the
3262 ** SQLITE_TESTCTRL_SORTER_MMAP test-control at runtime. */
3263 db->nMaxSorterMmap = 0x7FFFFFFF;
3264#endif
3265 db->flags |= SQLITE_ShortColNames
3266 | SQLITE_EnableTrigger
3267 | SQLITE_EnableView
3268 | SQLITE_CacheSpill
3269#if !defined(SQLITE_TRUSTED_SCHEMA) || SQLITE_TRUSTED_SCHEMA+0!=0
3270 | SQLITE_TrustedSchema
3271#endif
3272/* The SQLITE_DQS compile-time option determines the default settings
3273** for SQLITE_DBCONFIG_DQS_DDL and SQLITE_DBCONFIG_DQS_DML.
3274**
3275** SQLITE_DQS SQLITE_DBCONFIG_DQS_DDL SQLITE_DBCONFIG_DQS_DML
3276** ---------- ----------------------- -----------------------
3277** undefined on on
3278** 3 on on
3279** 2 on off
3280** 1 off on
3281** 0 off off
3282**
3283** Legacy behavior is 3 (double-quoted string literals are allowed anywhere)
3284** and so that is the default. But developers are encouranged to use
3285** -DSQLITE_DQS=0 (best) or -DSQLITE_DQS=1 (second choice) if possible.
3286*/
3287#if !defined(SQLITE_DQS)
3288# define SQLITE_DQS 3
3289#endif
3290#if (SQLITE_DQS&1)==1
3291 | SQLITE_DqsDML
3292#endif
3293#if (SQLITE_DQS&2)==2
3294 | SQLITE_DqsDDL
3295#endif
3296
3297#if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX
3298 | SQLITE_AutoIndex
3299#endif
3300#if SQLITE_DEFAULT_CKPTFULLFSYNC
3301 | SQLITE_CkptFullFSync
3302#endif
3303#if SQLITE_DEFAULT_FILE_FORMAT<4
3304 | SQLITE_LegacyFileFmt
3305#endif
3306#ifdef SQLITE_ENABLE_LOAD_EXTENSION
3307 | SQLITE_LoadExtension
3308#endif
3309#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
3310 | SQLITE_RecTriggers
3311#endif
3312#if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS
3313 | SQLITE_ForeignKeys
3314#endif
3315#if defined(SQLITE_REVERSE_UNORDERED_SELECTS)
3316 | SQLITE_ReverseOrder
3317#endif
3318#if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
3319 | SQLITE_CellSizeCk
3320#endif
3321#if defined(SQLITE_ENABLE_FTS3_TOKENIZER)
3322 | SQLITE_Fts3Tokenizer
3323#endif
3324#if defined(SQLITE_ENABLE_QPSG)
3325 | SQLITE_EnableQPSG
3326#endif
3327#if defined(SQLITE_DEFAULT_DEFENSIVE)
3328 | SQLITE_Defensive
3329#endif
3330#if defined(SQLITE_DEFAULT_LEGACY_ALTER_TABLE)
3331 | SQLITE_LegacyAlter
3332#endif
3333 ;
3334 sqlite3HashInit(&db->aCollSeq);
3335#ifndef SQLITE_OMIT_VIRTUALTABLE
3336 sqlite3HashInit(&db->aModule);
3337#endif
3338
3339 /* Add the default collation sequence BINARY. BINARY works for both UTF-8
3340 ** and UTF-16, so add a version for each to avoid any unnecessary
3341 ** conversions. The only error that can occur here is a malloc() failure.
3342 **
3343 ** EVIDENCE-OF: R-52786-44878 SQLite defines three built-in collating
3344 ** functions:
3345 */
3346 createCollation(db, sqlite3StrBINARY, SQLITE_UTF8, 0, binCollFunc, 0);
3347 createCollation(db, sqlite3StrBINARY, SQLITE_UTF16BE, 0, binCollFunc, 0);
3348 createCollation(db, sqlite3StrBINARY, SQLITE_UTF16LE, 0, binCollFunc, 0);
3349 createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
3350 createCollation(db, "RTRIM", SQLITE_UTF8, 0, rtrimCollFunc, 0);
3351 if( db->mallocFailed ){
3352 goto opendb_out;
3353 }
3354
3355#if SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL)
3356 /* Process magic filenames ":localStorage:" and ":sessionStorage:" */
3357 if( zFilename && zFilename[0]==':' ){
3358 if( strcmp(zFilename, ":localStorage:")==0 ){
3359 zFilename = "file:local?vfs=kvvfs";
3360 flags |= SQLITE_OPEN_URI;
3361 }else if( strcmp(zFilename, ":sessionStorage:")==0 ){
3362 zFilename = "file:session?vfs=kvvfs";
3363 flags |= SQLITE_OPEN_URI;
3364 }
3365 }
3366#endif /* SQLITE_OS_UNIX && defined(SQLITE_OS_KV_OPTIONAL) */
3367
3368 /* Parse the filename/URI argument
3369 **
3370 ** Only allow sensible combinations of bits in the flags argument.
3371 ** Throw an error if any non-sense combination is used. If we
3372 ** do not block illegal combinations here, it could trigger
3373 ** assert() statements in deeper layers. Sensible combinations
3374 ** are:
3375 **
3376 ** 1: SQLITE_OPEN_READONLY
3377 ** 2: SQLITE_OPEN_READWRITE
3378 ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
3379 */
3380 db->openFlags = flags;
3381 assert( SQLITE_OPEN_READONLY == 0x01 );
3382 assert( SQLITE_OPEN_READWRITE == 0x02 );
3383 assert( SQLITE_OPEN_CREATE == 0x04 );
3384 testcase( (1<<(flags&7))==0x02 ); /* READONLY */
3385 testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
3386 testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
3387 if( ((1<<(flags&7)) & 0x46)==0 ){
3388 rc = SQLITE_MISUSE_BKPT; /* IMP: R-18321-05872 */
3389 }else{
3390 rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
3391 }
3392 if( rc!=SQLITE_OK ){
3393 if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
3394 sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
3395 sqlite3_free(zErrMsg);
3396 goto opendb_out;
3397 }
3398 assert( db->pVfs!=0 );
3399#if SQLITE_OS_KV || defined(SQLITE_OS_KV_OPTIONAL)
3400 if( sqlite3_stricmp(db->pVfs->zName, "kvvfs")==0 ){
3401 db->temp_store = 2;
3402 }
3403#endif
3404
3405 /* Open the backend database driver */
3406 rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
3407 flags | SQLITE_OPEN_MAIN_DB);
3408 if( rc!=SQLITE_OK ){
3409 if( rc==SQLITE_IOERR_NOMEM ){
3410 rc = SQLITE_NOMEM_BKPT;
3411 }
3412 sqlite3Error(db, rc);
3413 goto opendb_out;
3414 }
3415 sqlite3BtreeEnter(db->aDb[0].pBt);
3416 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
3417 if( !db->mallocFailed ){
3418 sqlite3SetTextEncoding(db, SCHEMA_ENC(db));
3419 }
3420 sqlite3BtreeLeave(db->aDb[0].pBt);
3421 db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
3422
3423 /* The default safety_level for the main database is FULL; for the temp
3424 ** database it is OFF. This matches the pager layer defaults.
3425 */
3426 db->aDb[0].zDbSName = "main";
3427 db->aDb[0].safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
3428 db->aDb[1].zDbSName = "temp";
3429 db->aDb[1].safety_level = PAGER_SYNCHRONOUS_OFF;
3430
3431 db->eOpenState = SQLITE_STATE_OPEN;
3432 if( db->mallocFailed ){
3433 goto opendb_out;
3434 }
3435
3436 /* Register all built-in functions, but do not attempt to read the
3437 ** database schema yet. This is delayed until the first time the database
3438 ** is accessed.
3439 */
3440 sqlite3Error(db, SQLITE_OK);
3441 sqlite3RegisterPerConnectionBuiltinFunctions(db);
3442 rc = sqlite3_errcode(db);
3443
3444
3445 /* Load compiled-in extensions */
3446 for(i=0; rc==SQLITE_OK && i<ArraySize(sqlite3BuiltinExtensions); i++){
3447 rc = sqlite3BuiltinExtensions[i](db);
3448 }
3449
3450 /* Load automatic extensions - extensions that have been registered
3451 ** using the sqlite3_automatic_extension() API.
3452 */
3453 if( rc==SQLITE_OK ){
3454 sqlite3AutoLoadExtensions(db);
3455 rc = sqlite3_errcode(db);
3456 if( rc!=SQLITE_OK ){
3457 goto opendb_out;
3458 }
3459 }
3460
3461#ifdef SQLITE_ENABLE_INTERNAL_FUNCTIONS
3462 /* Testing use only!!! The -DSQLITE_ENABLE_INTERNAL_FUNCTIONS=1 compile-time
3463 ** option gives access to internal functions by default.
3464 ** Testing use only!!! */
3465 db->mDbFlags |= DBFLAG_InternalFunc;
3466#endif
3467
3468 /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
3469 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
3470 ** mode. Doing nothing at all also makes NORMAL the default.
3471 */
3472#ifdef SQLITE_DEFAULT_LOCKING_MODE
3473 db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
3474 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
3475 SQLITE_DEFAULT_LOCKING_MODE);
3476#endif
3477
3478 if( rc ) sqlite3Error(db, rc);
3479
3480 /* Enable the lookaside-malloc subsystem */
3481 setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside,
3482 sqlite3GlobalConfig.nLookaside);
3483
3484 sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT);
3485
3486opendb_out:
3487 if( db ){
3488 assert( db->mutex!=0 || isThreadsafe==0
3489 || sqlite3GlobalConfig.bFullMutex==0 );
3490 sqlite3_mutex_leave(db->mutex);
3491 }
3492 rc = sqlite3_errcode(db);
3493 assert( db!=0 || (rc&0xff)==SQLITE_NOMEM );
3494 if( (rc&0xff)==SQLITE_NOMEM ){
3495 sqlite3_close(db);
3496 db = 0;
3497 }else if( rc!=SQLITE_OK ){
3498 db->eOpenState = SQLITE_STATE_SICK;
3499 }
3500 *ppDb = db;
3501#ifdef SQLITE_ENABLE_SQLLOG
3502 if( sqlite3GlobalConfig.xSqllog ){
3503 /* Opening a db handle. Fourth parameter is passed 0. */
3504 void *pArg = sqlite3GlobalConfig.pSqllogArg;
3505 sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0);
3506 }
3507#endif
3508 sqlite3_free_filename(zOpen);
3509 return rc;
3510}
3511
3512
3513/*
3514** Open a new database handle.
3515*/
3516int sqlite3_open(
3517 const char *zFilename,
3518 sqlite3 **ppDb
3519){
3520 return openDatabase(zFilename, ppDb,
3521 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
3522}
3523int sqlite3_open_v2(
3524 const char *filename, /* Database filename (UTF-8) */
3525 sqlite3 **ppDb, /* OUT: SQLite db handle */
3526 int flags, /* Flags */
3527 const char *zVfs /* Name of VFS module to use */
3528){
3529 return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
3530}
3531
3532#ifndef SQLITE_OMIT_UTF16
3533/*
3534** Open a new database handle.
3535*/
3536int sqlite3_open16(
3537 const void *zFilename,
3538 sqlite3 **ppDb
3539){
3540 char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
3541 sqlite3_value *pVal;
3542 int rc;
3543
3544#ifdef SQLITE_ENABLE_API_ARMOR
3545 if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
3546#endif
3547 *ppDb = 0;
3548#ifndef SQLITE_OMIT_AUTOINIT
3549 rc = sqlite3_initialize();
3550 if( rc ) return rc;
3551#endif
3552 if( zFilename==0 ) zFilename = "\000\000";
3553 pVal = sqlite3ValueNew(0);
3554 sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
3555 zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
3556 if( zFilename8 ){
3557 rc = openDatabase(zFilename8, ppDb,
3558 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
3559 assert( *ppDb || rc==SQLITE_NOMEM );
3560 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
3561 SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE;
3562 }
3563 }else{
3564 rc = SQLITE_NOMEM_BKPT;
3565 }
3566 sqlite3ValueFree(pVal);
3567
3568 return rc & 0xff;
3569}
3570#endif /* SQLITE_OMIT_UTF16 */
3571
3572/*
3573** Register a new collation sequence with the database handle db.
3574*/
3575int sqlite3_create_collation(
3576 sqlite3* db,
3577 const char *zName,
3578 int enc,
3579 void* pCtx,
3580 int(*xCompare)(void*,int,const void*,int,const void*)
3581){
3582 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
3583}
3584
3585/*
3586** Register a new collation sequence with the database handle db.
3587*/
3588int sqlite3_create_collation_v2(
3589 sqlite3* db,
3590 const char *zName,
3591 int enc,
3592 void* pCtx,
3593 int(*xCompare)(void*,int,const void*,int,const void*),
3594 void(*xDel)(void*)
3595){
3596 int rc;
3597
3598#ifdef SQLITE_ENABLE_API_ARMOR
3599 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
3600#endif
3601 sqlite3_mutex_enter(db->mutex);
3602 assert( !db->mallocFailed );
3603 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
3604 rc = sqlite3ApiExit(db, rc);
3605 sqlite3_mutex_leave(db->mutex);
3606 return rc;
3607}
3608
3609#ifndef SQLITE_OMIT_UTF16
3610/*
3611** Register a new collation sequence with the database handle db.
3612*/
3613int sqlite3_create_collation16(
3614 sqlite3* db,
3615 const void *zName,
3616 int enc,
3617 void* pCtx,
3618 int(*xCompare)(void*,int,const void*,int,const void*)
3619){
3620 int rc = SQLITE_OK;
3621 char *zName8;
3622
3623#ifdef SQLITE_ENABLE_API_ARMOR
3624 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
3625#endif
3626 sqlite3_mutex_enter(db->mutex);
3627 assert( !db->mallocFailed );
3628 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
3629 if( zName8 ){
3630 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
3631 sqlite3DbFree(db, zName8);
3632 }
3633 rc = sqlite3ApiExit(db, rc);
3634 sqlite3_mutex_leave(db->mutex);
3635 return rc;
3636}
3637#endif /* SQLITE_OMIT_UTF16 */
3638
3639/*
3640** Register a collation sequence factory callback with the database handle
3641** db. Replace any previously installed collation sequence factory.
3642*/
3643int sqlite3_collation_needed(
3644 sqlite3 *db,
3645 void *pCollNeededArg,
3646 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
3647){
3648#ifdef SQLITE_ENABLE_API_ARMOR
3649 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3650#endif
3651 sqlite3_mutex_enter(db->mutex);
3652 db->xCollNeeded = xCollNeeded;
3653 db->xCollNeeded16 = 0;
3654 db->pCollNeededArg = pCollNeededArg;
3655 sqlite3_mutex_leave(db->mutex);
3656 return SQLITE_OK;
3657}
3658
3659#ifndef SQLITE_OMIT_UTF16
3660/*
3661** Register a collation sequence factory callback with the database handle
3662** db. Replace any previously installed collation sequence factory.
3663*/
3664int sqlite3_collation_needed16(
3665 sqlite3 *db,
3666 void *pCollNeededArg,
3667 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
3668){
3669#ifdef SQLITE_ENABLE_API_ARMOR
3670 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3671#endif
3672 sqlite3_mutex_enter(db->mutex);
3673 db->xCollNeeded = 0;
3674 db->xCollNeeded16 = xCollNeeded16;
3675 db->pCollNeededArg = pCollNeededArg;
3676 sqlite3_mutex_leave(db->mutex);
3677 return SQLITE_OK;
3678}
3679#endif /* SQLITE_OMIT_UTF16 */
3680
3681#ifndef SQLITE_OMIT_DEPRECATED
3682/*
3683** This function is now an anachronism. It used to be used to recover from a
3684** malloc() failure, but SQLite now does this automatically.
3685*/
3686int sqlite3_global_recover(void){
3687 return SQLITE_OK;
3688}
3689#endif
3690
3691/*
3692** Test to see whether or not the database connection is in autocommit
3693** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
3694** by default. Autocommit is disabled by a BEGIN statement and reenabled
3695** by the next COMMIT or ROLLBACK.
3696*/
3697int sqlite3_get_autocommit(sqlite3 *db){
3698#ifdef SQLITE_ENABLE_API_ARMOR
3699 if( !sqlite3SafetyCheckOk(db) ){
3700 (void)SQLITE_MISUSE_BKPT;
3701 return 0;
3702 }
3703#endif
3704 return db->autoCommit;
3705}
3706
3707/*
3708** The following routines are substitutes for constants SQLITE_CORRUPT,
3709** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_NOMEM and possibly other error
3710** constants. They serve two purposes:
3711**
3712** 1. Serve as a convenient place to set a breakpoint in a debugger
3713** to detect when version error conditions occurs.
3714**
3715** 2. Invoke sqlite3_log() to provide the source code location where
3716** a low-level error is first detected.
3717*/
3718int sqlite3ReportError(int iErr, int lineno, const char *zType){
3719 sqlite3_log(iErr, "%s at line %d of [%.10s]",
3720 zType, lineno, 20+sqlite3_sourceid());
3721 return iErr;
3722}
3723int sqlite3CorruptError(int lineno){
3724 testcase( sqlite3GlobalConfig.xLog!=0 );
3725 return sqlite3ReportError(SQLITE_CORRUPT, lineno, "database corruption");
3726}
3727int sqlite3MisuseError(int lineno){
3728 testcase( sqlite3GlobalConfig.xLog!=0 );
3729 return sqlite3ReportError(SQLITE_MISUSE, lineno, "misuse");
3730}
3731int sqlite3CantopenError(int lineno){
3732 testcase( sqlite3GlobalConfig.xLog!=0 );
3733 return sqlite3ReportError(SQLITE_CANTOPEN, lineno, "cannot open file");
3734}
3735#if defined(SQLITE_DEBUG) || defined(SQLITE_ENABLE_CORRUPT_PGNO)
3736int sqlite3CorruptPgnoError(int lineno, Pgno pgno){
3737 char zMsg[100];
3738 sqlite3_snprintf(sizeof(zMsg), zMsg, "database corruption page %d", pgno);
3739 testcase( sqlite3GlobalConfig.xLog!=0 );
3740 return sqlite3ReportError(SQLITE_CORRUPT, lineno, zMsg);
3741}
3742#endif
3743#ifdef SQLITE_DEBUG
3744int sqlite3NomemError(int lineno){
3745 testcase( sqlite3GlobalConfig.xLog!=0 );
3746 return sqlite3ReportError(SQLITE_NOMEM, lineno, "OOM");
3747}
3748int sqlite3IoerrnomemError(int lineno){
3749 testcase( sqlite3GlobalConfig.xLog!=0 );
3750 return sqlite3ReportError(SQLITE_IOERR_NOMEM, lineno, "I/O OOM error");
3751}
3752#endif
3753
3754#ifndef SQLITE_OMIT_DEPRECATED
3755/*
3756** This is a convenience routine that makes sure that all thread-specific
3757** data for this thread has been deallocated.
3758**
3759** SQLite no longer uses thread-specific data so this routine is now a
3760** no-op. It is retained for historical compatibility.
3761*/
3762void sqlite3_thread_cleanup(void){
3763}
3764#endif
3765
3766/*
3767** Return meta information about a specific column of a database table.
3768** See comment in sqlite3.h (sqlite.h.in) for details.
3769*/
3770int sqlite3_table_column_metadata(
3771 sqlite3 *db, /* Connection handle */
3772 const char *zDbName, /* Database name or NULL */
3773 const char *zTableName, /* Table name */
3774 const char *zColumnName, /* Column name */
3775 char const **pzDataType, /* OUTPUT: Declared data type */
3776 char const **pzCollSeq, /* OUTPUT: Collation sequence name */
3777 int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
3778 int *pPrimaryKey, /* OUTPUT: True if column part of PK */
3779 int *pAutoinc /* OUTPUT: True if column is auto-increment */
3780){
3781 int rc;
3782 char *zErrMsg = 0;
3783 Table *pTab = 0;
3784 Column *pCol = 0;
3785 int iCol = 0;
3786 char const *zDataType = 0;
3787 char const *zCollSeq = 0;
3788 int notnull = 0;
3789 int primarykey = 0;
3790 int autoinc = 0;
3791
3792
3793#ifdef SQLITE_ENABLE_API_ARMOR
3794 if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
3795 return SQLITE_MISUSE_BKPT;
3796 }
3797#endif
3798
3799 /* Ensure the database schema has been loaded */
3800 sqlite3_mutex_enter(db->mutex);
3801 sqlite3BtreeEnterAll(db);
3802 rc = sqlite3Init(db, &zErrMsg);
3803 if( SQLITE_OK!=rc ){
3804 goto error_out;
3805 }
3806
3807 /* Locate the table in question */
3808 pTab = sqlite3FindTable(db, zTableName, zDbName);
3809 if( !pTab || IsView(pTab) ){
3810 pTab = 0;
3811 goto error_out;
3812 }
3813
3814 /* Find the column for which info is requested */
3815 if( zColumnName==0 ){
3816 /* Query for existance of table only */
3817 }else{
3818 for(iCol=0; iCol<pTab->nCol; iCol++){
3819 pCol = &pTab->aCol[iCol];
3820 if( 0==sqlite3StrICmp(pCol->zCnName, zColumnName) ){
3821 break;
3822 }
3823 }
3824 if( iCol==pTab->nCol ){
3825 if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){
3826 iCol = pTab->iPKey;
3827 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
3828 }else{
3829 pTab = 0;
3830 goto error_out;
3831 }
3832 }
3833 }
3834
3835 /* The following block stores the meta information that will be returned
3836 ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
3837 ** and autoinc. At this point there are two possibilities:
3838 **
3839 ** 1. The specified column name was rowid", "oid" or "_rowid_"
3840 ** and there is no explicitly declared IPK column.
3841 **
3842 ** 2. The table is not a view and the column name identified an
3843 ** explicitly declared column. Copy meta information from *pCol.
3844 */
3845 if( pCol ){
3846 zDataType = sqlite3ColumnType(pCol,0);
3847 zCollSeq = sqlite3ColumnColl(pCol);
3848 notnull = pCol->notNull!=0;
3849 primarykey = (pCol->colFlags & COLFLAG_PRIMKEY)!=0;
3850 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
3851 }else{
3852 zDataType = "INTEGER";
3853 primarykey = 1;
3854 }
3855 if( !zCollSeq ){
3856 zCollSeq = sqlite3StrBINARY;
3857 }
3858
3859error_out:
3860 sqlite3BtreeLeaveAll(db);
3861
3862 /* Whether the function call succeeded or failed, set the output parameters
3863 ** to whatever their local counterparts contain. If an error did occur,
3864 ** this has the effect of zeroing all output parameters.
3865 */
3866 if( pzDataType ) *pzDataType = zDataType;
3867 if( pzCollSeq ) *pzCollSeq = zCollSeq;
3868 if( pNotNull ) *pNotNull = notnull;
3869 if( pPrimaryKey ) *pPrimaryKey = primarykey;
3870 if( pAutoinc ) *pAutoinc = autoinc;
3871
3872 if( SQLITE_OK==rc && !pTab ){
3873 sqlite3DbFree(db, zErrMsg);
3874 zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
3875 zColumnName);
3876 rc = SQLITE_ERROR;
3877 }
3878 sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg);
3879 sqlite3DbFree(db, zErrMsg);
3880 rc = sqlite3ApiExit(db, rc);
3881 sqlite3_mutex_leave(db->mutex);
3882 return rc;
3883}
3884
3885/*
3886** Sleep for a little while. Return the amount of time slept.
3887*/
3888int sqlite3_sleep(int ms){
3889 sqlite3_vfs *pVfs;
3890 int rc;
3891 pVfs = sqlite3_vfs_find(0);
3892 if( pVfs==0 ) return 0;
3893
3894 /* This function works in milliseconds, but the underlying OsSleep()
3895 ** API uses microseconds. Hence the 1000's.
3896 */
3897 rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
3898 return rc;
3899}
3900
3901/*
3902** Enable or disable the extended result codes.
3903*/
3904int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
3905#ifdef SQLITE_ENABLE_API_ARMOR
3906 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3907#endif
3908 sqlite3_mutex_enter(db->mutex);
3909 db->errMask = onoff ? 0xffffffff : 0xff;
3910 sqlite3_mutex_leave(db->mutex);
3911 return SQLITE_OK;
3912}
3913
3914/*
3915** Invoke the xFileControl method on a particular database.
3916*/
3917int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
3918 int rc = SQLITE_ERROR;
3919 Btree *pBtree;
3920
3921#ifdef SQLITE_ENABLE_API_ARMOR
3922 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3923#endif
3924 sqlite3_mutex_enter(db->mutex);
3925 pBtree = sqlite3DbNameToBtree(db, zDbName);
3926 if( pBtree ){
3927 Pager *pPager;
3928 sqlite3_file *fd;
3929 sqlite3BtreeEnter(pBtree);
3930 pPager = sqlite3BtreePager(pBtree);
3931 assert( pPager!=0 );
3932 fd = sqlite3PagerFile(pPager);
3933 assert( fd!=0 );
3934 if( op==SQLITE_FCNTL_FILE_POINTER ){
3935 *(sqlite3_file**)pArg = fd;
3936 rc = SQLITE_OK;
3937 }else if( op==SQLITE_FCNTL_VFS_POINTER ){
3938 *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager);
3939 rc = SQLITE_OK;
3940 }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){
3941 *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
3942 rc = SQLITE_OK;
3943 }else if( op==SQLITE_FCNTL_DATA_VERSION ){
3944 *(unsigned int*)pArg = sqlite3PagerDataVersion(pPager);
3945 rc = SQLITE_OK;
3946 }else if( op==SQLITE_FCNTL_RESERVE_BYTES ){
3947 int iNew = *(int*)pArg;
3948 *(int*)pArg = sqlite3BtreeGetRequestedReserve(pBtree);
3949 if( iNew>=0 && iNew<=255 ){
3950 sqlite3BtreeSetPageSize(pBtree, 0, iNew, 0);
3951 }
3952 rc = SQLITE_OK;
3953 }else if( op==SQLITE_FCNTL_RESET_CACHE ){
3954 sqlite3BtreeClearCache(pBtree);
3955 rc = SQLITE_OK;
3956 }else{
3957 int nSave = db->busyHandler.nBusy;
3958 rc = sqlite3OsFileControl(fd, op, pArg);
3959 db->busyHandler.nBusy = nSave;
3960 }
3961 sqlite3BtreeLeave(pBtree);
3962 }
3963 sqlite3_mutex_leave(db->mutex);
3964 return rc;
3965}
3966
3967/*
3968** Interface to the testing logic.
3969*/
3970int sqlite3_test_control(int op, ...){
3971 int rc = 0;
3972#ifdef SQLITE_UNTESTABLE
3973 UNUSED_PARAMETER(op);
3974#else
3975 va_list ap;
3976 va_start(ap, op);
3977 switch( op ){
3978
3979 /*
3980 ** Save the current state of the PRNG.
3981 */
3982 case SQLITE_TESTCTRL_PRNG_SAVE: {
3983 sqlite3PrngSaveState();
3984 break;
3985 }
3986
3987 /*
3988 ** Restore the state of the PRNG to the last state saved using
3989 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
3990 ** this verb acts like PRNG_RESET.
3991 */
3992 case SQLITE_TESTCTRL_PRNG_RESTORE: {
3993 sqlite3PrngRestoreState();
3994 break;
3995 }
3996
3997 /* sqlite3_test_control(SQLITE_TESTCTRL_PRNG_SEED, int x, sqlite3 *db);
3998 **
3999 ** Control the seed for the pseudo-random number generator (PRNG) that
4000 ** is built into SQLite. Cases:
4001 **
4002 ** x!=0 && db!=0 Seed the PRNG to the current value of the
4003 ** schema cookie in the main database for db, or
4004 ** x if the schema cookie is zero. This case
4005 ** is convenient to use with database fuzzers
4006 ** as it allows the fuzzer some control over the
4007 ** the PRNG seed.
4008 **
4009 ** x!=0 && db==0 Seed the PRNG to the value of x.
4010 **
4011 ** x==0 && db==0 Revert to default behavior of using the
4012 ** xRandomness method on the primary VFS.
4013 **
4014 ** This test-control also resets the PRNG so that the new seed will
4015 ** be used for the next call to sqlite3_randomness().
4016 */
4017#ifndef SQLITE_OMIT_WSD
4018 case SQLITE_TESTCTRL_PRNG_SEED: {
4019 int x = va_arg(ap, int);
4020 int y;
4021 sqlite3 *db = va_arg(ap, sqlite3*);
4022 assert( db==0 || db->aDb[0].pSchema!=0 );
4023 if( db && (y = db->aDb[0].pSchema->schema_cookie)!=0 ){ x = y; }
4024 sqlite3Config.iPrngSeed = x;
4025 sqlite3_randomness(0,0);
4026 break;
4027 }
4028#endif
4029
4030 /*
4031 ** sqlite3_test_control(BITVEC_TEST, size, program)
4032 **
4033 ** Run a test against a Bitvec object of size. The program argument
4034 ** is an array of integers that defines the test. Return -1 on a
4035 ** memory allocation error, 0 on success, or non-zero for an error.
4036 ** See the sqlite3BitvecBuiltinTest() for additional information.
4037 */
4038 case SQLITE_TESTCTRL_BITVEC_TEST: {
4039 int sz = va_arg(ap, int);
4040 int *aProg = va_arg(ap, int*);
4041 rc = sqlite3BitvecBuiltinTest(sz, aProg);
4042 break;
4043 }
4044
4045 /*
4046 ** sqlite3_test_control(FAULT_INSTALL, xCallback)
4047 **
4048 ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called,
4049 ** if xCallback is not NULL.
4050 **
4051 ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0)
4052 ** is called immediately after installing the new callback and the return
4053 ** value from sqlite3FaultSim(0) becomes the return from
4054 ** sqlite3_test_control().
4055 */
4056 case SQLITE_TESTCTRL_FAULT_INSTALL: {
4057 /* A bug in MSVC prevents it from understanding pointers to functions
4058 ** types in the second argument to va_arg(). Work around the problem
4059 ** using a typedef.
4060 ** http://support.microsoft.com/kb/47961 <-- dead hyperlink
4061 ** Search at http://web.archive.org/ to find the 2015-03-16 archive
4062 ** of the link above to see the original text.
4063 ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
4064 */
4065 typedef int(*sqlite3FaultFuncType)(int);
4066 sqlite3GlobalConfig.xTestCallback = va_arg(ap, sqlite3FaultFuncType);
4067 rc = sqlite3FaultSim(0);
4068 break;
4069 }
4070
4071 /*
4072 ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
4073 **
4074 ** Register hooks to call to indicate which malloc() failures
4075 ** are benign.
4076 */
4077 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
4078 typedef void (*void_function)(void);
4079 void_function xBenignBegin;
4080 void_function xBenignEnd;
4081 xBenignBegin = va_arg(ap, void_function);
4082 xBenignEnd = va_arg(ap, void_function);
4083 sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
4084 break;
4085 }
4086
4087 /*
4088 ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
4089 **
4090 ** Set the PENDING byte to the value in the argument, if X>0.
4091 ** Make no changes if X==0. Return the value of the pending byte
4092 ** as it existing before this routine was called.
4093 **
4094 ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in
4095 ** an incompatible database file format. Changing the PENDING byte
4096 ** while any database connection is open results in undefined and
4097 ** deleterious behavior.
4098 */
4099 case SQLITE_TESTCTRL_PENDING_BYTE: {
4100 rc = PENDING_BYTE;
4101#ifndef SQLITE_OMIT_WSD
4102 {
4103 unsigned int newVal = va_arg(ap, unsigned int);
4104 if( newVal ) sqlite3PendingByte = newVal;
4105 }
4106#endif
4107 break;
4108 }
4109
4110 /*
4111 ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
4112 **
4113 ** This action provides a run-time test to see whether or not
4114 ** assert() was enabled at compile-time. If X is true and assert()
4115 ** is enabled, then the return value is true. If X is true and
4116 ** assert() is disabled, then the return value is zero. If X is
4117 ** false and assert() is enabled, then the assertion fires and the
4118 ** process aborts. If X is false and assert() is disabled, then the
4119 ** return value is zero.
4120 */
4121 case SQLITE_TESTCTRL_ASSERT: {
4122 volatile int x = 0;
4123 assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 );
4124 rc = x;
4125#if defined(SQLITE_DEBUG)
4126 /* Invoke these debugging routines so that the compiler does not
4127 ** issue "defined but not used" warnings. */
4128 if( x==9999 ){
4129 sqlite3ShowExpr(0);
4130 sqlite3ShowExpr(0);
4131 sqlite3ShowExprList(0);
4132 sqlite3ShowIdList(0);
4133 sqlite3ShowSrcList(0);
4134 sqlite3ShowWith(0);
4135 sqlite3ShowUpsert(0);
4136 sqlite3ShowTriggerStep(0);
4137 sqlite3ShowTriggerStepList(0);
4138 sqlite3ShowTrigger(0);
4139 sqlite3ShowTriggerList(0);
4140#ifndef SQLITE_OMIT_WINDOWFUNC
4141 sqlite3ShowWindow(0);
4142 sqlite3ShowWinFunc(0);
4143#endif
4144 sqlite3ShowSelect(0);
4145 }
4146#endif
4147 break;
4148 }
4149
4150
4151 /*
4152 ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
4153 **
4154 ** This action provides a run-time test to see how the ALWAYS and
4155 ** NEVER macros were defined at compile-time.
4156 **
4157 ** The return value is ALWAYS(X) if X is true, or 0 if X is false.
4158 **
4159 ** The recommended test is X==2. If the return value is 2, that means
4160 ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
4161 ** default setting. If the return value is 1, then ALWAYS() is either
4162 ** hard-coded to true or else it asserts if its argument is false.
4163 ** The first behavior (hard-coded to true) is the case if
4164 ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
4165 ** behavior (assert if the argument to ALWAYS() is false) is the case if
4166 ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
4167 **
4168 ** The run-time test procedure might look something like this:
4169 **
4170 ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
4171 ** // ALWAYS() and NEVER() are no-op pass-through macros
4172 ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
4173 ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
4174 ** }else{
4175 ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0.
4176 ** }
4177 */
4178 case SQLITE_TESTCTRL_ALWAYS: {
4179 int x = va_arg(ap,int);
4180 rc = x ? ALWAYS(x) : 0;
4181 break;
4182 }
4183
4184 /*
4185 ** sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER);
4186 **
4187 ** The integer returned reveals the byte-order of the computer on which
4188 ** SQLite is running:
4189 **
4190 ** 1 big-endian, determined at run-time
4191 ** 10 little-endian, determined at run-time
4192 ** 432101 big-endian, determined at compile-time
4193 ** 123410 little-endian, determined at compile-time
4194 */
4195 case SQLITE_TESTCTRL_BYTEORDER: {
4196 rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN;
4197 break;
4198 }
4199
4200 /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
4201 **
4202 ** Enable or disable various optimizations for testing purposes. The
4203 ** argument N is a bitmask of optimizations to be disabled. For normal
4204 ** operation N should be 0. The idea is that a test program (like the
4205 ** SQL Logic Test or SLT test module) can run the same SQL multiple times
4206 ** with various optimizations disabled to verify that the same answer
4207 ** is obtained in every case.
4208 */
4209 case SQLITE_TESTCTRL_OPTIMIZATIONS: {
4210 sqlite3 *db = va_arg(ap, sqlite3*);
4211 db->dbOptFlags = va_arg(ap, u32);
4212 break;
4213 }
4214
4215 /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, onoff, xAlt);
4216 **
4217 ** If parameter onoff is 1, subsequent calls to localtime() fail.
4218 ** If 2, then invoke xAlt() instead of localtime(). If 0, normal
4219 ** processing.
4220 **
4221 ** xAlt arguments are void pointers, but they really want to be:
4222 **
4223 ** int xAlt(const time_t*, struct tm*);
4224 **
4225 ** xAlt should write results in to struct tm object of its 2nd argument
4226 ** and return zero on success, or return non-zero on failure.
4227 */
4228 case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
4229 sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
4230 if( sqlite3GlobalConfig.bLocaltimeFault==2 ){
4231 typedef int(*sqlite3LocaltimeType)(const void*,void*);
4232 sqlite3GlobalConfig.xAltLocaltime = va_arg(ap, sqlite3LocaltimeType);
4233 }else{
4234 sqlite3GlobalConfig.xAltLocaltime = 0;
4235 }
4236 break;
4237 }
4238
4239 /* sqlite3_test_control(SQLITE_TESTCTRL_INTERNAL_FUNCTIONS, sqlite3*);
4240 **
4241 ** Toggle the ability to use internal functions on or off for
4242 ** the database connection given in the argument.
4243 */
4244 case SQLITE_TESTCTRL_INTERNAL_FUNCTIONS: {
4245 sqlite3 *db = va_arg(ap, sqlite3*);
4246 db->mDbFlags ^= DBFLAG_InternalFunc;
4247 break;
4248 }
4249
4250 /* sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
4251 **
4252 ** Set or clear a flag that indicates that the database file is always well-
4253 ** formed and never corrupt. This flag is clear by default, indicating that
4254 ** database files might have arbitrary corruption. Setting the flag during
4255 ** testing causes certain assert() statements in the code to be activated
4256 ** that demonstrat invariants on well-formed database files.
4257 */
4258 case SQLITE_TESTCTRL_NEVER_CORRUPT: {
4259 sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int);
4260 break;
4261 }
4262
4263 /* sqlite3_test_control(SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS, int);
4264 **
4265 ** Set or clear a flag that causes SQLite to verify that type, name,
4266 ** and tbl_name fields of the sqlite_schema table. This is normally
4267 ** on, but it is sometimes useful to turn it off for testing.
4268 **
4269 ** 2020-07-22: Disabling EXTRA_SCHEMA_CHECKS also disables the
4270 ** verification of rootpage numbers when parsing the schema. This
4271 ** is useful to make it easier to reach strange internal error states
4272 ** during testing. The EXTRA_SCHEMA_CHECKS setting is always enabled
4273 ** in production.
4274 */
4275 case SQLITE_TESTCTRL_EXTRA_SCHEMA_CHECKS: {
4276 sqlite3GlobalConfig.bExtraSchemaChecks = va_arg(ap, int);
4277 break;
4278 }
4279
4280 /* Set the threshold at which OP_Once counters reset back to zero.
4281 ** By default this is 0x7ffffffe (over 2 billion), but that value is
4282 ** too big to test in a reasonable amount of time, so this control is
4283 ** provided to set a small and easily reachable reset value.
4284 */
4285 case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: {
4286 sqlite3GlobalConfig.iOnceResetThreshold = va_arg(ap, int);
4287 break;
4288 }
4289
4290 /* sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
4291 **
4292 ** Set the VDBE coverage callback function to xCallback with context
4293 ** pointer ptr.
4294 */
4295 case SQLITE_TESTCTRL_VDBE_COVERAGE: {
4296#ifdef SQLITE_VDBE_COVERAGE
4297 typedef void (*branch_callback)(void*,unsigned int,
4298 unsigned char,unsigned char);
4299 sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
4300 sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
4301#endif
4302 break;
4303 }
4304
4305 /* sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
4306 case SQLITE_TESTCTRL_SORTER_MMAP: {
4307 sqlite3 *db = va_arg(ap, sqlite3*);
4308 db->nMaxSorterMmap = va_arg(ap, int);
4309 break;
4310 }
4311
4312 /* sqlite3_test_control(SQLITE_TESTCTRL_ISINIT);
4313 **
4314 ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
4315 ** not.
4316 */
4317 case SQLITE_TESTCTRL_ISINIT: {
4318 if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR;
4319 break;
4320 }
4321
4322 /* sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
4323 **
4324 ** This test control is used to create imposter tables. "db" is a pointer
4325 ** to the database connection. dbName is the database name (ex: "main" or
4326 ** "temp") which will receive the imposter. "onOff" turns imposter mode on
4327 ** or off. "tnum" is the root page of the b-tree to which the imposter
4328 ** table should connect.
4329 **
4330 ** Enable imposter mode only when the schema has already been parsed. Then
4331 ** run a single CREATE TABLE statement to construct the imposter table in
4332 ** the parsed schema. Then turn imposter mode back off again.
4333 **
4334 ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
4335 ** the schema to be reparsed the next time it is needed. This has the
4336 ** effect of erasing all imposter tables.
4337 */
4338 case SQLITE_TESTCTRL_IMPOSTER: {
4339 sqlite3 *db = va_arg(ap, sqlite3*);
4340 int iDb;
4341 sqlite3_mutex_enter(db->mutex);
4342 iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
4343 if( iDb>=0 ){
4344 db->init.iDb = iDb;
4345 db->init.busy = db->init.imposterTable = va_arg(ap,int);
4346 db->init.newTnum = va_arg(ap,int);
4347 if( db->init.busy==0 && db->init.newTnum>0 ){
4348 sqlite3ResetAllSchemasOfConnection(db);
4349 }
4350 }
4351 sqlite3_mutex_leave(db->mutex);
4352 break;
4353 }
4354
4355#if defined(YYCOVERAGE)
4356 /* sqlite3_test_control(SQLITE_TESTCTRL_PARSER_COVERAGE, FILE *out)
4357 **
4358 ** This test control (only available when SQLite is compiled with
4359 ** -DYYCOVERAGE) writes a report onto "out" that shows all
4360 ** state/lookahead combinations in the parser state machine
4361 ** which are never exercised. If any state is missed, make the
4362 ** return code SQLITE_ERROR.
4363 */
4364 case SQLITE_TESTCTRL_PARSER_COVERAGE: {
4365 FILE *out = va_arg(ap, FILE*);
4366 if( sqlite3ParserCoverage(out) ) rc = SQLITE_ERROR;
4367 break;
4368 }
4369#endif /* defined(YYCOVERAGE) */
4370
4371 /* sqlite3_test_control(SQLITE_TESTCTRL_RESULT_INTREAL, sqlite3_context*);
4372 **
4373 ** This test-control causes the most recent sqlite3_result_int64() value
4374 ** to be interpreted as a MEM_IntReal instead of as an MEM_Int. Normally,
4375 ** MEM_IntReal values only arise during an INSERT operation of integer
4376 ** values into a REAL column, so they can be challenging to test. This
4377 ** test-control enables us to write an intreal() SQL function that can
4378 ** inject an intreal() value at arbitrary places in an SQL statement,
4379 ** for testing purposes.
4380 */
4381 case SQLITE_TESTCTRL_RESULT_INTREAL: {
4382 sqlite3_context *pCtx = va_arg(ap, sqlite3_context*);
4383 sqlite3ResultIntReal(pCtx);
4384 break;
4385 }
4386
4387 /* sqlite3_test_control(SQLITE_TESTCTRL_SEEK_COUNT,
4388 ** sqlite3 *db, // Database connection
4389 ** u64 *pnSeek // Write seek count here
4390 ** );
4391 **
4392 ** This test-control queries the seek-counter on the "main" database
4393 ** file. The seek-counter is written into *pnSeek and is then reset.
4394 ** The seek-count is only available if compiled with SQLITE_DEBUG.
4395 */
4396 case SQLITE_TESTCTRL_SEEK_COUNT: {
4397 sqlite3 *db = va_arg(ap, sqlite3*);
4398 u64 *pn = va_arg(ap, sqlite3_uint64*);
4399 *pn = sqlite3BtreeSeekCount(db->aDb->pBt);
4400 (void)db; /* Silence harmless unused variable warning */
4401 break;
4402 }
4403
4404 /* sqlite3_test_control(SQLITE_TESTCTRL_TRACEFLAGS, op, ptr)
4405 **
4406 ** "ptr" is a pointer to a u32.
4407 **
4408 ** op==0 Store the current sqlite3TreeTrace in *ptr
4409 ** op==1 Set sqlite3TreeTrace to the value *ptr
4410 ** op==3 Store the current sqlite3WhereTrace in *ptr
4411 ** op==3 Set sqlite3WhereTrace to the value *ptr
4412 */
4413 case SQLITE_TESTCTRL_TRACEFLAGS: {
4414 int opTrace = va_arg(ap, int);
4415 u32 *ptr = va_arg(ap, u32*);
4416 switch( opTrace ){
4417 case 0: *ptr = sqlite3TreeTrace; break;
4418 case 1: sqlite3TreeTrace = *ptr; break;
4419 case 2: *ptr = sqlite3WhereTrace; break;
4420 case 3: sqlite3WhereTrace = *ptr; break;
4421 }
4422 break;
4423 }
4424
4425 /* sqlite3_test_control(SQLITE_TESTCTRL_LOGEST,
4426 ** double fIn, // Input value
4427 ** int *pLogEst, // sqlite3LogEstFromDouble(fIn)
4428 ** u64 *pInt, // sqlite3LogEstToInt(*pLogEst)
4429 ** int *pLogEst2 // sqlite3LogEst(*pInt)
4430 ** );
4431 **
4432 ** Test access for the LogEst conversion routines.
4433 */
4434 case SQLITE_TESTCTRL_LOGEST: {
4435 double rIn = va_arg(ap, double);
4436 LogEst rLogEst = sqlite3LogEstFromDouble(rIn);
4437 int *pI1 = va_arg(ap,int*);
4438 u64 *pU64 = va_arg(ap,u64*);
4439 int *pI2 = va_arg(ap,int*);
4440 *pI1 = rLogEst;
4441 *pU64 = sqlite3LogEstToInt(rLogEst);
4442 *pI2 = sqlite3LogEst(*pU64);
4443 break;
4444 }
4445
4446
4447#if defined(SQLITE_DEBUG) && !defined(SQLITE_OMIT_WSD)
4448 /* sqlite3_test_control(SQLITE_TESTCTRL_TUNE, id, *piValue)
4449 **
4450 ** If "id" is an integer between 1 and SQLITE_NTUNE then set the value
4451 ** of the id-th tuning parameter to *piValue. If "id" is between -1
4452 ** and -SQLITE_NTUNE, then write the current value of the (-id)-th
4453 ** tuning parameter into *piValue.
4454 **
4455 ** Tuning parameters are for use during transient development builds,
4456 ** to help find the best values for constants in the query planner.
4457 ** Access tuning parameters using the Tuning(ID) macro. Set the
4458 ** parameters in the CLI using ".testctrl tune ID VALUE".
4459 **
4460 ** Transient use only. Tuning parameters should not be used in
4461 ** checked-in code.
4462 */
4463 case SQLITE_TESTCTRL_TUNE: {
4464 int id = va_arg(ap, int);
4465 int *piValue = va_arg(ap, int*);
4466 if( id>0 && id<=SQLITE_NTUNE ){
4467 Tuning(id) = *piValue;
4468 }else if( id<0 && id>=-SQLITE_NTUNE ){
4469 *piValue = Tuning(-id);
4470 }else{
4471 rc = SQLITE_NOTFOUND;
4472 }
4473 break;
4474 }
4475#endif
4476 }
4477 va_end(ap);
4478#endif /* SQLITE_UNTESTABLE */
4479 return rc;
4480}
4481
4482/*
4483** The Pager stores the Database filename, Journal filename, and WAL filename
4484** consecutively in memory, in that order. The database filename is prefixed
4485** by four zero bytes. Locate the start of the database filename by searching
4486** backwards for the first byte following four consecutive zero bytes.
4487**
4488** This only works if the filename passed in was obtained from the Pager.
4489*/
4490static const char *databaseName(const char *zName){
4491 while( zName[-1]!=0 || zName[-2]!=0 || zName[-3]!=0 || zName[-4]!=0 ){
4492 zName--;
4493 }
4494 return zName;
4495}
4496
4497/*
4498** Append text z[] to the end of p[]. Return a pointer to the first
4499** character after then zero terminator on the new text in p[].
4500*/
4501static char *appendText(char *p, const char *z){
4502 size_t n = strlen(z);
4503 memcpy(p, z, n+1);
4504 return p+n+1;
4505}
4506
4507/*
4508** Allocate memory to hold names for a database, journal file, WAL file,
4509** and query parameters. The pointer returned is valid for use by
4510** sqlite3_filename_database() and sqlite3_uri_parameter() and related
4511** functions.
4512**
4513** Memory layout must be compatible with that generated by the pager
4514** and expected by sqlite3_uri_parameter() and databaseName().
4515*/
4516const char *sqlite3_create_filename(
4517 const char *zDatabase,
4518 const char *zJournal,
4519 const char *zWal,
4520 int nParam,
4521 const char **azParam
4522){
4523 sqlite3_int64 nByte;
4524 int i;
4525 char *pResult, *p;
4526 nByte = strlen(zDatabase) + strlen(zJournal) + strlen(zWal) + 10;
4527 for(i=0; i<nParam*2; i++){
4528 nByte += strlen(azParam[i])+1;
4529 }
4530 pResult = p = sqlite3_malloc64( nByte );
4531 if( p==0 ) return 0;
4532 memset(p, 0, 4);
4533 p += 4;
4534 p = appendText(p, zDatabase);
4535 for(i=0; i<nParam*2; i++){
4536 p = appendText(p, azParam[i]);
4537 }
4538 *(p++) = 0;
4539 p = appendText(p, zJournal);
4540 p = appendText(p, zWal);
4541 *(p++) = 0;
4542 *(p++) = 0;
4543 assert( (sqlite3_int64)(p - pResult)==nByte );
4544 return pResult + 4;
4545}
4546
4547/*
4548** Free memory obtained from sqlite3_create_filename(). It is a severe
4549** error to call this routine with any parameter other than a pointer
4550** previously obtained from sqlite3_create_filename() or a NULL pointer.
4551*/
4552void sqlite3_free_filename(const char *p){
4553 if( p==0 ) return;
4554 p = databaseName(p);
4555 sqlite3_free((char*)p - 4);
4556}
4557
4558
4559/*
4560** This is a utility routine, useful to VFS implementations, that checks
4561** to see if a database file was a URI that contained a specific query
4562** parameter, and if so obtains the value of the query parameter.
4563**
4564** The zFilename argument is the filename pointer passed into the xOpen()
4565** method of a VFS implementation. The zParam argument is the name of the
4566** query parameter we seek. This routine returns the value of the zParam
4567** parameter if it exists. If the parameter does not exist, this routine
4568** returns a NULL pointer.
4569*/
4570const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam){
4571 if( zFilename==0 || zParam==0 ) return 0;
4572 zFilename = databaseName(zFilename);
4573 return uriParameter(zFilename, zParam);
4574}
4575
4576/*
4577** Return a pointer to the name of Nth query parameter of the filename.
4578*/
4579const char *sqlite3_uri_key(const char *zFilename, int N){
4580 if( zFilename==0 || N<0 ) return 0;
4581 zFilename = databaseName(zFilename);
4582 zFilename += sqlite3Strlen30(zFilename) + 1;
4583 while( ALWAYS(zFilename) && zFilename[0] && (N--)>0 ){
4584 zFilename += sqlite3Strlen30(zFilename) + 1;
4585 zFilename += sqlite3Strlen30(zFilename) + 1;
4586 }
4587 return zFilename[0] ? zFilename : 0;
4588}
4589
4590/*
4591** Return a boolean value for a query parameter.
4592*/
4593int sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){
4594 const char *z = sqlite3_uri_parameter(zFilename, zParam);
4595 bDflt = bDflt!=0;
4596 return z ? sqlite3GetBoolean(z, bDflt) : bDflt;
4597}
4598
4599/*
4600** Return a 64-bit integer value for a query parameter.
4601*/
4602sqlite3_int64 sqlite3_uri_int64(
4603 const char *zFilename, /* Filename as passed to xOpen */
4604 const char *zParam, /* URI parameter sought */
4605 sqlite3_int64 bDflt /* return if parameter is missing */
4606){
4607 const char *z = sqlite3_uri_parameter(zFilename, zParam);
4608 sqlite3_int64 v;
4609 if( z && sqlite3DecOrHexToI64(z, &v)==0 ){
4610 bDflt = v;
4611 }
4612 return bDflt;
4613}
4614
4615/*
4616** Translate a filename that was handed to a VFS routine into the corresponding
4617** database, journal, or WAL file.
4618**
4619** It is an error to pass this routine a filename string that was not
4620** passed into the VFS from the SQLite core. Doing so is similar to
4621** passing free() a pointer that was not obtained from malloc() - it is
4622** an error that we cannot easily detect but that will likely cause memory
4623** corruption.
4624*/
4625const char *sqlite3_filename_database(const char *zFilename){
4626 if( zFilename==0 ) return 0;
4627 return databaseName(zFilename);
4628}
4629const char *sqlite3_filename_journal(const char *zFilename){
4630 if( zFilename==0 ) return 0;
4631 zFilename = databaseName(zFilename);
4632 zFilename += sqlite3Strlen30(zFilename) + 1;
4633 while( ALWAYS(zFilename) && zFilename[0] ){
4634 zFilename += sqlite3Strlen30(zFilename) + 1;
4635 zFilename += sqlite3Strlen30(zFilename) + 1;
4636 }
4637 return zFilename + 1;
4638}
4639const char *sqlite3_filename_wal(const char *zFilename){
4640#ifdef SQLITE_OMIT_WAL
4641 return 0;
4642#else
4643 zFilename = sqlite3_filename_journal(zFilename);
4644 if( zFilename ) zFilename += sqlite3Strlen30(zFilename) + 1;
4645 return zFilename;
4646#endif
4647}
4648
4649/*
4650** Return the Btree pointer identified by zDbName. Return NULL if not found.
4651*/
4652Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){
4653 int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
4654 return iDb<0 ? 0 : db->aDb[iDb].pBt;
4655}
4656
4657/*
4658** Return the name of the N-th database schema. Return NULL if N is out
4659** of range.
4660*/
4661const char *sqlite3_db_name(sqlite3 *db, int N){
4662#ifdef SQLITE_ENABLE_API_ARMOR
4663 if( !sqlite3SafetyCheckOk(db) ){
4664 (void)SQLITE_MISUSE_BKPT;
4665 return 0;
4666 }
4667#endif
4668 if( N<0 || N>=db->nDb ){
4669 return 0;
4670 }else{
4671 return db->aDb[N].zDbSName;
4672 }
4673}
4674
4675/*
4676** Return the filename of the database associated with a database
4677** connection.
4678*/
4679const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){
4680 Btree *pBt;
4681#ifdef SQLITE_ENABLE_API_ARMOR
4682 if( !sqlite3SafetyCheckOk(db) ){
4683 (void)SQLITE_MISUSE_BKPT;
4684 return 0;
4685 }
4686#endif
4687 pBt = sqlite3DbNameToBtree(db, zDbName);
4688 return pBt ? sqlite3BtreeGetFilename(pBt) : 0;
4689}
4690
4691/*
4692** Return 1 if database is read-only or 0 if read/write. Return -1 if
4693** no such database exists.
4694*/
4695int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
4696 Btree *pBt;
4697#ifdef SQLITE_ENABLE_API_ARMOR
4698 if( !sqlite3SafetyCheckOk(db) ){
4699 (void)SQLITE_MISUSE_BKPT;
4700 return -1;
4701 }
4702#endif
4703 pBt = sqlite3DbNameToBtree(db, zDbName);
4704 return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
4705}
4706
4707#ifdef SQLITE_ENABLE_SNAPSHOT
4708/*
4709** Obtain a snapshot handle for the snapshot of database zDb currently
4710** being read by handle db.
4711*/
4712int sqlite3_snapshot_get(
4713 sqlite3 *db,
4714 const char *zDb,
4715 sqlite3_snapshot **ppSnapshot
4716){
4717 int rc = SQLITE_ERROR;
4718#ifndef SQLITE_OMIT_WAL
4719
4720#ifdef SQLITE_ENABLE_API_ARMOR
4721 if( !sqlite3SafetyCheckOk(db) ){
4722 return SQLITE_MISUSE_BKPT;
4723 }
4724#endif
4725 sqlite3_mutex_enter(db->mutex);
4726
4727 if( db->autoCommit==0 ){
4728 int iDb = sqlite3FindDbName(db, zDb);
4729 if( iDb==0 || iDb>1 ){
4730 Btree *pBt = db->aDb[iDb].pBt;
4731 if( SQLITE_TXN_WRITE!=sqlite3BtreeTxnState(pBt) ){
4732 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
4733 if( rc==SQLITE_OK ){
4734 rc = sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt), ppSnapshot);
4735 }
4736 }
4737 }
4738 }
4739
4740 sqlite3_mutex_leave(db->mutex);
4741#endif /* SQLITE_OMIT_WAL */
4742 return rc;
4743}
4744
4745/*
4746** Open a read-transaction on the snapshot idendified by pSnapshot.
4747*/
4748int sqlite3_snapshot_open(
4749 sqlite3 *db,
4750 const char *zDb,
4751 sqlite3_snapshot *pSnapshot
4752){
4753 int rc = SQLITE_ERROR;
4754#ifndef SQLITE_OMIT_WAL
4755
4756#ifdef SQLITE_ENABLE_API_ARMOR
4757 if( !sqlite3SafetyCheckOk(db) ){
4758 return SQLITE_MISUSE_BKPT;
4759 }
4760#endif
4761 sqlite3_mutex_enter(db->mutex);
4762 if( db->autoCommit==0 ){
4763 int iDb;
4764 iDb = sqlite3FindDbName(db, zDb);
4765 if( iDb==0 || iDb>1 ){
4766 Btree *pBt = db->aDb[iDb].pBt;
4767 if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_WRITE ){
4768 Pager *pPager = sqlite3BtreePager(pBt);
4769 int bUnlock = 0;
4770 if( sqlite3BtreeTxnState(pBt)!=SQLITE_TXN_NONE ){
4771 if( db->nVdbeActive==0 ){
4772 rc = sqlite3PagerSnapshotCheck(pPager, pSnapshot);
4773 if( rc==SQLITE_OK ){
4774 bUnlock = 1;
4775 rc = sqlite3BtreeCommit(pBt);
4776 }
4777 }
4778 }else{
4779 rc = SQLITE_OK;
4780 }
4781 if( rc==SQLITE_OK ){
4782 rc = sqlite3PagerSnapshotOpen(pPager, pSnapshot);
4783 }
4784 if( rc==SQLITE_OK ){
4785 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
4786 sqlite3PagerSnapshotOpen(pPager, 0);
4787 }
4788 if( bUnlock ){
4789 sqlite3PagerSnapshotUnlock(pPager);
4790 }
4791 }
4792 }
4793 }
4794
4795 sqlite3_mutex_leave(db->mutex);
4796#endif /* SQLITE_OMIT_WAL */
4797 return rc;
4798}
4799
4800/*
4801** Recover as many snapshots as possible from the wal file associated with
4802** schema zDb of database db.
4803*/
4804int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb){
4805 int rc = SQLITE_ERROR;
4806#ifndef SQLITE_OMIT_WAL
4807 int iDb;
4808
4809#ifdef SQLITE_ENABLE_API_ARMOR
4810 if( !sqlite3SafetyCheckOk(db) ){
4811 return SQLITE_MISUSE_BKPT;
4812 }
4813#endif
4814
4815 sqlite3_mutex_enter(db->mutex);
4816 iDb = sqlite3FindDbName(db, zDb);
4817 if( iDb==0 || iDb>1 ){
4818 Btree *pBt = db->aDb[iDb].pBt;
4819 if( SQLITE_TXN_NONE==sqlite3BtreeTxnState(pBt) ){
4820 rc = sqlite3BtreeBeginTrans(pBt, 0, 0);
4821 if( rc==SQLITE_OK ){
4822 rc = sqlite3PagerSnapshotRecover(sqlite3BtreePager(pBt));
4823 sqlite3BtreeCommit(pBt);
4824 }
4825 }
4826 }
4827 sqlite3_mutex_leave(db->mutex);
4828#endif /* SQLITE_OMIT_WAL */
4829 return rc;
4830}
4831
4832/*
4833** Free a snapshot handle obtained from sqlite3_snapshot_get().
4834*/
4835void sqlite3_snapshot_free(sqlite3_snapshot *pSnapshot){
4836 sqlite3_free(pSnapshot);
4837}
4838#endif /* SQLITE_ENABLE_SNAPSHOT */
4839
4840#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
4841/*
4842** Given the name of a compile-time option, return true if that option
4843** was used and false if not.
4844**
4845** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix
4846** is not required for a match.
4847*/
4848int sqlite3_compileoption_used(const char *zOptName){
4849 int i, n;
4850 int nOpt;
4851 const char **azCompileOpt;
4852
4853#if SQLITE_ENABLE_API_ARMOR
4854 if( zOptName==0 ){
4855 (void)SQLITE_MISUSE_BKPT;
4856 return 0;
4857 }
4858#endif
4859
4860 azCompileOpt = sqlite3CompileOptions(&nOpt);
4861
4862 if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
4863 n = sqlite3Strlen30(zOptName);
4864
4865 /* Since nOpt is normally in single digits, a linear search is
4866 ** adequate. No need for a binary search. */
4867 for(i=0; i<nOpt; i++){
4868 if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
4869 && sqlite3IsIdChar((unsigned char)azCompileOpt[i][n])==0
4870 ){
4871 return 1;
4872 }
4873 }
4874 return 0;
4875}
4876
4877/*
4878** Return the N-th compile-time option string. If N is out of range,
4879** return a NULL pointer.
4880*/
4881const char *sqlite3_compileoption_get(int N){
4882 int nOpt;
4883 const char **azCompileOpt;
4884 azCompileOpt = sqlite3CompileOptions(&nOpt);
4885 if( N>=0 && N<nOpt ){
4886 return azCompileOpt[N];
4887 }
4888 return 0;
4889}
4890#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
4891