blob: 2d81358370a29a287a8035a2cd40d9a9b4e31768 [file] [log] [blame]
drh75897232000-05-29 14:26:00 +00001/*
drhb19a2bc2001-09-16 00:13:26 +00002** 2001 September 15
drh75897232000-05-29 14:26:00 +00003**
drhb19a2bc2001-09-16 00:13:26 +00004** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
drh75897232000-05-29 14:26:00 +00006**
drhb19a2bc2001-09-16 00:13:26 +00007** 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.
drh75897232000-05-29 14:26:00 +000010**
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.
drh75897232000-05-29 14:26:00 +000016*/
17#include "sqliteInt.h"
drh58f1c8b2008-05-26 20:19:25 +000018
drh820a9062008-01-31 13:35:48 +000019#ifdef SQLITE_ENABLE_FTS3
20# include "fts3.h"
21#endif
drh58f1c8b2008-05-26 20:19:25 +000022#ifdef SQLITE_ENABLE_RTREE
23# include "rtree.h"
24#endif
danielk19771c826652008-09-08 08:08:09 +000025#ifdef SQLITE_ENABLE_ICU
26# include "sqliteicu.h"
27#endif
drhc306e082015-10-08 23:37:00 +000028#ifdef SQLITE_ENABLE_JSON1
29int sqlite3Json1Init(sqlite3*);
30#endif
drhc6603af2017-06-29 14:33:51 +000031#ifdef SQLITE_ENABLE_STMTVTAB
32int sqlite3StmtVtabInit(sqlite3*);
drhf00f5302017-06-28 15:47:29 +000033#endif
drhc306e082015-10-08 23:37:00 +000034#ifdef SQLITE_ENABLE_FTS5
35int sqlite3Fts5Init(sqlite3*);
36#endif
drh75897232000-05-29 14:26:00 +000037
drhb3190c12008-12-08 21:37:14 +000038#ifndef SQLITE_AMALGAMATION
drh9f129f42010-08-31 15:27:32 +000039/* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant
40** contains the text of SQLITE_VERSION macro.
41*/
danielk197724b03fd2004-05-10 10:34:34 +000042const char sqlite3_version[] = SQLITE_VERSION;
drhb3190c12008-12-08 21:37:14 +000043#endif
drh9f129f42010-08-31 15:27:32 +000044
45/* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns
46** a pointer to the to the sqlite3_version[] string constant.
47*/
drh4aec8b62004-08-28 16:19:00 +000048const char *sqlite3_libversion(void){ return sqlite3_version; }
drh9f129f42010-08-31 15:27:32 +000049
50/* IMPLEMENTATION-OF: R-63124-39300 The sqlite3_sourceid() function returns a
51** pointer to a string constant whose value is the same as the
52** SQLITE_SOURCE_ID C preprocessor macro.
53*/
drh47baebc2009-08-14 16:01:24 +000054const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }
drh9f129f42010-08-31 15:27:32 +000055
56/* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function
57** returns an integer equal to SQLITE_VERSION_NUMBER.
58*/
danielk197799ba19e2005-02-05 07:33:34 +000059int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
drh9f129f42010-08-31 15:27:32 +000060
drh5dc2bcd2012-01-02 15:45:12 +000061/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns
drhb8a45bb2011-12-31 21:51:55 +000062** zero if and only if SQLite was compiled with mutexing code omitted due to
drh9f129f42010-08-31 15:27:32 +000063** the SQLITE_THREADSAFE compile-time option being set to 0.
64*/
drhb67e8bf2007-08-30 20:09:48 +000065int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
drhb217a572000-08-22 13:40:18 +000066
mistachkin34cf2582015-04-02 17:46:52 +000067/*
68** When compiling the test fixture or with debugging enabled (on Win32),
69** this variable being set to non-zero will cause OSTRACE macros to emit
70** extra diagnostic information.
71*/
mistachkinfb383e92015-04-16 03:24:38 +000072#ifdef SQLITE_HAVE_OS_TRACE
mistachkin34cf2582015-04-02 17:46:52 +000073# ifndef SQLITE_DEBUG_OS_TRACE
74# define SQLITE_DEBUG_OS_TRACE 0
75# endif
76 int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;
77#endif
78
drhe265b082008-05-01 17:03:49 +000079#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
drhb217a572000-08-22 13:40:18 +000080/*
drhb0603412007-02-28 04:47:26 +000081** If the following function pointer is not NULL and if
82** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
83** I/O active are written using this function. These messages
84** are intended for debugging activity only.
85*/
mistachkin9871a932015-03-27 00:21:52 +000086SQLITE_API void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...) = 0;
drhe265b082008-05-01 17:03:49 +000087#endif
drhb0603412007-02-28 04:47:26 +000088
89/*
drha16313e2007-03-30 11:29:32 +000090** If the following global variable points to a string which is the
91** name of a directory, then that directory will be used to store
92** temporary files.
93**
94** See also the "PRAGMA temp_store_directory" SQL command.
95*/
96char *sqlite3_temp_directory = 0;
97
drhc5499be2008-04-01 15:06:33 +000098/*
mistachkina112d142012-03-14 00:44:01 +000099** If the following global variable points to a string which is the
100** name of a directory, then that directory will be used to store
101** all database files specified with a relative pathname.
102**
103** See also the "PRAGMA data_store_directory" SQL command.
104*/
105char *sqlite3_data_directory = 0;
106
107/*
drh40257ff2008-06-13 18:24:27 +0000108** Initialize SQLite.
109**
110** This routine must be called to initialize the memory allocation,
drh93ed56d2008-08-12 15:21:11 +0000111** VFS, and mutex subsystems prior to doing any serious work with
drh40257ff2008-06-13 18:24:27 +0000112** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
113** this routine will be called automatically by key routines such as
114** sqlite3_open().
115**
116** This routine is a no-op except on its very first call for the process,
117** or for the first call after a call to sqlite3_shutdown.
drh93ed56d2008-08-12 15:21:11 +0000118**
119** The first thread to call this routine runs the initialization to
120** completion. If subsequent threads call this routine before the first
121** thread has finished the initialization process, then the subsequent
122** threads must block until the first thread finishes with the initialization.
123**
124** The first thread might call this routine recursively. Recursive
125** calls to this routine should not block, of course. Otherwise the
126** initialization process would never complete.
127**
128** Let X be the first thread to enter this routine. Let Y be some other
129** thread. Then while the initial invocation of this routine by X is
130** incomplete, it is required that:
131**
132** * Calls to this routine from Y must block until the outer-most
133** call by X completes.
134**
135** * Recursive calls to this routine from thread X return immediately
136** without blocking.
drh40257ff2008-06-13 18:24:27 +0000137*/
138int sqlite3_initialize(void){
drh30ddce62011-10-15 00:16:30 +0000139 MUTEX_LOGIC( sqlite3_mutex *pMaster; ) /* The main static mutex */
danielk1977075c23a2008-09-01 18:34:20 +0000140 int rc; /* Result code */
drhab80be92013-08-08 14:38:45 +0000141#ifdef SQLITE_EXTRA_INIT
142 int bRunExtraInit = 0; /* Extra initialization needed */
143#endif
danielk1977075c23a2008-09-01 18:34:20 +0000144
145#ifdef SQLITE_OMIT_WSD
danielk1977a8f83bf2008-09-02 16:22:28 +0000146 rc = sqlite3_wsd_init(4096, 24);
danielk1977075c23a2008-09-01 18:34:20 +0000147 if( rc!=SQLITE_OK ){
148 return rc;
149 }
150#endif
danielk197771bc31c2008-06-26 08:29:34 +0000151
drh2b4905c2015-03-23 18:52:56 +0000152 /* If the following assert() fails on some obscure processor/compiler
153 ** combination, the work-around is to set the correct pointer
154 ** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */
155 assert( SQLITE_PTRSIZE==sizeof(char*) );
156
drh93ed56d2008-08-12 15:21:11 +0000157 /* If SQLite is already completely initialized, then this call
158 ** to sqlite3_initialize() should be a no-op. But the initialization
159 ** must be complete. So isInit must not be set until the very end
160 ** of this routine.
161 */
danielk1977075c23a2008-09-01 18:34:20 +0000162 if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;
danielk197771bc31c2008-06-26 08:29:34 +0000163
drh93ed56d2008-08-12 15:21:11 +0000164 /* Make sure the mutex subsystem is initialized. If unable to
165 ** initialize the mutex subsystem, return early with the error.
166 ** If the system is so sick that we are unable to allocate a mutex,
167 ** there is not much SQLite is going to be able to do.
168 **
169 ** The mutex subsystem must take care of serializing its own
170 ** initialization.
171 */
danielk1977d0251742008-06-18 18:57:42 +0000172 rc = sqlite3MutexInit();
drh93ed56d2008-08-12 15:21:11 +0000173 if( rc ) return rc;
danielk197771bc31c2008-06-26 08:29:34 +0000174
drh93ed56d2008-08-12 15:21:11 +0000175 /* Initialize the malloc() system and the recursive pInitMutex mutex.
176 ** This operation is protected by the STATIC_MASTER mutex. Note that
177 ** MutexAlloc() is called for a static mutex prior to initializing the
178 ** malloc subsystem - this implies that the allocation of a static
179 ** mutex must not require support from the malloc subsystem.
180 */
drh30ddce62011-10-15 00:16:30 +0000181 MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )
drh93ed56d2008-08-12 15:21:11 +0000182 sqlite3_mutex_enter(pMaster);
dane1ab2192009-08-17 15:16:19 +0000183 sqlite3GlobalConfig.isMutexInit = 1;
danielk1977075c23a2008-09-01 18:34:20 +0000184 if( !sqlite3GlobalConfig.isMallocInit ){
drh93ed56d2008-08-12 15:21:11 +0000185 rc = sqlite3MallocInit();
186 }
drh40257ff2008-06-13 18:24:27 +0000187 if( rc==SQLITE_OK ){
danielk1977075c23a2008-09-01 18:34:20 +0000188 sqlite3GlobalConfig.isMallocInit = 1;
189 if( !sqlite3GlobalConfig.pInitMutex ){
drh9ac06502009-08-17 13:42:29 +0000190 sqlite3GlobalConfig.pInitMutex =
191 sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
danielk1977075c23a2008-09-01 18:34:20 +0000192 if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){
mistachkinfad30392016-02-13 23:43:46 +0000193 rc = SQLITE_NOMEM_BKPT;
drh40257ff2008-06-13 18:24:27 +0000194 }
195 }
danielk197777eb5bb2008-09-22 17:22:19 +0000196 }
197 if( rc==SQLITE_OK ){
danielk1977075c23a2008-09-01 18:34:20 +0000198 sqlite3GlobalConfig.nRefInitMutex++;
drh93ed56d2008-08-12 15:21:11 +0000199 }
200 sqlite3_mutex_leave(pMaster);
danielk197771bc31c2008-06-26 08:29:34 +0000201
dane1ab2192009-08-17 15:16:19 +0000202 /* If rc is not SQLITE_OK at this point, then either the malloc
203 ** subsystem could not be initialized or the system failed to allocate
204 ** the pInitMutex mutex. Return an error in either case. */
drh93ed56d2008-08-12 15:21:11 +0000205 if( rc!=SQLITE_OK ){
206 return rc;
207 }
208
209 /* Do the rest of the initialization under the recursive mutex so
210 ** that we will be able to handle recursive calls into
211 ** sqlite3_initialize(). The recursive calls normally come through
212 ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
213 ** recursive calls might also be possible.
drhf759bb82010-09-09 18:25:34 +0000214 **
215 ** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls
216 ** to the xInit method, so the xInit method need not be threadsafe.
217 **
218 ** The following mutex is what serializes access to the appdef pcache xInit
219 ** methods. The sqlite3_pcache_methods.xInit() all is embedded in the
220 ** call to sqlite3PcacheInitialize().
drh93ed56d2008-08-12 15:21:11 +0000221 */
danielk1977075c23a2008-09-01 18:34:20 +0000222 sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);
danielk1977502b4e02008-09-02 14:07:24 +0000223 if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){
danielk1977502b4e02008-09-02 14:07:24 +0000224 sqlite3GlobalConfig.inProgress = 1;
drh5e3cefe2015-11-12 23:48:08 +0000225#ifdef SQLITE_ENABLE_SQLLOG
dand83f7ca2015-11-12 20:12:51 +0000226 {
drh5e3cefe2015-11-12 23:48:08 +0000227 extern void sqlite3_init_sqllog(void);
228 sqlite3_init_sqllog();
dand83f7ca2015-11-12 20:12:51 +0000229 }
230#endif
drh80738d92016-02-15 00:34:16 +0000231 memset(&sqlite3BuiltinFunctions, 0, sizeof(sqlite3BuiltinFunctions));
232 sqlite3RegisterBuiltinFunctions();
dane1ab2192009-08-17 15:16:19 +0000233 if( sqlite3GlobalConfig.isPCacheInit==0 ){
234 rc = sqlite3PcacheInitialize();
235 }
danielk19778c0a7912008-08-20 14:49:23 +0000236 if( rc==SQLITE_OK ){
dane1ab2192009-08-17 15:16:19 +0000237 sqlite3GlobalConfig.isPCacheInit = 1;
dan3d6e0602009-08-17 15:52:25 +0000238 rc = sqlite3OsInit();
drh0bf9f7b2009-04-17 16:54:22 +0000239 }
240 if( rc==SQLITE_OK ){
danielk19775b775292008-09-02 09:38:06 +0000241 sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,
242 sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);
drh0bf9f7b2009-04-17 16:54:22 +0000243 sqlite3GlobalConfig.isInit = 1;
drhab80be92013-08-08 14:38:45 +0000244#ifdef SQLITE_EXTRA_INIT
245 bRunExtraInit = 1;
246#endif
danielk19778c0a7912008-08-20 14:49:23 +0000247 }
danielk1977502b4e02008-09-02 14:07:24 +0000248 sqlite3GlobalConfig.inProgress = 0;
drh40257ff2008-06-13 18:24:27 +0000249 }
danielk1977075c23a2008-09-01 18:34:20 +0000250 sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);
shanedfb7b372008-07-22 05:13:30 +0000251
drh93ed56d2008-08-12 15:21:11 +0000252 /* Go back under the static mutex and clean up the recursive
253 ** mutex to prevent a resource leak.
254 */
255 sqlite3_mutex_enter(pMaster);
danielk1977075c23a2008-09-01 18:34:20 +0000256 sqlite3GlobalConfig.nRefInitMutex--;
257 if( sqlite3GlobalConfig.nRefInitMutex<=0 ){
258 assert( sqlite3GlobalConfig.nRefInitMutex==0 );
259 sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);
260 sqlite3GlobalConfig.pInitMutex = 0;
drh93ed56d2008-08-12 15:21:11 +0000261 }
262 sqlite3_mutex_leave(pMaster);
263
264 /* The following is just a sanity check to make sure SQLite has
265 ** been compiled correctly. It is important to run this code, but
266 ** we don't want to run it too often and soak up CPU cycles for no
267 ** reason. So we run it once during initialization.
268 */
shanedfb7b372008-07-22 05:13:30 +0000269#ifndef NDEBUG
shanefbd60f82009-02-04 03:59:25 +0000270#ifndef SQLITE_OMIT_FLOATING_POINT
shanedfb7b372008-07-22 05:13:30 +0000271 /* This section of code's only "output" is via assert() statements. */
272 if ( rc==SQLITE_OK ){
273 u64 x = (((u64)1)<<63)-1;
274 double y;
275 assert(sizeof(x)==8);
276 assert(sizeof(x)==sizeof(y));
277 memcpy(&y, &x, 8);
278 assert( sqlite3IsNaN(y) );
279 }
280#endif
shanefbd60f82009-02-04 03:59:25 +0000281#endif
shanedfb7b372008-07-22 05:13:30 +0000282
drhe4cf0b32011-08-25 00:14:41 +0000283 /* Do extra initialization steps requested by the SQLITE_EXTRA_INIT
284 ** compile-time option.
285 */
286#ifdef SQLITE_EXTRA_INIT
drhab80be92013-08-08 14:38:45 +0000287 if( bRunExtraInit ){
drhc7f94622011-12-13 18:22:38 +0000288 int SQLITE_EXTRA_INIT(const char*);
289 rc = SQLITE_EXTRA_INIT(0);
drhe4cf0b32011-08-25 00:14:41 +0000290 }
291#endif
292
drh40257ff2008-06-13 18:24:27 +0000293 return rc;
294}
295
296/*
297** Undo the effects of sqlite3_initialize(). Must not be called while
298** there are outstanding database connections or memory allocations or
299** while any part of SQLite is otherwise in use in any thread. This
drhd1a24402009-04-19 12:23:58 +0000300** routine is not threadsafe. But it is safe to invoke this routine
301** on when SQLite is already shut down. If SQLite is already shut down
302** when this routine is invoked, then this routine is a harmless no-op.
drh40257ff2008-06-13 18:24:27 +0000303*/
304int sqlite3_shutdown(void){
mistachkin054450f2014-12-23 20:42:48 +0000305#ifdef SQLITE_OMIT_WSD
306 int rc = sqlite3_wsd_init(4096, 24);
307 if( rc!=SQLITE_OK ){
308 return rc;
309 }
310#endif
311
danielk1977075c23a2008-09-01 18:34:20 +0000312 if( sqlite3GlobalConfig.isInit ){
drh97977062011-12-13 01:34:21 +0000313#ifdef SQLITE_EXTRA_SHUTDOWN
314 void SQLITE_EXTRA_SHUTDOWN(void);
315 SQLITE_EXTRA_SHUTDOWN();
316#endif
drha7640922009-04-21 12:02:56 +0000317 sqlite3_os_end();
drhd1a24402009-04-19 12:23:58 +0000318 sqlite3_reset_auto_extension();
drhd1a24402009-04-19 12:23:58 +0000319 sqlite3GlobalConfig.isInit = 0;
danielk1977fb437272008-07-08 12:02:35 +0000320 }
dane1ab2192009-08-17 15:16:19 +0000321 if( sqlite3GlobalConfig.isPCacheInit ){
322 sqlite3PcacheShutdown();
323 sqlite3GlobalConfig.isPCacheInit = 0;
324 }
325 if( sqlite3GlobalConfig.isMallocInit ){
326 sqlite3MallocEnd();
327 sqlite3GlobalConfig.isMallocInit = 0;
mistachkin86f89872012-03-18 01:32:44 +0000328
329#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES
330 /* The heap subsystem has now been shutdown and these values are supposed
331 ** to be NULL or point to memory that was obtained from sqlite3_malloc(),
332 ** which would rely on that heap subsystem; therefore, make sure these
333 ** values cannot refer to heap memory that was just invalidated when the
334 ** heap subsystem was shutdown. This is only done if the current call to
335 ** this function resulted in the heap subsystem actually being shutdown.
336 */
337 sqlite3_data_directory = 0;
338 sqlite3_temp_directory = 0;
339#endif
dane1ab2192009-08-17 15:16:19 +0000340 }
341 if( sqlite3GlobalConfig.isMutexInit ){
342 sqlite3MutexEnd();
343 sqlite3GlobalConfig.isMutexInit = 0;
344 }
345
drh40257ff2008-06-13 18:24:27 +0000346 return SQLITE_OK;
347}
348
349/*
350** This API allows applications to modify the global configuration of
351** the SQLite library at run-time.
352**
353** This routine should only be called when there are no outstanding
354** database connections or memory allocations. This routine is not
355** threadsafe. Failure to heed these warnings can lead to unpredictable
356** behavior.
357*/
358int sqlite3_config(int op, ...){
359 va_list ap;
360 int rc = SQLITE_OK;
361
362 /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
363 ** the SQLite library is in use. */
drh413c3d32010-02-23 20:11:56 +0000364 if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;
drh40257ff2008-06-13 18:24:27 +0000365
366 va_start(ap, op);
367 switch( op ){
drh18472fa2008-10-07 15:25:48 +0000368
369 /* Mutex configuration options are only available in a threadsafe
drhd1dcb232014-11-01 18:32:18 +0000370 ** compile.
drh18472fa2008-10-07 15:25:48 +0000371 */
drhd1dcb232014-11-01 18:32:18 +0000372#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */
drh40257ff2008-06-13 18:24:27 +0000373 case SQLITE_CONFIG_SINGLETHREAD: {
drh682a6ef2015-03-04 23:14:14 +0000374 /* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to
375 ** Single-thread. */
376 sqlite3GlobalConfig.bCoreMutex = 0; /* Disable mutex on core */
377 sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */
drh40257ff2008-06-13 18:24:27 +0000378 break;
379 }
drhd1dcb232014-11-01 18:32:18 +0000380#endif
381#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */
drh40257ff2008-06-13 18:24:27 +0000382 case SQLITE_CONFIG_MULTITHREAD: {
drh682a6ef2015-03-04 23:14:14 +0000383 /* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to
384 ** Multi-thread. */
385 sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */
386 sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */
drh40257ff2008-06-13 18:24:27 +0000387 break;
388 }
drhd1dcb232014-11-01 18:32:18 +0000389#endif
390#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */
drh40257ff2008-06-13 18:24:27 +0000391 case SQLITE_CONFIG_SERIALIZED: {
drh682a6ef2015-03-04 23:14:14 +0000392 /* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to
393 ** Serialized. */
394 sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */
395 sqlite3GlobalConfig.bFullMutex = 1; /* Enable mutex on connections */
drh40257ff2008-06-13 18:24:27 +0000396 break;
397 }
drhd1dcb232014-11-01 18:32:18 +0000398#endif
399#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */
drh18472fa2008-10-07 15:25:48 +0000400 case SQLITE_CONFIG_MUTEX: {
401 /* Specify an alternative mutex implementation */
402 sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);
403 break;
404 }
drhd1dcb232014-11-01 18:32:18 +0000405#endif
406#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */
drh18472fa2008-10-07 15:25:48 +0000407 case SQLITE_CONFIG_GETMUTEX: {
408 /* Retrieve the current mutex implementation */
409 *va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;
410 break;
411 }
412#endif
413
drh40257ff2008-06-13 18:24:27 +0000414 case SQLITE_CONFIG_MALLOC: {
drh5279d342014-11-04 13:41:32 +0000415 /* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a
416 ** single argument which is a pointer to an instance of the
417 ** sqlite3_mem_methods structure. The argument specifies alternative
418 ** low-level memory allocation routines to be used in place of the memory
419 ** allocation routines built into SQLite. */
danielk1977075c23a2008-09-01 18:34:20 +0000420 sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);
drh40257ff2008-06-13 18:24:27 +0000421 break;
422 }
drh33589792008-06-18 13:27:46 +0000423 case SQLITE_CONFIG_GETMALLOC: {
drh5279d342014-11-04 13:41:32 +0000424 /* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a
425 ** single argument which is a pointer to an instance of the
426 ** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is
427 ** filled with the currently defined memory allocation routines. */
danielk1977075c23a2008-09-01 18:34:20 +0000428 if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();
429 *va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;
drh33589792008-06-18 13:27:46 +0000430 break;
431 }
drhfec00ea2008-06-14 16:56:21 +0000432 case SQLITE_CONFIG_MEMSTATUS: {
drh5279d342014-11-04 13:41:32 +0000433 /* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes
434 ** single argument of type int, interpreted as a boolean, which enables
435 ** or disables the collection of memory allocation statistics. */
danielk1977075c23a2008-09-01 18:34:20 +0000436 sqlite3GlobalConfig.bMemstat = va_arg(ap, int);
drh40257ff2008-06-13 18:24:27 +0000437 break;
438 }
drh33589792008-06-18 13:27:46 +0000439 case SQLITE_CONFIG_SCRATCH: {
drh5279d342014-11-04 13:41:32 +0000440 /* EVIDENCE-OF: R-08404-60887 There are three arguments to
441 ** SQLITE_CONFIG_SCRATCH: A pointer an 8-byte aligned memory buffer from
442 ** which the scratch allocations will be drawn, the size of each scratch
443 ** allocation (sz), and the maximum number of scratch allocations (N). */
danielk1977075c23a2008-09-01 18:34:20 +0000444 sqlite3GlobalConfig.pScratch = va_arg(ap, void*);
445 sqlite3GlobalConfig.szScratch = va_arg(ap, int);
446 sqlite3GlobalConfig.nScratch = va_arg(ap, int);
drh33589792008-06-18 13:27:46 +0000447 break;
448 }
449 case SQLITE_CONFIG_PAGECACHE: {
drh15427272015-12-03 22:33:55 +0000450 /* EVIDENCE-OF: R-18761-36601 There are three arguments to
451 ** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem),
452 ** the size of each page cache line (sz), and the number of cache lines
453 ** (N). */
danielk1977075c23a2008-09-01 18:34:20 +0000454 sqlite3GlobalConfig.pPage = va_arg(ap, void*);
455 sqlite3GlobalConfig.szPage = va_arg(ap, int);
456 sqlite3GlobalConfig.nPage = va_arg(ap, int);
drh33589792008-06-18 13:27:46 +0000457 break;
458 }
drhdef68892014-11-04 12:11:23 +0000459 case SQLITE_CONFIG_PCACHE_HDRSZ: {
drh5279d342014-11-04 13:41:32 +0000460 /* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes
461 ** a single parameter which is a pointer to an integer and writes into
462 ** that integer the number of extra bytes per page required for each page
463 ** in SQLITE_CONFIG_PAGECACHE. */
drhdef68892014-11-04 12:11:23 +0000464 *va_arg(ap, int*) =
465 sqlite3HeaderSizeBtree() +
466 sqlite3HeaderSizePcache() +
467 sqlite3HeaderSizePcache1();
468 break;
469 }
danielk19775099be52008-06-27 13:27:03 +0000470
danielk1977bc2ca9e2008-11-13 14:28:28 +0000471 case SQLITE_CONFIG_PCACHE: {
dan22e21ff2011-11-08 20:08:44 +0000472 /* no-op */
473 break;
474 }
475 case SQLITE_CONFIG_GETPCACHE: {
476 /* now an error */
477 rc = SQLITE_ERROR;
danielk1977bc2ca9e2008-11-13 14:28:28 +0000478 break;
479 }
480
dan22e21ff2011-11-08 20:08:44 +0000481 case SQLITE_CONFIG_PCACHE2: {
drh5279d342014-11-04 13:41:32 +0000482 /* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a
483 ** single argument which is a pointer to an sqlite3_pcache_methods2
484 ** object. This object specifies the interface to a custom page cache
485 ** implementation. */
dan22e21ff2011-11-08 20:08:44 +0000486 sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);
487 break;
488 }
489 case SQLITE_CONFIG_GETPCACHE2: {
drh5279d342014-11-04 13:41:32 +0000490 /* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a
491 ** single argument which is a pointer to an sqlite3_pcache_methods2
492 ** object. SQLite copies of the current page cache implementation into
493 ** that object. */
dan22e21ff2011-11-08 20:08:44 +0000494 if( sqlite3GlobalConfig.pcache2.xInit==0 ){
drhb232c232008-11-19 01:20:26 +0000495 sqlite3PCacheSetDefault();
496 }
dan22e21ff2011-11-08 20:08:44 +0000497 *va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;
drhb232c232008-11-19 01:20:26 +0000498 break;
499 }
500
drh8790b6e2014-11-07 01:43:56 +0000501/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only
502** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or
503** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */
drh5d414832008-07-15 14:47:18 +0000504#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
drh33589792008-06-18 13:27:46 +0000505 case SQLITE_CONFIG_HEAP: {
drh5279d342014-11-04 13:41:32 +0000506 /* EVIDENCE-OF: R-19854-42126 There are three arguments to
507 ** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the
drh3ba689d2015-03-03 14:00:11 +0000508 ** number of bytes in the memory buffer, and the minimum allocation size.
509 */
danielk1977075c23a2008-09-01 18:34:20 +0000510 sqlite3GlobalConfig.pHeap = va_arg(ap, void*);
511 sqlite3GlobalConfig.nHeap = va_arg(ap, int);
512 sqlite3GlobalConfig.mnReq = va_arg(ap, int);
danielk19775099be52008-06-27 13:27:03 +0000513
shaneha6ec8922011-03-09 21:36:17 +0000514 if( sqlite3GlobalConfig.mnReq<1 ){
515 sqlite3GlobalConfig.mnReq = 1;
516 }else if( sqlite3GlobalConfig.mnReq>(1<<12) ){
517 /* cap min request size at 2^12 */
518 sqlite3GlobalConfig.mnReq = (1<<12);
519 }
520
danielk1977075c23a2008-09-01 18:34:20 +0000521 if( sqlite3GlobalConfig.pHeap==0 ){
drh8790b6e2014-11-07 01:43:56 +0000522 /* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)
523 ** is NULL, then SQLite reverts to using its default memory allocator
524 ** (the system malloc() implementation), undoing any prior invocation of
525 ** SQLITE_CONFIG_MALLOC.
526 **
527 ** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to
528 ** revert to its default implementation when sqlite3_initialize() is run
drh8a42cbd2008-07-10 18:13:42 +0000529 */
danielk1977075c23a2008-09-01 18:34:20 +0000530 memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));
drh8a42cbd2008-07-10 18:13:42 +0000531 }else{
drh8790b6e2014-11-07 01:43:56 +0000532 /* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the
533 ** alternative memory allocator is engaged to handle all of SQLites
534 ** memory allocation needs. */
danielk19775099be52008-06-27 13:27:03 +0000535#ifdef SQLITE_ENABLE_MEMSYS3
danielk1977075c23a2008-09-01 18:34:20 +0000536 sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();
drh8a42cbd2008-07-10 18:13:42 +0000537#endif
538#ifdef SQLITE_ENABLE_MEMSYS5
danielk1977075c23a2008-09-01 18:34:20 +0000539 sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();
drh8a42cbd2008-07-10 18:13:42 +0000540#endif
drh8a42cbd2008-07-10 18:13:42 +0000541 }
danielk19775099be52008-06-27 13:27:03 +0000542 break;
543 }
drh5d414832008-07-15 14:47:18 +0000544#endif
danielk19775099be52008-06-27 13:27:03 +0000545
drh633e6d52008-07-28 19:34:53 +0000546 case SQLITE_CONFIG_LOOKASIDE: {
danielk1977075c23a2008-09-01 18:34:20 +0000547 sqlite3GlobalConfig.szLookaside = va_arg(ap, int);
548 sqlite3GlobalConfig.nLookaside = va_arg(ap, int);
drh633e6d52008-07-28 19:34:53 +0000549 break;
550 }
drh3f280702010-02-18 18:45:09 +0000551
mistachkin037933b2013-08-13 22:33:41 +0000552 /* Record a pointer to the logger function and its first argument.
drh3f280702010-02-18 18:45:09 +0000553 ** The default is NULL. Logging is disabled if the function pointer is
554 ** NULL.
555 */
556 case SQLITE_CONFIG_LOG: {
shanehdc97a8c2010-02-23 20:08:35 +0000557 /* MSVC is picky about pulling func ptrs from va lists.
558 ** http://support.microsoft.com/kb/47961
559 ** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));
560 */
561 typedef void(*LOGFUNC_t)(void*,int,const char*);
562 sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);
drh3f280702010-02-18 18:45:09 +0000563 sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);
564 break;
565 }
drh633e6d52008-07-28 19:34:53 +0000566
drh00729cb2014-10-04 11:59:33 +0000567 /* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames
568 ** can be changed at start-time using the
569 ** sqlite3_config(SQLITE_CONFIG_URI,1) or
570 ** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.
571 */
dancd74b612011-04-22 19:37:32 +0000572 case SQLITE_CONFIG_URI: {
drh4d9f1882014-11-04 17:23:24 +0000573 /* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single
574 ** argument of type int. If non-zero, then URI handling is globally
575 ** enabled. If the parameter is zero, then URI handling is globally
576 ** disabled. */
dancd74b612011-04-22 19:37:32 +0000577 sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);
578 break;
579 }
580
drhde9a7b82012-09-17 20:44:46 +0000581 case SQLITE_CONFIG_COVERING_INDEX_SCAN: {
drh4d9f1882014-11-04 17:23:24 +0000582 /* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN
583 ** option takes a single integer argument which is interpreted as a
584 ** boolean in order to enable or disable the use of covering indices for
585 ** full table scans in the query optimizer. */
drhde9a7b82012-09-17 20:44:46 +0000586 sqlite3GlobalConfig.bUseCis = va_arg(ap, int);
587 break;
588 }
589
danac455932012-11-26 19:50:41 +0000590#ifdef SQLITE_ENABLE_SQLLOG
591 case SQLITE_CONFIG_SQLLOG: {
592 typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int);
593 sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);
594 sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);
595 break;
596 }
597#endif
598
drh9b4c59f2013-04-15 17:03:42 +0000599 case SQLITE_CONFIG_MMAP_SIZE: {
drh4d9f1882014-11-04 17:23:24 +0000600 /* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit
601 ** integer (sqlite3_int64) values that are the default mmap size limit
602 ** (the default setting for PRAGMA mmap_size) and the maximum allowed
603 ** mmap size limit. */
drh9b4c59f2013-04-15 17:03:42 +0000604 sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);
drha1f42c72013-04-01 22:38:06 +0000605 sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);
drh4d9f1882014-11-04 17:23:24 +0000606 /* EVIDENCE-OF: R-53367-43190 If either argument to this option is
drh8790b6e2014-11-07 01:43:56 +0000607 ** negative, then that argument is changed to its compile-time default.
608 **
609 ** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be
610 ** silently truncated if necessary so that it does not exceed the
611 ** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE
612 ** compile-time option.
613 */
drh3ba689d2015-03-03 14:00:11 +0000614 if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){
615 mxMmap = SQLITE_MAX_MMAP_SIZE;
616 }
drh9b4c59f2013-04-15 17:03:42 +0000617 if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;
618 if( szMmap>mxMmap) szMmap = mxMmap;
drh4d9f1882014-11-04 17:23:24 +0000619 sqlite3GlobalConfig.mxMmap = mxMmap;
drh9b4c59f2013-04-15 17:03:42 +0000620 sqlite3GlobalConfig.szMmap = szMmap;
drha1f42c72013-04-01 22:38:06 +0000621 break;
622 }
623
drh4d9f1882014-11-04 17:23:24 +0000624#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */
mistachkinaf8641b2013-11-25 21:49:04 +0000625 case SQLITE_CONFIG_WIN32_HEAPSIZE: {
drh4d9f1882014-11-04 17:23:24 +0000626 /* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit
627 ** unsigned integer value that specifies the maximum size of the created
628 ** heap. */
mistachkinac1f1042013-11-23 00:27:29 +0000629 sqlite3GlobalConfig.nHeap = va_arg(ap, int);
630 break;
631 }
632#endif
633
drh3bd17912015-01-02 15:55:29 +0000634 case SQLITE_CONFIG_PMASZ: {
635 sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int);
636 break;
637 }
638
drh8c71a982016-03-07 17:37:37 +0000639 case SQLITE_CONFIG_STMTJRNL_SPILL: {
640 sqlite3GlobalConfig.nStmtSpill = va_arg(ap, int);
641 break;
642 }
643
drh40257ff2008-06-13 18:24:27 +0000644 default: {
645 rc = SQLITE_ERROR;
646 break;
647 }
648 }
649 va_end(ap);
650 return rc;
651}
652
653/*
drh633e6d52008-07-28 19:34:53 +0000654** Set up the lookaside buffers for a database connection.
655** Return SQLITE_OK on success.
656** If lookaside is already active, return SQLITE_BUSY.
drhe9d1c722008-08-04 20:13:26 +0000657**
658** The sz parameter is the number of bytes in each lookaside slot.
659** The cnt parameter is the number of slots. If pStart is NULL the
660** space for the lookaside memory is obtained from sqlite3_malloc().
661** If pStart is not NULL then it is sz*cnt bytes of memory to use for
662** the lookaside memory.
drh633e6d52008-07-28 19:34:53 +0000663*/
drhe9d1c722008-08-04 20:13:26 +0000664static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
drh7877d9a2015-07-23 17:16:27 +0000665#ifndef SQLITE_OMIT_LOOKASIDE
drh633e6d52008-07-28 19:34:53 +0000666 void *pStart;
667 if( db->lookaside.nOut ){
668 return SQLITE_BUSY;
669 }
shanef71f89e2009-01-30 06:11:54 +0000670 /* Free any existing lookaside buffer for this handle before
671 ** allocating a new one so we don't have to have space for
672 ** both at the same time.
673 */
674 if( db->lookaside.bMalloced ){
675 sqlite3_free(db->lookaside.pStart);
676 }
drh61a4bd52011-11-10 02:39:28 +0000677 /* The size of a lookaside slot after ROUNDDOWN8 needs to be larger
678 ** than a pointer to be useful.
shanef71f89e2009-01-30 06:11:54 +0000679 */
drh61a4bd52011-11-10 02:39:28 +0000680 sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */
drh1d34fde2009-02-03 15:50:33 +0000681 if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;
drh633e6d52008-07-28 19:34:53 +0000682 if( cnt<0 ) cnt = 0;
shanef71f89e2009-01-30 06:11:54 +0000683 if( sz==0 || cnt==0 ){
684 sz = 0;
685 pStart = 0;
686 }else if( pBuf==0 ){
drhe9d1c722008-08-04 20:13:26 +0000687 sqlite3BeginBenignMalloc();
drh9dd55f52010-09-03 03:32:46 +0000688 pStart = sqlite3Malloc( sz*cnt ); /* IMP: R-61949-35727 */
drhe9d1c722008-08-04 20:13:26 +0000689 sqlite3EndBenignMalloc();
drh8225d662011-11-10 02:24:11 +0000690 if( pStart ) cnt = sqlite3MallocSize(pStart)/sz;
drhe9d1c722008-08-04 20:13:26 +0000691 }else{
692 pStart = pBuf;
693 }
drh4cfb22f2008-08-01 18:47:01 +0000694 db->lookaside.pStart = pStart;
695 db->lookaside.pFree = 0;
drh1bd10f82008-12-10 21:19:56 +0000696 db->lookaside.sz = (u16)sz;
drh633e6d52008-07-28 19:34:53 +0000697 if( pStart ){
698 int i;
699 LookasideSlot *p;
drhde467982009-04-02 17:22:41 +0000700 assert( sz > (int)sizeof(LookasideSlot*) );
drh633e6d52008-07-28 19:34:53 +0000701 p = (LookasideSlot*)pStart;
702 for(i=cnt-1; i>=0; i--){
703 p->pNext = db->lookaside.pFree;
704 db->lookaside.pFree = p;
705 p = (LookasideSlot*)&((u8*)p)[sz];
706 }
707 db->lookaside.pEnd = p;
drh4a642b62016-02-05 01:55:27 +0000708 db->lookaside.bDisable = 0;
shanef71f89e2009-01-30 06:11:54 +0000709 db->lookaside.bMalloced = pBuf==0 ?1:0;
drh4cfb22f2008-08-01 18:47:01 +0000710 }else{
drhb0e77042013-12-10 19:49:00 +0000711 db->lookaside.pStart = db;
712 db->lookaside.pEnd = db;
drh4a642b62016-02-05 01:55:27 +0000713 db->lookaside.bDisable = 1;
shanef71f89e2009-01-30 06:11:54 +0000714 db->lookaside.bMalloced = 0;
drh633e6d52008-07-28 19:34:53 +0000715 }
drh7877d9a2015-07-23 17:16:27 +0000716#endif /* SQLITE_OMIT_LOOKASIDE */
drh633e6d52008-07-28 19:34:53 +0000717 return SQLITE_OK;
718}
719
720/*
drh4413d0e2008-11-04 13:46:27 +0000721** Return the mutex associated with a database connection.
722*/
723sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){
drh9ca95732014-10-24 00:35:58 +0000724#ifdef SQLITE_ENABLE_API_ARMOR
725 if( !sqlite3SafetyCheckOk(db) ){
726 (void)SQLITE_MISUSE_BKPT;
727 return 0;
728 }
729#endif
drh4413d0e2008-11-04 13:46:27 +0000730 return db->mutex;
731}
732
733/*
drh09419b42011-11-16 19:29:17 +0000734** Free up as much memory as we can from the given database
735** connection.
736*/
737int sqlite3_db_release_memory(sqlite3 *db){
738 int i;
drh9ca95732014-10-24 00:35:58 +0000739
740#ifdef SQLITE_ENABLE_API_ARMOR
741 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
742#endif
dand9bb3a92011-12-30 11:43:59 +0000743 sqlite3_mutex_enter(db->mutex);
drh09419b42011-11-16 19:29:17 +0000744 sqlite3BtreeEnterAll(db);
745 for(i=0; i<db->nDb; i++){
746 Btree *pBt = db->aDb[i].pBt;
747 if( pBt ){
748 Pager *pPager = sqlite3BtreePager(pBt);
749 sqlite3PagerShrink(pPager);
750 }
751 }
752 sqlite3BtreeLeaveAll(db);
dand9bb3a92011-12-30 11:43:59 +0000753 sqlite3_mutex_leave(db->mutex);
drh09419b42011-11-16 19:29:17 +0000754 return SQLITE_OK;
755}
756
757/*
dan6fa255f2015-10-28 19:46:57 +0000758** Flush any dirty pages in the pager-cache for any attached database
759** to disk.
760*/
761int sqlite3_db_cacheflush(sqlite3 *db){
762 int i;
763 int rc = SQLITE_OK;
764 int bSeenBusy = 0;
765
766#ifdef SQLITE_ENABLE_API_ARMOR
767 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
768#endif
769 sqlite3_mutex_enter(db->mutex);
770 sqlite3BtreeEnterAll(db);
771 for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
772 Btree *pBt = db->aDb[i].pBt;
773 if( pBt && sqlite3BtreeIsInTrans(pBt) ){
774 Pager *pPager = sqlite3BtreePager(pBt);
775 rc = sqlite3PagerFlush(pPager);
776 if( rc==SQLITE_BUSY ){
777 bSeenBusy = 1;
778 rc = SQLITE_OK;
779 }
780 }
781 }
dan6fa255f2015-10-28 19:46:57 +0000782 sqlite3BtreeLeaveAll(db);
783 sqlite3_mutex_leave(db->mutex);
784 return ((rc==SQLITE_OK && bSeenBusy) ? SQLITE_BUSY : rc);
785}
786
787/*
drh633e6d52008-07-28 19:34:53 +0000788** Configuration settings for an individual database connection
789*/
790int sqlite3_db_config(sqlite3 *db, int op, ...){
791 va_list ap;
drh6480aad2008-08-01 16:31:14 +0000792 int rc;
drh633e6d52008-07-28 19:34:53 +0000793 va_start(ap, op);
794 switch( op ){
drhda84dca2016-08-18 22:44:22 +0000795 case SQLITE_DBCONFIG_MAINDBNAME: {
drh749e4a92017-07-14 19:47:32 +0000796 /* IMP: R-06824-28531 */
797 /* IMP: R-36257-52125 */
drhda84dca2016-08-18 22:44:22 +0000798 db->aDb[0].zDbSName = va_arg(ap,char*);
799 rc = SQLITE_OK;
800 break;
801 }
drhe9d1c722008-08-04 20:13:26 +0000802 case SQLITE_DBCONFIG_LOOKASIDE: {
drh8b2b2e62011-04-07 01:14:12 +0000803 void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */
drh9dd55f52010-09-03 03:32:46 +0000804 int sz = va_arg(ap, int); /* IMP: R-47871-25994 */
805 int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */
drhe9d1c722008-08-04 20:13:26 +0000806 rc = setupLookaside(db, pBuf, sz, cnt);
drh633e6d52008-07-28 19:34:53 +0000807 break;
808 }
drh6480aad2008-08-01 16:31:14 +0000809 default: {
drhe83cafd2011-03-21 17:15:58 +0000810 static const struct {
811 int op; /* The opcode */
812 u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */
813 } aFlagOp[] = {
drhd42908f2016-02-26 15:38:24 +0000814 { SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys },
815 { SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger },
816 { SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer },
drh191dd062016-04-21 01:30:09 +0000817 { SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension },
dan298af022016-10-31 16:16:49 +0000818 { SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_NoCkptOnClose },
drh169dd922017-06-26 13:57:49 +0000819 { SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_EnableQPSG },
drhe83cafd2011-03-21 17:15:58 +0000820 };
drh58ad5802011-03-23 22:02:23 +0000821 unsigned int i;
drh9dd55f52010-09-03 03:32:46 +0000822 rc = SQLITE_ERROR; /* IMP: R-42790-23372 */
drhe83cafd2011-03-21 17:15:58 +0000823 for(i=0; i<ArraySize(aFlagOp); i++){
824 if( aFlagOp[i].op==op ){
825 int onoff = va_arg(ap, int);
826 int *pRes = va_arg(ap, int*);
mistachkinf6285fa2017-07-28 22:13:26 +0000827 u32 oldFlags = db->flags;
drhe83cafd2011-03-21 17:15:58 +0000828 if( onoff>0 ){
829 db->flags |= aFlagOp[i].mask;
830 }else if( onoff==0 ){
831 db->flags &= ~aFlagOp[i].mask;
832 }
833 if( oldFlags!=db->flags ){
834 sqlite3ExpirePreparedStatements(db);
835 }
836 if( pRes ){
837 *pRes = (db->flags & aFlagOp[i].mask)!=0;
838 }
839 rc = SQLITE_OK;
840 break;
841 }
842 }
drh6480aad2008-08-01 16:31:14 +0000843 break;
844 }
drh633e6d52008-07-28 19:34:53 +0000845 }
846 va_end(ap);
847 return rc;
848}
849
drha16313e2007-03-30 11:29:32 +0000850
851/*
drh9b5adfa2008-01-20 23:19:56 +0000852** Return true if the buffer z[0..n-1] contains all spaces.
853*/
854static int allSpaces(const char *z, int n){
drh5f3a3672008-04-15 04:02:40 +0000855 while( n>0 && z[n-1]==' ' ){ n--; }
drh9b5adfa2008-01-20 23:19:56 +0000856 return n==0;
857}
858
859/*
drhd3d39e92004-05-20 22:16:29 +0000860** This is the default collating function named "BINARY" which is always
861** available.
drh9b5adfa2008-01-20 23:19:56 +0000862**
863** If the padFlag argument is not NULL then space padding at the end
864** of strings is ignored. This implements the RTRIM collation.
drhd3d39e92004-05-20 22:16:29 +0000865*/
danielk19772c336542005-01-13 02:14:23 +0000866static int binCollFunc(
drh9b5adfa2008-01-20 23:19:56 +0000867 void *padFlag,
drhd3d39e92004-05-20 22:16:29 +0000868 int nKey1, const void *pKey1,
869 int nKey2, const void *pKey2
870){
871 int rc, n;
872 n = nKey1<nKey2 ? nKey1 : nKey2;
drh5e3b49b2014-11-20 19:22:26 +0000873 /* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares
874 ** strings byte by byte using the memcmp() function from the standard C
875 ** library. */
dan21766c02017-05-22 08:04:09 +0000876 assert( pKey1 && pKey2 );
drhd3d39e92004-05-20 22:16:29 +0000877 rc = memcmp(pKey1, pKey2, n);
878 if( rc==0 ){
drh9b5adfa2008-01-20 23:19:56 +0000879 if( padFlag
880 && allSpaces(((char*)pKey1)+n, nKey1-n)
881 && allSpaces(((char*)pKey2)+n, nKey2-n)
882 ){
drh5e3b49b2014-11-20 19:22:26 +0000883 /* EVIDENCE-OF: R-31624-24737 RTRIM is like BINARY except that extra
884 ** spaces at the end of either string do not change the result. In other
885 ** words, strings will compare equal to one another as long as they
886 ** differ only in the number of spaces at the end.
887 */
drh9b5adfa2008-01-20 23:19:56 +0000888 }else{
889 rc = nKey1 - nKey2;
890 }
drhd3d39e92004-05-20 22:16:29 +0000891 }
892 return rc;
893}
894
895/*
danielk1977dc1bdc42004-06-11 10:51:27 +0000896** Another built-in collating sequence: NOCASE.
897**
drhf7b54962013-05-28 12:11:54 +0000898** This collating sequence is intended to be used for "case independent
danielk1977dc1bdc42004-06-11 10:51:27 +0000899** comparison". SQLite's knowledge of upper and lower case equivalents
900** extends only to the 26 characters used in the English language.
901**
902** At the moment there is only a UTF-8 implementation.
danielk19770202b292004-06-09 09:55:16 +0000903*/
904static int nocaseCollatingFunc(
905 void *NotUsed,
906 int nKey1, const void *pKey1,
907 int nKey2, const void *pKey2
908){
909 int r = sqlite3StrNICmp(
drh208f80a2004-08-29 20:08:58 +0000910 (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
danielk197762c14b32008-11-19 09:05:26 +0000911 UNUSED_PARAMETER(NotUsed);
danielk19770202b292004-06-09 09:55:16 +0000912 if( 0==r ){
913 r = nKey1-nKey2;
914 }
915 return r;
916}
917
918/*
drhaf9ff332002-01-16 21:00:27 +0000919** Return the ROWID of the most recent insert
920*/
drh9bb575f2004-09-06 17:24:11 +0000921sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
drh9ca95732014-10-24 00:35:58 +0000922#ifdef SQLITE_ENABLE_API_ARMOR
923 if( !sqlite3SafetyCheckOk(db) ){
924 (void)SQLITE_MISUSE_BKPT;
925 return 0;
926 }
927#endif
drhaf9ff332002-01-16 21:00:27 +0000928 return db->lastRowid;
929}
930
931/*
dan9c58b632017-02-27 14:52:48 +0000932** Set the value returned by the sqlite3_last_insert_rowid() API function.
933*/
934void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){
935#ifdef SQLITE_ENABLE_API_ARMOR
936 if( !sqlite3SafetyCheckOk(db) ){
937 (void)SQLITE_MISUSE_BKPT;
938 return;
939 }
940#endif
941 sqlite3_mutex_enter(db->mutex);
942 db->lastRowid = iRowid;
943 sqlite3_mutex_leave(db->mutex);
944}
945
946/*
danielk197724b03fd2004-05-10 10:34:34 +0000947** Return the number of changes in the most recent call to sqlite3_exec().
drhc8d30ac2002-04-12 10:08:59 +0000948*/
drh9bb575f2004-09-06 17:24:11 +0000949int sqlite3_changes(sqlite3 *db){
drh9ca95732014-10-24 00:35:58 +0000950#ifdef SQLITE_ENABLE_API_ARMOR
951 if( !sqlite3SafetyCheckOk(db) ){
952 (void)SQLITE_MISUSE_BKPT;
953 return 0;
954 }
955#endif
drhc8d30ac2002-04-12 10:08:59 +0000956 return db->nChange;
957}
958
rdcf146a772004-02-25 22:51:06 +0000959/*
danielk1977b28af712004-06-21 06:50:26 +0000960** Return the number of changes since the database handle was opened.
rdcf146a772004-02-25 22:51:06 +0000961*/
danielk1977b28af712004-06-21 06:50:26 +0000962int sqlite3_total_changes(sqlite3 *db){
drh9ca95732014-10-24 00:35:58 +0000963#ifdef SQLITE_ENABLE_API_ARMOR
964 if( !sqlite3SafetyCheckOk(db) ){
965 (void)SQLITE_MISUSE_BKPT;
966 return 0;
967 }
968#endif
danielk1977b28af712004-06-21 06:50:26 +0000969 return db->nTotalChange;
rdcb0c374f2004-02-20 22:53:38 +0000970}
971
drhc8d30ac2002-04-12 10:08:59 +0000972/*
danielk1977fd7f0452008-12-17 17:30:26 +0000973** Close all open savepoints. This function only manipulates fields of the
974** database handle object, it does not close any savepoints that may be open
975** at the b-tree/pager level.
976*/
977void sqlite3CloseSavepoints(sqlite3 *db){
978 while( db->pSavepoint ){
979 Savepoint *pTmp = db->pSavepoint;
980 db->pSavepoint = pTmp->pNext;
981 sqlite3DbFree(db, pTmp);
982 }
983 db->nSavepoint = 0;
danielk1977bd434552009-03-18 10:33:00 +0000984 db->nStatement = 0;
danielk1977fd7f0452008-12-17 17:30:26 +0000985 db->isTransactionSavepoint = 0;
986}
987
988/*
dand2199f02010-08-27 17:48:52 +0000989** Invoke the destructor function associated with FuncDef p, if any. Except,
990** if this is not the last copy of the function, do not invoke it. Multiple
991** copies of a single function are created when create_function() is called
992** with SQLITE_ANY as the encoding.
993*/
994static void functionDestroy(sqlite3 *db, FuncDef *p){
drh80738d92016-02-15 00:34:16 +0000995 FuncDestructor *pDestructor = p->u.pDestructor;
dand2199f02010-08-27 17:48:52 +0000996 if( pDestructor ){
997 pDestructor->nRef--;
998 if( pDestructor->nRef==0 ){
999 pDestructor->xDestroy(pDestructor->pUserData);
1000 sqlite3DbFree(db, pDestructor);
1001 }
1002 }
1003}
1004
1005/*
danbba02a92012-05-15 17:15:34 +00001006** Disconnect all sqlite3_vtab objects that belong to database connection
1007** db. This is called when db is being closed.
1008*/
1009static void disconnectAllVtab(sqlite3 *db){
1010#ifndef SQLITE_OMIT_VIRTUALTABLE
1011 int i;
drh51be3872015-08-19 02:32:25 +00001012 HashElem *p;
danbba02a92012-05-15 17:15:34 +00001013 sqlite3BtreeEnterAll(db);
1014 for(i=0; i<db->nDb; i++){
1015 Schema *pSchema = db->aDb[i].pSchema;
1016 if( db->aDb[i].pSchema ){
danbba02a92012-05-15 17:15:34 +00001017 for(p=sqliteHashFirst(&pSchema->tblHash); p; p=sqliteHashNext(p)){
1018 Table *pTab = (Table *)sqliteHashData(p);
1019 if( IsVirtual(pTab) ) sqlite3VtabDisconnect(db, pTab);
1020 }
1021 }
1022 }
drh51be3872015-08-19 02:32:25 +00001023 for(p=sqliteHashFirst(&db->aModule); p; p=sqliteHashNext(p)){
1024 Module *pMod = (Module *)sqliteHashData(p);
1025 if( pMod->pEpoTab ){
1026 sqlite3VtabDisconnect(db, pMod->pEpoTab);
1027 }
1028 }
dand88e5212014-03-12 19:38:38 +00001029 sqlite3VtabUnlockList(db);
danbba02a92012-05-15 17:15:34 +00001030 sqlite3BtreeLeaveAll(db);
1031#else
1032 UNUSED_PARAMETER(db);
1033#endif
1034}
1035
1036/*
drh167cd6a2012-06-02 17:09:46 +00001037** Return TRUE if database connection db has unfinalized prepared
1038** statements or unfinished sqlite3_backup objects.
1039*/
1040static int connectionIsBusy(sqlite3 *db){
1041 int j;
1042 assert( sqlite3_mutex_held(db->mutex) );
1043 if( db->pVdbe ) return 1;
1044 for(j=0; j<db->nDb; j++){
1045 Btree *pBt = db->aDb[j].pBt;
1046 if( pBt && sqlite3BtreeIsInBackup(pBt) ) return 1;
1047 }
1048 return 0;
1049}
1050
1051/*
drh50e5dad2001-09-15 00:57:28 +00001052** Close an existing SQLite database
1053*/
drh167cd6a2012-06-02 17:09:46 +00001054static int sqlite3Close(sqlite3 *db, int forceZombie){
danielk19775c4c7782004-06-16 10:39:23 +00001055 if( !db ){
drhddb17ca2014-08-11 15:54:11 +00001056 /* EVIDENCE-OF: R-63257-11740 Calling sqlite3_close() or
1057 ** sqlite3_close_v2() with a NULL pointer argument is a harmless no-op. */
danielk197796d81f92004-06-19 03:33:57 +00001058 return SQLITE_OK;
danielk19775c4c7782004-06-16 10:39:23 +00001059 }
drh7e8b8482008-01-23 03:03:05 +00001060 if( !sqlite3SafetyCheckSickOrOk(db) ){
drh413c3d32010-02-23 20:11:56 +00001061 return SQLITE_MISUSE_BKPT;
danielk1977e35ee192004-06-26 09:50:11 +00001062 }
drh605264d2007-08-21 15:13:19 +00001063 sqlite3_mutex_enter(db->mutex);
drh3d2a5292016-07-13 22:55:01 +00001064 if( db->mTrace & SQLITE_TRACE_CLOSE ){
1065 db->xTrace(SQLITE_TRACE_CLOSE, db->pTraceArg, db, 0);
1066 }
danielk1977e35ee192004-06-26 09:50:11 +00001067
danbba02a92012-05-15 17:15:34 +00001068 /* Force xDisconnect calls on all virtual tables */
1069 disconnectAllVtab(db);
danielk1977a04a34f2007-04-16 15:06:25 +00001070
danbba02a92012-05-15 17:15:34 +00001071 /* If a transaction is open, the disconnectAllVtab() call above
danielk197701256832007-04-18 14:24:32 +00001072 ** will not have called the xDisconnect() method on any virtual
1073 ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
1074 ** call will do so. We need to do this before the check for active
1075 ** SQL statements below, as the v-table implementation may be storing
1076 ** some prepared statements internally.
1077 */
1078 sqlite3VtabRollback(db);
1079
drh167cd6a2012-06-02 17:09:46 +00001080 /* Legacy behavior (sqlite3_close() behavior) is to return
1081 ** SQLITE_BUSY if the connection can not be closed immediately.
1082 */
1083 if( !forceZombie && connectionIsBusy(db) ){
drh13f40da2014-08-22 18:00:11 +00001084 sqlite3ErrorWithMsg(db, SQLITE_BUSY, "unable to close due to unfinalized "
drh167cd6a2012-06-02 17:09:46 +00001085 "statements or unfinished backups");
drh27641702007-08-22 02:56:42 +00001086 sqlite3_mutex_leave(db->mutex);
danielk197796d81f92004-06-19 03:33:57 +00001087 return SQLITE_BUSY;
1088 }
danielk1977e0048402004-06-15 16:51:01 +00001089
danac455932012-11-26 19:50:41 +00001090#ifdef SQLITE_ENABLE_SQLLOG
1091 if( sqlite3GlobalConfig.xSqllog ){
dan71ba10d2012-11-27 10:56:39 +00001092 /* Closing the handle. Fourth parameter is passed the value 2. */
1093 sqlite3GlobalConfig.xSqllog(sqlite3GlobalConfig.pSqllogArg, db, 0, 2);
danac455932012-11-26 19:50:41 +00001094 }
1095#endif
1096
drh167cd6a2012-06-02 17:09:46 +00001097 /* Convert the connection into a zombie and then close it.
drh4245c402012-06-02 14:32:21 +00001098 */
1099 db->magic = SQLITE_MAGIC_ZOMBIE;
1100 sqlite3LeaveMutexAndCloseZombie(db);
1101 return SQLITE_OK;
1102}
drh94e92032003-02-16 22:21:32 +00001103
drh167cd6a2012-06-02 17:09:46 +00001104/*
1105** Two variations on the public interface for closing a database
1106** connection. The sqlite3_close() version returns SQLITE_BUSY and
1107** leaves the connection option if there are unfinalized prepared
1108** statements or unfinished sqlite3_backups. The sqlite3_close_v2()
1109** version forces the connection to become a zombie if there are
1110** unclosed resources, and arranges for deallocation when the last
1111** prepare statement or sqlite3_backup closes.
1112*/
1113int sqlite3_close(sqlite3 *db){ return sqlite3Close(db,0); }
1114int sqlite3_close_v2(sqlite3 *db){ return sqlite3Close(db,1); }
1115
drh4245c402012-06-02 14:32:21 +00001116
1117/*
1118** Close the mutex on database connection db.
1119**
1120** Furthermore, if database connection db is a zombie (meaning that there
drh167cd6a2012-06-02 17:09:46 +00001121** has been a prior call to sqlite3_close(db) or sqlite3_close_v2(db)) and
1122** every sqlite3_stmt has now been finalized and every sqlite3_backup has
1123** finished, then free all resources.
drh4245c402012-06-02 14:32:21 +00001124*/
1125void sqlite3LeaveMutexAndCloseZombie(sqlite3 *db){
1126 HashElem *i; /* Hash table iterator */
1127 int j;
1128
drh4245c402012-06-02 14:32:21 +00001129 /* If there are outstanding sqlite3_stmt or sqlite3_backup objects
drh167cd6a2012-06-02 17:09:46 +00001130 ** or if the connection has not yet been closed by sqlite3_close_v2(),
1131 ** then just leave the mutex and return.
drh4245c402012-06-02 14:32:21 +00001132 */
drh167cd6a2012-06-02 17:09:46 +00001133 if( db->magic!=SQLITE_MAGIC_ZOMBIE || connectionIsBusy(db) ){
drh4245c402012-06-02 14:32:21 +00001134 sqlite3_mutex_leave(db->mutex);
1135 return;
danielk197704103022009-02-03 16:51:24 +00001136 }
1137
drh4245c402012-06-02 14:32:21 +00001138 /* If we reach this point, it means that the database connection has
1139 ** closed all sqlite3_stmt and sqlite3_backup objects and has been
mistachkin48864df2013-03-21 21:20:32 +00001140 ** passed to sqlite3_close (meaning that it is a zombie). Therefore,
drh4245c402012-06-02 14:32:21 +00001141 ** go ahead and free all resources.
1142 */
1143
dan617dc862013-05-16 11:57:28 +00001144 /* If a transaction is open, roll it back. This also ensures that if
1145 ** any database schemas have been modified by an uncommitted transaction
1146 ** they are reset. And that the required b-tree mutex is held to make
1147 ** the pager rollback and schema reset an atomic operation. */
1148 sqlite3RollbackAll(db, SQLITE_OK);
1149
danielk1977fd7f0452008-12-17 17:30:26 +00001150 /* Free any outstanding Savepoint structures. */
1151 sqlite3CloseSavepoints(db);
1152
drh5efb3142012-05-16 01:24:34 +00001153 /* Close all database connections */
drh001bbcb2003-03-19 03:14:00 +00001154 for(j=0; j<db->nDb; j++){
drh4d189ca2004-02-12 18:46:38 +00001155 struct Db *pDb = &db->aDb[j];
1156 if( pDb->pBt ){
danielk19774adee202004-05-08 08:23:19 +00001157 sqlite3BtreeClose(pDb->pBt);
drh4d189ca2004-02-12 18:46:38 +00001158 pDb->pBt = 0;
danielk1977311019b2006-01-10 07:14:23 +00001159 if( j!=1 ){
1160 pDb->pSchema = 0;
1161 }
drh113088e2003-03-20 01:16:58 +00001162 }
drhf57b3392001-10-08 13:22:32 +00001163 }
drh5efb3142012-05-16 01:24:34 +00001164 /* Clear the TEMP schema separately and last */
1165 if( db->aDb[1].pSchema ){
1166 sqlite3SchemaClear(db->aDb[1].pSchema);
1167 }
1168 sqlite3VtabUnlockList(db);
danbba02a92012-05-15 17:15:34 +00001169
drh5efb3142012-05-16 01:24:34 +00001170 /* Free up the array of auxiliary databases */
1171 sqlite3CollapseDatabaseArray(db);
danbba02a92012-05-15 17:15:34 +00001172 assert( db->nDb<=2 );
1173 assert( db->aDb==db->aDbStatic );
danielk1977404ca072009-03-16 13:19:36 +00001174
1175 /* Tell the code in notify.c that the connection no longer holds any
1176 ** locks and does not require any further unlock-notify callbacks.
1177 */
1178 sqlite3ConnectionClosed(db);
1179
drh80738d92016-02-15 00:34:16 +00001180 for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
1181 FuncDef *pNext, *p;
1182 p = sqliteHashData(i);
1183 do{
1184 functionDestroy(db, p);
1185 pNext = p->pNext;
1186 sqlite3DbFree(db, p);
1187 p = pNext;
1188 }while( p );
drh8e0a2f92002-02-23 23:45:45 +00001189 }
drh80738d92016-02-15 00:34:16 +00001190 sqlite3HashClear(&db->aFunc);
danielk1977d8123362004-06-12 09:25:12 +00001191 for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
danielk1977466be562004-06-10 02:16:01 +00001192 CollSeq *pColl = (CollSeq *)sqliteHashData(i);
danielk1977a9808b32007-05-07 09:32:45 +00001193 /* Invoke any destructors registered for collation sequence user data. */
1194 for(j=0; j<3; j++){
1195 if( pColl[j].xDel ){
1196 pColl[j].xDel(pColl[j].pUser);
1197 }
1198 }
drh633e6d52008-07-28 19:34:53 +00001199 sqlite3DbFree(db, pColl);
danielk1977466be562004-06-10 02:16:01 +00001200 }
danielk1977d8123362004-06-12 09:25:12 +00001201 sqlite3HashClear(&db->aCollSeq);
drhb9bb7c12006-06-11 23:41:55 +00001202#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977d1ab1ba2006-06-15 04:28:13 +00001203 for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
1204 Module *pMod = (Module *)sqliteHashData(i);
danielk1977832a58a2007-06-22 15:21:15 +00001205 if( pMod->xDestroy ){
1206 pMod->xDestroy(pMod->pAux);
1207 }
drh51be3872015-08-19 02:32:25 +00001208 sqlite3VtabEponymousTableClear(db, pMod);
drh633e6d52008-07-28 19:34:53 +00001209 sqlite3DbFree(db, pMod);
danielk1977d1ab1ba2006-06-15 04:28:13 +00001210 }
drhb9bb7c12006-06-11 23:41:55 +00001211 sqlite3HashClear(&db->aModule);
1212#endif
danielk1977466be562004-06-10 02:16:01 +00001213
drh13f40da2014-08-22 18:00:11 +00001214 sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */
drha3cc0072013-12-13 16:23:55 +00001215 sqlite3ValueFree(db->pErr);
drhf1952c52006-06-08 15:48:00 +00001216 sqlite3CloseExtensions(db);
drhd4530972014-09-09 14:47:53 +00001217#if SQLITE_USER_AUTHENTICATION
1218 sqlite3_free(db->auth.zAuthUser);
1219 sqlite3_free(db->auth.zAuthPW);
1220#endif
danielk197796d81f92004-06-19 03:33:57 +00001221
1222 db->magic = SQLITE_MAGIC_ERROR;
danielk1977311019b2006-01-10 07:14:23 +00001223
1224 /* The temp-database schema is allocated differently from the other schema
1225 ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
1226 ** So it needs to be freed here. Todo: Why not roll the temp schema into
1227 ** the same sqliteMalloc() as the one that allocates the database
1228 ** structure?
1229 */
drh633e6d52008-07-28 19:34:53 +00001230 sqlite3DbFree(db, db->aDb[1].pSchema);
drh605264d2007-08-21 15:13:19 +00001231 sqlite3_mutex_leave(db->mutex);
drh7e8b8482008-01-23 03:03:05 +00001232 db->magic = SQLITE_MAGIC_CLOSED;
drh605264d2007-08-21 15:13:19 +00001233 sqlite3_mutex_free(db->mutex);
drh4150ebf2008-10-11 15:38:29 +00001234 assert( db->lookaside.nOut==0 ); /* Fails on a lookaside memory leak */
drhe9d1c722008-08-04 20:13:26 +00001235 if( db->lookaside.bMalloced ){
1236 sqlite3_free(db->lookaside.pStart);
1237 }
drh17435752007-08-16 04:30:38 +00001238 sqlite3_free(db);
drh75897232000-05-29 14:26:00 +00001239}
1240
1241/*
drh0f198a72012-02-13 16:43:16 +00001242** Rollback all database files. If tripCode is not SQLITE_OK, then
drh47b7fc72014-11-11 01:33:57 +00001243** any write cursors are invalidated ("tripped" - as in "tripping a circuit
drh0f198a72012-02-13 16:43:16 +00001244** breaker") and made to return tripCode if there are any further
drh47b7fc72014-11-11 01:33:57 +00001245** attempts to use that cursor. Read cursors remain open and valid
1246** but are "saved" in case the table pages are moved around.
drh001bbcb2003-03-19 03:14:00 +00001247*/
drh0f198a72012-02-13 16:43:16 +00001248void sqlite3RollbackAll(sqlite3 *db, int tripCode){
drh001bbcb2003-03-19 03:14:00 +00001249 int i;
danielk1977f3f06bb2005-12-16 15:24:28 +00001250 int inTrans = 0;
drh47b7fc72014-11-11 01:33:57 +00001251 int schemaChange;
drhe30f4422007-08-21 16:15:55 +00001252 assert( sqlite3_mutex_held(db->mutex) );
danielk19772d1d86f2008-06-20 14:59:51 +00001253 sqlite3BeginBenignMalloc();
dan617dc862013-05-16 11:57:28 +00001254
1255 /* Obtain all b-tree mutexes before making any calls to BtreeRollback().
1256 ** This is important in case the transaction being rolled back has
1257 ** modified the database schema. If the b-tree mutexes are not taken
1258 ** here, then another shared-cache connection might sneak in between
1259 ** the database rollback and schema reset, which can cause false
1260 ** corruption reports in some cases. */
dancd7b91a2013-05-13 18:23:15 +00001261 sqlite3BtreeEnterAll(db);
drh8257aa82017-07-26 19:59:13 +00001262 schemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0 && db->init.busy==0;
dan617dc862013-05-16 11:57:28 +00001263
drh001bbcb2003-03-19 03:14:00 +00001264 for(i=0; i<db->nDb; i++){
drh0f198a72012-02-13 16:43:16 +00001265 Btree *p = db->aDb[i].pBt;
1266 if( p ){
1267 if( sqlite3BtreeIsInTrans(p) ){
danielk1977f3f06bb2005-12-16 15:24:28 +00001268 inTrans = 1;
1269 }
drh47b7fc72014-11-11 01:33:57 +00001270 sqlite3BtreeRollback(p, tripCode, !schemaChange);
drh001bbcb2003-03-19 03:14:00 +00001271 }
1272 }
danielk1977a298e902006-06-22 09:53:48 +00001273 sqlite3VtabRollback(db);
danielk19772d1d86f2008-06-20 14:59:51 +00001274 sqlite3EndBenignMalloc();
danielk1977ae72d982007-10-03 08:46:44 +00001275
drh8257aa82017-07-26 19:59:13 +00001276 if( (db->mDbFlags&DBFLAG_SchemaChange)!=0 && db->init.busy==0 ){
danielk1977ea4d9e22007-08-13 15:28:33 +00001277 sqlite3ExpirePreparedStatements(db);
drh81028a42012-05-15 18:28:27 +00001278 sqlite3ResetAllSchemasOfConnection(db);
danielk197771fd80b2005-12-16 06:54:01 +00001279 }
dancd7b91a2013-05-13 18:23:15 +00001280 sqlite3BtreeLeaveAll(db);
danielk197771fd80b2005-12-16 06:54:01 +00001281
dan1da40a32009-09-19 17:00:31 +00001282 /* Any deferred constraint violations have now been resolved. */
1283 db->nDeferredCons = 0;
dancb3e4b72013-07-03 19:53:05 +00001284 db->nDeferredImmCons = 0;
drh963c74d2013-07-11 12:19:12 +00001285 db->flags &= ~SQLITE_DeferFKs;
dan1da40a32009-09-19 17:00:31 +00001286
danielk197771fd80b2005-12-16 06:54:01 +00001287 /* If one has been configured, invoke the rollback-hook callback */
danielk1977f3f06bb2005-12-16 15:24:28 +00001288 if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
danielk197771fd80b2005-12-16 06:54:01 +00001289 db->xRollbackCallback(db->pRollbackArg);
1290 }
drh001bbcb2003-03-19 03:14:00 +00001291}
1292
1293/*
mistachkinf2c1c992013-04-28 01:44:43 +00001294** Return a static string containing the name corresponding to the error code
1295** specified in the argument.
1296*/
mistachkin5824d442015-04-28 23:34:10 +00001297#if defined(SQLITE_NEED_ERR_NAME)
mistachkinf2c1c992013-04-28 01:44:43 +00001298const char *sqlite3ErrName(int rc){
1299 const char *zName = 0;
mistachkin10269dc2013-04-30 07:54:42 +00001300 int i, origRc = rc;
mistachkinf2c1c992013-04-28 01:44:43 +00001301 for(i=0; i<2 && zName==0; i++, rc &= 0xff){
1302 switch( rc ){
1303 case SQLITE_OK: zName = "SQLITE_OK"; break;
1304 case SQLITE_ERROR: zName = "SQLITE_ERROR"; break;
1305 case SQLITE_INTERNAL: zName = "SQLITE_INTERNAL"; break;
1306 case SQLITE_PERM: zName = "SQLITE_PERM"; break;
1307 case SQLITE_ABORT: zName = "SQLITE_ABORT"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001308 case SQLITE_ABORT_ROLLBACK: zName = "SQLITE_ABORT_ROLLBACK"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001309 case SQLITE_BUSY: zName = "SQLITE_BUSY"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001310 case SQLITE_BUSY_RECOVERY: zName = "SQLITE_BUSY_RECOVERY"; break;
danf73819a2013-06-27 11:46:27 +00001311 case SQLITE_BUSY_SNAPSHOT: zName = "SQLITE_BUSY_SNAPSHOT"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001312 case SQLITE_LOCKED: zName = "SQLITE_LOCKED"; break;
1313 case SQLITE_LOCKED_SHAREDCACHE: zName = "SQLITE_LOCKED_SHAREDCACHE";break;
1314 case SQLITE_NOMEM: zName = "SQLITE_NOMEM"; break;
1315 case SQLITE_READONLY: zName = "SQLITE_READONLY"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001316 case SQLITE_READONLY_RECOVERY: zName = "SQLITE_READONLY_RECOVERY"; break;
1317 case SQLITE_READONLY_CANTLOCK: zName = "SQLITE_READONLY_CANTLOCK"; break;
1318 case SQLITE_READONLY_ROLLBACK: zName = "SQLITE_READONLY_ROLLBACK"; break;
mistachkin091a81b2013-12-06 19:58:32 +00001319 case SQLITE_READONLY_DBMOVED: zName = "SQLITE_READONLY_DBMOVED"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001320 case SQLITE_INTERRUPT: zName = "SQLITE_INTERRUPT"; break;
1321 case SQLITE_IOERR: zName = "SQLITE_IOERR"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001322 case SQLITE_IOERR_READ: zName = "SQLITE_IOERR_READ"; break;
1323 case SQLITE_IOERR_SHORT_READ: zName = "SQLITE_IOERR_SHORT_READ"; break;
1324 case SQLITE_IOERR_WRITE: zName = "SQLITE_IOERR_WRITE"; break;
1325 case SQLITE_IOERR_FSYNC: zName = "SQLITE_IOERR_FSYNC"; break;
1326 case SQLITE_IOERR_DIR_FSYNC: zName = "SQLITE_IOERR_DIR_FSYNC"; break;
1327 case SQLITE_IOERR_TRUNCATE: zName = "SQLITE_IOERR_TRUNCATE"; break;
1328 case SQLITE_IOERR_FSTAT: zName = "SQLITE_IOERR_FSTAT"; break;
1329 case SQLITE_IOERR_UNLOCK: zName = "SQLITE_IOERR_UNLOCK"; break;
1330 case SQLITE_IOERR_RDLOCK: zName = "SQLITE_IOERR_RDLOCK"; break;
1331 case SQLITE_IOERR_DELETE: zName = "SQLITE_IOERR_DELETE"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001332 case SQLITE_IOERR_NOMEM: zName = "SQLITE_IOERR_NOMEM"; break;
1333 case SQLITE_IOERR_ACCESS: zName = "SQLITE_IOERR_ACCESS"; break;
1334 case SQLITE_IOERR_CHECKRESERVEDLOCK:
1335 zName = "SQLITE_IOERR_CHECKRESERVEDLOCK"; break;
1336 case SQLITE_IOERR_LOCK: zName = "SQLITE_IOERR_LOCK"; break;
1337 case SQLITE_IOERR_CLOSE: zName = "SQLITE_IOERR_CLOSE"; break;
1338 case SQLITE_IOERR_DIR_CLOSE: zName = "SQLITE_IOERR_DIR_CLOSE"; break;
1339 case SQLITE_IOERR_SHMOPEN: zName = "SQLITE_IOERR_SHMOPEN"; break;
1340 case SQLITE_IOERR_SHMSIZE: zName = "SQLITE_IOERR_SHMSIZE"; break;
1341 case SQLITE_IOERR_SHMLOCK: zName = "SQLITE_IOERR_SHMLOCK"; break;
1342 case SQLITE_IOERR_SHMMAP: zName = "SQLITE_IOERR_SHMMAP"; break;
1343 case SQLITE_IOERR_SEEK: zName = "SQLITE_IOERR_SEEK"; break;
1344 case SQLITE_IOERR_DELETE_NOENT: zName = "SQLITE_IOERR_DELETE_NOENT";break;
1345 case SQLITE_IOERR_MMAP: zName = "SQLITE_IOERR_MMAP"; break;
mistachkin16a2e7a2013-07-31 22:27:16 +00001346 case SQLITE_IOERR_GETTEMPPATH: zName = "SQLITE_IOERR_GETTEMPPATH"; break;
mistachkind95a3d32013-08-30 21:52:38 +00001347 case SQLITE_IOERR_CONVPATH: zName = "SQLITE_IOERR_CONVPATH"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001348 case SQLITE_CORRUPT: zName = "SQLITE_CORRUPT"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001349 case SQLITE_CORRUPT_VTAB: zName = "SQLITE_CORRUPT_VTAB"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001350 case SQLITE_NOTFOUND: zName = "SQLITE_NOTFOUND"; break;
1351 case SQLITE_FULL: zName = "SQLITE_FULL"; break;
1352 case SQLITE_CANTOPEN: zName = "SQLITE_CANTOPEN"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001353 case SQLITE_CANTOPEN_NOTEMPDIR: zName = "SQLITE_CANTOPEN_NOTEMPDIR";break;
1354 case SQLITE_CANTOPEN_ISDIR: zName = "SQLITE_CANTOPEN_ISDIR"; break;
1355 case SQLITE_CANTOPEN_FULLPATH: zName = "SQLITE_CANTOPEN_FULLPATH"; break;
mistachkind95a3d32013-08-30 21:52:38 +00001356 case SQLITE_CANTOPEN_CONVPATH: zName = "SQLITE_CANTOPEN_CONVPATH"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001357 case SQLITE_PROTOCOL: zName = "SQLITE_PROTOCOL"; break;
1358 case SQLITE_EMPTY: zName = "SQLITE_EMPTY"; break;
1359 case SQLITE_SCHEMA: zName = "SQLITE_SCHEMA"; break;
1360 case SQLITE_TOOBIG: zName = "SQLITE_TOOBIG"; break;
1361 case SQLITE_CONSTRAINT: zName = "SQLITE_CONSTRAINT"; break;
1362 case SQLITE_CONSTRAINT_UNIQUE: zName = "SQLITE_CONSTRAINT_UNIQUE"; break;
1363 case SQLITE_CONSTRAINT_TRIGGER: zName = "SQLITE_CONSTRAINT_TRIGGER";break;
1364 case SQLITE_CONSTRAINT_FOREIGNKEY:
1365 zName = "SQLITE_CONSTRAINT_FOREIGNKEY"; break;
1366 case SQLITE_CONSTRAINT_CHECK: zName = "SQLITE_CONSTRAINT_CHECK"; break;
1367 case SQLITE_CONSTRAINT_PRIMARYKEY:
1368 zName = "SQLITE_CONSTRAINT_PRIMARYKEY"; break;
1369 case SQLITE_CONSTRAINT_NOTNULL: zName = "SQLITE_CONSTRAINT_NOTNULL";break;
1370 case SQLITE_CONSTRAINT_COMMITHOOK:
1371 zName = "SQLITE_CONSTRAINT_COMMITHOOK"; break;
1372 case SQLITE_CONSTRAINT_VTAB: zName = "SQLITE_CONSTRAINT_VTAB"; break;
1373 case SQLITE_CONSTRAINT_FUNCTION:
1374 zName = "SQLITE_CONSTRAINT_FUNCTION"; break;
drhf9c8ce32013-11-05 13:33:55 +00001375 case SQLITE_CONSTRAINT_ROWID: zName = "SQLITE_CONSTRAINT_ROWID"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001376 case SQLITE_MISMATCH: zName = "SQLITE_MISMATCH"; break;
1377 case SQLITE_MISUSE: zName = "SQLITE_MISUSE"; break;
1378 case SQLITE_NOLFS: zName = "SQLITE_NOLFS"; break;
1379 case SQLITE_AUTH: zName = "SQLITE_AUTH"; break;
1380 case SQLITE_FORMAT: zName = "SQLITE_FORMAT"; break;
1381 case SQLITE_RANGE: zName = "SQLITE_RANGE"; break;
1382 case SQLITE_NOTADB: zName = "SQLITE_NOTADB"; break;
1383 case SQLITE_ROW: zName = "SQLITE_ROW"; break;
1384 case SQLITE_NOTICE: zName = "SQLITE_NOTICE"; break;
mistachkine84d8d32013-04-29 03:09:10 +00001385 case SQLITE_NOTICE_RECOVER_WAL: zName = "SQLITE_NOTICE_RECOVER_WAL";break;
1386 case SQLITE_NOTICE_RECOVER_ROLLBACK:
1387 zName = "SQLITE_NOTICE_RECOVER_ROLLBACK"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001388 case SQLITE_WARNING: zName = "SQLITE_WARNING"; break;
drh8d56e202013-06-28 23:55:45 +00001389 case SQLITE_WARNING_AUTOINDEX: zName = "SQLITE_WARNING_AUTOINDEX"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001390 case SQLITE_DONE: zName = "SQLITE_DONE"; break;
mistachkinf2c1c992013-04-28 01:44:43 +00001391 }
1392 }
mistachkin10269dc2013-04-30 07:54:42 +00001393 if( zName==0 ){
1394 static char zBuf[50];
1395 sqlite3_snprintf(sizeof(zBuf), zBuf, "SQLITE_UNKNOWN(%d)", origRc);
1396 zName = zBuf;
1397 }
mistachkinf2c1c992013-04-28 01:44:43 +00001398 return zName;
1399}
mistachkin10269dc2013-04-30 07:54:42 +00001400#endif
mistachkinf2c1c992013-04-28 01:44:43 +00001401
1402/*
drhc22bd472002-05-10 13:14:07 +00001403** Return a static string that describes the kind of error specified in the
1404** argument.
drh247be432002-05-10 05:44:55 +00001405*/
danielk1977f20b21c2004-05-31 23:56:42 +00001406const char *sqlite3ErrStr(int rc){
drh51c7d862009-04-27 18:46:06 +00001407 static const char* const aMsg[] = {
1408 /* SQLITE_OK */ "not an error",
drha690ff32017-07-07 19:43:23 +00001409 /* SQLITE_ERROR */ "SQL logic error",
drh51c7d862009-04-27 18:46:06 +00001410 /* SQLITE_INTERNAL */ 0,
1411 /* SQLITE_PERM */ "access permission denied",
drhff4fa772017-07-10 12:07:53 +00001412 /* SQLITE_ABORT */ "query aborted",
drh51c7d862009-04-27 18:46:06 +00001413 /* SQLITE_BUSY */ "database is locked",
1414 /* SQLITE_LOCKED */ "database table is locked",
1415 /* SQLITE_NOMEM */ "out of memory",
1416 /* SQLITE_READONLY */ "attempt to write a readonly database",
1417 /* SQLITE_INTERRUPT */ "interrupted",
1418 /* SQLITE_IOERR */ "disk I/O error",
1419 /* SQLITE_CORRUPT */ "database disk image is malformed",
drh0b52b7d2011-01-26 19:46:22 +00001420 /* SQLITE_NOTFOUND */ "unknown operation",
drh51c7d862009-04-27 18:46:06 +00001421 /* SQLITE_FULL */ "database or disk is full",
1422 /* SQLITE_CANTOPEN */ "unable to open database file",
dan0dc7b742010-06-04 15:59:58 +00001423 /* SQLITE_PROTOCOL */ "locking protocol",
drhe75be1a2017-07-10 11:17:51 +00001424 /* SQLITE_EMPTY */ 0,
drh51c7d862009-04-27 18:46:06 +00001425 /* SQLITE_SCHEMA */ "database schema has changed",
drh4c8555f2009-06-25 01:47:11 +00001426 /* SQLITE_TOOBIG */ "string or blob too big",
drh51c7d862009-04-27 18:46:06 +00001427 /* SQLITE_CONSTRAINT */ "constraint failed",
1428 /* SQLITE_MISMATCH */ "datatype mismatch",
drhff4fa772017-07-10 12:07:53 +00001429 /* SQLITE_MISUSE */ "bad parameter or other API misuse",
drhe75be1a2017-07-10 11:17:51 +00001430#ifdef SQLITE_DISABLE_LFS
drh51c7d862009-04-27 18:46:06 +00001431 /* SQLITE_NOLFS */ "large file support is disabled",
drhe75be1a2017-07-10 11:17:51 +00001432#else
1433 /* SQLITE_NOLFS */ 0,
1434#endif
drh51c7d862009-04-27 18:46:06 +00001435 /* SQLITE_AUTH */ "authorization denied",
drhe75be1a2017-07-10 11:17:51 +00001436 /* SQLITE_FORMAT */ 0,
drhff4fa772017-07-10 12:07:53 +00001437 /* SQLITE_RANGE */ "column index out of range",
1438 /* SQLITE_NOTADB */ "file is not a database",
drh51c7d862009-04-27 18:46:06 +00001439 };
drh21021a52012-02-13 17:01:51 +00001440 const char *zErr = "unknown error";
1441 switch( rc ){
1442 case SQLITE_ABORT_ROLLBACK: {
1443 zErr = "abort due to ROLLBACK";
1444 break;
1445 }
1446 default: {
1447 rc &= 0xff;
1448 if( ALWAYS(rc>=0) && rc<ArraySize(aMsg) && aMsg[rc]!=0 ){
1449 zErr = aMsg[rc];
1450 }
1451 break;
1452 }
drh247be432002-05-10 05:44:55 +00001453 }
drh21021a52012-02-13 17:01:51 +00001454 return zErr;
drh247be432002-05-10 05:44:55 +00001455}
1456
1457/*
drh2dfbbca2000-07-28 14:32:48 +00001458** This routine implements a busy callback that sleeps and tries
1459** again until a timeout value is reached. The timeout value is
1460** an integer number of milliseconds passed in as the first
1461** argument.
1462*/
drhdaffd0e2001-04-11 14:28:42 +00001463static int sqliteDefaultBusyCallback(
drh97903fe2005-05-24 20:19:57 +00001464 void *ptr, /* Database connection */
drh2dfbbca2000-07-28 14:32:48 +00001465 int count /* Number of times table has been busy */
1466){
drh0ede9eb2015-01-10 16:49:23 +00001467#if SQLITE_OS_WIN || HAVE_USLEEP
drhee570fa2005-04-28 12:06:05 +00001468 static const u8 delays[] =
1469 { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
1470 static const u8 totals[] =
1471 { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
drhfcd71b62011-04-05 22:08:24 +00001472# define NDELAY ArraySize(delays)
danielk1977b4b47412007-08-17 15:53:36 +00001473 sqlite3 *db = (sqlite3 *)ptr;
1474 int timeout = db->busyTimeout;
drh97903fe2005-05-24 20:19:57 +00001475 int delay, prior;
drh2dfbbca2000-07-28 14:32:48 +00001476
drhee570fa2005-04-28 12:06:05 +00001477 assert( count>=0 );
1478 if( count < NDELAY ){
1479 delay = delays[count];
1480 prior = totals[count];
drhd1bec472004-01-15 13:29:31 +00001481 }else{
1482 delay = delays[NDELAY-1];
drh68cb6192005-05-06 22:05:56 +00001483 prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
drh2dfbbca2000-07-28 14:32:48 +00001484 }
drhd1bec472004-01-15 13:29:31 +00001485 if( prior + delay > timeout ){
1486 delay = timeout - prior;
drh2dfbbca2000-07-28 14:32:48 +00001487 if( delay<=0 ) return 0;
1488 }
danielk19772a6bdf62007-08-20 16:07:00 +00001489 sqlite3OsSleep(db->pVfs, delay*1000);
drh2dfbbca2000-07-28 14:32:48 +00001490 return 1;
1491#else
drh482ea182007-08-20 11:12:40 +00001492 sqlite3 *db = (sqlite3 *)ptr;
drh3f737082005-06-14 02:24:31 +00001493 int timeout = ((sqlite3 *)ptr)->busyTimeout;
drh2dfbbca2000-07-28 14:32:48 +00001494 if( (count+1)*1000 > timeout ){
1495 return 0;
1496 }
drh482ea182007-08-20 11:12:40 +00001497 sqlite3OsSleep(db->pVfs, 1000000);
drh2dfbbca2000-07-28 14:32:48 +00001498 return 1;
1499#endif
1500}
1501
1502/*
drha4afb652005-07-09 02:16:02 +00001503** Invoke the given busy handler.
1504**
1505** This routine is called when an operation failed with a lock.
1506** If this routine returns non-zero, the lock is retried. If it
1507** returns 0, the operation aborts with an SQLITE_BUSY error.
1508*/
1509int sqlite3InvokeBusyHandler(BusyHandler *p){
1510 int rc;
drh34004ce2008-07-11 16:15:17 +00001511 if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0;
drha4afb652005-07-09 02:16:02 +00001512 rc = p->xFunc(p->pArg, p->nBusy);
1513 if( rc==0 ){
1514 p->nBusy = -1;
1515 }else{
1516 p->nBusy++;
1517 }
1518 return rc;
1519}
1520
1521/*
drh2dfbbca2000-07-28 14:32:48 +00001522** This routine sets the busy callback for an Sqlite database to the
1523** given callback function with the given argument.
1524*/
danielk1977f9d64d22004-06-19 08:18:07 +00001525int sqlite3_busy_handler(
1526 sqlite3 *db,
danielk19772a764eb2004-06-12 01:43:26 +00001527 int (*xBusy)(void*,int),
drh2dfbbca2000-07-28 14:32:48 +00001528 void *pArg
1529){
drh9ca95732014-10-24 00:35:58 +00001530#ifdef SQLITE_ENABLE_API_ARMOR
drh96c707a2015-02-13 16:36:14 +00001531 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
drh9ca95732014-10-24 00:35:58 +00001532#endif
drhe30f4422007-08-21 16:15:55 +00001533 sqlite3_mutex_enter(db->mutex);
danielk197724162fe2004-06-04 06:22:00 +00001534 db->busyHandler.xFunc = xBusy;
1535 db->busyHandler.pArg = pArg;
drha4afb652005-07-09 02:16:02 +00001536 db->busyHandler.nBusy = 0;
drhc0c7b5e2012-09-07 18:49:57 +00001537 db->busyTimeout = 0;
drhe30f4422007-08-21 16:15:55 +00001538 sqlite3_mutex_leave(db->mutex);
danielk1977f9d64d22004-06-19 08:18:07 +00001539 return SQLITE_OK;
drh2dfbbca2000-07-28 14:32:48 +00001540}
1541
danielk1977348bb5d2003-10-18 09:37:26 +00001542#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1543/*
1544** This routine sets the progress callback for an Sqlite database to the
1545** given callback function with the given argument. The progress callback will
1546** be invoked every nOps opcodes.
1547*/
danielk197724b03fd2004-05-10 10:34:34 +00001548void sqlite3_progress_handler(
drh9bb575f2004-09-06 17:24:11 +00001549 sqlite3 *db,
danielk1977348bb5d2003-10-18 09:37:26 +00001550 int nOps,
1551 int (*xProgress)(void*),
1552 void *pArg
1553){
drh9ca95732014-10-24 00:35:58 +00001554#ifdef SQLITE_ENABLE_API_ARMOR
1555 if( !sqlite3SafetyCheckOk(db) ){
1556 (void)SQLITE_MISUSE_BKPT;
1557 return;
1558 }
1559#endif
drhbd0b1b52008-07-07 19:52:09 +00001560 sqlite3_mutex_enter(db->mutex);
1561 if( nOps>0 ){
1562 db->xProgress = xProgress;
drh8f8c65f2013-07-10 18:14:29 +00001563 db->nProgressOps = (unsigned)nOps;
drhbd0b1b52008-07-07 19:52:09 +00001564 db->pProgressArg = pArg;
1565 }else{
1566 db->xProgress = 0;
1567 db->nProgressOps = 0;
1568 db->pProgressArg = 0;
danielk1977348bb5d2003-10-18 09:37:26 +00001569 }
drhbd0b1b52008-07-07 19:52:09 +00001570 sqlite3_mutex_leave(db->mutex);
danielk1977348bb5d2003-10-18 09:37:26 +00001571}
1572#endif
1573
1574
drh2dfbbca2000-07-28 14:32:48 +00001575/*
1576** This routine installs a default busy handler that waits for the
1577** specified number of milliseconds before returning 0.
1578*/
danielk1977f9d64d22004-06-19 08:18:07 +00001579int sqlite3_busy_timeout(sqlite3 *db, int ms){
drh9ca95732014-10-24 00:35:58 +00001580#ifdef SQLITE_ENABLE_API_ARMOR
1581 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
1582#endif
drh2dfbbca2000-07-28 14:32:48 +00001583 if( ms>0 ){
drh97903fe2005-05-24 20:19:57 +00001584 sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
drhc0c7b5e2012-09-07 18:49:57 +00001585 db->busyTimeout = ms;
drh2dfbbca2000-07-28 14:32:48 +00001586 }else{
danielk197724b03fd2004-05-10 10:34:34 +00001587 sqlite3_busy_handler(db, 0, 0);
drh2dfbbca2000-07-28 14:32:48 +00001588 }
danielk1977f9d64d22004-06-19 08:18:07 +00001589 return SQLITE_OK;
drh2dfbbca2000-07-28 14:32:48 +00001590}
drh4c504392000-10-16 22:06:40 +00001591
1592/*
1593** Cause any pending operation to stop at its earliest opportunity.
1594*/
drh9bb575f2004-09-06 17:24:11 +00001595void sqlite3_interrupt(sqlite3 *db){
drh9ca95732014-10-24 00:35:58 +00001596#ifdef SQLITE_ENABLE_API_ARMOR
drh575242f2016-12-27 13:33:52 +00001597 if( !sqlite3SafetyCheckOk(db) && (db==0 || db->magic!=SQLITE_MAGIC_ZOMBIE) ){
drh9ca95732014-10-24 00:35:58 +00001598 (void)SQLITE_MISUSE_BKPT;
1599 return;
1600 }
1601#endif
drhbd0b1b52008-07-07 19:52:09 +00001602 db->u1.isInterrupted = 1;
drh4c504392000-10-16 22:06:40 +00001603}
drhfa86c412002-02-02 15:01:15 +00001604
drhfa86c412002-02-02 15:01:15 +00001605
1606/*
danielk1977771151b2006-01-17 13:21:40 +00001607** This function is exactly the same as sqlite3_create_function(), except
1608** that it is designed to be called by internal code. The difference is
1609** that if a malloc() fails in sqlite3_create_function(), an error code
1610** is returned and the mallocFailed flag cleared.
drhfa86c412002-02-02 15:01:15 +00001611*/
danielk1977771151b2006-01-17 13:21:40 +00001612int sqlite3CreateFunc(
danielk197765904932004-05-26 06:18:37 +00001613 sqlite3 *db,
1614 const char *zFunctionName,
1615 int nArg,
danielk1977d8123362004-06-12 09:25:12 +00001616 int enc,
danielk197765904932004-05-26 06:18:37 +00001617 void *pUserData,
drh2d801512016-01-14 22:19:58 +00001618 void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
danielk197765904932004-05-26 06:18:37 +00001619 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
dand2199f02010-08-27 17:48:52 +00001620 void (*xFinal)(sqlite3_context*),
1621 FuncDestructor *pDestructor
drh8e0a2f92002-02-23 23:45:45 +00001622){
drh0bce8352002-02-28 00:41:10 +00001623 FuncDef *p;
drh4b59ab52002-08-24 18:24:51 +00001624 int nName;
drh4a8ee3d2013-12-14 13:44:22 +00001625 int extraFlags;
danielk197765904932004-05-26 06:18:37 +00001626
drhe30f4422007-08-21 16:15:55 +00001627 assert( sqlite3_mutex_held(db->mutex) );
drhc60d0442004-09-30 13:43:13 +00001628 if( zFunctionName==0 ||
drh2d801512016-01-14 22:19:58 +00001629 (xSFunc && (xFinal || xStep)) ||
1630 (!xSFunc && (xFinal && !xStep)) ||
1631 (!xSFunc && (!xFinal && xStep)) ||
drh24b58dd2008-07-07 14:50:14 +00001632 (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) ||
drhdee0e402009-05-03 20:23:53 +00001633 (255<(nName = sqlite3Strlen30( zFunctionName))) ){
drh413c3d32010-02-23 20:11:56 +00001634 return SQLITE_MISUSE_BKPT;
danielk197765904932004-05-26 06:18:37 +00001635 }
drh4a8ee3d2013-12-14 13:44:22 +00001636
1637 assert( SQLITE_FUNC_CONSTANT==SQLITE_DETERMINISTIC );
1638 extraFlags = enc & SQLITE_DETERMINISTIC;
1639 enc &= (SQLITE_FUNC_ENCMASK|SQLITE_ANY);
danielk1977d8123362004-06-12 09:25:12 +00001640
danielk197793758c82005-01-21 08:13:14 +00001641#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +00001642 /* If SQLITE_UTF16 is specified as the encoding type, transform this
1643 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
1644 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
1645 **
1646 ** If SQLITE_ANY is specified, add three versions of the function
1647 ** to the hash table.
1648 */
1649 if( enc==SQLITE_UTF16 ){
1650 enc = SQLITE_UTF16NATIVE;
1651 }else if( enc==SQLITE_ANY ){
1652 int rc;
drh4a8ee3d2013-12-14 13:44:22 +00001653 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8|extraFlags,
drh2d801512016-01-14 22:19:58 +00001654 pUserData, xSFunc, xStep, xFinal, pDestructor);
drhe30f4422007-08-21 16:15:55 +00001655 if( rc==SQLITE_OK ){
drh4a8ee3d2013-12-14 13:44:22 +00001656 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE|extraFlags,
drh2d801512016-01-14 22:19:58 +00001657 pUserData, xSFunc, xStep, xFinal, pDestructor);
drhe30f4422007-08-21 16:15:55 +00001658 }
1659 if( rc!=SQLITE_OK ){
1660 return rc;
1661 }
danielk1977d8123362004-06-12 09:25:12 +00001662 enc = SQLITE_UTF16BE;
1663 }
danielk197793758c82005-01-21 08:13:14 +00001664#else
1665 enc = SQLITE_UTF8;
1666#endif
danielk19779636c4e2005-01-25 04:27:54 +00001667
1668 /* Check if an existing function is being overridden or deleted. If so,
1669 ** and there are active VMs, then return SQLITE_BUSY. If a function
1670 ** is being overridden/deleted but there are no active VMs, allow the
1671 ** operation to continue but invalidate all precompiled statements.
1672 */
drh80738d92016-02-15 00:34:16 +00001673 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 0);
drhd36e1042013-09-06 13:10:12 +00001674 if( p && (p->funcFlags & SQLITE_FUNC_ENCMASK)==enc && p->nArg==nArg ){
drh4f7d3a52013-06-27 23:54:02 +00001675 if( db->nVdbeActive ){
drh13f40da2014-08-22 18:00:11 +00001676 sqlite3ErrorWithMsg(db, SQLITE_BUSY,
drhb309bec2009-02-04 17:40:57 +00001677 "unable to delete/modify user-function due to active statements");
drh17435752007-08-16 04:30:38 +00001678 assert( !db->mallocFailed );
danielk19779636c4e2005-01-25 04:27:54 +00001679 return SQLITE_BUSY;
1680 }else{
1681 sqlite3ExpirePreparedStatements(db);
1682 }
1683 }
danielk197765904932004-05-26 06:18:37 +00001684
drh80738d92016-02-15 00:34:16 +00001685 p = sqlite3FindFunction(db, zFunctionName, nArg, (u8)enc, 1);
danielk1977fa18bec2007-09-03 11:04:22 +00001686 assert(p || db->mallocFailed);
1687 if( !p ){
mistachkinfad30392016-02-13 23:43:46 +00001688 return SQLITE_NOMEM_BKPT;
danielk1977771151b2006-01-17 13:21:40 +00001689 }
dand2199f02010-08-27 17:48:52 +00001690
1691 /* If an older version of the function with a configured destructor is
1692 ** being replaced invoke the destructor function here. */
1693 functionDestroy(db, p);
1694
1695 if( pDestructor ){
1696 pDestructor->nRef++;
1697 }
drh80738d92016-02-15 00:34:16 +00001698 p->u.pDestructor = pDestructor;
drh4a8ee3d2013-12-14 13:44:22 +00001699 p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags;
1700 testcase( p->funcFlags & SQLITE_DETERMINISTIC );
drh2d801512016-01-14 22:19:58 +00001701 p->xSFunc = xSFunc ? xSFunc : xStep;
danielk1977fa18bec2007-09-03 11:04:22 +00001702 p->xFinalize = xFinal;
1703 p->pUserData = pUserData;
drh1bd10f82008-12-10 21:19:56 +00001704 p->nArg = (u16)nArg;
danielk197765904932004-05-26 06:18:37 +00001705 return SQLITE_OK;
1706}
danielk1977771151b2006-01-17 13:21:40 +00001707
1708/*
1709** Create new user functions.
1710*/
1711int sqlite3_create_function(
1712 sqlite3 *db,
dand2199f02010-08-27 17:48:52 +00001713 const char *zFunc,
danielk1977771151b2006-01-17 13:21:40 +00001714 int nArg,
1715 int enc,
1716 void *p,
drh2d801512016-01-14 22:19:58 +00001717 void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
danielk1977771151b2006-01-17 13:21:40 +00001718 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
1719 void (*xFinal)(sqlite3_context*)
1720){
drh2d801512016-01-14 22:19:58 +00001721 return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xSFunc, xStep,
drh7b19fac2010-08-27 18:44:54 +00001722 xFinal, 0);
dand2199f02010-08-27 17:48:52 +00001723}
1724
1725int sqlite3_create_function_v2(
1726 sqlite3 *db,
1727 const char *zFunc,
1728 int nArg,
1729 int enc,
1730 void *p,
drh2d801512016-01-14 22:19:58 +00001731 void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
dand2199f02010-08-27 17:48:52 +00001732 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
1733 void (*xFinal)(sqlite3_context*),
1734 void (*xDestroy)(void *)
1735){
shanehbd2aaf92010-09-01 02:38:21 +00001736 int rc = SQLITE_ERROR;
dand2199f02010-08-27 17:48:52 +00001737 FuncDestructor *pArg = 0;
drh9ca95732014-10-24 00:35:58 +00001738
1739#ifdef SQLITE_ENABLE_API_ARMOR
1740 if( !sqlite3SafetyCheckOk(db) ){
1741 return SQLITE_MISUSE_BKPT;
1742 }
1743#endif
dand2199f02010-08-27 17:48:52 +00001744 sqlite3_mutex_enter(db->mutex);
1745 if( xDestroy ){
1746 pArg = (FuncDestructor *)sqlite3DbMallocZero(db, sizeof(FuncDestructor));
dan9508daa2010-08-28 18:58:00 +00001747 if( !pArg ){
1748 xDestroy(p);
1749 goto out;
1750 }
dand2199f02010-08-27 17:48:52 +00001751 pArg->xDestroy = xDestroy;
1752 pArg->pUserData = p;
1753 }
drh2d801512016-01-14 22:19:58 +00001754 rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xSFunc, xStep, xFinal, pArg);
dand2199f02010-08-27 17:48:52 +00001755 if( pArg && pArg->nRef==0 ){
1756 assert( rc!=SQLITE_OK );
dan9508daa2010-08-28 18:58:00 +00001757 xDestroy(p);
dand2199f02010-08-27 17:48:52 +00001758 sqlite3DbFree(db, pArg);
1759 }
1760
1761 out:
drhe30f4422007-08-21 16:15:55 +00001762 rc = sqlite3ApiExit(db, rc);
1763 sqlite3_mutex_leave(db->mutex);
1764 return rc;
danielk1977771151b2006-01-17 13:21:40 +00001765}
1766
danielk197793758c82005-01-21 08:13:14 +00001767#ifndef SQLITE_OMIT_UTF16
danielk197765904932004-05-26 06:18:37 +00001768int sqlite3_create_function16(
1769 sqlite3 *db,
1770 const void *zFunctionName,
1771 int nArg,
1772 int eTextRep,
danielk1977771151b2006-01-17 13:21:40 +00001773 void *p,
drh2d801512016-01-14 22:19:58 +00001774 void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
danielk197765904932004-05-26 06:18:37 +00001775 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
1776 void (*xFinal)(sqlite3_context*)
1777){
1778 int rc;
drhaf9a7c22005-12-15 03:04:10 +00001779 char *zFunc8;
drh9ca95732014-10-24 00:35:58 +00001780
1781#ifdef SQLITE_ENABLE_API_ARMOR
1782 if( !sqlite3SafetyCheckOk(db) || zFunctionName==0 ) return SQLITE_MISUSE_BKPT;
1783#endif
drhe30f4422007-08-21 16:15:55 +00001784 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00001785 assert( !db->mallocFailed );
danb7dca7d2010-03-05 16:32:12 +00001786 zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
drh2d801512016-01-14 22:19:58 +00001787 rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xSFunc,xStep,xFinal,0);
drh633e6d52008-07-28 19:34:53 +00001788 sqlite3DbFree(db, zFunc8);
drhe30f4422007-08-21 16:15:55 +00001789 rc = sqlite3ApiExit(db, rc);
1790 sqlite3_mutex_leave(db->mutex);
1791 return rc;
drh8e0a2f92002-02-23 23:45:45 +00001792}
danielk197793758c82005-01-21 08:13:14 +00001793#endif
drhc9b84a12002-06-20 11:36:48 +00001794
drhb7481e72006-09-16 21:45:14 +00001795
1796/*
1797** Declare that a function has been overloaded by a virtual table.
1798**
1799** If the function already exists as a regular global function, then
1800** this routine is a no-op. If the function does not exist, then create
1801** a new one that always throws a run-time error.
1802**
1803** When virtual tables intend to provide an overloaded function, they
1804** should call this routine to make sure the global function exists.
1805** A global function must exist in order for name resolution to work
1806** properly.
1807*/
1808int sqlite3_overload_function(
1809 sqlite3 *db,
1810 const char *zName,
1811 int nArg
1812){
drhcb5e4db2011-10-12 23:49:49 +00001813 int rc = SQLITE_OK;
drh9ca95732014-10-24 00:35:58 +00001814
1815#ifdef SQLITE_ENABLE_API_ARMOR
1816 if( !sqlite3SafetyCheckOk(db) || zName==0 || nArg<-2 ){
1817 return SQLITE_MISUSE_BKPT;
1818 }
1819#endif
drhe30f4422007-08-21 16:15:55 +00001820 sqlite3_mutex_enter(db->mutex);
drh80738d92016-02-15 00:34:16 +00001821 if( sqlite3FindFunction(db, zName, nArg, SQLITE_UTF8, 0)==0 ){
drhcb5e4db2011-10-12 23:49:49 +00001822 rc = sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
1823 0, sqlite3InvalidFunction, 0, 0, 0);
drhb7481e72006-09-16 21:45:14 +00001824 }
drhcb5e4db2011-10-12 23:49:49 +00001825 rc = sqlite3ApiExit(db, rc);
drhe30f4422007-08-21 16:15:55 +00001826 sqlite3_mutex_leave(db->mutex);
1827 return rc;
drhb7481e72006-09-16 21:45:14 +00001828}
1829
drh19e2d372005-08-29 23:00:03 +00001830#ifndef SQLITE_OMIT_TRACE
drhc9b84a12002-06-20 11:36:48 +00001831/*
drh18de4822003-01-16 16:28:53 +00001832** Register a trace function. The pArg from the previously registered trace
1833** is returned.
1834**
1835** A NULL trace function means that no tracing is executes. A non-NULL
1836** trace is a pointer to a function that is invoked at the start of each
drh19e2d372005-08-29 23:00:03 +00001837** SQL statement.
drh18de4822003-01-16 16:28:53 +00001838*/
drh3d2a5292016-07-13 22:55:01 +00001839#ifndef SQLITE_OMIT_DEPRECATED
drhfca760c2016-07-14 01:09:08 +00001840void *sqlite3_trace(sqlite3 *db, void(*xTrace)(void*,const char*), void *pArg){
drhe30f4422007-08-21 16:15:55 +00001841 void *pOld;
drh9ca95732014-10-24 00:35:58 +00001842
1843#ifdef SQLITE_ENABLE_API_ARMOR
1844 if( !sqlite3SafetyCheckOk(db) ){
1845 (void)SQLITE_MISUSE_BKPT;
1846 return 0;
1847 }
1848#endif
drhe30f4422007-08-21 16:15:55 +00001849 sqlite3_mutex_enter(db->mutex);
1850 pOld = db->pTraceArg;
drh1637a512016-07-13 23:18:27 +00001851 db->mTrace = xTrace ? SQLITE_TRACE_LEGACY : 0;
drhfca760c2016-07-14 01:09:08 +00001852 db->xTrace = (int(*)(u32,void*,void*,void*))xTrace;
drh18de4822003-01-16 16:28:53 +00001853 db->pTraceArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001854 sqlite3_mutex_leave(db->mutex);
drh18de4822003-01-16 16:28:53 +00001855 return pOld;
drh0d1a6432003-04-03 15:46:04 +00001856}
drh3d2a5292016-07-13 22:55:01 +00001857#endif /* SQLITE_OMIT_DEPRECATED */
1858
1859/* Register a trace callback using the version-2 interface.
1860*/
1861int sqlite3_trace_v2(
drhfca760c2016-07-14 01:09:08 +00001862 sqlite3 *db, /* Trace this connection */
1863 unsigned mTrace, /* Mask of events to be traced */
1864 int(*xTrace)(unsigned,void*,void*,void*), /* Callback to invoke */
1865 void *pArg /* Context */
drh3d2a5292016-07-13 22:55:01 +00001866){
1867#ifdef SQLITE_ENABLE_API_ARMOR
1868 if( !sqlite3SafetyCheckOk(db) ){
mistachkin283a85c2016-07-15 00:39:47 +00001869 return SQLITE_MISUSE_BKPT;
drh3d2a5292016-07-13 22:55:01 +00001870 }
1871#endif
1872 sqlite3_mutex_enter(db->mutex);
drhfb828202016-08-25 22:06:37 +00001873 if( mTrace==0 ) xTrace = 0;
1874 if( xTrace==0 ) mTrace = 0;
drh3d2a5292016-07-13 22:55:01 +00001875 db->mTrace = mTrace;
1876 db->xTrace = xTrace;
1877 db->pTraceArg = pArg;
1878 sqlite3_mutex_leave(db->mutex);
1879 return SQLITE_OK;
1880}
1881
drh087ec072016-07-25 00:05:56 +00001882#ifndef SQLITE_OMIT_DEPRECATED
drh19e2d372005-08-29 23:00:03 +00001883/*
1884** Register a profile function. The pArg from the previously registered
1885** profile function is returned.
1886**
1887** A NULL profile function means that no profiling is executes. A non-NULL
1888** profile is a pointer to a function that is invoked at the conclusion of
1889** each SQL statement that is run.
1890*/
1891void *sqlite3_profile(
1892 sqlite3 *db,
1893 void (*xProfile)(void*,const char*,sqlite_uint64),
1894 void *pArg
1895){
drhe30f4422007-08-21 16:15:55 +00001896 void *pOld;
drh9ca95732014-10-24 00:35:58 +00001897
1898#ifdef SQLITE_ENABLE_API_ARMOR
1899 if( !sqlite3SafetyCheckOk(db) ){
1900 (void)SQLITE_MISUSE_BKPT;
1901 return 0;
1902 }
1903#endif
drhe30f4422007-08-21 16:15:55 +00001904 sqlite3_mutex_enter(db->mutex);
1905 pOld = db->pProfileArg;
drh19e2d372005-08-29 23:00:03 +00001906 db->xProfile = xProfile;
1907 db->pProfileArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001908 sqlite3_mutex_leave(db->mutex);
drh19e2d372005-08-29 23:00:03 +00001909 return pOld;
1910}
drh087ec072016-07-25 00:05:56 +00001911#endif /* SQLITE_OMIT_DEPRECATED */
drh19e2d372005-08-29 23:00:03 +00001912#endif /* SQLITE_OMIT_TRACE */
paulb0208cc2003-04-13 18:26:49 +00001913
drhcd565fd2012-03-01 21:30:44 +00001914/*
1915** Register a function to be invoked when a transaction commits.
danielk197771fd80b2005-12-16 06:54:01 +00001916** If the invoked function returns non-zero, then the commit becomes a
drhaa940ea2004-01-15 02:44:03 +00001917** rollback.
1918*/
danielk197724b03fd2004-05-10 10:34:34 +00001919void *sqlite3_commit_hook(
drh9bb575f2004-09-06 17:24:11 +00001920 sqlite3 *db, /* Attach the hook to this database */
drhaa940ea2004-01-15 02:44:03 +00001921 int (*xCallback)(void*), /* Function to invoke on each commit */
1922 void *pArg /* Argument to the function */
1923){
drhe30f4422007-08-21 16:15:55 +00001924 void *pOld;
drh9ca95732014-10-24 00:35:58 +00001925
1926#ifdef SQLITE_ENABLE_API_ARMOR
1927 if( !sqlite3SafetyCheckOk(db) ){
1928 (void)SQLITE_MISUSE_BKPT;
1929 return 0;
1930 }
1931#endif
drhe30f4422007-08-21 16:15:55 +00001932 sqlite3_mutex_enter(db->mutex);
1933 pOld = db->pCommitArg;
drhaa940ea2004-01-15 02:44:03 +00001934 db->xCommitCallback = xCallback;
1935 db->pCommitArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001936 sqlite3_mutex_leave(db->mutex);
drhaa940ea2004-01-15 02:44:03 +00001937 return pOld;
1938}
1939
danielk197794eb6a12005-12-15 15:22:08 +00001940/*
1941** Register a callback to be invoked each time a row is updated,
1942** inserted or deleted using this database connection.
1943*/
danielk197771fd80b2005-12-16 06:54:01 +00001944void *sqlite3_update_hook(
danielk197794eb6a12005-12-15 15:22:08 +00001945 sqlite3 *db, /* Attach the hook to this database */
1946 void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
1947 void *pArg /* Argument to the function */
1948){
drhe30f4422007-08-21 16:15:55 +00001949 void *pRet;
drh9ca95732014-10-24 00:35:58 +00001950
1951#ifdef SQLITE_ENABLE_API_ARMOR
1952 if( !sqlite3SafetyCheckOk(db) ){
1953 (void)SQLITE_MISUSE_BKPT;
1954 return 0;
1955 }
1956#endif
drhe30f4422007-08-21 16:15:55 +00001957 sqlite3_mutex_enter(db->mutex);
1958 pRet = db->pUpdateArg;
danielk197794eb6a12005-12-15 15:22:08 +00001959 db->xUpdateCallback = xCallback;
1960 db->pUpdateArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001961 sqlite3_mutex_leave(db->mutex);
danielk197771fd80b2005-12-16 06:54:01 +00001962 return pRet;
danielk197794eb6a12005-12-15 15:22:08 +00001963}
1964
danielk197771fd80b2005-12-16 06:54:01 +00001965/*
1966** Register a callback to be invoked each time a transaction is rolled
1967** back by this database connection.
1968*/
1969void *sqlite3_rollback_hook(
1970 sqlite3 *db, /* Attach the hook to this database */
1971 void (*xCallback)(void*), /* Callback function */
1972 void *pArg /* Argument to the function */
1973){
drhe30f4422007-08-21 16:15:55 +00001974 void *pRet;
drh9ca95732014-10-24 00:35:58 +00001975
1976#ifdef SQLITE_ENABLE_API_ARMOR
1977 if( !sqlite3SafetyCheckOk(db) ){
1978 (void)SQLITE_MISUSE_BKPT;
1979 return 0;
1980 }
1981#endif
drhe30f4422007-08-21 16:15:55 +00001982 sqlite3_mutex_enter(db->mutex);
1983 pRet = db->pRollbackArg;
danielk197771fd80b2005-12-16 06:54:01 +00001984 db->xRollbackCallback = xCallback;
1985 db->pRollbackArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001986 sqlite3_mutex_leave(db->mutex);
danielk197771fd80b2005-12-16 06:54:01 +00001987 return pRet;
1988}
drhaa940ea2004-01-15 02:44:03 +00001989
drh9b1c62d2011-03-30 21:04:43 +00001990#ifdef SQLITE_ENABLE_PREUPDATE_HOOK
dan46c47d42011-03-01 18:42:07 +00001991/*
1992** Register a callback to be invoked each time a row is updated,
1993** inserted or deleted using this database connection.
1994*/
1995void *sqlite3_preupdate_hook(
1996 sqlite3 *db, /* Attach the hook to this database */
1997 void(*xCallback)( /* Callback function */
1998 void*,sqlite3*,int,char const*,char const*,sqlite3_int64,sqlite3_int64),
1999 void *pArg /* First callback argument */
2000){
2001 void *pRet;
2002 sqlite3_mutex_enter(db->mutex);
2003 pRet = db->pPreUpdateArg;
2004 db->xPreUpdateCallback = xCallback;
2005 db->pPreUpdateArg = pArg;
2006 sqlite3_mutex_leave(db->mutex);
2007 return pRet;
2008}
drh9b1c62d2011-03-30 21:04:43 +00002009#endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
dan46c47d42011-03-01 18:42:07 +00002010
dan586b9c82010-05-03 08:04:49 +00002011#ifndef SQLITE_OMIT_WAL
2012/*
2013** The sqlite3_wal_hook() callback registered by sqlite3_wal_autocheckpoint().
drh5def0842010-05-05 20:00:25 +00002014** Invoke sqlite3_wal_checkpoint if the number of frames in the log file
2015** is greater than sqlite3.pWalArg cast to an integer (the value configured by
drhb033d8b2010-05-03 13:37:30 +00002016** wal_autocheckpoint()).
dan586b9c82010-05-03 08:04:49 +00002017*/
drhb033d8b2010-05-03 13:37:30 +00002018int sqlite3WalDefaultHook(
drh5def0842010-05-05 20:00:25 +00002019 void *pClientData, /* Argument */
drhb033d8b2010-05-03 13:37:30 +00002020 sqlite3 *db, /* Connection */
drh5def0842010-05-05 20:00:25 +00002021 const char *zDb, /* Database */
drhb033d8b2010-05-03 13:37:30 +00002022 int nFrame /* Size of WAL */
2023){
drh5def0842010-05-05 20:00:25 +00002024 if( nFrame>=SQLITE_PTR_TO_INT(pClientData) ){
drhf5330352010-05-24 20:27:44 +00002025 sqlite3BeginBenignMalloc();
drh5def0842010-05-05 20:00:25 +00002026 sqlite3_wal_checkpoint(db, zDb);
drhf5330352010-05-24 20:27:44 +00002027 sqlite3EndBenignMalloc();
drh5def0842010-05-05 20:00:25 +00002028 }
2029 return SQLITE_OK;
dan586b9c82010-05-03 08:04:49 +00002030}
drhb033d8b2010-05-03 13:37:30 +00002031#endif /* SQLITE_OMIT_WAL */
dan586b9c82010-05-03 08:04:49 +00002032
2033/*
2034** Configure an sqlite3_wal_hook() callback to automatically checkpoint
2035** a database after committing a transaction if there are nFrame or
2036** more frames in the log file. Passing zero or a negative value as the
2037** nFrame parameter disables automatic checkpoints entirely.
2038**
2039** The callback registered by this function replaces any existing callback
2040** registered using sqlite3_wal_hook(). Likewise, registering a callback
2041** using sqlite3_wal_hook() disables the automatic checkpoint mechanism
2042** configured by this function.
2043*/
2044int sqlite3_wal_autocheckpoint(sqlite3 *db, int nFrame){
shanehbd2aaf92010-09-01 02:38:21 +00002045#ifdef SQLITE_OMIT_WAL
drh9dd55f52010-09-03 03:32:46 +00002046 UNUSED_PARAMETER(db);
2047 UNUSED_PARAMETER(nFrame);
shanehbd2aaf92010-09-01 02:38:21 +00002048#else
drh9ca95732014-10-24 00:35:58 +00002049#ifdef SQLITE_ENABLE_API_ARMOR
2050 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
2051#endif
dan586b9c82010-05-03 08:04:49 +00002052 if( nFrame>0 ){
drhb033d8b2010-05-03 13:37:30 +00002053 sqlite3_wal_hook(db, sqlite3WalDefaultHook, SQLITE_INT_TO_PTR(nFrame));
dan586b9c82010-05-03 08:04:49 +00002054 }else{
2055 sqlite3_wal_hook(db, 0, 0);
2056 }
drhb033d8b2010-05-03 13:37:30 +00002057#endif
dan586b9c82010-05-03 08:04:49 +00002058 return SQLITE_OK;
2059}
2060
paulb0208cc2003-04-13 18:26:49 +00002061/*
dan8d22a172010-04-19 18:03:51 +00002062** Register a callback to be invoked each time a transaction is written
2063** into the write-ahead-log by this database connection.
2064*/
drh833bf962010-04-28 14:42:19 +00002065void *sqlite3_wal_hook(
dan8d22a172010-04-19 18:03:51 +00002066 sqlite3 *db, /* Attach the hook to this db handle */
2067 int(*xCallback)(void *, sqlite3*, const char*, int),
2068 void *pArg /* First argument passed to xCallback() */
2069){
drhb033d8b2010-05-03 13:37:30 +00002070#ifndef SQLITE_OMIT_WAL
dan8d22a172010-04-19 18:03:51 +00002071 void *pRet;
drh9ca95732014-10-24 00:35:58 +00002072#ifdef SQLITE_ENABLE_API_ARMOR
2073 if( !sqlite3SafetyCheckOk(db) ){
2074 (void)SQLITE_MISUSE_BKPT;
2075 return 0;
2076 }
2077#endif
dan8d22a172010-04-19 18:03:51 +00002078 sqlite3_mutex_enter(db->mutex);
drh7ed91f22010-04-29 22:34:07 +00002079 pRet = db->pWalArg;
2080 db->xWalCallback = xCallback;
2081 db->pWalArg = pArg;
dan8d22a172010-04-19 18:03:51 +00002082 sqlite3_mutex_leave(db->mutex);
2083 return pRet;
drhb033d8b2010-05-03 13:37:30 +00002084#else
2085 return 0;
2086#endif
dan8d22a172010-04-19 18:03:51 +00002087}
2088
2089/*
dancdc1f042010-11-18 12:11:05 +00002090** Checkpoint database zDb.
dan586b9c82010-05-03 08:04:49 +00002091*/
dancdc1f042010-11-18 12:11:05 +00002092int sqlite3_wal_checkpoint_v2(
2093 sqlite3 *db, /* Database handle */
2094 const char *zDb, /* Name of attached database (or NULL) */
2095 int eMode, /* SQLITE_CHECKPOINT_* value */
2096 int *pnLog, /* OUT: Size of WAL log in frames */
2097 int *pnCkpt /* OUT: Total number of frames checkpointed */
2098){
drhb033d8b2010-05-03 13:37:30 +00002099#ifdef SQLITE_OMIT_WAL
2100 return SQLITE_OK;
2101#else
dan586b9c82010-05-03 08:04:49 +00002102 int rc; /* Return code */
dan6fcff072010-05-03 14:05:43 +00002103 int iDb = SQLITE_MAX_ATTACHED; /* sqlite3.aDb[] index of db to checkpoint */
dan586b9c82010-05-03 08:04:49 +00002104
drh9ca95732014-10-24 00:35:58 +00002105#ifdef SQLITE_ENABLE_API_ARMOR
2106 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
2107#endif
2108
dan9c5e3682011-02-07 15:12:12 +00002109 /* Initialize the output variables to -1 in case an error occurs. */
2110 if( pnLog ) *pnLog = -1;
2111 if( pnCkpt ) *pnCkpt = -1;
2112
danf26a1542014-12-02 19:04:54 +00002113 assert( SQLITE_CHECKPOINT_PASSIVE==0 );
2114 assert( SQLITE_CHECKPOINT_FULL==1 );
2115 assert( SQLITE_CHECKPOINT_RESTART==2 );
2116 assert( SQLITE_CHECKPOINT_TRUNCATE==3 );
2117 if( eMode<SQLITE_CHECKPOINT_PASSIVE || eMode>SQLITE_CHECKPOINT_TRUNCATE ){
drhbb9a3782014-12-03 18:32:47 +00002118 /* EVIDENCE-OF: R-03996-12088 The M parameter must be a valid checkpoint
2119 ** mode: */
dancdc1f042010-11-18 12:11:05 +00002120 return SQLITE_MISUSE;
2121 }
2122
dan586b9c82010-05-03 08:04:49 +00002123 sqlite3_mutex_enter(db->mutex);
danaf0cfd32010-05-03 15:58:50 +00002124 if( zDb && zDb[0] ){
dan586b9c82010-05-03 08:04:49 +00002125 iDb = sqlite3FindDbName(db, zDb);
2126 }
2127 if( iDb<0 ){
2128 rc = SQLITE_ERROR;
drh13f40da2014-08-22 18:00:11 +00002129 sqlite3ErrorWithMsg(db, SQLITE_ERROR, "unknown database: %s", zDb);
dan586b9c82010-05-03 08:04:49 +00002130 }else{
dan976b0032015-01-29 19:12:12 +00002131 db->busyHandler.nBusy = 0;
dancdc1f042010-11-18 12:11:05 +00002132 rc = sqlite3Checkpoint(db, iDb, eMode, pnLog, pnCkpt);
drh13f40da2014-08-22 18:00:11 +00002133 sqlite3Error(db, rc);
dan586b9c82010-05-03 08:04:49 +00002134 }
drhb033d8b2010-05-03 13:37:30 +00002135 rc = sqlite3ApiExit(db, rc);
dan7fb89902016-08-12 16:21:15 +00002136
2137 /* If there are no active statements, clear the interrupt flag at this
2138 ** point. */
2139 if( db->nVdbeActive==0 ){
2140 db->u1.isInterrupted = 0;
2141 }
2142
dan586b9c82010-05-03 08:04:49 +00002143 sqlite3_mutex_leave(db->mutex);
drhb033d8b2010-05-03 13:37:30 +00002144 return rc;
2145#endif
dan586b9c82010-05-03 08:04:49 +00002146}
2147
dancdc1f042010-11-18 12:11:05 +00002148
2149/*
2150** Checkpoint database zDb. If zDb is NULL, or if the buffer zDb points
2151** to contains a zero-length string, all attached databases are
2152** checkpointed.
2153*/
2154int sqlite3_wal_checkpoint(sqlite3 *db, const char *zDb){
drhbb9a3782014-12-03 18:32:47 +00002155 /* EVIDENCE-OF: R-41613-20553 The sqlite3_wal_checkpoint(D,X) is equivalent to
2156 ** sqlite3_wal_checkpoint_v2(D,X,SQLITE_CHECKPOINT_PASSIVE,0,0). */
2157 return sqlite3_wal_checkpoint_v2(db,zDb,SQLITE_CHECKPOINT_PASSIVE,0,0);
dancdc1f042010-11-18 12:11:05 +00002158}
2159
drhb033d8b2010-05-03 13:37:30 +00002160#ifndef SQLITE_OMIT_WAL
dan586b9c82010-05-03 08:04:49 +00002161/*
2162** Run a checkpoint on database iDb. This is a no-op if database iDb is
2163** not currently open in WAL mode.
2164**
dan6fcff072010-05-03 14:05:43 +00002165** If a transaction is open on the database being checkpointed, this
2166** function returns SQLITE_LOCKED and a checkpoint is not attempted. If
2167** an error occurs while running the checkpoint, an SQLite error code is
2168** returned (i.e. SQLITE_IOERR). Otherwise, SQLITE_OK.
dan586b9c82010-05-03 08:04:49 +00002169**
2170** The mutex on database handle db should be held by the caller. The mutex
2171** associated with the specific b-tree being checkpointed is taken by
2172** this function while the checkpoint is running.
dan6fcff072010-05-03 14:05:43 +00002173**
2174** If iDb is passed SQLITE_MAX_ATTACHED, then all attached databases are
2175** checkpointed. If an error is encountered it is returned immediately -
2176** no attempt is made to checkpoint any remaining databases.
dana58f26f2010-11-16 18:56:51 +00002177**
dancdc1f042010-11-18 12:11:05 +00002178** Parameter eMode is one of SQLITE_CHECKPOINT_PASSIVE, FULL or RESTART.
dan586b9c82010-05-03 08:04:49 +00002179*/
dancdc1f042010-11-18 12:11:05 +00002180int sqlite3Checkpoint(sqlite3 *db, int iDb, int eMode, int *pnLog, int *pnCkpt){
dan6fcff072010-05-03 14:05:43 +00002181 int rc = SQLITE_OK; /* Return code */
2182 int i; /* Used to iterate through attached dbs */
danf2b8dd52010-11-18 19:28:01 +00002183 int bBusy = 0; /* True if SQLITE_BUSY has been encountered */
dan586b9c82010-05-03 08:04:49 +00002184
2185 assert( sqlite3_mutex_held(db->mutex) );
dan9c5e3682011-02-07 15:12:12 +00002186 assert( !pnLog || *pnLog==-1 );
2187 assert( !pnCkpt || *pnCkpt==-1 );
dan586b9c82010-05-03 08:04:49 +00002188
dan6fcff072010-05-03 14:05:43 +00002189 for(i=0; i<db->nDb && rc==SQLITE_OK; i++){
2190 if( i==iDb || iDb==SQLITE_MAX_ATTACHED ){
dancdc1f042010-11-18 12:11:05 +00002191 rc = sqlite3BtreeCheckpoint(db->aDb[i].pBt, eMode, pnLog, pnCkpt);
danf2b8dd52010-11-18 19:28:01 +00002192 pnLog = 0;
2193 pnCkpt = 0;
2194 if( rc==SQLITE_BUSY ){
2195 bBusy = 1;
2196 rc = SQLITE_OK;
2197 }
dan6fcff072010-05-03 14:05:43 +00002198 }
dan586b9c82010-05-03 08:04:49 +00002199 }
2200
danf2b8dd52010-11-18 19:28:01 +00002201 return (rc==SQLITE_OK && bBusy) ? SQLITE_BUSY : rc;
dan586b9c82010-05-03 08:04:49 +00002202}
drhb033d8b2010-05-03 13:37:30 +00002203#endif /* SQLITE_OMIT_WAL */
dan586b9c82010-05-03 08:04:49 +00002204
2205/*
danielk1977d8293352009-04-30 09:10:37 +00002206** This function returns true if main-memory should be used instead of
2207** a temporary file for transient pager files and statement journals.
2208** The value returned depends on the value of db->temp_store (runtime
2209** parameter) and the compile time value of SQLITE_TEMP_STORE. The
2210** following table describes the relationship between these two values
2211** and this functions return value.
2212**
2213** SQLITE_TEMP_STORE db->temp_store Location of temporary database
2214** ----------------- -------------- ------------------------------
2215** 0 any file (return 0)
2216** 1 1 file (return 0)
2217** 1 2 memory (return 1)
2218** 1 0 file (return 0)
2219** 2 1 file (return 0)
2220** 2 2 memory (return 1)
2221** 2 0 memory (return 1)
2222** 3 any memory (return 1)
2223*/
drh1c514142009-04-30 12:25:10 +00002224int sqlite3TempInMemory(const sqlite3 *db){
danielk1977d8293352009-04-30 09:10:37 +00002225#if SQLITE_TEMP_STORE==1
2226 return ( db->temp_store==2 );
2227#endif
2228#if SQLITE_TEMP_STORE==2
2229 return ( db->temp_store!=1 );
2230#endif
2231#if SQLITE_TEMP_STORE==3
drhf5ed7ad2015-06-15 14:43:25 +00002232 UNUSED_PARAMETER(db);
danielk1977d8293352009-04-30 09:10:37 +00002233 return 1;
shanecf697392009-06-01 16:53:09 +00002234#endif
2235#if SQLITE_TEMP_STORE<1 || SQLITE_TEMP_STORE>3
drhf5ed7ad2015-06-15 14:43:25 +00002236 UNUSED_PARAMETER(db);
danielk1977d8293352009-04-30 09:10:37 +00002237 return 0;
shane60a4b532009-05-06 18:57:09 +00002238#endif
danielk1977d8293352009-04-30 09:10:37 +00002239}
2240
2241/*
danielk19774ad17132004-05-21 01:47:26 +00002242** Return UTF-8 encoded English language explanation of the most recent
2243** error.
2244*/
danielk19776622cce2004-05-20 11:00:52 +00002245const char *sqlite3_errmsg(sqlite3 *db){
drhc60d0442004-09-30 13:43:13 +00002246 const char *z;
drhf49661a2008-12-10 16:45:50 +00002247 if( !db ){
mistachkinfad30392016-02-13 23:43:46 +00002248 return sqlite3ErrStr(SQLITE_NOMEM_BKPT);
danielk19774ad17132004-05-21 01:47:26 +00002249 }
drhd55d57e2008-07-07 17:53:07 +00002250 if( !sqlite3SafetyCheckSickOrOk(db) ){
drh413c3d32010-02-23 20:11:56 +00002251 return sqlite3ErrStr(SQLITE_MISUSE_BKPT);
danielk1977e35ee192004-06-26 09:50:11 +00002252 }
drh27641702007-08-22 02:56:42 +00002253 sqlite3_mutex_enter(db->mutex);
danielk1977238746a2009-03-19 18:51:06 +00002254 if( db->mallocFailed ){
mistachkinfad30392016-02-13 23:43:46 +00002255 z = sqlite3ErrStr(SQLITE_NOMEM_BKPT);
danielk1977238746a2009-03-19 18:51:06 +00002256 }else{
drha3cc0072013-12-13 16:23:55 +00002257 testcase( db->pErr==0 );
danielk1977238746a2009-03-19 18:51:06 +00002258 z = (char*)sqlite3_value_text(db->pErr);
2259 assert( !db->mallocFailed );
2260 if( z==0 ){
2261 z = sqlite3ErrStr(db->errCode);
2262 }
danielk19776622cce2004-05-20 11:00:52 +00002263 }
drhe30f4422007-08-21 16:15:55 +00002264 sqlite3_mutex_leave(db->mutex);
drhc60d0442004-09-30 13:43:13 +00002265 return z;
danielk19776622cce2004-05-20 11:00:52 +00002266}
2267
drh6c626082004-11-14 21:56:29 +00002268#ifndef SQLITE_OMIT_UTF16
danielk19774ad17132004-05-21 01:47:26 +00002269/*
2270** Return UTF-16 encoded English language explanation of the most recent
2271** error.
2272*/
danielk19776622cce2004-05-20 11:00:52 +00002273const void *sqlite3_errmsg16(sqlite3 *db){
danielk19777c5c3ca2009-02-23 14:42:53 +00002274 static const u16 outOfMem[] = {
2275 'o', 'u', 't', ' ', 'o', 'f', ' ', 'm', 'e', 'm', 'o', 'r', 'y', 0
danielk1977bfd6cce2004-06-18 04:24:54 +00002276 };
danielk19777c5c3ca2009-02-23 14:42:53 +00002277 static const u16 misuse[] = {
drhff4fa772017-07-10 12:07:53 +00002278 'b', 'a', 'd', ' ', 'p', 'a', 'r', 'a', 'm', 'e', 't', 'e', 'r', ' ',
2279 'o', 'r', ' ', 'o', 't', 'h', 'e', 'r', ' ', 'A', 'P', 'I', ' ',
2280 'm', 'i', 's', 'u', 's', 'e', 0
danielk1977e35ee192004-06-26 09:50:11 +00002281 };
danielk19774ad17132004-05-21 01:47:26 +00002282
drhc60d0442004-09-30 13:43:13 +00002283 const void *z;
danielk1977ae7fc492007-03-29 15:00:52 +00002284 if( !db ){
danielk19777c5c3ca2009-02-23 14:42:53 +00002285 return (void *)outOfMem;
drhc60d0442004-09-30 13:43:13 +00002286 }
drhd55d57e2008-07-07 17:53:07 +00002287 if( !sqlite3SafetyCheckSickOrOk(db) ){
danielk19777c5c3ca2009-02-23 14:42:53 +00002288 return (void *)misuse;
drhc60d0442004-09-30 13:43:13 +00002289 }
drhe30f4422007-08-21 16:15:55 +00002290 sqlite3_mutex_enter(db->mutex);
danielk1977238746a2009-03-19 18:51:06 +00002291 if( db->mallocFailed ){
2292 z = (void *)outOfMem;
2293 }else{
drhc60d0442004-09-30 13:43:13 +00002294 z = sqlite3_value_text16(db->pErr);
danielk1977238746a2009-03-19 18:51:06 +00002295 if( z==0 ){
drh13f40da2014-08-22 18:00:11 +00002296 sqlite3ErrorWithMsg(db, db->errCode, sqlite3ErrStr(db->errCode));
danielk1977238746a2009-03-19 18:51:06 +00002297 z = sqlite3_value_text16(db->pErr);
2298 }
2299 /* A malloc() may have failed within the call to sqlite3_value_text16()
2300 ** above. If this is the case, then the db->mallocFailed flag needs to
2301 ** be cleared before returning. Do this directly, instead of via
2302 ** sqlite3ApiExit(), to avoid setting the database handle error message.
2303 */
drh4a642b62016-02-05 01:55:27 +00002304 sqlite3OomClear(db);
drhc60d0442004-09-30 13:43:13 +00002305 }
drhe30f4422007-08-21 16:15:55 +00002306 sqlite3_mutex_leave(db->mutex);
drhc60d0442004-09-30 13:43:13 +00002307 return z;
danielk19776622cce2004-05-20 11:00:52 +00002308}
drh6c626082004-11-14 21:56:29 +00002309#endif /* SQLITE_OMIT_UTF16 */
danielk19776622cce2004-05-20 11:00:52 +00002310
drhc60d0442004-09-30 13:43:13 +00002311/*
danielk19777ddad962005-12-12 06:53:03 +00002312** Return the most recent error code generated by an SQLite routine. If NULL is
2313** passed to this function, we assume a malloc() failed during sqlite3_open().
drhc60d0442004-09-30 13:43:13 +00002314*/
danielk19776622cce2004-05-20 11:00:52 +00002315int sqlite3_errcode(sqlite3 *db){
danielk19777c36d072008-01-31 15:31:01 +00002316 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
drh413c3d32010-02-23 20:11:56 +00002317 return SQLITE_MISUSE_BKPT;
drhc60d0442004-09-30 13:43:13 +00002318 }
drh01495b92008-01-23 12:52:40 +00002319 if( !db || db->mallocFailed ){
mistachkinfad30392016-02-13 23:43:46 +00002320 return SQLITE_NOMEM_BKPT;
drh01495b92008-01-23 12:52:40 +00002321 }
drh4ac285a2006-09-15 07:28:50 +00002322 return db->errCode & db->errMask;
danielk19776622cce2004-05-20 11:00:52 +00002323}
drh99dfe5e2008-10-30 15:03:15 +00002324int sqlite3_extended_errcode(sqlite3 *db){
2325 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
drh413c3d32010-02-23 20:11:56 +00002326 return SQLITE_MISUSE_BKPT;
drh99dfe5e2008-10-30 15:03:15 +00002327 }
2328 if( !db || db->mallocFailed ){
mistachkinfad30392016-02-13 23:43:46 +00002329 return SQLITE_NOMEM_BKPT;
drh99dfe5e2008-10-30 15:03:15 +00002330 }
2331 return db->errCode;
2332}
drh1b9f2142016-03-17 16:01:23 +00002333int sqlite3_system_errno(sqlite3 *db){
2334 return db ? db->iSysErrno : 0;
2335}
danielk19776622cce2004-05-20 11:00:52 +00002336
drh0e819f92006-02-01 13:50:41 +00002337/*
mistachkin5dac8432012-09-11 02:00:25 +00002338** Return a string that describes the kind of error specified in the
2339** argument. For now, this simply calls the internal sqlite3ErrStr()
2340** function.
2341*/
2342const char *sqlite3_errstr(int rc){
2343 return sqlite3ErrStr(rc);
2344}
2345
2346/*
drh0e819f92006-02-01 13:50:41 +00002347** Create a new collating function for database "db". The name is zName
2348** and the encoding is enc.
2349*/
danielk19779a30cf62006-01-18 04:26:07 +00002350static int createCollation(
drhf8d4e8b2009-08-20 02:49:30 +00002351 sqlite3* db,
danielk19779a30cf62006-01-18 04:26:07 +00002352 const char *zName,
shanecea72b22009-09-07 04:38:36 +00002353 u8 enc,
danielk19779a30cf62006-01-18 04:26:07 +00002354 void* pCtx,
danielk1977a9808b32007-05-07 09:32:45 +00002355 int(*xCompare)(void*,int,const void*,int,const void*),
2356 void(*xDel)(void*)
danielk19779a30cf62006-01-18 04:26:07 +00002357){
2358 CollSeq *pColl;
drh7d9bd4e2006-02-16 18:16:36 +00002359 int enc2;
danielk19779a30cf62006-01-18 04:26:07 +00002360
drhe30f4422007-08-21 16:15:55 +00002361 assert( sqlite3_mutex_held(db->mutex) );
danielk19779a30cf62006-01-18 04:26:07 +00002362
2363 /* If SQLITE_UTF16 is specified as the encoding type, transform this
2364 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
2365 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
2366 */
drh51c7d862009-04-27 18:46:06 +00002367 enc2 = enc;
danielk1977ebb32932009-04-28 15:35:38 +00002368 testcase( enc2==SQLITE_UTF16 );
2369 testcase( enc2==SQLITE_UTF16_ALIGNED );
2370 if( enc2==SQLITE_UTF16 || enc2==SQLITE_UTF16_ALIGNED ){
drh7d9bd4e2006-02-16 18:16:36 +00002371 enc2 = SQLITE_UTF16NATIVE;
danielk19779a30cf62006-01-18 04:26:07 +00002372 }
drh51c7d862009-04-27 18:46:06 +00002373 if( enc2<SQLITE_UTF8 || enc2>SQLITE_UTF16BE ){
drh413c3d32010-02-23 20:11:56 +00002374 return SQLITE_MISUSE_BKPT;
danielk19779a30cf62006-01-18 04:26:07 +00002375 }
2376
2377 /* Check if this call is removing or replacing an existing collation
2378 ** sequence. If so, and there are active VMs, return busy. If there
2379 ** are no active VMs, invalidate any pre-compiled statements.
2380 */
drhc4a64fa2009-05-11 20:53:28 +00002381 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 0);
danielk19779a30cf62006-01-18 04:26:07 +00002382 if( pColl && pColl->xCmp ){
drh4f7d3a52013-06-27 23:54:02 +00002383 if( db->nVdbeActive ){
drh13f40da2014-08-22 18:00:11 +00002384 sqlite3ErrorWithMsg(db, SQLITE_BUSY,
drhb309bec2009-02-04 17:40:57 +00002385 "unable to delete/modify collation sequence due to active statements");
danielk19779a30cf62006-01-18 04:26:07 +00002386 return SQLITE_BUSY;
2387 }
2388 sqlite3ExpirePreparedStatements(db);
danielk1977a9808b32007-05-07 09:32:45 +00002389
2390 /* If collation sequence pColl was created directly by a call to
2391 ** sqlite3_create_collation, and not generated by synthCollSeq(),
2392 ** then any copies made by synthCollSeq() need to be invalidated.
2393 ** Also, collation destructor - CollSeq.xDel() - function may need
2394 ** to be called.
2395 */
2396 if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
drhacbcb7e2014-08-21 20:26:37 +00002397 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName);
danielk1977a9808b32007-05-07 09:32:45 +00002398 int j;
2399 for(j=0; j<3; j++){
2400 CollSeq *p = &aColl[j];
2401 if( p->enc==pColl->enc ){
2402 if( p->xDel ){
2403 p->xDel(p->pUser);
2404 }
2405 p->xCmp = 0;
2406 }
2407 }
2408 }
danielk19779a30cf62006-01-18 04:26:07 +00002409 }
2410
drhc4a64fa2009-05-11 20:53:28 +00002411 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, 1);
mistachkinfad30392016-02-13 23:43:46 +00002412 if( pColl==0 ) return SQLITE_NOMEM_BKPT;
drh88404c22010-10-11 17:58:21 +00002413 pColl->xCmp = xCompare;
2414 pColl->pUser = pCtx;
2415 pColl->xDel = xDel;
2416 pColl->enc = (u8)(enc2 | (enc & SQLITE_UTF16_ALIGNED));
drh13f40da2014-08-22 18:00:11 +00002417 sqlite3Error(db, SQLITE_OK);
danielk19779a30cf62006-01-18 04:26:07 +00002418 return SQLITE_OK;
2419}
2420
2421
danielk19776622cce2004-05-20 11:00:52 +00002422/*
drhbb4957f2008-03-20 14:03:29 +00002423** This array defines hard upper bounds on limit values. The
2424** initializer must be kept in sync with the SQLITE_LIMIT_*
2425** #defines in sqlite3.h.
2426*/
drhb1a6c3c2008-03-20 16:30:17 +00002427static const int aHardLimit[] = {
drhbb4957f2008-03-20 14:03:29 +00002428 SQLITE_MAX_LENGTH,
2429 SQLITE_MAX_SQL_LENGTH,
2430 SQLITE_MAX_COLUMN,
2431 SQLITE_MAX_EXPR_DEPTH,
2432 SQLITE_MAX_COMPOUND_SELECT,
2433 SQLITE_MAX_VDBE_OP,
2434 SQLITE_MAX_FUNCTION_ARG,
2435 SQLITE_MAX_ATTACHED,
drhbb4957f2008-03-20 14:03:29 +00002436 SQLITE_MAX_LIKE_PATTERN_LENGTH,
drh9f959b02014-08-11 17:37:27 +00002437 SQLITE_MAX_VARIABLE_NUMBER, /* IMP: R-38091-32352 */
drh417168a2009-09-07 18:14:02 +00002438 SQLITE_MAX_TRIGGER_DEPTH,
drh111544c2014-08-29 16:20:47 +00002439 SQLITE_MAX_WORKER_THREADS,
drhbb4957f2008-03-20 14:03:29 +00002440};
2441
2442/*
2443** Make sure the hard limits are set to reasonable values
2444*/
2445#if SQLITE_MAX_LENGTH<100
2446# error SQLITE_MAX_LENGTH must be at least 100
2447#endif
2448#if SQLITE_MAX_SQL_LENGTH<100
2449# error SQLITE_MAX_SQL_LENGTH must be at least 100
2450#endif
2451#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
2452# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
2453#endif
drhbb4957f2008-03-20 14:03:29 +00002454#if SQLITE_MAX_COMPOUND_SELECT<2
2455# error SQLITE_MAX_COMPOUND_SELECT must be at least 2
2456#endif
2457#if SQLITE_MAX_VDBE_OP<40
2458# error SQLITE_MAX_VDBE_OP must be at least 40
2459#endif
drh80738d92016-02-15 00:34:16 +00002460#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>127
2461# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
drhbb4957f2008-03-20 14:03:29 +00002462#endif
drhd08b2792014-07-22 15:33:31 +00002463#if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>125
2464# error SQLITE_MAX_ATTACHED must be between 0 and 125
drhbb4957f2008-03-20 14:03:29 +00002465#endif
drhbb4957f2008-03-20 14:03:29 +00002466#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
2467# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
2468#endif
drh70a8ca32008-08-21 18:49:27 +00002469#if SQLITE_MAX_COLUMN>32767
2470# error SQLITE_MAX_COLUMN must not exceed 32767
2471#endif
drh417168a2009-09-07 18:14:02 +00002472#if SQLITE_MAX_TRIGGER_DEPTH<1
2473# error SQLITE_MAX_TRIGGER_DEPTH must be at least 1
2474#endif
drh111544c2014-08-29 16:20:47 +00002475#if SQLITE_MAX_WORKER_THREADS<0 || SQLITE_MAX_WORKER_THREADS>50
2476# error SQLITE_MAX_WORKER_THREADS must be between 0 and 50
2477#endif
drhbb4957f2008-03-20 14:03:29 +00002478
2479
2480/*
2481** Change the value of a limit. Report the old value.
2482** If an invalid limit index is supplied, report -1.
2483** Make no changes but still report the old value if the
2484** new limit is negative.
2485**
2486** A new lower limit does not shrink existing constructs.
2487** It merely prevents new constructs that exceed the limit
2488** from forming.
2489*/
2490int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
2491 int oldLimit;
drh4e93f5b2010-09-07 14:59:15 +00002492
drh9ca95732014-10-24 00:35:58 +00002493#ifdef SQLITE_ENABLE_API_ARMOR
2494 if( !sqlite3SafetyCheckOk(db) ){
2495 (void)SQLITE_MISUSE_BKPT;
2496 return -1;
2497 }
2498#endif
drh4e93f5b2010-09-07 14:59:15 +00002499
2500 /* EVIDENCE-OF: R-30189-54097 For each limit category SQLITE_LIMIT_NAME
2501 ** there is a hard upper bound set at compile-time by a C preprocessor
2502 ** macro called SQLITE_MAX_NAME. (The "_LIMIT_" in the name is changed to
2503 ** "_MAX_".)
2504 */
2505 assert( aHardLimit[SQLITE_LIMIT_LENGTH]==SQLITE_MAX_LENGTH );
2506 assert( aHardLimit[SQLITE_LIMIT_SQL_LENGTH]==SQLITE_MAX_SQL_LENGTH );
2507 assert( aHardLimit[SQLITE_LIMIT_COLUMN]==SQLITE_MAX_COLUMN );
2508 assert( aHardLimit[SQLITE_LIMIT_EXPR_DEPTH]==SQLITE_MAX_EXPR_DEPTH );
2509 assert( aHardLimit[SQLITE_LIMIT_COMPOUND_SELECT]==SQLITE_MAX_COMPOUND_SELECT);
2510 assert( aHardLimit[SQLITE_LIMIT_VDBE_OP]==SQLITE_MAX_VDBE_OP );
2511 assert( aHardLimit[SQLITE_LIMIT_FUNCTION_ARG]==SQLITE_MAX_FUNCTION_ARG );
2512 assert( aHardLimit[SQLITE_LIMIT_ATTACHED]==SQLITE_MAX_ATTACHED );
2513 assert( aHardLimit[SQLITE_LIMIT_LIKE_PATTERN_LENGTH]==
2514 SQLITE_MAX_LIKE_PATTERN_LENGTH );
2515 assert( aHardLimit[SQLITE_LIMIT_VARIABLE_NUMBER]==SQLITE_MAX_VARIABLE_NUMBER);
2516 assert( aHardLimit[SQLITE_LIMIT_TRIGGER_DEPTH]==SQLITE_MAX_TRIGGER_DEPTH );
drh111544c2014-08-29 16:20:47 +00002517 assert( aHardLimit[SQLITE_LIMIT_WORKER_THREADS]==SQLITE_MAX_WORKER_THREADS );
2518 assert( SQLITE_LIMIT_WORKER_THREADS==(SQLITE_N_LIMIT-1) );
drh4e93f5b2010-09-07 14:59:15 +00002519
2520
drh521cc842008-04-15 02:36:33 +00002521 if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
drhbb4957f2008-03-20 14:03:29 +00002522 return -1;
2523 }
2524 oldLimit = db->aLimit[limitId];
drh4e93f5b2010-09-07 14:59:15 +00002525 if( newLimit>=0 ){ /* IMP: R-52476-28732 */
drhf47ce562008-03-20 18:00:49 +00002526 if( newLimit>aHardLimit[limitId] ){
drh4e93f5b2010-09-07 14:59:15 +00002527 newLimit = aHardLimit[limitId]; /* IMP: R-51463-25634 */
drhbb4957f2008-03-20 14:03:29 +00002528 }
2529 db->aLimit[limitId] = newLimit;
2530 }
drh4e93f5b2010-09-07 14:59:15 +00002531 return oldLimit; /* IMP: R-53341-35419 */
drhbb4957f2008-03-20 14:03:29 +00002532}
2533
2534/*
dan286ab7c2011-05-06 18:34:54 +00002535** This function is used to parse both URIs and non-URI filenames passed by the
2536** user to API functions sqlite3_open() or sqlite3_open_v2(), and for database
2537** URIs specified as part of ATTACH statements.
2538**
2539** The first argument to this function is the name of the VFS to use (or
2540** a NULL to signify the default VFS) if the URI does not contain a "vfs=xxx"
2541** query parameter. The second argument contains the URI (or non-URI filename)
2542** itself. When this function is called the *pFlags variable should contain
2543** the default flags to open the database handle with. The value stored in
2544** *pFlags may be updated before returning if the URI filename contains
2545** "cache=xxx" or "mode=xxx" query parameters.
2546**
2547** If successful, SQLITE_OK is returned. In this case *ppVfs is set to point to
2548** the VFS that should be used to open the database file. *pzFile is set to
2549** point to a buffer containing the name of the file to open. It is the
2550** responsibility of the caller to eventually call sqlite3_free() to release
2551** this buffer.
2552**
2553** If an error occurs, then an SQLite error code is returned and *pzErrMsg
2554** may be set to point to a buffer containing an English language error
2555** message. It is the responsibility of the caller to eventually release
2556** this buffer by calling sqlite3_free().
dancd74b612011-04-22 19:37:32 +00002557*/
2558int sqlite3ParseUri(
2559 const char *zDefaultVfs, /* VFS to use if no "vfs=xxx" query option */
2560 const char *zUri, /* Nul-terminated URI to parse */
drh522c26f2011-05-07 14:40:29 +00002561 unsigned int *pFlags, /* IN/OUT: SQLITE_OPEN_XXX flags */
dancd74b612011-04-22 19:37:32 +00002562 sqlite3_vfs **ppVfs, /* OUT: VFS to use */
2563 char **pzFile, /* OUT: Filename component of URI */
2564 char **pzErrMsg /* OUT: Error message (if rc!=SQLITE_OK) */
2565){
dan78e9dd22011-05-03 10:22:32 +00002566 int rc = SQLITE_OK;
drh522c26f2011-05-07 14:40:29 +00002567 unsigned int flags = *pFlags;
dancd74b612011-04-22 19:37:32 +00002568 const char *zVfs = zDefaultVfs;
2569 char *zFile;
drhde941c32011-05-09 19:20:17 +00002570 char c;
dancd74b612011-04-22 19:37:32 +00002571 int nUri = sqlite3Strlen30(zUri);
2572
2573 assert( *pzErrMsg==0 );
2574
drh8790b6e2014-11-07 01:43:56 +00002575 if( ((flags & SQLITE_OPEN_URI) /* IMP: R-48725-32206 */
2576 || sqlite3GlobalConfig.bOpenUri) /* IMP: R-51689-46548 */
drh00729cb2014-10-04 11:59:33 +00002577 && nUri>=5 && memcmp(zUri, "file:", 5)==0 /* IMP: R-57884-37496 */
dancd74b612011-04-22 19:37:32 +00002578 ){
dan5de15372011-04-23 10:12:30 +00002579 char *zOpt;
dancd74b612011-04-22 19:37:32 +00002580 int eState; /* Parser state when parsing URI */
2581 int iIn; /* Input character index */
2582 int iOut = 0; /* Output character index */
drhf3cdcdc2015-04-29 16:50:28 +00002583 u64 nByte = nUri+2; /* Bytes of space to allocate */
dancd74b612011-04-22 19:37:32 +00002584
dan286ab7c2011-05-06 18:34:54 +00002585 /* Make sure the SQLITE_OPEN_URI flag is set to indicate to the VFS xOpen
2586 ** method that there may be extra parameters following the file-name. */
2587 flags |= SQLITE_OPEN_URI;
2588
2589 for(iIn=0; iIn<nUri; iIn++) nByte += (zUri[iIn]=='&');
drhf3cdcdc2015-04-29 16:50:28 +00002590 zFile = sqlite3_malloc64(nByte);
mistachkinfad30392016-02-13 23:43:46 +00002591 if( !zFile ) return SQLITE_NOMEM_BKPT;
dancd74b612011-04-22 19:37:32 +00002592
drh869c0402013-08-07 23:15:52 +00002593 iIn = 5;
drh4a4b1382015-03-03 16:58:56 +00002594#ifdef SQLITE_ALLOW_URI_AUTHORITY
2595 if( strncmp(zUri+5, "///", 3)==0 ){
2596 iIn = 7;
2597 /* The following condition causes URIs with five leading / characters
2598 ** like file://///host/path to be converted into UNCs like //host/path.
2599 ** The correct URI for that UNC has only two or four leading / characters
2600 ** file://host/path or file:////host/path. But 5 leading slashes is a
2601 ** common error, we are told, so we handle it as a special case. */
2602 if( strncmp(zUri+7, "///", 3)==0 ){ iIn++; }
2603 }else if( strncmp(zUri+5, "//localhost/", 12)==0 ){
2604 iIn = 16;
2605 }
2606#else
dancd74b612011-04-22 19:37:32 +00002607 /* Discard the scheme and authority segments of the URI. */
2608 if( zUri[5]=='/' && zUri[6]=='/' ){
2609 iIn = 7;
2610 while( zUri[iIn] && zUri[iIn]!='/' ) iIn++;
dan3b18a9a2011-05-03 11:53:20 +00002611 if( iIn!=7 && (iIn!=16 || memcmp("localhost", &zUri[7], 9)) ){
2612 *pzErrMsg = sqlite3_mprintf("invalid uri authority: %.*s",
2613 iIn-7, &zUri[7]);
2614 rc = SQLITE_ERROR;
2615 goto parse_uri_out;
2616 }
dancd74b612011-04-22 19:37:32 +00002617 }
drh869c0402013-08-07 23:15:52 +00002618#endif
dancd74b612011-04-22 19:37:32 +00002619
2620 /* Copy the filename and any query parameters into the zFile buffer.
2621 ** Decode %HH escape codes along the way.
2622 **
2623 ** Within this loop, variable eState may be set to 0, 1 or 2, depending
2624 ** on the parsing context. As follows:
2625 **
2626 ** 0: Parsing file-name.
2627 ** 1: Parsing name section of a name=value query parameter.
2628 ** 2: Parsing value section of a name=value query parameter.
2629 */
2630 eState = 0;
drhde941c32011-05-09 19:20:17 +00002631 while( (c = zUri[iIn])!=0 && c!='#' ){
2632 iIn++;
dancd74b612011-04-22 19:37:32 +00002633 if( c=='%'
2634 && sqlite3Isxdigit(zUri[iIn])
2635 && sqlite3Isxdigit(zUri[iIn+1])
2636 ){
dan6d49e252011-05-03 15:09:05 +00002637 int octet = (sqlite3HexToInt(zUri[iIn++]) << 4);
2638 octet += sqlite3HexToInt(zUri[iIn++]);
dancd74b612011-04-22 19:37:32 +00002639
dan6d49e252011-05-03 15:09:05 +00002640 assert( octet>=0 && octet<256 );
2641 if( octet==0 ){
dan5c35e902016-10-26 12:15:41 +00002642#ifndef SQLITE_ENABLE_URI_00_ERROR
dan5de15372011-04-23 10:12:30 +00002643 /* This branch is taken when "%00" appears within the URI. In this
2644 ** case we ignore all text in the remainder of the path, name or
2645 ** value currently being parsed. So ignore the current character
2646 ** and skip to the next "?", "=" or "&", as appropriate. */
drhde941c32011-05-09 19:20:17 +00002647 while( (c = zUri[iIn])!=0 && c!='#'
2648 && (eState!=0 || c!='?')
2649 && (eState!=1 || (c!='=' && c!='&'))
2650 && (eState!=2 || c!='&')
dan5de15372011-04-23 10:12:30 +00002651 ){
2652 iIn++;
2653 }
2654 continue;
dan5c35e902016-10-26 12:15:41 +00002655#else
2656 /* If ENABLE_URI_00_ERROR is defined, "%00" in a URI is an error. */
2657 *pzErrMsg = sqlite3_mprintf("unexpected %%00 in uri");
2658 rc = SQLITE_ERROR;
2659 goto parse_uri_out;
2660#endif
dancd74b612011-04-22 19:37:32 +00002661 }
dan6d49e252011-05-03 15:09:05 +00002662 c = octet;
dan5de15372011-04-23 10:12:30 +00002663 }else if( eState==1 && (c=='&' || c=='=') ){
2664 if( zFile[iOut-1]==0 ){
2665 /* An empty option name. Ignore this option altogether. */
2666 while( zUri[iIn] && zUri[iIn]!='#' && zUri[iIn-1]!='&' ) iIn++;
2667 continue;
2668 }
2669 if( c=='&' ){
2670 zFile[iOut++] = '\0';
2671 }else{
2672 eState = 2;
2673 }
dancd74b612011-04-22 19:37:32 +00002674 c = 0;
dan5de15372011-04-23 10:12:30 +00002675 }else if( (eState==0 && c=='?') || (eState==2 && c=='&') ){
2676 c = 0;
dancd74b612011-04-22 19:37:32 +00002677 eState = 1;
dancd74b612011-04-22 19:37:32 +00002678 }
2679 zFile[iOut++] = c;
2680 }
2681 if( eState==1 ) zFile[iOut++] = '\0';
2682 zFile[iOut++] = '\0';
2683 zFile[iOut++] = '\0';
2684
2685 /* Check if there were any options specified that should be interpreted
2686 ** here. Options that are interpreted here include "vfs" and those that
2687 ** correspond to flags that may be passed to the sqlite3_open_v2()
dan78e9dd22011-05-03 10:22:32 +00002688 ** method. */
dan5de15372011-04-23 10:12:30 +00002689 zOpt = &zFile[sqlite3Strlen30(zFile)+1];
2690 while( zOpt[0] ){
2691 int nOpt = sqlite3Strlen30(zOpt);
2692 char *zVal = &zOpt[nOpt+1];
2693 int nVal = sqlite3Strlen30(zVal);
dancd74b612011-04-22 19:37:32 +00002694
dan286ab7c2011-05-06 18:34:54 +00002695 if( nOpt==3 && memcmp("vfs", zOpt, 3)==0 ){
dan78e9dd22011-05-03 10:22:32 +00002696 zVfs = zVal;
2697 }else{
2698 struct OpenMode {
2699 const char *z;
2700 int mode;
2701 } *aMode = 0;
drh45caede2011-06-03 14:19:10 +00002702 char *zModeType = 0;
2703 int mask = 0;
2704 int limit = 0;
dan78e9dd22011-05-03 10:22:32 +00002705
dan286ab7c2011-05-06 18:34:54 +00002706 if( nOpt==5 && memcmp("cache", zOpt, 5)==0 ){
dan78e9dd22011-05-03 10:22:32 +00002707 static struct OpenMode aCacheMode[] = {
2708 { "shared", SQLITE_OPEN_SHAREDCACHE },
2709 { "private", SQLITE_OPEN_PRIVATECACHE },
2710 { 0, 0 }
2711 };
2712
2713 mask = SQLITE_OPEN_SHAREDCACHE|SQLITE_OPEN_PRIVATECACHE;
2714 aMode = aCacheMode;
2715 limit = mask;
2716 zModeType = "cache";
2717 }
dan286ab7c2011-05-06 18:34:54 +00002718 if( nOpt==4 && memcmp("mode", zOpt, 4)==0 ){
dan78e9dd22011-05-03 10:22:32 +00002719 static struct OpenMode aOpenMode[] = {
2720 { "ro", SQLITE_OPEN_READONLY },
2721 { "rw", SQLITE_OPEN_READWRITE },
2722 { "rwc", SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE },
dan0b8dcfa2012-06-07 17:16:04 +00002723 { "memory", SQLITE_OPEN_MEMORY },
dan78e9dd22011-05-03 10:22:32 +00002724 { 0, 0 }
2725 };
2726
drh9c67b2a2012-05-28 13:58:00 +00002727 mask = SQLITE_OPEN_READONLY | SQLITE_OPEN_READWRITE
2728 | SQLITE_OPEN_CREATE | SQLITE_OPEN_MEMORY;
dan78e9dd22011-05-03 10:22:32 +00002729 aMode = aOpenMode;
2730 limit = mask & flags;
2731 zModeType = "access";
2732 }
2733
2734 if( aMode ){
2735 int i;
2736 int mode = 0;
2737 for(i=0; aMode[i].z; i++){
2738 const char *z = aMode[i].z;
drh522c26f2011-05-07 14:40:29 +00002739 if( nVal==sqlite3Strlen30(z) && 0==memcmp(zVal, z, nVal) ){
dan78e9dd22011-05-03 10:22:32 +00002740 mode = aMode[i].mode;
2741 break;
dancd74b612011-04-22 19:37:32 +00002742 }
2743 }
dan78e9dd22011-05-03 10:22:32 +00002744 if( mode==0 ){
2745 *pzErrMsg = sqlite3_mprintf("no such %s mode: %s", zModeType, zVal);
2746 rc = SQLITE_ERROR;
2747 goto parse_uri_out;
2748 }
drh9c67b2a2012-05-28 13:58:00 +00002749 if( (mode & ~SQLITE_OPEN_MEMORY)>limit ){
drhde941c32011-05-09 19:20:17 +00002750 *pzErrMsg = sqlite3_mprintf("%s mode not allowed: %s",
2751 zModeType, zVal);
dan78e9dd22011-05-03 10:22:32 +00002752 rc = SQLITE_PERM;
2753 goto parse_uri_out;
2754 }
2755 flags = (flags & ~mask) | mode;
dancd74b612011-04-22 19:37:32 +00002756 }
dancd74b612011-04-22 19:37:32 +00002757 }
dan5de15372011-04-23 10:12:30 +00002758
2759 zOpt = &zVal[nVal+1];
dancd74b612011-04-22 19:37:32 +00002760 }
2761
2762 }else{
drhf3cdcdc2015-04-29 16:50:28 +00002763 zFile = sqlite3_malloc64(nUri+2);
mistachkinfad30392016-02-13 23:43:46 +00002764 if( !zFile ) return SQLITE_NOMEM_BKPT;
dan895decf2016-12-30 14:15:56 +00002765 if( nUri ){
2766 memcpy(zFile, zUri, nUri);
2767 }
dancd74b612011-04-22 19:37:32 +00002768 zFile[nUri] = '\0';
2769 zFile[nUri+1] = '\0';
drh4ab9d252012-05-26 20:08:49 +00002770 flags &= ~SQLITE_OPEN_URI;
dancd74b612011-04-22 19:37:32 +00002771 }
2772
2773 *ppVfs = sqlite3_vfs_find(zVfs);
2774 if( *ppVfs==0 ){
dancd74b612011-04-22 19:37:32 +00002775 *pzErrMsg = sqlite3_mprintf("no such vfs: %s", zVfs);
dan78e9dd22011-05-03 10:22:32 +00002776 rc = SQLITE_ERROR;
2777 }
2778 parse_uri_out:
2779 if( rc!=SQLITE_OK ){
dan5de15372011-04-23 10:12:30 +00002780 sqlite3_free(zFile);
dan78e9dd22011-05-03 10:22:32 +00002781 zFile = 0;
dancd74b612011-04-22 19:37:32 +00002782 }
2783 *pFlags = flags;
2784 *pzFile = zFile;
dan78e9dd22011-05-03 10:22:32 +00002785 return rc;
dancd74b612011-04-22 19:37:32 +00002786}
2787
2788
2789/*
danielk19774ad17132004-05-21 01:47:26 +00002790** This routine does the work of opening a database on behalf of
2791** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
drhee570fa2005-04-28 12:06:05 +00002792** is UTF-8 encoded.
danielk19774ad17132004-05-21 01:47:26 +00002793*/
2794static int openDatabase(
2795 const char *zFilename, /* Database filename UTF-8 encoded */
drh605264d2007-08-21 15:13:19 +00002796 sqlite3 **ppDb, /* OUT: Returned database handle */
drh522c26f2011-05-07 14:40:29 +00002797 unsigned int flags, /* Operational flags */
drh605264d2007-08-21 15:13:19 +00002798 const char *zVfs /* Name of the VFS to use */
danielk19774ad17132004-05-21 01:47:26 +00002799){
dancd74b612011-04-22 19:37:32 +00002800 sqlite3 *db; /* Store allocated handle here */
2801 int rc; /* Return code */
2802 int isThreadsafe; /* True for threadsafe connections */
2803 char *zOpen = 0; /* Filename argument to pass to BtreeOpen() */
2804 char *zErrMsg = 0; /* Error message from sqlite3ParseUri() */
danielk19774ad17132004-05-21 01:47:26 +00002805
drh9ca95732014-10-24 00:35:58 +00002806#ifdef SQLITE_ENABLE_API_ARMOR
2807 if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
2808#endif
drhe0d0f8e2009-04-28 04:47:31 +00002809 *ppDb = 0;
drh40257ff2008-06-13 18:24:27 +00002810#ifndef SQLITE_OMIT_AUTOINIT
2811 rc = sqlite3_initialize();
2812 if( rc ) return rc;
2813#endif
2814
drh039963a2008-09-03 00:43:15 +00002815 if( sqlite3GlobalConfig.bCoreMutex==0 ){
danielk19779a6284c2008-07-10 17:52:49 +00002816 isThreadsafe = 0;
drh039963a2008-09-03 00:43:15 +00002817 }else if( flags & SQLITE_OPEN_NOMUTEX ){
2818 isThreadsafe = 0;
2819 }else if( flags & SQLITE_OPEN_FULLMUTEX ){
2820 isThreadsafe = 1;
2821 }else{
2822 isThreadsafe = sqlite3GlobalConfig.bFullMutex;
danielk19779a6284c2008-07-10 17:52:49 +00002823 }
drhf1f12682009-09-09 14:17:52 +00002824 if( flags & SQLITE_OPEN_PRIVATECACHE ){
drhf4cfac92009-09-09 15:29:41 +00002825 flags &= ~SQLITE_OPEN_SHAREDCACHE;
drhf1f12682009-09-09 14:17:52 +00002826 }else if( sqlite3GlobalConfig.sharedCacheEnabled ){
2827 flags |= SQLITE_OPEN_SHAREDCACHE;
2828 }
danielk19779a6284c2008-07-10 17:52:49 +00002829
drhb25a9f42009-05-12 13:35:11 +00002830 /* Remove harmful bits from the flags parameter
2831 **
2832 ** The SQLITE_OPEN_NOMUTEX and SQLITE_OPEN_FULLMUTEX flags were
2833 ** dealt with in the previous code block. Besides these, the only
2834 ** valid input flags for sqlite3_open_v2() are SQLITE_OPEN_READONLY,
drh03e1b402011-02-23 22:39:23 +00002835 ** SQLITE_OPEN_READWRITE, SQLITE_OPEN_CREATE, SQLITE_OPEN_SHAREDCACHE,
2836 ** SQLITE_OPEN_PRIVATECACHE, and some reserved bits. Silently mask
drhb25a9f42009-05-12 13:35:11 +00002837 ** off all other flags.
2838 */
drha4267dc2008-02-19 15:20:44 +00002839 flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
drhb25a9f42009-05-12 13:35:11 +00002840 SQLITE_OPEN_EXCLUSIVE |
drha4267dc2008-02-19 15:20:44 +00002841 SQLITE_OPEN_MAIN_DB |
2842 SQLITE_OPEN_TEMP_DB |
2843 SQLITE_OPEN_TRANSIENT_DB |
2844 SQLITE_OPEN_MAIN_JOURNAL |
2845 SQLITE_OPEN_TEMP_JOURNAL |
2846 SQLITE_OPEN_SUBJOURNAL |
danielk19779a6284c2008-07-10 17:52:49 +00002847 SQLITE_OPEN_MASTER_JOURNAL |
drh039963a2008-09-03 00:43:15 +00002848 SQLITE_OPEN_NOMUTEX |
drh357b5f92010-08-24 18:07:57 +00002849 SQLITE_OPEN_FULLMUTEX |
2850 SQLITE_OPEN_WAL
drha4267dc2008-02-19 15:20:44 +00002851 );
2852
danielk19774ad17132004-05-21 01:47:26 +00002853 /* Allocate the sqlite data structure */
drh17435752007-08-16 04:30:38 +00002854 db = sqlite3MallocZero( sizeof(sqlite3) );
danielk19774ad17132004-05-21 01:47:26 +00002855 if( db==0 ) goto opendb_out;
drh039963a2008-09-03 00:43:15 +00002856 if( isThreadsafe ){
danielk197759f8c082008-06-18 17:09:10 +00002857 db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
2858 if( db->mutex==0 ){
2859 sqlite3_free(db);
2860 db = 0;
2861 goto opendb_out;
2862 }
drh605264d2007-08-21 15:13:19 +00002863 }
drh27641702007-08-22 02:56:42 +00002864 sqlite3_mutex_enter(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00002865 db->errMask = 0xff;
danielk19774ad17132004-05-21 01:47:26 +00002866 db->nDb = 2;
drh153c62c2007-08-24 03:51:33 +00002867 db->magic = SQLITE_MAGIC_BUSY;
danielk19774ad17132004-05-21 01:47:26 +00002868 db->aDb = db->aDbStatic;
drh633e6d52008-07-28 19:34:53 +00002869
drhbb4957f2008-03-20 14:03:29 +00002870 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
2871 memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
drh6b2129a2014-08-29 19:06:07 +00002872 db->aLimit[SQLITE_LIMIT_WORKER_THREADS] = SQLITE_DEFAULT_WORKER_THREADS;
danielk19771d850a72004-05-31 08:26:49 +00002873 db->autoCommit = 1;
drhddac25c2007-12-05 01:38:23 +00002874 db->nextAutovac = -1;
drh9b4c59f2013-04-15 17:03:42 +00002875 db->szMmap = sqlite3GlobalConfig.szMmap;
danielk1977f653d782008-03-20 11:04:21 +00002876 db->nextPagesize = 0;
dan8930c2a2014-04-03 16:25:29 +00002877 db->nMaxSorterMmap = 0x7FFFFFFF;
drh40c39412013-08-16 20:42:20 +00002878 db->flags |= SQLITE_ShortColNames | SQLITE_EnableTrigger | SQLITE_CacheSpill
dan1d1f07d2013-07-25 16:41:39 +00002879#if !defined(SQLITE_DEFAULT_AUTOMATIC_INDEX) || SQLITE_DEFAULT_AUTOMATIC_INDEX
drh986b3872013-06-28 21:12:20 +00002880 | SQLITE_AutoIndex
2881#endif
drh883ad042015-02-19 00:29:11 +00002882#if SQLITE_DEFAULT_CKPTFULLFSYNC
2883 | SQLITE_CkptFullFSync
2884#endif
drh76fe8032006-07-11 14:17:51 +00002885#if SQLITE_DEFAULT_FILE_FORMAT<4
2886 | SQLITE_LegacyFileFmt
2887#endif
drh56424db2007-03-27 22:24:11 +00002888#ifdef SQLITE_ENABLE_LOAD_EXTENSION
2889 | SQLITE_LoadExtension
2890#endif
dan5bde73c2009-09-01 17:11:07 +00002891#if SQLITE_DEFAULT_RECURSIVE_TRIGGERS
dan5e1a2782009-09-01 17:28:29 +00002892 | SQLITE_RecTriggers
dan76d462e2009-08-30 11:42:51 +00002893#endif
drha4bfd7f2010-12-09 19:15:17 +00002894#if defined(SQLITE_DEFAULT_FOREIGN_KEYS) && SQLITE_DEFAULT_FOREIGN_KEYS
2895 | SQLITE_ForeignKeys
2896#endif
drhf5471922014-12-09 15:12:11 +00002897#if defined(SQLITE_REVERSE_UNORDERED_SELECTS)
2898 | SQLITE_ReverseOrder
2899#endif
drh1421d982015-05-27 03:46:18 +00002900#if defined(SQLITE_ENABLE_OVERSIZE_CELL_CHECK)
2901 | SQLITE_CellSizeCk
2902#endif
drhd42908f2016-02-26 15:38:24 +00002903#if defined(SQLITE_ENABLE_FTS3_TOKENIZER)
2904 | SQLITE_Fts3Tokenizer
2905#endif
drh169dd922017-06-26 13:57:49 +00002906#if defined(SQLITE_ENABLE_QPSG)
2907 | SQLITE_EnableQPSG
2908#endif
drh76fe8032006-07-11 14:17:51 +00002909 ;
drhe61922a2009-05-02 13:29:37 +00002910 sqlite3HashInit(&db->aCollSeq);
drhb9bb7c12006-06-11 23:41:55 +00002911#ifndef SQLITE_OMIT_VIRTUALTABLE
drhe61922a2009-05-02 13:29:37 +00002912 sqlite3HashInit(&db->aModule);
drhb9bb7c12006-06-11 23:41:55 +00002913#endif
danielk1977da184232006-01-05 11:34:32 +00002914
danielk19770202b292004-06-09 09:55:16 +00002915 /* Add the default collation sequence BINARY. BINARY works for both UTF-8
2916 ** and UTF-16, so add a version for each to avoid any unnecessary
2917 ** conversions. The only error that can occur here is a malloc() failure.
drh5e3b49b2014-11-20 19:22:26 +00002918 **
2919 ** EVIDENCE-OF: R-52786-44878 SQLite defines three built-in collating
2920 ** functions:
danielk19770202b292004-06-09 09:55:16 +00002921 */
drhf19aa5f2015-12-30 16:51:20 +00002922 createCollation(db, sqlite3StrBINARY, SQLITE_UTF8, 0, binCollFunc, 0);
2923 createCollation(db, sqlite3StrBINARY, SQLITE_UTF16BE, 0, binCollFunc, 0);
2924 createCollation(db, sqlite3StrBINARY, SQLITE_UTF16LE, 0, binCollFunc, 0);
drh5e3b49b2014-11-20 19:22:26 +00002925 createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
drh4dd65e02011-11-29 14:46:56 +00002926 createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
drh77db4c02008-03-18 13:01:38 +00002927 if( db->mallocFailed ){
danielk19770202b292004-06-09 09:55:16 +00002928 goto opendb_out;
2929 }
drh5e3b49b2014-11-20 19:22:26 +00002930 /* EVIDENCE-OF: R-08308-17224 The default collating function for all
2931 ** strings is BINARY.
2932 */
drhf19aa5f2015-12-30 16:51:20 +00002933 db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, sqlite3StrBINARY, 0);
drh77db4c02008-03-18 13:01:38 +00002934 assert( db->pDfltColl!=0 );
danielk19770202b292004-06-09 09:55:16 +00002935
drhff4fa772017-07-10 12:07:53 +00002936 /* Parse the filename/URI argument
2937 **
2938 ** Only allow sensible combinations of bits in the flags argument.
2939 ** Throw an error if any non-sense combination is used. If we
2940 ** do not block illegal combinations here, it could trigger
2941 ** assert() statements in deeper layers. Sensible combinations
2942 ** are:
2943 **
2944 ** 1: SQLITE_OPEN_READONLY
2945 ** 2: SQLITE_OPEN_READWRITE
2946 ** 6: SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE
2947 */
drh33f4e022007-09-03 15:19:34 +00002948 db->openFlags = flags;
drhff4fa772017-07-10 12:07:53 +00002949 assert( SQLITE_OPEN_READONLY == 0x01 );
2950 assert( SQLITE_OPEN_READWRITE == 0x02 );
2951 assert( SQLITE_OPEN_CREATE == 0x04 );
2952 testcase( (1<<(flags&7))==0x02 ); /* READONLY */
2953 testcase( (1<<(flags&7))==0x04 ); /* READWRITE */
2954 testcase( (1<<(flags&7))==0x40 ); /* READWRITE | CREATE */
2955 if( ((1<<(flags&7)) & 0x46)==0 ){
2956 rc = SQLITE_MISUSE_BKPT; /* IMP: R-65497-44594 */
2957 }else{
2958 rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
2959 }
dancd74b612011-04-22 19:37:32 +00002960 if( rc!=SQLITE_OK ){
drh4a642b62016-02-05 01:55:27 +00002961 if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
drh13f40da2014-08-22 18:00:11 +00002962 sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
dancd74b612011-04-22 19:37:32 +00002963 sqlite3_free(zErrMsg);
2964 goto opendb_out;
2965 }
2966
danielk19774ad17132004-05-21 01:47:26 +00002967 /* Open the backend database driver */
dan3a6d8ae2011-04-23 15:54:54 +00002968 rc = sqlite3BtreeOpen(db->pVfs, zOpen, db, &db->aDb[0].pBt, 0,
drh75c014c2010-08-30 15:02:28 +00002969 flags | SQLITE_OPEN_MAIN_DB);
danielk19774ad17132004-05-21 01:47:26 +00002970 if( rc!=SQLITE_OK ){
danielk197745e60aa2008-09-23 17:39:26 +00002971 if( rc==SQLITE_IOERR_NOMEM ){
mistachkinfad30392016-02-13 23:43:46 +00002972 rc = SQLITE_NOMEM_BKPT;
danielk197745e60aa2008-09-23 17:39:26 +00002973 }
drh13f40da2014-08-22 18:00:11 +00002974 sqlite3Error(db, rc);
danielk19774ad17132004-05-21 01:47:26 +00002975 goto opendb_out;
2976 }
dan0235a032014-12-08 20:20:16 +00002977 sqlite3BtreeEnter(db->aDb[0].pBt);
drh17435752007-08-16 04:30:38 +00002978 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
drh9bd3cc42014-12-12 23:17:54 +00002979 if( !db->mallocFailed ) ENC(db) = SCHEMA_ENC(db);
dan0235a032014-12-08 20:20:16 +00002980 sqlite3BtreeLeave(db->aDb[0].pBt);
drh17435752007-08-16 04:30:38 +00002981 db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
danielk197714db2662006-01-09 16:12:04 +00002982
drhe872d512016-02-22 13:23:16 +00002983 /* The default safety_level for the main database is FULL; for the temp
2984 ** database it is OFF. This matches the pager layer defaults.
danielk197753c0f742005-03-29 03:10:59 +00002985 */
drh69c33822016-08-18 14:33:11 +00002986 db->aDb[0].zDbSName = "main";
drhc2ae2072016-03-08 15:30:01 +00002987 db->aDb[0].safety_level = SQLITE_DEFAULT_SYNCHRONOUS+1;
drh69c33822016-08-18 14:33:11 +00002988 db->aDb[1].zDbSName = "temp";
drhe872d512016-02-22 13:23:16 +00002989 db->aDb[1].safety_level = PAGER_SYNCHRONOUS_OFF;
danielk197753c0f742005-03-29 03:10:59 +00002990
danielk1977832a58a2007-06-22 15:21:15 +00002991 db->magic = SQLITE_MAGIC_OPEN;
drh17435752007-08-16 04:30:38 +00002992 if( db->mallocFailed ){
danielk1977832a58a2007-06-22 15:21:15 +00002993 goto opendb_out;
2994 }
2995
danielk19778e227872004-06-07 07:52:17 +00002996 /* Register all built-in functions, but do not attempt to read the
2997 ** database schema yet. This is delayed until the first time the database
2998 ** is accessed.
2999 */
drh13f40da2014-08-22 18:00:11 +00003000 sqlite3Error(db, SQLITE_OK);
drh80738d92016-02-15 00:34:16 +00003001 sqlite3RegisterPerConnectionBuiltinFunctions(db);
danc9e75fb2016-08-19 18:37:35 +00003002 rc = sqlite3_errcode(db);
3003
3004#ifdef SQLITE_ENABLE_FTS5
3005 /* Register any built-in FTS5 module before loading the automatic
3006 ** extensions. This allows automatic extensions to register FTS5
3007 ** tokenizers and auxiliary functions. */
3008 if( !db->mallocFailed && rc==SQLITE_OK ){
3009 rc = sqlite3Fts5Init(db);
3010 }
3011#endif
danielk19774ad17132004-05-21 01:47:26 +00003012
drh1409be62006-08-23 20:07:20 +00003013 /* Load automatic extensions - extensions that have been registered
3014 ** using the sqlite3_automatic_extension() API.
3015 */
drhe5077c12011-12-13 04:08:36 +00003016 if( rc==SQLITE_OK ){
3017 sqlite3AutoLoadExtensions(db);
3018 rc = sqlite3_errcode(db);
drh76f63782017-02-07 03:44:42 +00003019 if( rc!=SQLITE_OK ){
3020 goto opendb_out;
3021 }
danielk1977832a58a2007-06-22 15:21:15 +00003022 }
drh1409be62006-08-23 20:07:20 +00003023
drhaa29c132006-09-02 13:58:06 +00003024#ifdef SQLITE_ENABLE_FTS1
drh76f63782017-02-07 03:44:42 +00003025 if( !db->mallocFailed ){
drhaa29c132006-09-02 13:58:06 +00003026 extern int sqlite3Fts1Init(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00003027 rc = sqlite3Fts1Init(db);
drhaa29c132006-09-02 13:58:06 +00003028 }
3029#endif
3030
shessa26cf572006-10-19 20:27:58 +00003031#ifdef SQLITE_ENABLE_FTS2
drh17435752007-08-16 04:30:38 +00003032 if( !db->mallocFailed && rc==SQLITE_OK ){
shessa26cf572006-10-19 20:27:58 +00003033 extern int sqlite3Fts2Init(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00003034 rc = sqlite3Fts2Init(db);
shessa26cf572006-10-19 20:27:58 +00003035 }
3036#endif
3037
drh50065652015-10-08 19:29:18 +00003038#ifdef SQLITE_ENABLE_FTS3 /* automatically defined by SQLITE_ENABLE_FTS4 */
shess69c4ae22007-08-20 17:37:47 +00003039 if( !db->mallocFailed && rc==SQLITE_OK ){
shess69c4ae22007-08-20 17:37:47 +00003040 rc = sqlite3Fts3Init(db);
3041 }
3042#endif
3043
danielk197783852ac2007-05-06 16:04:11 +00003044#ifdef SQLITE_ENABLE_ICU
drh17435752007-08-16 04:30:38 +00003045 if( !db->mallocFailed && rc==SQLITE_OK ){
danielk1977832a58a2007-06-22 15:21:15 +00003046 rc = sqlite3IcuInit(db);
danielk197783852ac2007-05-06 16:04:11 +00003047 }
3048#endif
danielk1977ebaecc12008-05-26 18:41:54 +00003049
3050#ifdef SQLITE_ENABLE_RTREE
3051 if( !db->mallocFailed && rc==SQLITE_OK){
danielk1977ebaecc12008-05-26 18:41:54 +00003052 rc = sqlite3RtreeInit(db);
3053 }
3054#endif
3055
drha3ab9d02015-05-04 20:25:05 +00003056#ifdef SQLITE_ENABLE_DBSTAT_VTAB
3057 if( !db->mallocFailed && rc==SQLITE_OK){
drh3e0327d2015-05-11 11:59:15 +00003058 rc = sqlite3DbstatRegister(db);
drha3ab9d02015-05-04 20:25:05 +00003059 }
3060#endif
3061
drh2f20e132015-09-26 17:44:59 +00003062#ifdef SQLITE_ENABLE_JSON1
3063 if( !db->mallocFailed && rc==SQLITE_OK){
drh2f20e132015-09-26 17:44:59 +00003064 rc = sqlite3Json1Init(db);
3065 }
3066#endif
3067
drhc6603af2017-06-29 14:33:51 +00003068#ifdef SQLITE_ENABLE_STMTVTAB
drhf00f5302017-06-28 15:47:29 +00003069 if( !db->mallocFailed && rc==SQLITE_OK){
drhc6603af2017-06-29 14:33:51 +00003070 rc = sqlite3StmtVtabInit(db);
drhf00f5302017-06-28 15:47:29 +00003071 }
3072#endif
3073
drh76f63782017-02-07 03:44:42 +00003074 /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
3075 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
3076 ** mode. Doing nothing at all also makes NORMAL the default.
3077 */
drh8fd5bd32007-04-02 16:40:37 +00003078#ifdef SQLITE_DEFAULT_LOCKING_MODE
drh76f63782017-02-07 03:44:42 +00003079 db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
3080 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
3081 SQLITE_DEFAULT_LOCKING_MODE);
drh8fd5bd32007-04-02 16:40:37 +00003082#endif
3083
drh76f63782017-02-07 03:44:42 +00003084 if( rc ) sqlite3Error(db, rc);
drhf6b1a8e2013-12-19 16:26:05 +00003085
drh76f63782017-02-07 03:44:42 +00003086 /* Enable the lookaside-malloc subsystem */
3087 setupLookaside(db, 0, sqlite3GlobalConfig.szLookaside,
3088 sqlite3GlobalConfig.nLookaside);
3089
3090 sqlite3_wal_autocheckpoint(db, SQLITE_DEFAULT_WAL_AUTOCHECKPOINT);
dan586b9c82010-05-03 08:04:49 +00003091
danielk19774ad17132004-05-21 01:47:26 +00003092opendb_out:
drhafc91042008-02-21 02:09:45 +00003093 if( db ){
drh3ba689d2015-03-03 14:00:11 +00003094 assert( db->mutex!=0 || isThreadsafe==0
3095 || sqlite3GlobalConfig.bFullMutex==0 );
drhf3a65f72007-08-22 20:18:21 +00003096 sqlite3_mutex_leave(db->mutex);
3097 }
danielk197759633ae2008-08-27 19:01:57 +00003098 rc = sqlite3_errcode(db);
drhb07028f2011-10-14 21:49:18 +00003099 assert( db!=0 || rc==SQLITE_NOMEM );
danielk197759633ae2008-08-27 19:01:57 +00003100 if( rc==SQLITE_NOMEM ){
danielk19777ddad962005-12-12 06:53:03 +00003101 sqlite3_close(db);
3102 db = 0;
danielk197759633ae2008-08-27 19:01:57 +00003103 }else if( rc!=SQLITE_OK ){
3104 db->magic = SQLITE_MAGIC_SICK;
danielk197713073932004-06-30 11:54:06 +00003105 }
danielk19774ad17132004-05-21 01:47:26 +00003106 *ppDb = db;
danac455932012-11-26 19:50:41 +00003107#ifdef SQLITE_ENABLE_SQLLOG
3108 if( sqlite3GlobalConfig.xSqllog ){
dan71ba10d2012-11-27 10:56:39 +00003109 /* Opening a db handle. Fourth parameter is passed 0. */
3110 void *pArg = sqlite3GlobalConfig.pSqllogArg;
3111 sqlite3GlobalConfig.xSqllog(pArg, db, zFilename, 0);
danac455932012-11-26 19:50:41 +00003112 }
3113#endif
drh46e6ea02015-10-26 14:41:35 +00003114#if defined(SQLITE_HAS_CODEC)
3115 if( rc==SQLITE_OK ){
drhad012d02017-05-03 15:54:53 +00003116 const char *zKey;
drhd4fb1962017-05-23 00:32:56 +00003117 if( (zKey = sqlite3_uri_parameter(zOpen, "hexkey"))!=0 && zKey[0] ){
drh46e6ea02015-10-26 14:41:35 +00003118 u8 iByte;
3119 int i;
drhad012d02017-05-03 15:54:53 +00003120 char zDecoded[40];
3121 for(i=0, iByte=0; i<sizeof(zDecoded)*2 && sqlite3Isxdigit(zKey[i]); i++){
3122 iByte = (iByte<<4) + sqlite3HexToInt(zKey[i]);
3123 if( (i&1)!=0 ) zDecoded[i/2] = iByte;
drh46e6ea02015-10-26 14:41:35 +00003124 }
drhad012d02017-05-03 15:54:53 +00003125 sqlite3_key_v2(db, 0, zDecoded, i/2);
3126 }else if( (zKey = sqlite3_uri_parameter(zOpen, "key"))!=0 ){
3127 sqlite3_key_v2(db, 0, zKey, sqlite3Strlen30(zKey));
drh46e6ea02015-10-26 14:41:35 +00003128 }
3129 }
3130#endif
drh095fb472016-01-16 03:16:19 +00003131 sqlite3_free(zOpen);
drh597d2b62015-06-30 03:13:47 +00003132 return rc & 0xff;
danielk19774ad17132004-05-21 01:47:26 +00003133}
3134
3135/*
3136** Open a new database handle.
3137*/
danielk197780290862004-05-22 09:21:21 +00003138int sqlite3_open(
danielk19774ad17132004-05-21 01:47:26 +00003139 const char *zFilename,
danielk19774f057f92004-06-08 00:02:33 +00003140 sqlite3 **ppDb
danielk19774ad17132004-05-21 01:47:26 +00003141){
drh605264d2007-08-21 15:13:19 +00003142 return openDatabase(zFilename, ppDb,
3143 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
3144}
3145int sqlite3_open_v2(
drh428e2822007-08-30 16:23:19 +00003146 const char *filename, /* Database filename (UTF-8) */
drh605264d2007-08-21 15:13:19 +00003147 sqlite3 **ppDb, /* OUT: SQLite db handle */
3148 int flags, /* Flags */
3149 const char *zVfs /* Name of VFS module to use */
3150){
drh522c26f2011-05-07 14:40:29 +00003151 return openDatabase(filename, ppDb, (unsigned int)flags, zVfs);
danielk197783ab5a82004-05-21 11:39:05 +00003152}
3153
drh6c626082004-11-14 21:56:29 +00003154#ifndef SQLITE_OMIT_UTF16
danielk19774ad17132004-05-21 01:47:26 +00003155/*
3156** Open a new database handle.
3157*/
3158int sqlite3_open16(
3159 const void *zFilename,
danielk19774f057f92004-06-08 00:02:33 +00003160 sqlite3 **ppDb
danielk19774ad17132004-05-21 01:47:26 +00003161){
danielk1977bfd6cce2004-06-18 04:24:54 +00003162 char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
danielk1977bfd6cce2004-06-18 04:24:54 +00003163 sqlite3_value *pVal;
drh40257ff2008-06-13 18:24:27 +00003164 int rc;
danielk19774ad17132004-05-21 01:47:26 +00003165
drh9ca95732014-10-24 00:35:58 +00003166#ifdef SQLITE_ENABLE_API_ARMOR
3167 if( ppDb==0 ) return SQLITE_MISUSE_BKPT;
3168#endif
danielk1977bfd6cce2004-06-18 04:24:54 +00003169 *ppDb = 0;
drh40257ff2008-06-13 18:24:27 +00003170#ifndef SQLITE_OMIT_AUTOINIT
3171 rc = sqlite3_initialize();
3172 if( rc ) return rc;
3173#endif
drh9ca95732014-10-24 00:35:58 +00003174 if( zFilename==0 ) zFilename = "\000\000";
danielk19771e536952007-08-16 10:09:01 +00003175 pVal = sqlite3ValueNew(0);
drhb21c8cd2007-08-21 19:33:56 +00003176 sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
3177 zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
danielk1977bfd6cce2004-06-18 04:24:54 +00003178 if( zFilename8 ){
drh605264d2007-08-21 15:13:19 +00003179 rc = openDatabase(zFilename8, ppDb,
3180 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
drhafc91042008-02-21 02:09:45 +00003181 assert( *ppDb || rc==SQLITE_NOMEM );
danielk1977f51bf482008-04-28 16:19:35 +00003182 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
drh9bd3cc42014-12-12 23:17:54 +00003183 SCHEMA_ENC(*ppDb) = ENC(*ppDb) = SQLITE_UTF16NATIVE;
danielk1977bfd6cce2004-06-18 04:24:54 +00003184 }
drh40257ff2008-06-13 18:24:27 +00003185 }else{
mistachkinfad30392016-02-13 23:43:46 +00003186 rc = SQLITE_NOMEM_BKPT;
danielk19774ad17132004-05-21 01:47:26 +00003187 }
danielk19777ddad962005-12-12 06:53:03 +00003188 sqlite3ValueFree(pVal);
danielk19778e227872004-06-07 07:52:17 +00003189
drh597d2b62015-06-30 03:13:47 +00003190 return rc & 0xff;
danielk19774ad17132004-05-21 01:47:26 +00003191}
drh6c626082004-11-14 21:56:29 +00003192#endif /* SQLITE_OMIT_UTF16 */
danielk19774ad17132004-05-21 01:47:26 +00003193
danielk1977106bb232004-05-21 10:08:53 +00003194/*
danielk1977d8123362004-06-12 09:25:12 +00003195** Register a new collation sequence with the database handle db.
3196*/
danielk19770202b292004-06-09 09:55:16 +00003197int sqlite3_create_collation(
3198 sqlite3* db,
3199 const char *zName,
danielk1977466be562004-06-10 02:16:01 +00003200 int enc,
danielk19770202b292004-06-09 09:55:16 +00003201 void* pCtx,
3202 int(*xCompare)(void*,int,const void*,int,const void*)
3203){
drh4f81bbb2014-10-23 01:01:26 +00003204 return sqlite3_create_collation_v2(db, zName, enc, pCtx, xCompare, 0);
danielk1977a9808b32007-05-07 09:32:45 +00003205}
3206
3207/*
3208** Register a new collation sequence with the database handle db.
3209*/
danielk1977a393c032007-05-07 14:58:53 +00003210int sqlite3_create_collation_v2(
danielk1977a9808b32007-05-07 09:32:45 +00003211 sqlite3* db,
3212 const char *zName,
3213 int enc,
3214 void* pCtx,
3215 int(*xCompare)(void*,int,const void*,int,const void*),
3216 void(*xDel)(void*)
3217){
3218 int rc;
drh9ca95732014-10-24 00:35:58 +00003219
3220#ifdef SQLITE_ENABLE_API_ARMOR
3221 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
3222#endif
drhe30f4422007-08-21 16:15:55 +00003223 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00003224 assert( !db->mallocFailed );
drh4dd65e02011-11-29 14:46:56 +00003225 rc = createCollation(db, zName, (u8)enc, pCtx, xCompare, xDel);
drhe30f4422007-08-21 16:15:55 +00003226 rc = sqlite3ApiExit(db, rc);
3227 sqlite3_mutex_leave(db->mutex);
3228 return rc;
danielk19770202b292004-06-09 09:55:16 +00003229}
3230
drh6c626082004-11-14 21:56:29 +00003231#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +00003232/*
3233** Register a new collation sequence with the database handle db.
3234*/
danielk19770202b292004-06-09 09:55:16 +00003235int sqlite3_create_collation16(
3236 sqlite3* db,
mihailimbda2e622008-06-23 11:23:14 +00003237 const void *zName,
danielk1977466be562004-06-10 02:16:01 +00003238 int enc,
danielk19770202b292004-06-09 09:55:16 +00003239 void* pCtx,
3240 int(*xCompare)(void*,int,const void*,int,const void*)
3241){
danielk19779a30cf62006-01-18 04:26:07 +00003242 int rc = SQLITE_OK;
drh01495b92008-01-23 12:52:40 +00003243 char *zName8;
drh9ca95732014-10-24 00:35:58 +00003244
3245#ifdef SQLITE_ENABLE_API_ARMOR
3246 if( !sqlite3SafetyCheckOk(db) || zName==0 ) return SQLITE_MISUSE_BKPT;
3247#endif
drhe30f4422007-08-21 16:15:55 +00003248 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00003249 assert( !db->mallocFailed );
danb7dca7d2010-03-05 16:32:12 +00003250 zName8 = sqlite3Utf16to8(db, zName, -1, SQLITE_UTF16NATIVE);
danielk19779a30cf62006-01-18 04:26:07 +00003251 if( zName8 ){
drh4dd65e02011-11-29 14:46:56 +00003252 rc = createCollation(db, zName8, (u8)enc, pCtx, xCompare, 0);
drh633e6d52008-07-28 19:34:53 +00003253 sqlite3DbFree(db, zName8);
danielk19779a30cf62006-01-18 04:26:07 +00003254 }
drhe30f4422007-08-21 16:15:55 +00003255 rc = sqlite3ApiExit(db, rc);
3256 sqlite3_mutex_leave(db->mutex);
3257 return rc;
danielk19770202b292004-06-09 09:55:16 +00003258}
drh6c626082004-11-14 21:56:29 +00003259#endif /* SQLITE_OMIT_UTF16 */
danielk19777cedc8d2004-06-10 10:50:08 +00003260
danielk1977d8123362004-06-12 09:25:12 +00003261/*
3262** Register a collation sequence factory callback with the database handle
3263** db. Replace any previously installed collation sequence factory.
3264*/
danielk19777cedc8d2004-06-10 10:50:08 +00003265int sqlite3_collation_needed(
3266 sqlite3 *db,
3267 void *pCollNeededArg,
3268 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
3269){
drh9ca95732014-10-24 00:35:58 +00003270#ifdef SQLITE_ENABLE_API_ARMOR
3271 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3272#endif
drhe30f4422007-08-21 16:15:55 +00003273 sqlite3_mutex_enter(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00003274 db->xCollNeeded = xCollNeeded;
3275 db->xCollNeeded16 = 0;
3276 db->pCollNeededArg = pCollNeededArg;
drhe30f4422007-08-21 16:15:55 +00003277 sqlite3_mutex_leave(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00003278 return SQLITE_OK;
3279}
danielk1977d8123362004-06-12 09:25:12 +00003280
drh6c626082004-11-14 21:56:29 +00003281#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +00003282/*
3283** Register a collation sequence factory callback with the database handle
3284** db. Replace any previously installed collation sequence factory.
3285*/
danielk19777cedc8d2004-06-10 10:50:08 +00003286int sqlite3_collation_needed16(
3287 sqlite3 *db,
3288 void *pCollNeededArg,
3289 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
3290){
drh9ca95732014-10-24 00:35:58 +00003291#ifdef SQLITE_ENABLE_API_ARMOR
3292 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3293#endif
drhe30f4422007-08-21 16:15:55 +00003294 sqlite3_mutex_enter(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00003295 db->xCollNeeded = 0;
3296 db->xCollNeeded16 = xCollNeeded16;
3297 db->pCollNeededArg = pCollNeededArg;
drhe30f4422007-08-21 16:15:55 +00003298 sqlite3_mutex_leave(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00003299 return SQLITE_OK;
3300}
drh6c626082004-11-14 21:56:29 +00003301#endif /* SQLITE_OMIT_UTF16 */
danielk19776b456a22005-03-21 04:04:02 +00003302
shaneeec556d2008-10-12 00:27:53 +00003303#ifndef SQLITE_OMIT_DEPRECATED
danielk19776b456a22005-03-21 04:04:02 +00003304/*
danielk19777ddad962005-12-12 06:53:03 +00003305** This function is now an anachronism. It used to be used to recover from a
3306** malloc() failure, but SQLite now does this automatically.
danielk19776b456a22005-03-21 04:04:02 +00003307*/
drh7d97efb2007-10-12 19:35:48 +00003308int sqlite3_global_recover(void){
danielk1977261919c2005-12-06 12:52:59 +00003309 return SQLITE_OK;
danielk19776b456a22005-03-21 04:04:02 +00003310}
3311#endif
drh3e1d8e62005-05-26 16:23:34 +00003312
3313/*
3314** Test to see whether or not the database connection is in autocommit
3315** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
3316** by default. Autocommit is disabled by a BEGIN statement and reenabled
3317** by the next COMMIT or ROLLBACK.
drh3e1d8e62005-05-26 16:23:34 +00003318*/
3319int sqlite3_get_autocommit(sqlite3 *db){
drh9ca95732014-10-24 00:35:58 +00003320#ifdef SQLITE_ENABLE_API_ARMOR
3321 if( !sqlite3SafetyCheckOk(db) ){
3322 (void)SQLITE_MISUSE_BKPT;
3323 return 0;
3324 }
3325#endif
drh3e1d8e62005-05-26 16:23:34 +00003326 return db->autoCommit;
3327}
drh49285702005-09-17 15:20:26 +00003328
drh49285702005-09-17 15:20:26 +00003329/*
peter.d.reid60ec9142014-09-06 16:39:46 +00003330** The following routines are substitutes for constants SQLITE_CORRUPT,
mistachkin8fd84132016-02-14 00:14:35 +00003331** SQLITE_MISUSE, SQLITE_CANTOPEN, SQLITE_NOMEM and possibly other error
peter.d.reid60ec9142014-09-06 16:39:46 +00003332** constants. They serve two purposes:
drh9978c972010-02-23 17:36:32 +00003333**
3334** 1. Serve as a convenient place to set a breakpoint in a debugger
3335** to detect when version error conditions occurs.
3336**
3337** 2. Invoke sqlite3_log() to provide the source code location where
3338** a low-level error is first detected.
drh49285702005-09-17 15:20:26 +00003339*/
drh32c49902016-02-15 18:15:15 +00003340static int reportError(int iErr, int lineno, const char *zType){
3341 sqlite3_log(iErr, "%s at line %d of [%.10s]",
3342 zType, lineno, 20+sqlite3_sourceid());
3343 return iErr;
3344}
drh9978c972010-02-23 17:36:32 +00003345int sqlite3CorruptError(int lineno){
drhaf46dc12010-02-24 21:44:07 +00003346 testcase( sqlite3GlobalConfig.xLog!=0 );
drh32c49902016-02-15 18:15:15 +00003347 return reportError(SQLITE_CORRUPT, lineno, "database corruption");
drh49285702005-09-17 15:20:26 +00003348}
drh9978c972010-02-23 17:36:32 +00003349int sqlite3MisuseError(int lineno){
drhaf46dc12010-02-24 21:44:07 +00003350 testcase( sqlite3GlobalConfig.xLog!=0 );
drh32c49902016-02-15 18:15:15 +00003351 return reportError(SQLITE_MISUSE, lineno, "misuse");
drh9978c972010-02-23 17:36:32 +00003352}
3353int sqlite3CantopenError(int lineno){
drhaf46dc12010-02-24 21:44:07 +00003354 testcase( sqlite3GlobalConfig.xLog!=0 );
drh32c49902016-02-15 18:15:15 +00003355 return reportError(SQLITE_CANTOPEN, lineno, "cannot open file");
drh9978c972010-02-23 17:36:32 +00003356}
drh32c49902016-02-15 18:15:15 +00003357#ifdef SQLITE_DEBUG
drhcc97ca42017-06-07 22:32:59 +00003358int sqlite3CorruptPgnoError(int lineno, Pgno pgno){
3359 char zMsg[100];
3360 sqlite3_snprintf(sizeof(zMsg), zMsg, "database corruption page %d", pgno);
3361 testcase( sqlite3GlobalConfig.xLog!=0 );
3362 return reportError(SQLITE_CORRUPT, lineno, zMsg);
3363}
mistachkinfad30392016-02-13 23:43:46 +00003364int sqlite3NomemError(int lineno){
3365 testcase( sqlite3GlobalConfig.xLog!=0 );
drh32c49902016-02-15 18:15:15 +00003366 return reportError(SQLITE_NOMEM, lineno, "OOM");
mistachkinfad30392016-02-13 23:43:46 +00003367}
3368int sqlite3IoerrnomemError(int lineno){
3369 testcase( sqlite3GlobalConfig.xLog!=0 );
drh32c49902016-02-15 18:15:15 +00003370 return reportError(SQLITE_IOERR_NOMEM, lineno, "I/O OOM error");
mistachkinfad30392016-02-13 23:43:46 +00003371}
drh32c49902016-02-15 18:15:15 +00003372#endif
drh7c1817e2006-01-10 13:58:48 +00003373
shaneeec556d2008-10-12 00:27:53 +00003374#ifndef SQLITE_OMIT_DEPRECATED
drh6f7adc82006-01-11 21:41:20 +00003375/*
3376** This is a convenience routine that makes sure that all thread-specific
3377** data for this thread has been deallocated.
drhdce8bdb2007-08-16 13:01:44 +00003378**
3379** SQLite no longer uses thread-specific data so this routine is now a
3380** no-op. It is retained for historical compatibility.
drh6f7adc82006-01-11 21:41:20 +00003381*/
3382void sqlite3_thread_cleanup(void){
drh6f7adc82006-01-11 21:41:20 +00003383}
shaneeec556d2008-10-12 00:27:53 +00003384#endif
danielk1977deb802c2006-02-09 13:43:28 +00003385
3386/*
3387** Return meta information about a specific column of a database table.
3388** See comment in sqlite3.h (sqlite.h.in) for details.
3389*/
danielk1977deb802c2006-02-09 13:43:28 +00003390int sqlite3_table_column_metadata(
3391 sqlite3 *db, /* Connection handle */
3392 const char *zDbName, /* Database name or NULL */
3393 const char *zTableName, /* Table name */
3394 const char *zColumnName, /* Column name */
3395 char const **pzDataType, /* OUTPUT: Declared data type */
3396 char const **pzCollSeq, /* OUTPUT: Collation sequence name */
3397 int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
3398 int *pPrimaryKey, /* OUTPUT: True if column part of PK */
drh9be07162008-06-16 20:51:15 +00003399 int *pAutoinc /* OUTPUT: True if column is auto-increment */
danielk1977deb802c2006-02-09 13:43:28 +00003400){
3401 int rc;
3402 char *zErrMsg = 0;
3403 Table *pTab = 0;
3404 Column *pCol = 0;
mistachkin1a51ce72015-01-12 18:38:02 +00003405 int iCol = 0;
danielk1977deb802c2006-02-09 13:43:28 +00003406 char const *zDataType = 0;
3407 char const *zCollSeq = 0;
3408 int notnull = 0;
3409 int primarykey = 0;
3410 int autoinc = 0;
3411
drh96c707a2015-02-13 16:36:14 +00003412
3413#ifdef SQLITE_ENABLE_API_ARMOR
3414 if( !sqlite3SafetyCheckOk(db) || zTableName==0 ){
3415 return SQLITE_MISUSE_BKPT;
3416 }
3417#endif
3418
danielk1977deb802c2006-02-09 13:43:28 +00003419 /* Ensure the database schema has been loaded */
drhe30f4422007-08-21 16:15:55 +00003420 sqlite3_mutex_enter(db->mutex);
drh3cb3edc2008-03-07 21:37:19 +00003421 sqlite3BtreeEnterAll(db);
danielk1977deb802c2006-02-09 13:43:28 +00003422 rc = sqlite3Init(db, &zErrMsg);
3423 if( SQLITE_OK!=rc ){
3424 goto error_out;
3425 }
3426
3427 /* Locate the table in question */
3428 pTab = sqlite3FindTable(db, zTableName, zDbName);
3429 if( !pTab || pTab->pSelect ){
3430 pTab = 0;
3431 goto error_out;
3432 }
3433
3434 /* Find the column for which info is requested */
drh45d1b202014-12-09 22:24:42 +00003435 if( zColumnName==0 ){
3436 /* Query for existance of table only */
danielk1977deb802c2006-02-09 13:43:28 +00003437 }else{
3438 for(iCol=0; iCol<pTab->nCol; iCol++){
3439 pCol = &pTab->aCol[iCol];
3440 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
3441 break;
3442 }
3443 }
3444 if( iCol==pTab->nCol ){
drh45d1b202014-12-09 22:24:42 +00003445 if( HasRowid(pTab) && sqlite3IsRowid(zColumnName) ){
3446 iCol = pTab->iPKey;
3447 pCol = iCol>=0 ? &pTab->aCol[iCol] : 0;
3448 }else{
3449 pTab = 0;
3450 goto error_out;
3451 }
danielk1977deb802c2006-02-09 13:43:28 +00003452 }
3453 }
3454
3455 /* The following block stores the meta information that will be returned
3456 ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
3457 ** and autoinc. At this point there are two possibilities:
3458 **
3459 ** 1. The specified column name was rowid", "oid" or "_rowid_"
3460 ** and there is no explicitly declared IPK column.
3461 **
3462 ** 2. The table is not a view and the column name identified an
3463 ** explicitly declared column. Copy meta information from *pCol.
3464 */
3465 if( pCol ){
drhd7564862016-03-22 20:05:09 +00003466 zDataType = sqlite3ColumnType(pCol,0);
danielk1977deb802c2006-02-09 13:43:28 +00003467 zCollSeq = pCol->zColl;
drh9be07162008-06-16 20:51:15 +00003468 notnull = pCol->notNull!=0;
drha371ace2012-09-13 14:22:47 +00003469 primarykey = (pCol->colFlags & COLFLAG_PRIMKEY)!=0;
drh7d10d5a2008-08-20 16:35:10 +00003470 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
danielk1977deb802c2006-02-09 13:43:28 +00003471 }else{
3472 zDataType = "INTEGER";
3473 primarykey = 1;
3474 }
3475 if( !zCollSeq ){
drhf19aa5f2015-12-30 16:51:20 +00003476 zCollSeq = sqlite3StrBINARY;
danielk1977deb802c2006-02-09 13:43:28 +00003477 }
3478
3479error_out:
danielk197702b4e3b2009-02-26 07:15:59 +00003480 sqlite3BtreeLeaveAll(db);
danielk1977deb802c2006-02-09 13:43:28 +00003481
3482 /* Whether the function call succeeded or failed, set the output parameters
3483 ** to whatever their local counterparts contain. If an error did occur,
3484 ** this has the effect of zeroing all output parameters.
3485 */
3486 if( pzDataType ) *pzDataType = zDataType;
3487 if( pzCollSeq ) *pzCollSeq = zCollSeq;
3488 if( pNotNull ) *pNotNull = notnull;
3489 if( pPrimaryKey ) *pPrimaryKey = primarykey;
3490 if( pAutoinc ) *pAutoinc = autoinc;
3491
3492 if( SQLITE_OK==rc && !pTab ){
drh633e6d52008-07-28 19:34:53 +00003493 sqlite3DbFree(db, zErrMsg);
drh118640b2008-07-16 14:02:32 +00003494 zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
drhf089aa42008-07-08 19:34:06 +00003495 zColumnName);
danielk1977deb802c2006-02-09 13:43:28 +00003496 rc = SQLITE_ERROR;
3497 }
drh13f40da2014-08-22 18:00:11 +00003498 sqlite3ErrorWithMsg(db, rc, (zErrMsg?"%s":0), zErrMsg);
drh633e6d52008-07-28 19:34:53 +00003499 sqlite3DbFree(db, zErrMsg);
drhe30f4422007-08-21 16:15:55 +00003500 rc = sqlite3ApiExit(db, rc);
3501 sqlite3_mutex_leave(db->mutex);
drhf9cb7f52006-06-27 20:06:44 +00003502 return rc;
3503}
3504
3505/*
3506** Sleep for a little while. Return the amount of time slept.
3507*/
3508int sqlite3_sleep(int ms){
danielk1977b4b47412007-08-17 15:53:36 +00003509 sqlite3_vfs *pVfs;
drhe30f4422007-08-21 16:15:55 +00003510 int rc;
drhd677b3d2007-08-20 22:48:41 +00003511 pVfs = sqlite3_vfs_find(0);
drh40257ff2008-06-13 18:24:27 +00003512 if( pVfs==0 ) return 0;
danielk1977fee2d252007-08-18 10:59:19 +00003513
3514 /* This function works in milliseconds, but the underlying OsSleep()
3515 ** API uses microseconds. Hence the 1000's.
3516 */
drhe30f4422007-08-21 16:15:55 +00003517 rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
drhe30f4422007-08-21 16:15:55 +00003518 return rc;
drhf9cb7f52006-06-27 20:06:44 +00003519}
drh4ac285a2006-09-15 07:28:50 +00003520
3521/*
3522** Enable or disable the extended result codes.
3523*/
3524int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
drh9ca95732014-10-24 00:35:58 +00003525#ifdef SQLITE_ENABLE_API_ARMOR
3526 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3527#endif
drhe30f4422007-08-21 16:15:55 +00003528 sqlite3_mutex_enter(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00003529 db->errMask = onoff ? 0xffffffff : 0xff;
drhe30f4422007-08-21 16:15:55 +00003530 sqlite3_mutex_leave(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00003531 return SQLITE_OK;
3532}
drhcc6bb3e2007-08-31 16:11:35 +00003533
3534/*
3535** Invoke the xFileControl method on a particular database.
3536*/
3537int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
3538 int rc = SQLITE_ERROR;
drh421377e2012-03-15 21:28:54 +00003539 Btree *pBtree;
3540
drh9ca95732014-10-24 00:35:58 +00003541#ifdef SQLITE_ENABLE_API_ARMOR
3542 if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;
3543#endif
drhcc6bb3e2007-08-31 16:11:35 +00003544 sqlite3_mutex_enter(db->mutex);
drh421377e2012-03-15 21:28:54 +00003545 pBtree = sqlite3DbNameToBtree(db, zDbName);
3546 if( pBtree ){
3547 Pager *pPager;
3548 sqlite3_file *fd;
3549 sqlite3BtreeEnter(pBtree);
3550 pPager = sqlite3BtreePager(pBtree);
3551 assert( pPager!=0 );
3552 fd = sqlite3PagerFile(pPager);
3553 assert( fd!=0 );
3554 if( op==SQLITE_FCNTL_FILE_POINTER ){
3555 *(sqlite3_file**)pArg = fd;
3556 rc = SQLITE_OK;
drh790f2872015-11-28 18:06:36 +00003557 }else if( op==SQLITE_FCNTL_VFS_POINTER ){
3558 *(sqlite3_vfs**)pArg = sqlite3PagerVfs(pPager);
3559 rc = SQLITE_OK;
drh21d61852016-01-08 02:27:01 +00003560 }else if( op==SQLITE_FCNTL_JOURNAL_POINTER ){
3561 *(sqlite3_file**)pArg = sqlite3PagerJrnlFile(pPager);
3562 rc = SQLITE_OK;
drh421377e2012-03-15 21:28:54 +00003563 }else if( fd->pMethods ){
3564 rc = sqlite3OsFileControl(fd, op, pArg);
3565 }else{
3566 rc = SQLITE_NOTFOUND;
drhcc6bb3e2007-08-31 16:11:35 +00003567 }
drh421377e2012-03-15 21:28:54 +00003568 sqlite3BtreeLeave(pBtree);
drhcc6bb3e2007-08-31 16:11:35 +00003569 }
3570 sqlite3_mutex_leave(db->mutex);
drh883ad042015-02-19 00:29:11 +00003571 return rc;
drhcc6bb3e2007-08-31 16:11:35 +00003572}
drhed13d982008-01-31 14:43:24 +00003573
3574/*
3575** Interface to the testing logic.
3576*/
3577int sqlite3_test_control(int op, ...){
drhed13d982008-01-31 14:43:24 +00003578 int rc = 0;
drhd12602a2016-12-07 15:49:02 +00003579#ifdef SQLITE_UNTESTABLE
drhf5ed7ad2015-06-15 14:43:25 +00003580 UNUSED_PARAMETER(op);
3581#else
drh2fa18682008-03-19 14:15:34 +00003582 va_list ap;
drhed13d982008-01-31 14:43:24 +00003583 va_start(ap, op);
3584 switch( op ){
danielk1977d09414c2008-06-19 18:17:49 +00003585
3586 /*
drh984bfaa2008-03-19 16:08:53 +00003587 ** Save the current state of the PRNG.
3588 */
drh2fa18682008-03-19 14:15:34 +00003589 case SQLITE_TESTCTRL_PRNG_SAVE: {
3590 sqlite3PrngSaveState();
3591 break;
3592 }
drh984bfaa2008-03-19 16:08:53 +00003593
3594 /*
3595 ** Restore the state of the PRNG to the last state saved using
3596 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
3597 ** this verb acts like PRNG_RESET.
3598 */
drh2fa18682008-03-19 14:15:34 +00003599 case SQLITE_TESTCTRL_PRNG_RESTORE: {
3600 sqlite3PrngRestoreState();
3601 break;
3602 }
drh984bfaa2008-03-19 16:08:53 +00003603
3604 /*
3605 ** Reset the PRNG back to its uninitialized state. The next call
3606 ** to sqlite3_randomness() will reseed the PRNG using a single call
3607 ** to the xRandomness method of the default VFS.
3608 */
drh2fa18682008-03-19 14:15:34 +00003609 case SQLITE_TESTCTRL_PRNG_RESET: {
drhfe980812014-01-01 14:00:13 +00003610 sqlite3_randomness(0,0);
drh2fa18682008-03-19 14:15:34 +00003611 break;
3612 }
drh3088d592008-03-21 16:45:47 +00003613
3614 /*
3615 ** sqlite3_test_control(BITVEC_TEST, size, program)
3616 **
3617 ** Run a test against a Bitvec object of size. The program argument
3618 ** is an array of integers that defines the test. Return -1 on a
3619 ** memory allocation error, 0 on success, or non-zero for an error.
3620 ** See the sqlite3BitvecBuiltinTest() for additional information.
3621 */
3622 case SQLITE_TESTCTRL_BITVEC_TEST: {
3623 int sz = va_arg(ap, int);
3624 int *aProg = va_arg(ap, int*);
3625 rc = sqlite3BitvecBuiltinTest(sz, aProg);
3626 break;
3627 }
danielk19772d1d86f2008-06-20 14:59:51 +00003628
3629 /*
drhc007f612014-05-16 14:17:01 +00003630 ** sqlite3_test_control(FAULT_INSTALL, xCallback)
3631 **
3632 ** Arrange to invoke xCallback() whenever sqlite3FaultSim() is called,
3633 ** if xCallback is not NULL.
3634 **
3635 ** As a test of the fault simulator mechanism itself, sqlite3FaultSim(0)
3636 ** is called immediately after installing the new callback and the return
3637 ** value from sqlite3FaultSim(0) becomes the return from
3638 ** sqlite3_test_control().
3639 */
3640 case SQLITE_TESTCTRL_FAULT_INSTALL: {
mistachkin77a90ce2014-05-16 23:15:50 +00003641 /* MSVC is picky about pulling func ptrs from va lists.
3642 ** http://support.microsoft.com/kb/47961
dan685ffb12014-06-23 10:18:50 +00003643 ** sqlite3GlobalConfig.xTestCallback = va_arg(ap, int(*)(int));
mistachkin77a90ce2014-05-16 23:15:50 +00003644 */
3645 typedef int(*TESTCALLBACKFUNC_t)(int);
dan685ffb12014-06-23 10:18:50 +00003646 sqlite3GlobalConfig.xTestCallback = va_arg(ap, TESTCALLBACKFUNC_t);
drhc007f612014-05-16 14:17:01 +00003647 rc = sqlite3FaultSim(0);
3648 break;
3649 }
3650
3651 /*
danielk19772d1d86f2008-06-20 14:59:51 +00003652 ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
3653 **
3654 ** Register hooks to call to indicate which malloc() failures
3655 ** are benign.
3656 */
3657 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
danielk1977ca026792008-06-23 14:15:52 +00003658 typedef void (*void_function)(void);
3659 void_function xBenignBegin;
3660 void_function xBenignEnd;
3661 xBenignBegin = va_arg(ap, void_function);
3662 xBenignEnd = va_arg(ap, void_function);
danielk19772d1d86f2008-06-20 14:59:51 +00003663 sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
3664 break;
3665 }
drhc7a3bb92009-02-05 16:31:45 +00003666
3667 /*
drhf3af63f2009-05-09 18:59:42 +00003668 ** sqlite3_test_control(SQLITE_TESTCTRL_PENDING_BYTE, unsigned int X)
drhc7a3bb92009-02-05 16:31:45 +00003669 **
3670 ** Set the PENDING byte to the value in the argument, if X>0.
3671 ** Make no changes if X==0. Return the value of the pending byte
3672 ** as it existing before this routine was called.
3673 **
3674 ** IMPORTANT: Changing the PENDING byte from 0x40000000 results in
3675 ** an incompatible database file format. Changing the PENDING byte
3676 ** while any database connection is open results in undefined and
peter.d.reid60ec9142014-09-06 16:39:46 +00003677 ** deleterious behavior.
drhc7a3bb92009-02-05 16:31:45 +00003678 */
3679 case SQLITE_TESTCTRL_PENDING_BYTE: {
drhf83dc1e2010-06-03 12:09:52 +00003680 rc = PENDING_BYTE;
3681#ifndef SQLITE_OMIT_WSD
3682 {
3683 unsigned int newVal = va_arg(ap, unsigned int);
3684 if( newVal ) sqlite3PendingByte = newVal;
3685 }
3686#endif
drhc7a3bb92009-02-05 16:31:45 +00003687 break;
3688 }
drhf3af63f2009-05-09 18:59:42 +00003689
3690 /*
3691 ** sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, int X)
3692 **
3693 ** This action provides a run-time test to see whether or not
3694 ** assert() was enabled at compile-time. If X is true and assert()
3695 ** is enabled, then the return value is true. If X is true and
3696 ** assert() is disabled, then the return value is zero. If X is
3697 ** false and assert() is enabled, then the assertion fires and the
3698 ** process aborts. If X is false and assert() is disabled, then the
3699 ** return value is zero.
3700 */
3701 case SQLITE_TESTCTRL_ASSERT: {
3702 volatile int x = 0;
drhcc5f8a42016-02-06 22:32:06 +00003703 assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 );
drhf3af63f2009-05-09 18:59:42 +00003704 rc = x;
3705 break;
3706 }
3707
3708
3709 /*
3710 ** sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, int X)
3711 **
3712 ** This action provides a run-time test to see how the ALWAYS and
3713 ** NEVER macros were defined at compile-time.
3714 **
3715 ** The return value is ALWAYS(X).
3716 **
3717 ** The recommended test is X==2. If the return value is 2, that means
3718 ** ALWAYS() and NEVER() are both no-op pass-through macros, which is the
3719 ** default setting. If the return value is 1, then ALWAYS() is either
3720 ** hard-coded to true or else it asserts if its argument is false.
3721 ** The first behavior (hard-coded to true) is the case if
3722 ** SQLITE_TESTCTRL_ASSERT shows that assert() is disabled and the second
3723 ** behavior (assert if the argument to ALWAYS() is false) is the case if
3724 ** SQLITE_TESTCTRL_ASSERT shows that assert() is enabled.
3725 **
3726 ** The run-time test procedure might look something like this:
3727 **
3728 ** if( sqlite3_test_control(SQLITE_TESTCTRL_ALWAYS, 2)==2 ){
3729 ** // ALWAYS() and NEVER() are no-op pass-through macros
3730 ** }else if( sqlite3_test_control(SQLITE_TESTCTRL_ASSERT, 1) ){
3731 ** // ALWAYS(x) asserts that x is true. NEVER(x) asserts x is false.
3732 ** }else{
3733 ** // ALWAYS(x) is a constant 1. NEVER(x) is a constant 0.
3734 ** }
3735 */
3736 case SQLITE_TESTCTRL_ALWAYS: {
3737 int x = va_arg(ap,int);
3738 rc = ALWAYS(x);
3739 break;
3740 }
drhc046e3e2009-07-15 11:26:44 +00003741
drh2cf4acb2014-04-18 00:06:02 +00003742 /*
3743 ** sqlite3_test_control(SQLITE_TESTCTRL_BYTEORDER);
3744 **
3745 ** The integer returned reveals the byte-order of the computer on which
3746 ** SQLite is running:
3747 **
3748 ** 1 big-endian, determined at run-time
3749 ** 10 little-endian, determined at run-time
3750 ** 432101 big-endian, determined at compile-time
3751 ** 123410 little-endian, determined at compile-time
3752 */
3753 case SQLITE_TESTCTRL_BYTEORDER: {
3754 rc = SQLITE_BYTEORDER*100 + SQLITE_LITTLEENDIAN*10 + SQLITE_BIGENDIAN;
3755 break;
3756 }
3757
drhc046e3e2009-07-15 11:26:44 +00003758 /* sqlite3_test_control(SQLITE_TESTCTRL_RESERVE, sqlite3 *db, int N)
3759 **
3760 ** Set the nReserve size to N for the main database on the database
3761 ** connection db.
3762 */
3763 case SQLITE_TESTCTRL_RESERVE: {
3764 sqlite3 *db = va_arg(ap, sqlite3*);
3765 int x = va_arg(ap,int);
3766 sqlite3_mutex_enter(db->mutex);
3767 sqlite3BtreeSetPageSize(db->aDb[0].pBt, 0, x, 0);
3768 sqlite3_mutex_leave(db->mutex);
3769 break;
3770 }
3771
drh07096f62009-12-22 23:52:32 +00003772 /* sqlite3_test_control(SQLITE_TESTCTRL_OPTIMIZATIONS, sqlite3 *db, int N)
3773 **
3774 ** Enable or disable various optimizations for testing purposes. The
3775 ** argument N is a bitmask of optimizations to be disabled. For normal
3776 ** operation N should be 0. The idea is that a test program (like the
3777 ** SQL Logic Test or SLT test module) can run the same SQL multiple times
3778 ** with various optimizations disabled to verify that the same answer
3779 ** is obtained in every case.
3780 */
3781 case SQLITE_TESTCTRL_OPTIMIZATIONS: {
3782 sqlite3 *db = va_arg(ap, sqlite3*);
drha5759672012-10-30 14:39:12 +00003783 db->dbOptFlags = (u16)(va_arg(ap, int) & 0xffff);
drh07096f62009-12-22 23:52:32 +00003784 break;
3785 }
3786
drh0e857732010-01-02 03:21:35 +00003787#ifdef SQLITE_N_KEYWORD
3788 /* sqlite3_test_control(SQLITE_TESTCTRL_ISKEYWORD, const char *zWord)
3789 **
3790 ** If zWord is a keyword recognized by the parser, then return the
3791 ** number of keywords. Or if zWord is not a keyword, return 0.
3792 **
3793 ** This test feature is only available in the amalgamation since
3794 ** the SQLITE_N_KEYWORD macro is not defined in this file if SQLite
3795 ** is built using separate source files.
3796 */
3797 case SQLITE_TESTCTRL_ISKEYWORD: {
3798 const char *zWord = va_arg(ap, const char*);
3799 int n = sqlite3Strlen30(zWord);
drh855787a2010-01-02 03:46:43 +00003800 rc = (sqlite3KeywordCode((u8*)zWord, n)!=TK_ID) ? SQLITE_N_KEYWORD : 0;
drh0e857732010-01-02 03:21:35 +00003801 break;
3802 }
3803#endif
3804
drhbadc9802010-08-27 17:16:44 +00003805 /* sqlite3_test_control(SQLITE_TESTCTRL_SCRATCHMALLOC, sz, &pNew, pFree);
3806 **
3807 ** Pass pFree into sqlite3ScratchFree().
3808 ** If sz>0 then allocate a scratch buffer into pNew.
3809 */
3810 case SQLITE_TESTCTRL_SCRATCHMALLOC: {
3811 void *pFree, **ppNew;
3812 int sz;
3813 sz = va_arg(ap, int);
3814 ppNew = va_arg(ap, void**);
3815 pFree = va_arg(ap, void*);
3816 if( sz ) *ppNew = sqlite3ScratchMalloc(sz);
3817 sqlite3ScratchFree(pFree);
3818 break;
3819 }
3820
danc17d6962011-06-21 12:47:30 +00003821 /* sqlite3_test_control(SQLITE_TESTCTRL_LOCALTIME_FAULT, int onoff);
3822 **
3823 ** If parameter onoff is non-zero, configure the wrappers so that all
3824 ** subsequent calls to localtime() and variants fail. If onoff is zero,
3825 ** undo this setting.
3826 */
3827 case SQLITE_TESTCTRL_LOCALTIME_FAULT: {
3828 sqlite3GlobalConfig.bLocaltimeFault = va_arg(ap, int);
3829 break;
3830 }
3831
drh09fe6142013-11-29 15:06:27 +00003832 /* sqlite3_test_control(SQLITE_TESTCTRL_NEVER_CORRUPT, int);
3833 **
3834 ** Set or clear a flag that indicates that the database file is always well-
3835 ** formed and never corrupt. This flag is clear by default, indicating that
3836 ** database files might have arbitrary corruption. Setting the flag during
3837 ** testing causes certain assert() statements in the code to be activated
3838 ** that demonstrat invariants on well-formed database files.
3839 */
3840 case SQLITE_TESTCTRL_NEVER_CORRUPT: {
dan9c2552f2014-01-28 17:49:13 +00003841 sqlite3GlobalConfig.neverCorrupt = va_arg(ap, int);
drh09fe6142013-11-29 15:06:27 +00003842 break;
3843 }
3844
drh9e5eb9c2016-09-18 16:08:10 +00003845 /* Set the threshold at which OP_Once counters reset back to zero.
mistachkine0736da2016-09-20 17:38:27 +00003846 ** By default this is 0x7ffffffe (over 2 billion), but that value is
drh9e5eb9c2016-09-18 16:08:10 +00003847 ** too big to test in a reasonable amount of time, so this control is
3848 ** provided to set a small and easily reachable reset value.
3849 */
3850 case SQLITE_TESTCTRL_ONCE_RESET_THRESHOLD: {
3851 sqlite3GlobalConfig.iOnceResetThreshold = va_arg(ap, int);
3852 break;
3853 }
drh688852a2014-02-17 22:40:43 +00003854
3855 /* sqlite3_test_control(SQLITE_TESTCTRL_VDBE_COVERAGE, xCallback, ptr);
3856 **
3857 ** Set the VDBE coverage callback function to xCallback with context
3858 ** pointer ptr.
3859 */
3860 case SQLITE_TESTCTRL_VDBE_COVERAGE: {
3861#ifdef SQLITE_VDBE_COVERAGE
3862 typedef void (*branch_callback)(void*,int,u8,u8);
3863 sqlite3GlobalConfig.xVdbeBranch = va_arg(ap,branch_callback);
3864 sqlite3GlobalConfig.pVdbeBranchArg = va_arg(ap,void*);
3865#endif
3866 break;
3867 }
3868
dan8930c2a2014-04-03 16:25:29 +00003869 /* sqlite3_test_control(SQLITE_TESTCTRL_SORTER_MMAP, db, nMax); */
3870 case SQLITE_TESTCTRL_SORTER_MMAP: {
3871 sqlite3 *db = va_arg(ap, sqlite3*);
3872 db->nMaxSorterMmap = va_arg(ap, int);
3873 break;
3874 }
3875
drh43cfc232014-07-29 14:09:21 +00003876 /* sqlite3_test_control(SQLITE_TESTCTRL_ISINIT);
3877 **
3878 ** Return SQLITE_OK if SQLite has been initialized and SQLITE_ERROR if
3879 ** not.
3880 */
3881 case SQLITE_TESTCTRL_ISINIT: {
3882 if( sqlite3GlobalConfig.isInit==0 ) rc = SQLITE_ERROR;
3883 break;
3884 }
drh8964b342015-01-29 17:54:52 +00003885
drh3ba689d2015-03-03 14:00:11 +00003886 /* sqlite3_test_control(SQLITE_TESTCTRL_IMPOSTER, db, dbName, onOff, tnum);
drh8964b342015-01-29 17:54:52 +00003887 **
drh1ffede82015-01-30 20:59:27 +00003888 ** This test control is used to create imposter tables. "db" is a pointer
3889 ** to the database connection. dbName is the database name (ex: "main" or
3890 ** "temp") which will receive the imposter. "onOff" turns imposter mode on
3891 ** or off. "tnum" is the root page of the b-tree to which the imposter
3892 ** table should connect.
3893 **
3894 ** Enable imposter mode only when the schema has already been parsed. Then
drh3ba689d2015-03-03 14:00:11 +00003895 ** run a single CREATE TABLE statement to construct the imposter table in
3896 ** the parsed schema. Then turn imposter mode back off again.
drh1ffede82015-01-30 20:59:27 +00003897 **
3898 ** If onOff==0 and tnum>0 then reset the schema for all databases, causing
3899 ** the schema to be reparsed the next time it is needed. This has the
3900 ** effect of erasing all imposter tables.
drh8964b342015-01-29 17:54:52 +00003901 */
drh1ffede82015-01-30 20:59:27 +00003902 case SQLITE_TESTCTRL_IMPOSTER: {
drh8964b342015-01-29 17:54:52 +00003903 sqlite3 *db = va_arg(ap, sqlite3*);
drh8fb15e32015-02-04 20:56:49 +00003904 sqlite3_mutex_enter(db->mutex);
drh1ffede82015-01-30 20:59:27 +00003905 db->init.iDb = sqlite3FindDbName(db, va_arg(ap,const char*));
3906 db->init.busy = db->init.imposterTable = va_arg(ap,int);
drh8964b342015-01-29 17:54:52 +00003907 db->init.newTnum = va_arg(ap,int);
drh1ffede82015-01-30 20:59:27 +00003908 if( db->init.busy==0 && db->init.newTnum>0 ){
3909 sqlite3ResetAllSchemasOfConnection(db);
3910 }
drh8fb15e32015-02-04 20:56:49 +00003911 sqlite3_mutex_leave(db->mutex);
drh8964b342015-01-29 17:54:52 +00003912 break;
3913 }
drhed13d982008-01-31 14:43:24 +00003914 }
3915 va_end(ap);
drhd12602a2016-12-07 15:49:02 +00003916#endif /* SQLITE_UNTESTABLE */
danielk19777c36d072008-01-31 15:31:01 +00003917 return rc;
drhed13d982008-01-31 14:43:24 +00003918}
drhcc487d12011-05-17 18:53:08 +00003919
3920/*
3921** This is a utility routine, useful to VFS implementations, that checks
3922** to see if a database file was a URI that contained a specific query
3923** parameter, and if so obtains the value of the query parameter.
3924**
3925** The zFilename argument is the filename pointer passed into the xOpen()
3926** method of a VFS implementation. The zParam argument is the name of the
3927** query parameter we seek. This routine returns the value of the zParam
3928** parameter if it exists. If the parameter does not exist, this routine
3929** returns a NULL pointer.
3930*/
3931const char *sqlite3_uri_parameter(const char *zFilename, const char *zParam){
drh9ca95732014-10-24 00:35:58 +00003932 if( zFilename==0 || zParam==0 ) return 0;
drhbd695592011-05-17 19:43:38 +00003933 zFilename += sqlite3Strlen30(zFilename) + 1;
drhcc487d12011-05-17 18:53:08 +00003934 while( zFilename[0] ){
3935 int x = strcmp(zFilename, zParam);
drhbd695592011-05-17 19:43:38 +00003936 zFilename += sqlite3Strlen30(zFilename) + 1;
drhcc487d12011-05-17 18:53:08 +00003937 if( x==0 ) return zFilename;
drhbd695592011-05-17 19:43:38 +00003938 zFilename += sqlite3Strlen30(zFilename) + 1;
drhcc487d12011-05-17 18:53:08 +00003939 }
3940 return 0;
3941}
drh283829c2011-11-17 00:56:20 +00003942
3943/*
drh92913722011-12-23 00:07:33 +00003944** Return a boolean value for a query parameter.
3945*/
3946int sqlite3_uri_boolean(const char *zFilename, const char *zParam, int bDflt){
3947 const char *z = sqlite3_uri_parameter(zFilename, zParam);
drh38d9c612012-01-31 14:24:47 +00003948 bDflt = bDflt!=0;
3949 return z ? sqlite3GetBoolean(z, bDflt) : bDflt;
drh92913722011-12-23 00:07:33 +00003950}
3951
3952/*
3953** Return a 64-bit integer value for a query parameter.
3954*/
3955sqlite3_int64 sqlite3_uri_int64(
3956 const char *zFilename, /* Filename as passed to xOpen */
3957 const char *zParam, /* URI parameter sought */
3958 sqlite3_int64 bDflt /* return if parameter is missing */
3959){
3960 const char *z = sqlite3_uri_parameter(zFilename, zParam);
3961 sqlite3_int64 v;
drh9296c182014-07-23 13:40:49 +00003962 if( z && sqlite3DecOrHexToI64(z, &v)==SQLITE_OK ){
drh92913722011-12-23 00:07:33 +00003963 bDflt = v;
3964 }
3965 return bDflt;
3966}
3967
3968/*
drh421377e2012-03-15 21:28:54 +00003969** Return the Btree pointer identified by zDbName. Return NULL if not found.
3970*/
3971Btree *sqlite3DbNameToBtree(sqlite3 *db, const char *zDbName){
drh29518092016-12-24 19:37:16 +00003972 int iDb = zDbName ? sqlite3FindDbName(db, zDbName) : 0;
3973 return iDb<0 ? 0 : db->aDb[iDb].pBt;
drh421377e2012-03-15 21:28:54 +00003974}
3975
3976/*
drh283829c2011-11-17 00:56:20 +00003977** Return the filename of the database associated with a database
3978** connection.
3979*/
3980const char *sqlite3_db_filename(sqlite3 *db, const char *zDbName){
mistachkincd54bab2014-12-20 21:14:14 +00003981 Btree *pBt;
drh9ca95732014-10-24 00:35:58 +00003982#ifdef SQLITE_ENABLE_API_ARMOR
3983 if( !sqlite3SafetyCheckOk(db) ){
3984 (void)SQLITE_MISUSE_BKPT;
3985 return 0;
3986 }
3987#endif
mistachkincd54bab2014-12-20 21:14:14 +00003988 pBt = sqlite3DbNameToBtree(db, zDbName);
drh421377e2012-03-15 21:28:54 +00003989 return pBt ? sqlite3BtreeGetFilename(pBt) : 0;
3990}
3991
3992/*
3993** Return 1 if database is read-only or 0 if read/write. Return -1 if
3994** no such database exists.
3995*/
3996int sqlite3_db_readonly(sqlite3 *db, const char *zDbName){
mistachkincd54bab2014-12-20 21:14:14 +00003997 Btree *pBt;
drh9ca95732014-10-24 00:35:58 +00003998#ifdef SQLITE_ENABLE_API_ARMOR
3999 if( !sqlite3SafetyCheckOk(db) ){
4000 (void)SQLITE_MISUSE_BKPT;
4001 return -1;
4002 }
4003#endif
mistachkincd54bab2014-12-20 21:14:14 +00004004 pBt = sqlite3DbNameToBtree(db, zDbName);
drh781597f2014-05-21 08:21:07 +00004005 return pBt ? sqlite3BtreeIsReadonly(pBt) : -1;
drh283829c2011-11-17 00:56:20 +00004006}
danfc1acf32015-12-05 20:51:54 +00004007
4008#ifdef SQLITE_ENABLE_SNAPSHOT
4009/*
4010** Obtain a snapshot handle for the snapshot of database zDb currently
4011** being read by handle db.
4012*/
4013int sqlite3_snapshot_get(
4014 sqlite3 *db,
4015 const char *zDb,
4016 sqlite3_snapshot **ppSnapshot
4017){
4018 int rc = SQLITE_ERROR;
4019#ifndef SQLITE_OMIT_WAL
danfc1acf32015-12-05 20:51:54 +00004020
4021#ifdef SQLITE_ENABLE_API_ARMOR
4022 if( !sqlite3SafetyCheckOk(db) ){
4023 return SQLITE_MISUSE_BKPT;
4024 }
4025#endif
4026 sqlite3_mutex_enter(db->mutex);
4027
danedace5d2016-11-18 18:43:39 +00004028 if( db->autoCommit==0 ){
4029 int iDb = sqlite3FindDbName(db, zDb);
4030 if( iDb==0 || iDb>1 ){
4031 Btree *pBt = db->aDb[iDb].pBt;
4032 if( 0==sqlite3BtreeIsInTrans(pBt) ){
4033 rc = sqlite3BtreeBeginTrans(pBt, 0);
4034 if( rc==SQLITE_OK ){
4035 rc = sqlite3PagerSnapshotGet(sqlite3BtreePager(pBt), ppSnapshot);
4036 }
dan7116dc62015-12-10 20:03:08 +00004037 }
danfc1acf32015-12-05 20:51:54 +00004038 }
4039 }
4040
4041 sqlite3_mutex_leave(db->mutex);
4042#endif /* SQLITE_OMIT_WAL */
4043 return rc;
4044}
4045
4046/*
4047** Open a read-transaction on the snapshot idendified by pSnapshot.
4048*/
4049int sqlite3_snapshot_open(
4050 sqlite3 *db,
4051 const char *zDb,
4052 sqlite3_snapshot *pSnapshot
4053){
4054 int rc = SQLITE_ERROR;
4055#ifndef SQLITE_OMIT_WAL
4056
4057#ifdef SQLITE_ENABLE_API_ARMOR
4058 if( !sqlite3SafetyCheckOk(db) ){
4059 return SQLITE_MISUSE_BKPT;
4060 }
4061#endif
4062 sqlite3_mutex_enter(db->mutex);
4063 if( db->autoCommit==0 ){
4064 int iDb;
4065 iDb = sqlite3FindDbName(db, zDb);
4066 if( iDb==0 || iDb>1 ){
4067 Btree *pBt = db->aDb[iDb].pBt;
4068 if( 0==sqlite3BtreeIsInReadTrans(pBt) ){
4069 rc = sqlite3PagerSnapshotOpen(sqlite3BtreePager(pBt), pSnapshot);
4070 if( rc==SQLITE_OK ){
4071 rc = sqlite3BtreeBeginTrans(pBt, 0);
4072 sqlite3PagerSnapshotOpen(sqlite3BtreePager(pBt), 0);
4073 }
4074 }
4075 }
4076 }
4077
4078 sqlite3_mutex_leave(db->mutex);
4079#endif /* SQLITE_OMIT_WAL */
4080 return rc;
4081}
4082
4083/*
dan11584982016-11-18 20:49:43 +00004084** Recover as many snapshots as possible from the wal file associated with
4085** schema zDb of database db.
4086*/
4087int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb){
4088 int rc = SQLITE_ERROR;
4089 int iDb;
4090#ifndef SQLITE_OMIT_WAL
4091
4092#ifdef SQLITE_ENABLE_API_ARMOR
4093 if( !sqlite3SafetyCheckOk(db) ){
4094 return SQLITE_MISUSE_BKPT;
4095 }
4096#endif
4097
4098 sqlite3_mutex_enter(db->mutex);
4099 iDb = sqlite3FindDbName(db, zDb);
4100 if( iDb==0 || iDb>1 ){
4101 Btree *pBt = db->aDb[iDb].pBt;
4102 if( 0==sqlite3BtreeIsInReadTrans(pBt) ){
dan93f51132016-11-19 18:31:37 +00004103 rc = sqlite3BtreeBeginTrans(pBt, 0);
4104 if( rc==SQLITE_OK ){
4105 rc = sqlite3PagerSnapshotRecover(sqlite3BtreePager(pBt));
4106 sqlite3BtreeCommit(pBt);
4107 }
dan11584982016-11-18 20:49:43 +00004108 }
4109 }
4110 sqlite3_mutex_leave(db->mutex);
4111#endif /* SQLITE_OMIT_WAL */
4112 return rc;
4113}
4114
4115/*
danfc1acf32015-12-05 20:51:54 +00004116** Free a snapshot handle obtained from sqlite3_snapshot_get().
4117*/
4118void sqlite3_snapshot_free(sqlite3_snapshot *pSnapshot){
4119 sqlite3_free(pSnapshot);
4120}
4121#endif /* SQLITE_ENABLE_SNAPSHOT */
danda1f49b2017-06-16 19:51:47 +00004122
4123#ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
4124/*
4125** Given the name of a compile-time option, return true if that option
4126** was used and false if not.
4127**
4128** The name can optionally begin with "SQLITE_" but the "SQLITE_" prefix
4129** is not required for a match.
4130*/
4131int sqlite3_compileoption_used(const char *zOptName){
4132 int i, n;
4133 int nOpt;
4134 const char **azCompileOpt;
4135
4136#if SQLITE_ENABLE_API_ARMOR
4137 if( zOptName==0 ){
4138 (void)SQLITE_MISUSE_BKPT;
4139 return 0;
4140 }
4141#endif
4142
4143 azCompileOpt = sqlite3CompileOptions(&nOpt);
4144
4145 if( sqlite3StrNICmp(zOptName, "SQLITE_", 7)==0 ) zOptName += 7;
4146 n = sqlite3Strlen30(zOptName);
4147
4148 /* Since nOpt is normally in single digits, a linear search is
4149 ** adequate. No need for a binary search. */
4150 for(i=0; i<nOpt; i++){
4151 if( sqlite3StrNICmp(zOptName, azCompileOpt[i], n)==0
4152 && sqlite3IsIdChar((unsigned char)azCompileOpt[i][n])==0
4153 ){
4154 return 1;
4155 }
4156 }
4157 return 0;
4158}
4159
4160/*
4161** Return the N-th compile-time option string. If N is out of range,
4162** return a NULL pointer.
4163*/
4164const char *sqlite3_compileoption_get(int N){
4165 int nOpt;
4166 const char **azCompileOpt;
4167 azCompileOpt = sqlite3CompileOptions(&nOpt);
4168 if( N>=0 && N<nOpt ){
4169 return azCompileOpt[N];
4170 }
4171 return 0;
4172}
4173#endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */