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