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