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