blob: af8aadc1d05925eac48a2117a411ee5e04005d21 [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.
16**
drh93ed56d2008-08-12 15:21:11 +000017** $Id: main.c,v 1.488 2008/08/12 15:21:12 drh Exp $
drh75897232000-05-29 14:26:00 +000018*/
19#include "sqliteInt.h"
drhce9079c2002-05-15 14:17:44 +000020#include <ctype.h>
drh58f1c8b2008-05-26 20:19:25 +000021
drh820a9062008-01-31 13:35:48 +000022#ifdef SQLITE_ENABLE_FTS3
23# include "fts3.h"
24#endif
drh58f1c8b2008-05-26 20:19:25 +000025#ifdef SQLITE_ENABLE_RTREE
26# include "rtree.h"
27#endif
drh75897232000-05-29 14:26:00 +000028
29/*
drhb217a572000-08-22 13:40:18 +000030** The version of the library
31*/
danielk197724b03fd2004-05-10 10:34:34 +000032const char sqlite3_version[] = SQLITE_VERSION;
drh4aec8b62004-08-28 16:19:00 +000033const char *sqlite3_libversion(void){ return sqlite3_version; }
danielk197799ba19e2005-02-05 07:33:34 +000034int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
drhb67e8bf2007-08-30 20:09:48 +000035int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
drhb217a572000-08-22 13:40:18 +000036
drhe265b082008-05-01 17:03:49 +000037#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
drhb217a572000-08-22 13:40:18 +000038/*
drhb0603412007-02-28 04:47:26 +000039** If the following function pointer is not NULL and if
40** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
41** I/O active are written using this function. These messages
42** are intended for debugging activity only.
43*/
mlcreech3a00f902008-03-04 17:45:01 +000044void (*sqlite3IoTrace)(const char*, ...) = 0;
drhe265b082008-05-01 17:03:49 +000045#endif
drhb0603412007-02-28 04:47:26 +000046
47/*
drha16313e2007-03-30 11:29:32 +000048** If the following global variable points to a string which is the
49** name of a directory, then that directory will be used to store
50** temporary files.
51**
52** See also the "PRAGMA temp_store_directory" SQL command.
53*/
54char *sqlite3_temp_directory = 0;
55
drhc5499be2008-04-01 15:06:33 +000056/*
drh40257ff2008-06-13 18:24:27 +000057** Initialize SQLite.
58**
59** This routine must be called to initialize the memory allocation,
drh93ed56d2008-08-12 15:21:11 +000060** VFS, and mutex subsystems prior to doing any serious work with
drh40257ff2008-06-13 18:24:27 +000061** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT
62** this routine will be called automatically by key routines such as
63** sqlite3_open().
64**
65** This routine is a no-op except on its very first call for the process,
66** or for the first call after a call to sqlite3_shutdown.
drh93ed56d2008-08-12 15:21:11 +000067**
68** The first thread to call this routine runs the initialization to
69** completion. If subsequent threads call this routine before the first
70** thread has finished the initialization process, then the subsequent
71** threads must block until the first thread finishes with the initialization.
72**
73** The first thread might call this routine recursively. Recursive
74** calls to this routine should not block, of course. Otherwise the
75** initialization process would never complete.
76**
77** Let X be the first thread to enter this routine. Let Y be some other
78** thread. Then while the initial invocation of this routine by X is
79** incomplete, it is required that:
80**
81** * Calls to this routine from Y must block until the outer-most
82** call by X completes.
83**
84** * Recursive calls to this routine from thread X return immediately
85** without blocking.
drh40257ff2008-06-13 18:24:27 +000086*/
87int sqlite3_initialize(void){
drh93ed56d2008-08-12 15:21:11 +000088 static int inProgress = 0; /* Prevent recursion */
89 sqlite3_mutex *pMaster; /* The main static mutex */
90 int rc; /* Result code */
danielk197771bc31c2008-06-26 08:29:34 +000091
drh93ed56d2008-08-12 15:21:11 +000092 /* If SQLite is already completely initialized, then this call
93 ** to sqlite3_initialize() should be a no-op. But the initialization
94 ** must be complete. So isInit must not be set until the very end
95 ** of this routine.
96 */
danielk1977c0fa4c52008-06-25 17:19:00 +000097 if( sqlite3Config.isInit ) return SQLITE_OK;
danielk197771bc31c2008-06-26 08:29:34 +000098
drh93ed56d2008-08-12 15:21:11 +000099 /* Make sure the mutex subsystem is initialized. If unable to
100 ** initialize the mutex subsystem, return early with the error.
101 ** If the system is so sick that we are unable to allocate a mutex,
102 ** there is not much SQLite is going to be able to do.
103 **
104 ** The mutex subsystem must take care of serializing its own
105 ** initialization.
106 */
danielk1977d0251742008-06-18 18:57:42 +0000107 rc = sqlite3MutexInit();
drh93ed56d2008-08-12 15:21:11 +0000108 if( rc ) return rc;
danielk197771bc31c2008-06-26 08:29:34 +0000109
drh93ed56d2008-08-12 15:21:11 +0000110 /* Initialize the malloc() system and the recursive pInitMutex mutex.
111 ** This operation is protected by the STATIC_MASTER mutex. Note that
112 ** MutexAlloc() is called for a static mutex prior to initializing the
113 ** malloc subsystem - this implies that the allocation of a static
114 ** mutex must not require support from the malloc subsystem.
115 */
116 pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);
117 sqlite3_mutex_enter(pMaster);
118 if( !sqlite3Config.isMallocInit ){
119 rc = sqlite3MallocInit();
120 }
drh40257ff2008-06-13 18:24:27 +0000121 if( rc==SQLITE_OK ){
drh93ed56d2008-08-12 15:21:11 +0000122 sqlite3Config.isMallocInit = 1;
123 if( !sqlite3Config.pInitMutex ){
124 sqlite3Config.pInitMutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
125 if( sqlite3Config.bCoreMutex && !sqlite3Config.pInitMutex ){
126 rc = SQLITE_NOMEM;
drh40257ff2008-06-13 18:24:27 +0000127 }
128 }
drh93ed56d2008-08-12 15:21:11 +0000129 sqlite3Config.nRefInitMutex++;
130 }
131 sqlite3_mutex_leave(pMaster);
danielk197771bc31c2008-06-26 08:29:34 +0000132
drh93ed56d2008-08-12 15:21:11 +0000133 /* If unable to initialize the malloc subsystem, then return early.
134 ** There is little hope of getting SQLite to run if the malloc
135 ** subsystem cannot be initialized.
136 */
137 if( rc!=SQLITE_OK ){
138 return rc;
139 }
140
141 /* Do the rest of the initialization under the recursive mutex so
142 ** that we will be able to handle recursive calls into
143 ** sqlite3_initialize(). The recursive calls normally come through
144 ** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other
145 ** recursive calls might also be possible.
146 */
147 sqlite3_mutex_enter(sqlite3Config.pInitMutex);
148 if( sqlite3Config.isInit==0 && inProgress==0 ){
danielk197771bc31c2008-06-26 08:29:34 +0000149 inProgress = 1;
150 rc = sqlite3_os_init();
151 inProgress = 0;
152 sqlite3Config.isInit = (rc==SQLITE_OK ? 1 : 0);
drh40257ff2008-06-13 18:24:27 +0000153 }
drh93ed56d2008-08-12 15:21:11 +0000154 sqlite3_mutex_leave(sqlite3Config.pInitMutex);
shanedfb7b372008-07-22 05:13:30 +0000155
drh93ed56d2008-08-12 15:21:11 +0000156 /* Go back under the static mutex and clean up the recursive
157 ** mutex to prevent a resource leak.
158 */
159 sqlite3_mutex_enter(pMaster);
160 sqlite3Config.nRefInitMutex--;
161 if( sqlite3Config.nRefInitMutex<=0 ){
162 assert( sqlite3Config.nRefInitMutex==0 );
163 sqlite3_mutex_free(sqlite3Config.pInitMutex);
164 sqlite3Config.pInitMutex = 0;
165 }
166 sqlite3_mutex_leave(pMaster);
167
168 /* The following is just a sanity check to make sure SQLite has
169 ** been compiled correctly. It is important to run this code, but
170 ** we don't want to run it too often and soak up CPU cycles for no
171 ** reason. So we run it once during initialization.
172 */
shanedfb7b372008-07-22 05:13:30 +0000173#ifndef NDEBUG
174 /* This section of code's only "output" is via assert() statements. */
175 if ( rc==SQLITE_OK ){
176 u64 x = (((u64)1)<<63)-1;
177 double y;
178 assert(sizeof(x)==8);
179 assert(sizeof(x)==sizeof(y));
180 memcpy(&y, &x, 8);
181 assert( sqlite3IsNaN(y) );
182 }
183#endif
184
drh40257ff2008-06-13 18:24:27 +0000185 return rc;
186}
187
188/*
189** Undo the effects of sqlite3_initialize(). Must not be called while
190** there are outstanding database connections or memory allocations or
191** while any part of SQLite is otherwise in use in any thread. This
192** routine is not threadsafe. Not by a long shot.
193*/
194int sqlite3_shutdown(void){
danielk197771bc31c2008-06-26 08:29:34 +0000195 sqlite3Config.isMallocInit = 0;
danielk1977fb437272008-07-08 12:02:35 +0000196 if( sqlite3Config.isInit ){
197 sqlite3_os_end();
198 }
199 if( sqlite3Config.m.xShutdown ){
200 sqlite3MallocEnd();
201 }
202 if( sqlite3Config.mutex.xMutexEnd ){
203 sqlite3MutexEnd();
204 }
danielk1977c0fa4c52008-06-25 17:19:00 +0000205 sqlite3Config.isInit = 0;
drh40257ff2008-06-13 18:24:27 +0000206 return SQLITE_OK;
207}
208
209/*
210** This API allows applications to modify the global configuration of
211** the SQLite library at run-time.
212**
213** This routine should only be called when there are no outstanding
214** database connections or memory allocations. This routine is not
215** threadsafe. Failure to heed these warnings can lead to unpredictable
216** behavior.
217*/
218int sqlite3_config(int op, ...){
219 va_list ap;
220 int rc = SQLITE_OK;
221
222 /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
223 ** the SQLite library is in use. */
danielk197771bc31c2008-06-26 08:29:34 +0000224 if( sqlite3Config.isInit ) return SQLITE_MISUSE;
drh40257ff2008-06-13 18:24:27 +0000225
226 va_start(ap, op);
227 switch( op ){
228 case SQLITE_CONFIG_SINGLETHREAD: {
229 /* Disable all mutexing */
230 sqlite3Config.bCoreMutex = 0;
231 sqlite3Config.bFullMutex = 0;
232 break;
233 }
234 case SQLITE_CONFIG_MULTITHREAD: {
235 /* Disable mutexing of database connections */
236 /* Enable mutexing of core data structures */
237 sqlite3Config.bCoreMutex = 1;
238 sqlite3Config.bFullMutex = 0;
239 break;
240 }
241 case SQLITE_CONFIG_SERIALIZED: {
242 /* Enable all mutexing */
243 sqlite3Config.bCoreMutex = 1;
244 sqlite3Config.bFullMutex = 1;
245 break;
246 }
247 case SQLITE_CONFIG_MALLOC: {
248 /* Specify an alternative malloc implementation */
drhfec00ea2008-06-14 16:56:21 +0000249 sqlite3Config.m = *va_arg(ap, sqlite3_mem_methods*);
drh40257ff2008-06-13 18:24:27 +0000250 break;
251 }
drh33589792008-06-18 13:27:46 +0000252 case SQLITE_CONFIG_GETMALLOC: {
danielk197757e5ea92008-06-24 19:02:55 +0000253 /* Retrieve the current malloc() implementation */
drh33589792008-06-18 13:27:46 +0000254 if( sqlite3Config.m.xMalloc==0 ) sqlite3MemSetDefault();
255 *va_arg(ap, sqlite3_mem_methods*) = sqlite3Config.m;
256 break;
257 }
danielk1977b2e36222008-06-17 18:57:49 +0000258 case SQLITE_CONFIG_MUTEX: {
259 /* Specify an alternative mutex implementation */
260 sqlite3Config.mutex = *va_arg(ap, sqlite3_mutex_methods*);
261 break;
262 }
danielk19771a9ed0b2008-06-18 09:45:56 +0000263 case SQLITE_CONFIG_GETMUTEX: {
264 /* Retrieve the current mutex implementation */
265 *va_arg(ap, sqlite3_mutex_methods*) = sqlite3Config.mutex;
266 break;
267 }
drhfec00ea2008-06-14 16:56:21 +0000268 case SQLITE_CONFIG_MEMSTATUS: {
drh40257ff2008-06-13 18:24:27 +0000269 /* Enable or disable the malloc status collection */
270 sqlite3Config.bMemstat = va_arg(ap, int);
271 break;
272 }
drh33589792008-06-18 13:27:46 +0000273 case SQLITE_CONFIG_SCRATCH: {
274 /* Designate a buffer for scratch memory space */
275 sqlite3Config.pScratch = va_arg(ap, void*);
276 sqlite3Config.szScratch = va_arg(ap, int);
277 sqlite3Config.nScratch = va_arg(ap, int);
278 break;
279 }
280 case SQLITE_CONFIG_PAGECACHE: {
281 /* Designate a buffer for scratch memory space */
282 sqlite3Config.pPage = va_arg(ap, void*);
283 sqlite3Config.szPage = va_arg(ap, int);
284 sqlite3Config.nPage = va_arg(ap, int);
285 break;
286 }
danielk19775099be52008-06-27 13:27:03 +0000287
drh5d414832008-07-15 14:47:18 +0000288#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
drh33589792008-06-18 13:27:46 +0000289 case SQLITE_CONFIG_HEAP: {
danielk19775099be52008-06-27 13:27:03 +0000290 /* Designate a buffer for heap memory space */
drh33589792008-06-18 13:27:46 +0000291 sqlite3Config.pHeap = va_arg(ap, void*);
292 sqlite3Config.nHeap = va_arg(ap, int);
293 sqlite3Config.mnReq = va_arg(ap, int);
danielk19775099be52008-06-27 13:27:03 +0000294
drh8a42cbd2008-07-10 18:13:42 +0000295 if( sqlite3Config.pHeap==0 ){
296 /* If the heap pointer is NULL, then restore the malloc implementation
297 ** back to NULL pointers too. This will cause the malloc to go
298 ** back to its default implementation when sqlite3_initialize() is
299 ** run.
300 */
301 memset(&sqlite3Config.m, 0, sizeof(sqlite3Config.m));
302 }else{
303 /* The heap pointer is not NULL, then install one of the
304 ** mem5.c/mem3.c methods. If neither ENABLE_MEMSYS3 nor
305 ** ENABLE_MEMSYS5 is defined, return an error.
306 ** the default case and return an error.
307 */
danielk19775099be52008-06-27 13:27:03 +0000308#ifdef SQLITE_ENABLE_MEMSYS3
drh7830cd42008-07-16 12:25:32 +0000309 sqlite3Config.m = *sqlite3MemGetMemsys3();
drh8a42cbd2008-07-10 18:13:42 +0000310#endif
311#ifdef SQLITE_ENABLE_MEMSYS5
drh7830cd42008-07-16 12:25:32 +0000312 sqlite3Config.m = *sqlite3MemGetMemsys5();
drh8a42cbd2008-07-10 18:13:42 +0000313#endif
drh8a42cbd2008-07-10 18:13:42 +0000314 }
danielk19775099be52008-06-27 13:27:03 +0000315 break;
316 }
drh5d414832008-07-15 14:47:18 +0000317#endif
danielk19775099be52008-06-27 13:27:03 +0000318
danielk19772d340812008-07-24 08:20:40 +0000319#if defined(SQLITE_ENABLE_MEMSYS6)
320 case SQLITE_CONFIG_CHUNKALLOC: {
danielk197731fab4f2008-07-25 08:48:59 +0000321 sqlite3Config.nSmall = va_arg(ap, int);
danielk19772d340812008-07-24 08:20:40 +0000322 sqlite3Config.m = *sqlite3MemGetMemsys6();
323 break;
324 }
325#endif
326
drh633e6d52008-07-28 19:34:53 +0000327 case SQLITE_CONFIG_LOOKASIDE: {
328 sqlite3Config.szLookaside = va_arg(ap, int);
329 sqlite3Config.nLookaside = va_arg(ap, int);
330 break;
331 }
332
drh40257ff2008-06-13 18:24:27 +0000333 default: {
334 rc = SQLITE_ERROR;
335 break;
336 }
337 }
338 va_end(ap);
339 return rc;
340}
341
342/*
drh633e6d52008-07-28 19:34:53 +0000343** Set up the lookaside buffers for a database connection.
344** Return SQLITE_OK on success.
345** If lookaside is already active, return SQLITE_BUSY.
drhe9d1c722008-08-04 20:13:26 +0000346**
347** The sz parameter is the number of bytes in each lookaside slot.
348** The cnt parameter is the number of slots. If pStart is NULL the
349** space for the lookaside memory is obtained from sqlite3_malloc().
350** If pStart is not NULL then it is sz*cnt bytes of memory to use for
351** the lookaside memory.
drh633e6d52008-07-28 19:34:53 +0000352*/
drhe9d1c722008-08-04 20:13:26 +0000353static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
drh633e6d52008-07-28 19:34:53 +0000354 void *pStart;
355 if( db->lookaside.nOut ){
356 return SQLITE_BUSY;
357 }
358 if( sz<0 ) sz = 0;
359 if( cnt<0 ) cnt = 0;
drhe9d1c722008-08-04 20:13:26 +0000360 if( pBuf==0 ){
drh63820332008-08-08 14:33:12 +0000361 sz = (sz + 7)&~7;
drhe9d1c722008-08-04 20:13:26 +0000362 sqlite3BeginBenignMalloc();
363 pStart = sqlite3Malloc( sz*cnt );
364 sqlite3EndBenignMalloc();
365 }else{
drh63820332008-08-08 14:33:12 +0000366 sz = sz&~7;
drhe9d1c722008-08-04 20:13:26 +0000367 pStart = pBuf;
368 }
369 if( db->lookaside.bMalloced ){
370 sqlite3_free(db->lookaside.pStart);
371 }
drh4cfb22f2008-08-01 18:47:01 +0000372 db->lookaside.pStart = pStart;
373 db->lookaside.pFree = 0;
374 db->lookaside.sz = sz;
drhe9d1c722008-08-04 20:13:26 +0000375 db->lookaside.bMalloced = pBuf==0;
drh633e6d52008-07-28 19:34:53 +0000376 if( pStart ){
377 int i;
378 LookasideSlot *p;
drh633e6d52008-07-28 19:34:53 +0000379 p = (LookasideSlot*)pStart;
380 for(i=cnt-1; i>=0; i--){
381 p->pNext = db->lookaside.pFree;
382 db->lookaside.pFree = p;
383 p = (LookasideSlot*)&((u8*)p)[sz];
384 }
385 db->lookaside.pEnd = p;
386 db->lookaside.bEnabled = 1;
drh4cfb22f2008-08-01 18:47:01 +0000387 }else{
388 db->lookaside.pEnd = 0;
389 db->lookaside.bEnabled = 0;
drh633e6d52008-07-28 19:34:53 +0000390 }
391 return SQLITE_OK;
392}
393
394/*
395** Configuration settings for an individual database connection
396*/
397int sqlite3_db_config(sqlite3 *db, int op, ...){
398 va_list ap;
drh6480aad2008-08-01 16:31:14 +0000399 int rc;
drh633e6d52008-07-28 19:34:53 +0000400 va_start(ap, op);
401 switch( op ){
drhe9d1c722008-08-04 20:13:26 +0000402 case SQLITE_DBCONFIG_LOOKASIDE: {
403 void *pBuf = va_arg(ap, void*);
drh633e6d52008-07-28 19:34:53 +0000404 int sz = va_arg(ap, int);
405 int cnt = va_arg(ap, int);
drhe9d1c722008-08-04 20:13:26 +0000406 rc = setupLookaside(db, pBuf, sz, cnt);
drh633e6d52008-07-28 19:34:53 +0000407 break;
408 }
drh6480aad2008-08-01 16:31:14 +0000409 default: {
410 rc = SQLITE_ERROR;
411 break;
412 }
drh633e6d52008-07-28 19:34:53 +0000413 }
414 va_end(ap);
415 return rc;
416}
417
418/*
drhc5499be2008-04-01 15:06:33 +0000419** Routine needed to support the testcase() macro.
420*/
421#ifdef SQLITE_COVERAGE_TEST
422void sqlite3Coverage(int x){
423 static int dummy = 0;
424 dummy += x;
425}
426#endif
427
drha16313e2007-03-30 11:29:32 +0000428
429/*
drh9b5adfa2008-01-20 23:19:56 +0000430** Return true if the buffer z[0..n-1] contains all spaces.
431*/
432static int allSpaces(const char *z, int n){
drh5f3a3672008-04-15 04:02:40 +0000433 while( n>0 && z[n-1]==' ' ){ n--; }
drh9b5adfa2008-01-20 23:19:56 +0000434 return n==0;
435}
436
437/*
drhd3d39e92004-05-20 22:16:29 +0000438** This is the default collating function named "BINARY" which is always
439** available.
drh9b5adfa2008-01-20 23:19:56 +0000440**
441** If the padFlag argument is not NULL then space padding at the end
442** of strings is ignored. This implements the RTRIM collation.
drhd3d39e92004-05-20 22:16:29 +0000443*/
danielk19772c336542005-01-13 02:14:23 +0000444static int binCollFunc(
drh9b5adfa2008-01-20 23:19:56 +0000445 void *padFlag,
drhd3d39e92004-05-20 22:16:29 +0000446 int nKey1, const void *pKey1,
447 int nKey2, const void *pKey2
448){
449 int rc, n;
450 n = nKey1<nKey2 ? nKey1 : nKey2;
451 rc = memcmp(pKey1, pKey2, n);
452 if( rc==0 ){
drh9b5adfa2008-01-20 23:19:56 +0000453 if( padFlag
454 && allSpaces(((char*)pKey1)+n, nKey1-n)
455 && allSpaces(((char*)pKey2)+n, nKey2-n)
456 ){
457 /* Leave rc unchanged at 0 */
458 }else{
459 rc = nKey1 - nKey2;
460 }
drhd3d39e92004-05-20 22:16:29 +0000461 }
462 return rc;
463}
464
465/*
danielk1977dc1bdc42004-06-11 10:51:27 +0000466** Another built-in collating sequence: NOCASE.
467**
468** This collating sequence is intended to be used for "case independant
469** comparison". SQLite's knowledge of upper and lower case equivalents
470** extends only to the 26 characters used in the English language.
471**
472** At the moment there is only a UTF-8 implementation.
danielk19770202b292004-06-09 09:55:16 +0000473*/
474static int nocaseCollatingFunc(
475 void *NotUsed,
476 int nKey1, const void *pKey1,
477 int nKey2, const void *pKey2
478){
479 int r = sqlite3StrNICmp(
drh208f80a2004-08-29 20:08:58 +0000480 (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
danielk19770202b292004-06-09 09:55:16 +0000481 if( 0==r ){
482 r = nKey1-nKey2;
483 }
484 return r;
485}
486
487/*
drhaf9ff332002-01-16 21:00:27 +0000488** Return the ROWID of the most recent insert
489*/
drh9bb575f2004-09-06 17:24:11 +0000490sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
drhaf9ff332002-01-16 21:00:27 +0000491 return db->lastRowid;
492}
493
494/*
danielk197724b03fd2004-05-10 10:34:34 +0000495** Return the number of changes in the most recent call to sqlite3_exec().
drhc8d30ac2002-04-12 10:08:59 +0000496*/
drh9bb575f2004-09-06 17:24:11 +0000497int sqlite3_changes(sqlite3 *db){
drhc8d30ac2002-04-12 10:08:59 +0000498 return db->nChange;
499}
500
rdcf146a772004-02-25 22:51:06 +0000501/*
danielk1977b28af712004-06-21 06:50:26 +0000502** Return the number of changes since the database handle was opened.
rdcf146a772004-02-25 22:51:06 +0000503*/
danielk1977b28af712004-06-21 06:50:26 +0000504int sqlite3_total_changes(sqlite3 *db){
505 return db->nTotalChange;
rdcb0c374f2004-02-20 22:53:38 +0000506}
507
drhc8d30ac2002-04-12 10:08:59 +0000508/*
drh50e5dad2001-09-15 00:57:28 +0000509** Close an existing SQLite database
510*/
drh9bb575f2004-09-06 17:24:11 +0000511int sqlite3_close(sqlite3 *db){
drh8e0a2f92002-02-23 23:45:45 +0000512 HashElem *i;
drh001bbcb2003-03-19 03:14:00 +0000513 int j;
danielk19775c4c7782004-06-16 10:39:23 +0000514
515 if( !db ){
danielk197796d81f92004-06-19 03:33:57 +0000516 return SQLITE_OK;
danielk19775c4c7782004-06-16 10:39:23 +0000517 }
drh7e8b8482008-01-23 03:03:05 +0000518 if( !sqlite3SafetyCheckSickOrOk(db) ){
danielk1977e35ee192004-06-26 09:50:11 +0000519 return SQLITE_MISUSE;
520 }
drh605264d2007-08-21 15:13:19 +0000521 sqlite3_mutex_enter(db->mutex);
danielk1977e35ee192004-06-26 09:50:11 +0000522
danielk19771f723bd2005-05-26 12:37:29 +0000523#ifdef SQLITE_SSE
drh37527852006-03-16 16:19:56 +0000524 {
525 extern void sqlite3SseCleanup(sqlite3*);
526 sqlite3SseCleanup(db);
527 }
danielk19771f723bd2005-05-26 12:37:29 +0000528#endif
529
drhffc13f62006-07-30 20:50:44 +0000530 sqlite3ResetInternalSchema(db, 0);
danielk1977a04a34f2007-04-16 15:06:25 +0000531
danielk197701256832007-04-18 14:24:32 +0000532 /* If a transaction is open, the ResetInternalSchema() call above
533 ** will not have called the xDisconnect() method on any virtual
534 ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
535 ** call will do so. We need to do this before the check for active
536 ** SQL statements below, as the v-table implementation may be storing
537 ** some prepared statements internally.
538 */
539 sqlite3VtabRollback(db);
540
danielk1977a04a34f2007-04-16 15:06:25 +0000541 /* If there are any outstanding VMs, return SQLITE_BUSY. */
danielk197796d81f92004-06-19 03:33:57 +0000542 if( db->pVdbe ){
543 sqlite3Error(db, SQLITE_BUSY,
544 "Unable to close due to unfinalised statements");
drh27641702007-08-22 02:56:42 +0000545 sqlite3_mutex_leave(db->mutex);
danielk197796d81f92004-06-19 03:33:57 +0000546 return SQLITE_BUSY;
547 }
drh7e8b8482008-01-23 03:03:05 +0000548 assert( sqlite3SafetyCheckSickOrOk(db) );
danielk1977e0048402004-06-15 16:51:01 +0000549
drh001bbcb2003-03-19 03:14:00 +0000550 for(j=0; j<db->nDb; j++){
drh4d189ca2004-02-12 18:46:38 +0000551 struct Db *pDb = &db->aDb[j];
552 if( pDb->pBt ){
danielk19774adee202004-05-08 08:23:19 +0000553 sqlite3BtreeClose(pDb->pBt);
drh4d189ca2004-02-12 18:46:38 +0000554 pDb->pBt = 0;
danielk1977311019b2006-01-10 07:14:23 +0000555 if( j!=1 ){
556 pDb->pSchema = 0;
557 }
drh113088e2003-03-20 01:16:58 +0000558 }
drhf57b3392001-10-08 13:22:32 +0000559 }
danielk19774adee202004-05-08 08:23:19 +0000560 sqlite3ResetInternalSchema(db, 0);
drh1c2d8412003-03-31 00:30:47 +0000561 assert( db->nDb<=2 );
562 assert( db->aDb==db->aDbStatic );
drh0bce8352002-02-28 00:41:10 +0000563 for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
564 FuncDef *pFunc, *pNext;
565 for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){
drh8e0a2f92002-02-23 23:45:45 +0000566 pNext = pFunc->pNext;
drh633e6d52008-07-28 19:34:53 +0000567 sqlite3DbFree(db, pFunc);
drh8e0a2f92002-02-23 23:45:45 +0000568 }
569 }
danielk1977466be562004-06-10 02:16:01 +0000570
danielk1977d8123362004-06-12 09:25:12 +0000571 for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
danielk1977466be562004-06-10 02:16:01 +0000572 CollSeq *pColl = (CollSeq *)sqliteHashData(i);
danielk1977a9808b32007-05-07 09:32:45 +0000573 /* Invoke any destructors registered for collation sequence user data. */
574 for(j=0; j<3; j++){
575 if( pColl[j].xDel ){
576 pColl[j].xDel(pColl[j].pUser);
577 }
578 }
drh633e6d52008-07-28 19:34:53 +0000579 sqlite3DbFree(db, pColl);
danielk1977466be562004-06-10 02:16:01 +0000580 }
danielk1977d8123362004-06-12 09:25:12 +0000581 sqlite3HashClear(&db->aCollSeq);
drhb9bb7c12006-06-11 23:41:55 +0000582#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977d1ab1ba2006-06-15 04:28:13 +0000583 for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
584 Module *pMod = (Module *)sqliteHashData(i);
danielk1977832a58a2007-06-22 15:21:15 +0000585 if( pMod->xDestroy ){
586 pMod->xDestroy(pMod->pAux);
587 }
drh633e6d52008-07-28 19:34:53 +0000588 sqlite3DbFree(db, pMod);
danielk1977d1ab1ba2006-06-15 04:28:13 +0000589 }
drhb9bb7c12006-06-11 23:41:55 +0000590 sqlite3HashClear(&db->aModule);
591#endif
danielk1977466be562004-06-10 02:16:01 +0000592
danielk19774adee202004-05-08 08:23:19 +0000593 sqlite3HashClear(&db->aFunc);
danielk19776622cce2004-05-20 11:00:52 +0000594 sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
danielk1977bfd6cce2004-06-18 04:24:54 +0000595 if( db->pErr ){
596 sqlite3ValueFree(db->pErr);
597 }
drhf1952c52006-06-08 15:48:00 +0000598 sqlite3CloseExtensions(db);
danielk197796d81f92004-06-19 03:33:57 +0000599
600 db->magic = SQLITE_MAGIC_ERROR;
danielk1977311019b2006-01-10 07:14:23 +0000601
602 /* The temp-database schema is allocated differently from the other schema
603 ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
604 ** So it needs to be freed here. Todo: Why not roll the temp schema into
605 ** the same sqliteMalloc() as the one that allocates the database
606 ** structure?
607 */
drh633e6d52008-07-28 19:34:53 +0000608 sqlite3DbFree(db, db->aDb[1].pSchema);
drh605264d2007-08-21 15:13:19 +0000609 sqlite3_mutex_leave(db->mutex);
drh7e8b8482008-01-23 03:03:05 +0000610 db->magic = SQLITE_MAGIC_CLOSED;
drh605264d2007-08-21 15:13:19 +0000611 sqlite3_mutex_free(db->mutex);
drhe9d1c722008-08-04 20:13:26 +0000612 if( db->lookaside.bMalloced ){
613 sqlite3_free(db->lookaside.pStart);
614 }
drh17435752007-08-16 04:30:38 +0000615 sqlite3_free(db);
danielk197796d81f92004-06-19 03:33:57 +0000616 return SQLITE_OK;
drh75897232000-05-29 14:26:00 +0000617}
618
619/*
drh001bbcb2003-03-19 03:14:00 +0000620** Rollback all database files.
621*/
drh9bb575f2004-09-06 17:24:11 +0000622void sqlite3RollbackAll(sqlite3 *db){
drh001bbcb2003-03-19 03:14:00 +0000623 int i;
danielk1977f3f06bb2005-12-16 15:24:28 +0000624 int inTrans = 0;
drhe30f4422007-08-21 16:15:55 +0000625 assert( sqlite3_mutex_held(db->mutex) );
danielk19772d1d86f2008-06-20 14:59:51 +0000626 sqlite3BeginBenignMalloc();
drh001bbcb2003-03-19 03:14:00 +0000627 for(i=0; i<db->nDb; i++){
628 if( db->aDb[i].pBt ){
danielk1977f3f06bb2005-12-16 15:24:28 +0000629 if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
630 inTrans = 1;
631 }
danielk19774adee202004-05-08 08:23:19 +0000632 sqlite3BtreeRollback(db->aDb[i].pBt);
drh001bbcb2003-03-19 03:14:00 +0000633 db->aDb[i].inTrans = 0;
634 }
635 }
danielk1977a298e902006-06-22 09:53:48 +0000636 sqlite3VtabRollback(db);
danielk19772d1d86f2008-06-20 14:59:51 +0000637 sqlite3EndBenignMalloc();
danielk1977ae72d982007-10-03 08:46:44 +0000638
danielk197771fd80b2005-12-16 06:54:01 +0000639 if( db->flags&SQLITE_InternChanges ){
danielk1977ea4d9e22007-08-13 15:28:33 +0000640 sqlite3ExpirePreparedStatements(db);
danielk197771fd80b2005-12-16 06:54:01 +0000641 sqlite3ResetInternalSchema(db, 0);
642 }
643
644 /* If one has been configured, invoke the rollback-hook callback */
danielk1977f3f06bb2005-12-16 15:24:28 +0000645 if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
danielk197771fd80b2005-12-16 06:54:01 +0000646 db->xRollbackCallback(db->pRollbackArg);
647 }
drh001bbcb2003-03-19 03:14:00 +0000648}
649
650/*
drhc22bd472002-05-10 13:14:07 +0000651** Return a static string that describes the kind of error specified in the
652** argument.
drh247be432002-05-10 05:44:55 +0000653*/
danielk1977f20b21c2004-05-31 23:56:42 +0000654const char *sqlite3ErrStr(int rc){
drhc22bd472002-05-10 13:14:07 +0000655 const char *z;
drh4ac285a2006-09-15 07:28:50 +0000656 switch( rc & 0xff ){
drhc60d0442004-09-30 13:43:13 +0000657 case SQLITE_ROW:
658 case SQLITE_DONE:
drhc22bd472002-05-10 13:14:07 +0000659 case SQLITE_OK: z = "not an error"; break;
660 case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
drhc22bd472002-05-10 13:14:07 +0000661 case SQLITE_PERM: z = "access permission denied"; break;
662 case SQLITE_ABORT: z = "callback requested query abort"; break;
663 case SQLITE_BUSY: z = "database is locked"; break;
664 case SQLITE_LOCKED: z = "database table is locked"; break;
665 case SQLITE_NOMEM: z = "out of memory"; break;
666 case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
667 case SQLITE_INTERRUPT: z = "interrupted"; break;
668 case SQLITE_IOERR: z = "disk I/O error"; break;
669 case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
drh2db0bbc2005-08-11 02:10:18 +0000670 case SQLITE_FULL: z = "database or disk is full"; break;
drhc22bd472002-05-10 13:14:07 +0000671 case SQLITE_CANTOPEN: z = "unable to open database file"; break;
drhc22bd472002-05-10 13:14:07 +0000672 case SQLITE_EMPTY: z = "table contains no data"; break;
673 case SQLITE_SCHEMA: z = "database schema has changed"; break;
drh023ae032007-05-08 12:12:16 +0000674 case SQLITE_TOOBIG: z = "String or BLOB exceeded size limit"; break;
drhc22bd472002-05-10 13:14:07 +0000675 case SQLITE_CONSTRAINT: z = "constraint failed"; break;
676 case SQLITE_MISMATCH: z = "datatype mismatch"; break;
677 case SQLITE_MISUSE: z = "library routine called out of sequence";break;
drh65594042008-05-05 16:56:34 +0000678 case SQLITE_NOLFS: z = "large file support is disabled"; break;
drhed6c8672003-01-12 18:02:16 +0000679 case SQLITE_AUTH: z = "authorization denied"; break;
jplyon892f6712003-06-12 08:59:00 +0000680 case SQLITE_FORMAT: z = "auxiliary database format error"; break;
drhb08153d2004-11-20 20:18:55 +0000681 case SQLITE_RANGE: z = "bind or column index out of range"; break;
drhc602f9a2004-02-12 19:01:04 +0000682 case SQLITE_NOTADB: z = "file is encrypted or is not a database";break;
drhc22bd472002-05-10 13:14:07 +0000683 default: z = "unknown error"; break;
drh247be432002-05-10 05:44:55 +0000684 }
drhc22bd472002-05-10 13:14:07 +0000685 return z;
drh247be432002-05-10 05:44:55 +0000686}
687
688/*
drh2dfbbca2000-07-28 14:32:48 +0000689** This routine implements a busy callback that sleeps and tries
690** again until a timeout value is reached. The timeout value is
691** an integer number of milliseconds passed in as the first
692** argument.
693*/
drhdaffd0e2001-04-11 14:28:42 +0000694static int sqliteDefaultBusyCallback(
drh97903fe2005-05-24 20:19:57 +0000695 void *ptr, /* Database connection */
drh2dfbbca2000-07-28 14:32:48 +0000696 int count /* Number of times table has been busy */
697){
danielk197729bafea2008-06-26 10:41:19 +0000698#if SQLITE_OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
drhee570fa2005-04-28 12:06:05 +0000699 static const u8 delays[] =
700 { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
701 static const u8 totals[] =
702 { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
drhd1bec472004-01-15 13:29:31 +0000703# define NDELAY (sizeof(delays)/sizeof(delays[0]))
danielk1977b4b47412007-08-17 15:53:36 +0000704 sqlite3 *db = (sqlite3 *)ptr;
705 int timeout = db->busyTimeout;
drh97903fe2005-05-24 20:19:57 +0000706 int delay, prior;
drh2dfbbca2000-07-28 14:32:48 +0000707
drhee570fa2005-04-28 12:06:05 +0000708 assert( count>=0 );
709 if( count < NDELAY ){
710 delay = delays[count];
711 prior = totals[count];
drhd1bec472004-01-15 13:29:31 +0000712 }else{
713 delay = delays[NDELAY-1];
drh68cb6192005-05-06 22:05:56 +0000714 prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
drh2dfbbca2000-07-28 14:32:48 +0000715 }
drhd1bec472004-01-15 13:29:31 +0000716 if( prior + delay > timeout ){
717 delay = timeout - prior;
drh2dfbbca2000-07-28 14:32:48 +0000718 if( delay<=0 ) return 0;
719 }
danielk19772a6bdf62007-08-20 16:07:00 +0000720 sqlite3OsSleep(db->pVfs, delay*1000);
drh2dfbbca2000-07-28 14:32:48 +0000721 return 1;
722#else
drh482ea182007-08-20 11:12:40 +0000723 sqlite3 *db = (sqlite3 *)ptr;
drh3f737082005-06-14 02:24:31 +0000724 int timeout = ((sqlite3 *)ptr)->busyTimeout;
drh2dfbbca2000-07-28 14:32:48 +0000725 if( (count+1)*1000 > timeout ){
726 return 0;
727 }
drh482ea182007-08-20 11:12:40 +0000728 sqlite3OsSleep(db->pVfs, 1000000);
drh2dfbbca2000-07-28 14:32:48 +0000729 return 1;
730#endif
731}
732
733/*
drha4afb652005-07-09 02:16:02 +0000734** Invoke the given busy handler.
735**
736** This routine is called when an operation failed with a lock.
737** If this routine returns non-zero, the lock is retried. If it
738** returns 0, the operation aborts with an SQLITE_BUSY error.
739*/
740int sqlite3InvokeBusyHandler(BusyHandler *p){
741 int rc;
drh34004ce2008-07-11 16:15:17 +0000742 if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0;
drha4afb652005-07-09 02:16:02 +0000743 rc = p->xFunc(p->pArg, p->nBusy);
744 if( rc==0 ){
745 p->nBusy = -1;
746 }else{
747 p->nBusy++;
748 }
749 return rc;
750}
751
752/*
drh2dfbbca2000-07-28 14:32:48 +0000753** This routine sets the busy callback for an Sqlite database to the
754** given callback function with the given argument.
755*/
danielk1977f9d64d22004-06-19 08:18:07 +0000756int sqlite3_busy_handler(
757 sqlite3 *db,
danielk19772a764eb2004-06-12 01:43:26 +0000758 int (*xBusy)(void*,int),
drh2dfbbca2000-07-28 14:32:48 +0000759 void *pArg
760){
drhe30f4422007-08-21 16:15:55 +0000761 sqlite3_mutex_enter(db->mutex);
danielk197724162fe2004-06-04 06:22:00 +0000762 db->busyHandler.xFunc = xBusy;
763 db->busyHandler.pArg = pArg;
drha4afb652005-07-09 02:16:02 +0000764 db->busyHandler.nBusy = 0;
drhe30f4422007-08-21 16:15:55 +0000765 sqlite3_mutex_leave(db->mutex);
danielk1977f9d64d22004-06-19 08:18:07 +0000766 return SQLITE_OK;
drh2dfbbca2000-07-28 14:32:48 +0000767}
768
danielk1977348bb5d2003-10-18 09:37:26 +0000769#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
770/*
771** This routine sets the progress callback for an Sqlite database to the
772** given callback function with the given argument. The progress callback will
773** be invoked every nOps opcodes.
774*/
danielk197724b03fd2004-05-10 10:34:34 +0000775void sqlite3_progress_handler(
drh9bb575f2004-09-06 17:24:11 +0000776 sqlite3 *db,
danielk1977348bb5d2003-10-18 09:37:26 +0000777 int nOps,
778 int (*xProgress)(void*),
779 void *pArg
780){
drhbd0b1b52008-07-07 19:52:09 +0000781 sqlite3_mutex_enter(db->mutex);
782 if( nOps>0 ){
783 db->xProgress = xProgress;
784 db->nProgressOps = nOps;
785 db->pProgressArg = pArg;
786 }else{
787 db->xProgress = 0;
788 db->nProgressOps = 0;
789 db->pProgressArg = 0;
danielk1977348bb5d2003-10-18 09:37:26 +0000790 }
drhbd0b1b52008-07-07 19:52:09 +0000791 sqlite3_mutex_leave(db->mutex);
danielk1977348bb5d2003-10-18 09:37:26 +0000792}
793#endif
794
795
drh2dfbbca2000-07-28 14:32:48 +0000796/*
797** This routine installs a default busy handler that waits for the
798** specified number of milliseconds before returning 0.
799*/
danielk1977f9d64d22004-06-19 08:18:07 +0000800int sqlite3_busy_timeout(sqlite3 *db, int ms){
drh2dfbbca2000-07-28 14:32:48 +0000801 if( ms>0 ){
drh97903fe2005-05-24 20:19:57 +0000802 db->busyTimeout = ms;
803 sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
drh2dfbbca2000-07-28 14:32:48 +0000804 }else{
danielk197724b03fd2004-05-10 10:34:34 +0000805 sqlite3_busy_handler(db, 0, 0);
drh2dfbbca2000-07-28 14:32:48 +0000806 }
danielk1977f9d64d22004-06-19 08:18:07 +0000807 return SQLITE_OK;
drh2dfbbca2000-07-28 14:32:48 +0000808}
drh4c504392000-10-16 22:06:40 +0000809
810/*
811** Cause any pending operation to stop at its earliest opportunity.
812*/
drh9bb575f2004-09-06 17:24:11 +0000813void sqlite3_interrupt(sqlite3 *db){
drhbd0b1b52008-07-07 19:52:09 +0000814 db->u1.isInterrupted = 1;
drh4c504392000-10-16 22:06:40 +0000815}
drhfa86c412002-02-02 15:01:15 +0000816
drhfa86c412002-02-02 15:01:15 +0000817
818/*
danielk1977771151b2006-01-17 13:21:40 +0000819** This function is exactly the same as sqlite3_create_function(), except
820** that it is designed to be called by internal code. The difference is
821** that if a malloc() fails in sqlite3_create_function(), an error code
822** is returned and the mallocFailed flag cleared.
drhfa86c412002-02-02 15:01:15 +0000823*/
danielk1977771151b2006-01-17 13:21:40 +0000824int sqlite3CreateFunc(
danielk197765904932004-05-26 06:18:37 +0000825 sqlite3 *db,
826 const char *zFunctionName,
827 int nArg,
danielk1977d8123362004-06-12 09:25:12 +0000828 int enc,
danielk197765904932004-05-26 06:18:37 +0000829 void *pUserData,
830 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
831 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
832 void (*xFinal)(sqlite3_context*)
drh8e0a2f92002-02-23 23:45:45 +0000833){
drh0bce8352002-02-28 00:41:10 +0000834 FuncDef *p;
drh4b59ab52002-08-24 18:24:51 +0000835 int nName;
danielk197765904932004-05-26 06:18:37 +0000836
drhe30f4422007-08-21 16:15:55 +0000837 assert( sqlite3_mutex_held(db->mutex) );
drhc60d0442004-09-30 13:43:13 +0000838 if( zFunctionName==0 ||
danielk1977398eae72004-05-26 06:58:43 +0000839 (xFunc && (xFinal || xStep)) ||
840 (!xFunc && (xFinal && !xStep)) ||
841 (!xFunc && (!xFinal && xStep)) ||
drh24b58dd2008-07-07 14:50:14 +0000842 (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) ||
drh0a687d12008-07-08 14:52:07 +0000843 (255<(nName = sqlite3Strlen(db, zFunctionName))) ){
drhbadf7a72006-06-14 15:35:36 +0000844 sqlite3Error(db, SQLITE_ERROR, "bad parameters");
danielk197765904932004-05-26 06:18:37 +0000845 return SQLITE_ERROR;
846 }
danielk1977d8123362004-06-12 09:25:12 +0000847
danielk197793758c82005-01-21 08:13:14 +0000848#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +0000849 /* If SQLITE_UTF16 is specified as the encoding type, transform this
850 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
851 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
852 **
853 ** If SQLITE_ANY is specified, add three versions of the function
854 ** to the hash table.
855 */
856 if( enc==SQLITE_UTF16 ){
857 enc = SQLITE_UTF16NATIVE;
858 }else if( enc==SQLITE_ANY ){
859 int rc;
danielk1977771151b2006-01-17 13:21:40 +0000860 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
danielk1977f9d64d22004-06-19 08:18:07 +0000861 pUserData, xFunc, xStep, xFinal);
drhe30f4422007-08-21 16:15:55 +0000862 if( rc==SQLITE_OK ){
863 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
864 pUserData, xFunc, xStep, xFinal);
865 }
866 if( rc!=SQLITE_OK ){
867 return rc;
868 }
danielk1977d8123362004-06-12 09:25:12 +0000869 enc = SQLITE_UTF16BE;
870 }
danielk197793758c82005-01-21 08:13:14 +0000871#else
872 enc = SQLITE_UTF8;
873#endif
danielk19779636c4e2005-01-25 04:27:54 +0000874
875 /* Check if an existing function is being overridden or deleted. If so,
876 ** and there are active VMs, then return SQLITE_BUSY. If a function
877 ** is being overridden/deleted but there are no active VMs, allow the
878 ** operation to continue but invalidate all precompiled statements.
879 */
880 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
881 if( p && p->iPrefEnc==enc && p->nArg==nArg ){
882 if( db->activeVdbeCnt ){
883 sqlite3Error(db, SQLITE_BUSY,
884 "Unable to delete/modify user-function due to active statements");
drh17435752007-08-16 04:30:38 +0000885 assert( !db->mallocFailed );
danielk19779636c4e2005-01-25 04:27:54 +0000886 return SQLITE_BUSY;
887 }else{
888 sqlite3ExpirePreparedStatements(db);
889 }
890 }
danielk197765904932004-05-26 06:18:37 +0000891
danielk1977d8123362004-06-12 09:25:12 +0000892 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
danielk1977fa18bec2007-09-03 11:04:22 +0000893 assert(p || db->mallocFailed);
894 if( !p ){
895 return SQLITE_NOMEM;
danielk1977771151b2006-01-17 13:21:40 +0000896 }
danielk1977fa18bec2007-09-03 11:04:22 +0000897 p->flags = 0;
898 p->xFunc = xFunc;
899 p->xStep = xStep;
900 p->xFinalize = xFinal;
901 p->pUserData = pUserData;
902 p->nArg = nArg;
danielk197765904932004-05-26 06:18:37 +0000903 return SQLITE_OK;
904}
danielk1977771151b2006-01-17 13:21:40 +0000905
906/*
907** Create new user functions.
908*/
909int sqlite3_create_function(
910 sqlite3 *db,
911 const char *zFunctionName,
912 int nArg,
913 int enc,
914 void *p,
915 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
916 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
917 void (*xFinal)(sqlite3_context*)
918){
919 int rc;
drhe30f4422007-08-21 16:15:55 +0000920 sqlite3_mutex_enter(db->mutex);
danielk1977771151b2006-01-17 13:21:40 +0000921 rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
drhe30f4422007-08-21 16:15:55 +0000922 rc = sqlite3ApiExit(db, rc);
923 sqlite3_mutex_leave(db->mutex);
924 return rc;
danielk1977771151b2006-01-17 13:21:40 +0000925}
926
danielk197793758c82005-01-21 08:13:14 +0000927#ifndef SQLITE_OMIT_UTF16
danielk197765904932004-05-26 06:18:37 +0000928int sqlite3_create_function16(
929 sqlite3 *db,
930 const void *zFunctionName,
931 int nArg,
932 int eTextRep,
danielk1977771151b2006-01-17 13:21:40 +0000933 void *p,
danielk197765904932004-05-26 06:18:37 +0000934 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
935 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
936 void (*xFinal)(sqlite3_context*)
937){
938 int rc;
drhaf9a7c22005-12-15 03:04:10 +0000939 char *zFunc8;
drhe30f4422007-08-21 16:15:55 +0000940 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +0000941 assert( !db->mallocFailed );
danielk19771e536952007-08-16 10:09:01 +0000942 zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
danielk1977771151b2006-01-17 13:21:40 +0000943 rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
drh633e6d52008-07-28 19:34:53 +0000944 sqlite3DbFree(db, zFunc8);
drhe30f4422007-08-21 16:15:55 +0000945 rc = sqlite3ApiExit(db, rc);
946 sqlite3_mutex_leave(db->mutex);
947 return rc;
drh8e0a2f92002-02-23 23:45:45 +0000948}
danielk197793758c82005-01-21 08:13:14 +0000949#endif
drhc9b84a12002-06-20 11:36:48 +0000950
drhb7481e72006-09-16 21:45:14 +0000951
952/*
953** Declare that a function has been overloaded by a virtual table.
954**
955** If the function already exists as a regular global function, then
956** this routine is a no-op. If the function does not exist, then create
957** a new one that always throws a run-time error.
958**
959** When virtual tables intend to provide an overloaded function, they
960** should call this routine to make sure the global function exists.
961** A global function must exist in order for name resolution to work
962** properly.
963*/
964int sqlite3_overload_function(
965 sqlite3 *db,
966 const char *zName,
967 int nArg
968){
drh0a687d12008-07-08 14:52:07 +0000969 int nName = sqlite3Strlen(db, zName);
drhe30f4422007-08-21 16:15:55 +0000970 int rc;
971 sqlite3_mutex_enter(db->mutex);
drhb7481e72006-09-16 21:45:14 +0000972 if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
973 sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
974 0, sqlite3InvalidFunction, 0, 0);
975 }
drhe30f4422007-08-21 16:15:55 +0000976 rc = sqlite3ApiExit(db, SQLITE_OK);
977 sqlite3_mutex_leave(db->mutex);
978 return rc;
drhb7481e72006-09-16 21:45:14 +0000979}
980
drh19e2d372005-08-29 23:00:03 +0000981#ifndef SQLITE_OMIT_TRACE
drhc9b84a12002-06-20 11:36:48 +0000982/*
drh18de4822003-01-16 16:28:53 +0000983** Register a trace function. The pArg from the previously registered trace
984** is returned.
985**
986** A NULL trace function means that no tracing is executes. A non-NULL
987** trace is a pointer to a function that is invoked at the start of each
drh19e2d372005-08-29 23:00:03 +0000988** SQL statement.
drh18de4822003-01-16 16:28:53 +0000989*/
drh9bb575f2004-09-06 17:24:11 +0000990void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
drhe30f4422007-08-21 16:15:55 +0000991 void *pOld;
992 sqlite3_mutex_enter(db->mutex);
993 pOld = db->pTraceArg;
drh18de4822003-01-16 16:28:53 +0000994 db->xTrace = xTrace;
995 db->pTraceArg = pArg;
drhe30f4422007-08-21 16:15:55 +0000996 sqlite3_mutex_leave(db->mutex);
drh18de4822003-01-16 16:28:53 +0000997 return pOld;
drh0d1a6432003-04-03 15:46:04 +0000998}
drh19e2d372005-08-29 23:00:03 +0000999/*
1000** Register a profile function. The pArg from the previously registered
1001** profile function is returned.
1002**
1003** A NULL profile function means that no profiling is executes. A non-NULL
1004** profile is a pointer to a function that is invoked at the conclusion of
1005** each SQL statement that is run.
1006*/
1007void *sqlite3_profile(
1008 sqlite3 *db,
1009 void (*xProfile)(void*,const char*,sqlite_uint64),
1010 void *pArg
1011){
drhe30f4422007-08-21 16:15:55 +00001012 void *pOld;
1013 sqlite3_mutex_enter(db->mutex);
1014 pOld = db->pProfileArg;
drh19e2d372005-08-29 23:00:03 +00001015 db->xProfile = xProfile;
1016 db->pProfileArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001017 sqlite3_mutex_leave(db->mutex);
drh19e2d372005-08-29 23:00:03 +00001018 return pOld;
1019}
1020#endif /* SQLITE_OMIT_TRACE */
paulb0208cc2003-04-13 18:26:49 +00001021
drhaa940ea2004-01-15 02:44:03 +00001022/*** EXPERIMENTAL ***
1023**
1024** Register a function to be invoked when a transaction comments.
danielk197771fd80b2005-12-16 06:54:01 +00001025** If the invoked function returns non-zero, then the commit becomes a
drhaa940ea2004-01-15 02:44:03 +00001026** rollback.
1027*/
danielk197724b03fd2004-05-10 10:34:34 +00001028void *sqlite3_commit_hook(
drh9bb575f2004-09-06 17:24:11 +00001029 sqlite3 *db, /* Attach the hook to this database */
drhaa940ea2004-01-15 02:44:03 +00001030 int (*xCallback)(void*), /* Function to invoke on each commit */
1031 void *pArg /* Argument to the function */
1032){
drhe30f4422007-08-21 16:15:55 +00001033 void *pOld;
1034 sqlite3_mutex_enter(db->mutex);
1035 pOld = db->pCommitArg;
drhaa940ea2004-01-15 02:44:03 +00001036 db->xCommitCallback = xCallback;
1037 db->pCommitArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001038 sqlite3_mutex_leave(db->mutex);
drhaa940ea2004-01-15 02:44:03 +00001039 return pOld;
1040}
1041
danielk197794eb6a12005-12-15 15:22:08 +00001042/*
1043** Register a callback to be invoked each time a row is updated,
1044** inserted or deleted using this database connection.
1045*/
danielk197771fd80b2005-12-16 06:54:01 +00001046void *sqlite3_update_hook(
danielk197794eb6a12005-12-15 15:22:08 +00001047 sqlite3 *db, /* Attach the hook to this database */
1048 void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
1049 void *pArg /* Argument to the function */
1050){
drhe30f4422007-08-21 16:15:55 +00001051 void *pRet;
1052 sqlite3_mutex_enter(db->mutex);
1053 pRet = db->pUpdateArg;
danielk197794eb6a12005-12-15 15:22:08 +00001054 db->xUpdateCallback = xCallback;
1055 db->pUpdateArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001056 sqlite3_mutex_leave(db->mutex);
danielk197771fd80b2005-12-16 06:54:01 +00001057 return pRet;
danielk197794eb6a12005-12-15 15:22:08 +00001058}
1059
danielk197771fd80b2005-12-16 06:54:01 +00001060/*
1061** Register a callback to be invoked each time a transaction is rolled
1062** back by this database connection.
1063*/
1064void *sqlite3_rollback_hook(
1065 sqlite3 *db, /* Attach the hook to this database */
1066 void (*xCallback)(void*), /* Callback function */
1067 void *pArg /* Argument to the function */
1068){
drhe30f4422007-08-21 16:15:55 +00001069 void *pRet;
1070 sqlite3_mutex_enter(db->mutex);
1071 pRet = db->pRollbackArg;
danielk197771fd80b2005-12-16 06:54:01 +00001072 db->xRollbackCallback = xCallback;
1073 db->pRollbackArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001074 sqlite3_mutex_leave(db->mutex);
danielk197771fd80b2005-12-16 06:54:01 +00001075 return pRet;
1076}
drhaa940ea2004-01-15 02:44:03 +00001077
paulb0208cc2003-04-13 18:26:49 +00001078/*
drh13bff812003-04-15 01:19:47 +00001079** This routine is called to create a connection to a database BTree
1080** driver. If zFilename is the name of a file, then that file is
1081** opened and used. If zFilename is the magic name ":memory:" then
1082** the database is stored in memory (and is thus forgotten as soon as
1083** the connection is closed.) If zFilename is NULL then the database
drh84bfda42005-07-15 13:05:21 +00001084** is a "virtual" database for transient use only and is deleted as
1085** soon as the connection is closed.
drh90f5ecb2004-07-22 01:19:35 +00001086**
drh84bfda42005-07-15 13:05:21 +00001087** A virtual database can be either a disk file (that is automatically
1088** deleted when the file is closed) or it an be held entirely in memory,
danielk1977b06a0b62008-06-26 10:54:12 +00001089** depending on the values of the SQLITE_TEMP_STORE compile-time macro and the
drh90f5ecb2004-07-22 01:19:35 +00001090** db->temp_store variable, according to the following chart:
1091**
danielk1977b06a0b62008-06-26 10:54:12 +00001092** SQLITE_TEMP_STORE db->temp_store Location of temporary database
1093** ----------------- -------------- ------------------------------
1094** 0 any file
1095** 1 1 file
1096** 1 2 memory
1097** 1 0 file
1098** 2 1 file
1099** 2 2 memory
1100** 2 0 memory
1101** 3 any memory
paulb0208cc2003-04-13 18:26:49 +00001102*/
danielk19774adee202004-05-08 08:23:19 +00001103int sqlite3BtreeFactory(
drh9bb575f2004-09-06 17:24:11 +00001104 const sqlite3 *db, /* Main database when opening aux otherwise 0 */
paulb0208cc2003-04-13 18:26:49 +00001105 const char *zFilename, /* Name of the file containing the BTree database */
1106 int omitJournal, /* if TRUE then do not journal this file */
1107 int nCache, /* How many pages in the page cache */
drh33f4e022007-09-03 15:19:34 +00001108 int vfsFlags, /* Flags passed through to vfsOpen */
danielk19774adee202004-05-08 08:23:19 +00001109 Btree **ppBtree /* Pointer to new Btree object written here */
1110){
drh33f4e022007-09-03 15:19:34 +00001111 int btFlags = 0;
drh90f5ecb2004-07-22 01:19:35 +00001112 int rc;
danielk19774adee202004-05-08 08:23:19 +00001113
drhe30f4422007-08-21 16:15:55 +00001114 assert( sqlite3_mutex_held(db->mutex) );
drheec983e2004-05-08 10:11:36 +00001115 assert( ppBtree != 0);
danielk19774adee202004-05-08 08:23:19 +00001116 if( omitJournal ){
drh33f4e022007-09-03 15:19:34 +00001117 btFlags |= BTREE_OMIT_JOURNAL;
paulb0208cc2003-04-13 18:26:49 +00001118 }
drh7bec5052005-02-06 02:45:41 +00001119 if( db->flags & SQLITE_NoReadlock ){
drh33f4e022007-09-03 15:19:34 +00001120 btFlags |= BTREE_NO_READLOCK;
drh7bec5052005-02-06 02:45:41 +00001121 }
drh90f5ecb2004-07-22 01:19:35 +00001122 if( zFilename==0 ){
danielk1977b06a0b62008-06-26 10:54:12 +00001123#if SQLITE_TEMP_STORE==0
drh22ac46d2004-08-14 18:34:54 +00001124 /* Do nothing */
drh90f5ecb2004-07-22 01:19:35 +00001125#endif
danielk197703aded42004-11-22 05:26:27 +00001126#ifndef SQLITE_OMIT_MEMORYDB
danielk1977b06a0b62008-06-26 10:54:12 +00001127#if SQLITE_TEMP_STORE==1
drh22ac46d2004-08-14 18:34:54 +00001128 if( db->temp_store==2 ) zFilename = ":memory:";
drh90f5ecb2004-07-22 01:19:35 +00001129#endif
danielk1977b06a0b62008-06-26 10:54:12 +00001130#if SQLITE_TEMP_STORE==2
drh22ac46d2004-08-14 18:34:54 +00001131 if( db->temp_store!=1 ) zFilename = ":memory:";
drh90f5ecb2004-07-22 01:19:35 +00001132#endif
danielk1977b06a0b62008-06-26 10:54:12 +00001133#if SQLITE_TEMP_STORE==3
drh22ac46d2004-08-14 18:34:54 +00001134 zFilename = ":memory:";
drh90f5ecb2004-07-22 01:19:35 +00001135#endif
danielk197703aded42004-11-22 05:26:27 +00001136#endif /* SQLITE_OMIT_MEMORYDB */
drh90f5ecb2004-07-22 01:19:35 +00001137 }
danielk19774adee202004-05-08 08:23:19 +00001138
drh33f4e022007-09-03 15:19:34 +00001139 if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 || *zFilename==0) ){
1140 vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
1141 }
1142 rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags);
danielk1977171bfed2008-06-23 09:50:50 +00001143
1144 /* If the B-Tree was successfully opened, set the pager-cache size to the
1145 ** default value. Except, if the call to BtreeOpen() returned a handle
1146 ** open on an existing shared pager-cache, do not change the pager-cache
1147 ** size.
1148 */
1149 if( rc==SQLITE_OK && 0==sqlite3BtreeSchema(*ppBtree, 0, 0) ){
drh90f5ecb2004-07-22 01:19:35 +00001150 sqlite3BtreeSetCacheSize(*ppBtree, nCache);
1151 }
1152 return rc;
paulb0208cc2003-04-13 18:26:49 +00001153}
danielk19774adee202004-05-08 08:23:19 +00001154
danielk19774ad17132004-05-21 01:47:26 +00001155/*
1156** Return UTF-8 encoded English language explanation of the most recent
1157** error.
1158*/
danielk19776622cce2004-05-20 11:00:52 +00001159const char *sqlite3_errmsg(sqlite3 *db){
drhc60d0442004-09-30 13:43:13 +00001160 const char *z;
danielk1977ae7fc492007-03-29 15:00:52 +00001161 if( !db ){
danielk1977f20b21c2004-05-31 23:56:42 +00001162 return sqlite3ErrStr(SQLITE_NOMEM);
danielk19774ad17132004-05-21 01:47:26 +00001163 }
drhd55d57e2008-07-07 17:53:07 +00001164 if( !sqlite3SafetyCheckSickOrOk(db) ){
danielk1977e35ee192004-06-26 09:50:11 +00001165 return sqlite3ErrStr(SQLITE_MISUSE);
1166 }
drh27641702007-08-22 02:56:42 +00001167 sqlite3_mutex_enter(db->mutex);
drh86f8c192007-08-22 00:39:19 +00001168 assert( !db->mallocFailed );
drh2646da72005-12-09 20:02:05 +00001169 z = (char*)sqlite3_value_text(db->pErr);
danielk1977131c8bc2008-05-22 13:56:17 +00001170 assert( !db->mallocFailed );
drhc60d0442004-09-30 13:43:13 +00001171 if( z==0 ){
1172 z = sqlite3ErrStr(db->errCode);
danielk19776622cce2004-05-20 11:00:52 +00001173 }
drhe30f4422007-08-21 16:15:55 +00001174 sqlite3_mutex_leave(db->mutex);
drhc60d0442004-09-30 13:43:13 +00001175 return z;
danielk19776622cce2004-05-20 11:00:52 +00001176}
1177
drh6c626082004-11-14 21:56:29 +00001178#ifndef SQLITE_OMIT_UTF16
danielk19774ad17132004-05-21 01:47:26 +00001179/*
1180** Return UTF-16 encoded English language explanation of the most recent
1181** error.
1182*/
danielk19776622cce2004-05-20 11:00:52 +00001183const void *sqlite3_errmsg16(sqlite3 *db){
danielk1977bfd6cce2004-06-18 04:24:54 +00001184 /* Because all the characters in the string are in the unicode
1185 ** range 0x00-0xFF, if we pad the big-endian string with a
1186 ** zero byte, we can obtain the little-endian string with
1187 ** &big_endian[1].
1188 */
drh57196282004-10-06 15:41:16 +00001189 static const char outOfMemBe[] = {
danielk1977bfd6cce2004-06-18 04:24:54 +00001190 0, 'o', 0, 'u', 0, 't', 0, ' ',
1191 0, 'o', 0, 'f', 0, ' ',
1192 0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
1193 };
drh57196282004-10-06 15:41:16 +00001194 static const char misuseBe [] = {
danielk1977e35ee192004-06-26 09:50:11 +00001195 0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ',
1196 0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ',
1197 0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ',
1198 0, 'o', 0, 'u', 0, 't', 0, ' ',
1199 0, 'o', 0, 'f', 0, ' ',
1200 0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
1201 };
danielk19774ad17132004-05-21 01:47:26 +00001202
drhc60d0442004-09-30 13:43:13 +00001203 const void *z;
danielk1977ae7fc492007-03-29 15:00:52 +00001204 if( !db ){
drhc60d0442004-09-30 13:43:13 +00001205 return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
1206 }
drhd55d57e2008-07-07 17:53:07 +00001207 if( !sqlite3SafetyCheckSickOrOk(db) ){
drhc60d0442004-09-30 13:43:13 +00001208 return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
1209 }
drhe30f4422007-08-21 16:15:55 +00001210 sqlite3_mutex_enter(db->mutex);
1211 assert( !db->mallocFailed );
drhc60d0442004-09-30 13:43:13 +00001212 z = sqlite3_value_text16(db->pErr);
1213 if( z==0 ){
drhb21c8cd2007-08-21 19:33:56 +00001214 sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
drhc60d0442004-09-30 13:43:13 +00001215 SQLITE_UTF8, SQLITE_STATIC);
1216 z = sqlite3_value_text16(db->pErr);
1217 }
danielk1977131c8bc2008-05-22 13:56:17 +00001218 /* A malloc() may have failed within the call to sqlite3_value_text16()
1219 ** above. If this is the case, then the db->mallocFailed flag needs to
1220 ** be cleared before returning. Do this directly, instead of via
1221 ** sqlite3ApiExit(), to avoid setting the database handle error message.
1222 */
1223 db->mallocFailed = 0;
drhe30f4422007-08-21 16:15:55 +00001224 sqlite3_mutex_leave(db->mutex);
drhc60d0442004-09-30 13:43:13 +00001225 return z;
danielk19776622cce2004-05-20 11:00:52 +00001226}
drh6c626082004-11-14 21:56:29 +00001227#endif /* SQLITE_OMIT_UTF16 */
danielk19776622cce2004-05-20 11:00:52 +00001228
drhc60d0442004-09-30 13:43:13 +00001229/*
danielk19777ddad962005-12-12 06:53:03 +00001230** Return the most recent error code generated by an SQLite routine. If NULL is
1231** passed to this function, we assume a malloc() failed during sqlite3_open().
drhc60d0442004-09-30 13:43:13 +00001232*/
danielk19776622cce2004-05-20 11:00:52 +00001233int sqlite3_errcode(sqlite3 *db){
danielk19777c36d072008-01-31 15:31:01 +00001234 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
drhc60d0442004-09-30 13:43:13 +00001235 return SQLITE_MISUSE;
1236 }
drh01495b92008-01-23 12:52:40 +00001237 if( !db || db->mallocFailed ){
1238 return SQLITE_NOMEM;
1239 }
drh4ac285a2006-09-15 07:28:50 +00001240 return db->errCode & db->errMask;
danielk19776622cce2004-05-20 11:00:52 +00001241}
1242
drh0e819f92006-02-01 13:50:41 +00001243/*
1244** Create a new collating function for database "db". The name is zName
1245** and the encoding is enc.
1246*/
danielk19779a30cf62006-01-18 04:26:07 +00001247static int createCollation(
1248 sqlite3* db,
1249 const char *zName,
1250 int enc,
1251 void* pCtx,
danielk1977a9808b32007-05-07 09:32:45 +00001252 int(*xCompare)(void*,int,const void*,int,const void*),
1253 void(*xDel)(void*)
danielk19779a30cf62006-01-18 04:26:07 +00001254){
1255 CollSeq *pColl;
drh7d9bd4e2006-02-16 18:16:36 +00001256 int enc2;
drh0a687d12008-07-08 14:52:07 +00001257 int nName;
danielk19779a30cf62006-01-18 04:26:07 +00001258
drhe30f4422007-08-21 16:15:55 +00001259 assert( sqlite3_mutex_held(db->mutex) );
danielk19779a30cf62006-01-18 04:26:07 +00001260
1261 /* If SQLITE_UTF16 is specified as the encoding type, transform this
1262 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
1263 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
1264 */
drh7d9bd4e2006-02-16 18:16:36 +00001265 enc2 = enc & ~SQLITE_UTF16_ALIGNED;
1266 if( enc2==SQLITE_UTF16 ){
1267 enc2 = SQLITE_UTF16NATIVE;
danielk19779a30cf62006-01-18 04:26:07 +00001268 }
drh7d9bd4e2006-02-16 18:16:36 +00001269 if( (enc2&~3)!=0 ){
drhd55d57e2008-07-07 17:53:07 +00001270 return SQLITE_MISUSE;
danielk19779a30cf62006-01-18 04:26:07 +00001271 }
1272
1273 /* Check if this call is removing or replacing an existing collation
1274 ** sequence. If so, and there are active VMs, return busy. If there
1275 ** are no active VMs, invalidate any pre-compiled statements.
1276 */
drh0a687d12008-07-08 14:52:07 +00001277 nName = sqlite3Strlen(db, zName);
1278 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, nName, 0);
danielk19779a30cf62006-01-18 04:26:07 +00001279 if( pColl && pColl->xCmp ){
1280 if( db->activeVdbeCnt ){
1281 sqlite3Error(db, SQLITE_BUSY,
1282 "Unable to delete/modify collation sequence due to active statements");
1283 return SQLITE_BUSY;
1284 }
1285 sqlite3ExpirePreparedStatements(db);
danielk1977a9808b32007-05-07 09:32:45 +00001286
1287 /* If collation sequence pColl was created directly by a call to
1288 ** sqlite3_create_collation, and not generated by synthCollSeq(),
1289 ** then any copies made by synthCollSeq() need to be invalidated.
1290 ** Also, collation destructor - CollSeq.xDel() - function may need
1291 ** to be called.
1292 */
1293 if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
drh0a687d12008-07-08 14:52:07 +00001294 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
danielk1977a9808b32007-05-07 09:32:45 +00001295 int j;
1296 for(j=0; j<3; j++){
1297 CollSeq *p = &aColl[j];
1298 if( p->enc==pColl->enc ){
1299 if( p->xDel ){
1300 p->xDel(p->pUser);
1301 }
1302 p->xCmp = 0;
1303 }
1304 }
1305 }
danielk19779a30cf62006-01-18 04:26:07 +00001306 }
1307
drh0a687d12008-07-08 14:52:07 +00001308 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, nName, 1);
danielk19779a30cf62006-01-18 04:26:07 +00001309 if( pColl ){
1310 pColl->xCmp = xCompare;
1311 pColl->pUser = pCtx;
danielk1977a9808b32007-05-07 09:32:45 +00001312 pColl->xDel = xDel;
drh7d9bd4e2006-02-16 18:16:36 +00001313 pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED);
danielk19779a30cf62006-01-18 04:26:07 +00001314 }
1315 sqlite3Error(db, SQLITE_OK, 0);
1316 return SQLITE_OK;
1317}
1318
1319
danielk19776622cce2004-05-20 11:00:52 +00001320/*
drhbb4957f2008-03-20 14:03:29 +00001321** This array defines hard upper bounds on limit values. The
1322** initializer must be kept in sync with the SQLITE_LIMIT_*
1323** #defines in sqlite3.h.
1324*/
drhb1a6c3c2008-03-20 16:30:17 +00001325static const int aHardLimit[] = {
drhbb4957f2008-03-20 14:03:29 +00001326 SQLITE_MAX_LENGTH,
1327 SQLITE_MAX_SQL_LENGTH,
1328 SQLITE_MAX_COLUMN,
1329 SQLITE_MAX_EXPR_DEPTH,
1330 SQLITE_MAX_COMPOUND_SELECT,
1331 SQLITE_MAX_VDBE_OP,
1332 SQLITE_MAX_FUNCTION_ARG,
1333 SQLITE_MAX_ATTACHED,
drhbb4957f2008-03-20 14:03:29 +00001334 SQLITE_MAX_LIKE_PATTERN_LENGTH,
1335 SQLITE_MAX_VARIABLE_NUMBER,
1336};
1337
1338/*
1339** Make sure the hard limits are set to reasonable values
1340*/
1341#if SQLITE_MAX_LENGTH<100
1342# error SQLITE_MAX_LENGTH must be at least 100
1343#endif
1344#if SQLITE_MAX_SQL_LENGTH<100
1345# error SQLITE_MAX_SQL_LENGTH must be at least 100
1346#endif
1347#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
1348# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
1349#endif
drhbb4957f2008-03-20 14:03:29 +00001350#if SQLITE_MAX_COMPOUND_SELECT<2
1351# error SQLITE_MAX_COMPOUND_SELECT must be at least 2
1352#endif
1353#if SQLITE_MAX_VDBE_OP<40
1354# error SQLITE_MAX_VDBE_OP must be at least 40
1355#endif
drh24b58dd2008-07-07 14:50:14 +00001356#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>127
1357# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
drhbb4957f2008-03-20 14:03:29 +00001358#endif
1359#if SQLITE_MAX_ATTACH<0 || SQLITE_MAX_ATTACH>30
1360# error SQLITE_MAX_ATTACH must be between 0 and 30
1361#endif
drhbb4957f2008-03-20 14:03:29 +00001362#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
1363# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
1364#endif
1365#if SQLITE_MAX_VARIABLE_NUMBER<1
1366# error SQLITE_MAX_VARIABLE_NUMBER must be at least 1
1367#endif
1368
1369
1370/*
1371** Change the value of a limit. Report the old value.
1372** If an invalid limit index is supplied, report -1.
1373** Make no changes but still report the old value if the
1374** new limit is negative.
1375**
1376** A new lower limit does not shrink existing constructs.
1377** It merely prevents new constructs that exceed the limit
1378** from forming.
1379*/
1380int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
1381 int oldLimit;
drh521cc842008-04-15 02:36:33 +00001382 if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
drhbb4957f2008-03-20 14:03:29 +00001383 return -1;
1384 }
1385 oldLimit = db->aLimit[limitId];
1386 if( newLimit>=0 ){
drhf47ce562008-03-20 18:00:49 +00001387 if( newLimit>aHardLimit[limitId] ){
drhbb4957f2008-03-20 14:03:29 +00001388 newLimit = aHardLimit[limitId];
1389 }
1390 db->aLimit[limitId] = newLimit;
1391 }
1392 return oldLimit;
1393}
1394
1395/*
danielk19774ad17132004-05-21 01:47:26 +00001396** This routine does the work of opening a database on behalf of
1397** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
drhee570fa2005-04-28 12:06:05 +00001398** is UTF-8 encoded.
danielk19774ad17132004-05-21 01:47:26 +00001399*/
1400static int openDatabase(
1401 const char *zFilename, /* Database filename UTF-8 encoded */
drh605264d2007-08-21 15:13:19 +00001402 sqlite3 **ppDb, /* OUT: Returned database handle */
1403 unsigned flags, /* Operational flags */
1404 const char *zVfs /* Name of the VFS to use */
danielk19774ad17132004-05-21 01:47:26 +00001405){
1406 sqlite3 *db;
danielk1977da184232006-01-05 11:34:32 +00001407 int rc;
drhd64fe2f2005-08-28 17:00:23 +00001408 CollSeq *pColl;
danielk19779a6284c2008-07-10 17:52:49 +00001409 int isThreadsafe = 1;
danielk19774ad17132004-05-21 01:47:26 +00001410
drh40257ff2008-06-13 18:24:27 +00001411#ifndef SQLITE_OMIT_AUTOINIT
1412 rc = sqlite3_initialize();
1413 if( rc ) return rc;
1414#endif
1415
danielk19779a6284c2008-07-10 17:52:49 +00001416 if( flags&SQLITE_OPEN_NOMUTEX ){
1417 isThreadsafe = 0;
1418 }
1419
drha4267dc2008-02-19 15:20:44 +00001420 /* Remove harmful bits from the flags parameter */
1421 flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
1422 SQLITE_OPEN_MAIN_DB |
1423 SQLITE_OPEN_TEMP_DB |
1424 SQLITE_OPEN_TRANSIENT_DB |
1425 SQLITE_OPEN_MAIN_JOURNAL |
1426 SQLITE_OPEN_TEMP_JOURNAL |
1427 SQLITE_OPEN_SUBJOURNAL |
danielk19779a6284c2008-07-10 17:52:49 +00001428 SQLITE_OPEN_MASTER_JOURNAL |
1429 SQLITE_OPEN_NOMUTEX
drha4267dc2008-02-19 15:20:44 +00001430 );
1431
danielk19774ad17132004-05-21 01:47:26 +00001432 /* Allocate the sqlite data structure */
drh17435752007-08-16 04:30:38 +00001433 db = sqlite3MallocZero( sizeof(sqlite3) );
danielk19774ad17132004-05-21 01:47:26 +00001434 if( db==0 ) goto opendb_out;
danielk19779a6284c2008-07-10 17:52:49 +00001435 if( sqlite3Config.bFullMutex && isThreadsafe ){
danielk197759f8c082008-06-18 17:09:10 +00001436 db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
1437 if( db->mutex==0 ){
1438 sqlite3_free(db);
1439 db = 0;
1440 goto opendb_out;
1441 }
drh605264d2007-08-21 15:13:19 +00001442 }
drh27641702007-08-22 02:56:42 +00001443 sqlite3_mutex_enter(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00001444 db->errMask = 0xff;
danielk19774ad17132004-05-21 01:47:26 +00001445 db->priorNewRowid = 0;
danielk19774ad17132004-05-21 01:47:26 +00001446 db->nDb = 2;
drh153c62c2007-08-24 03:51:33 +00001447 db->magic = SQLITE_MAGIC_BUSY;
danielk19774ad17132004-05-21 01:47:26 +00001448 db->aDb = db->aDbStatic;
drh633e6d52008-07-28 19:34:53 +00001449
drhbb4957f2008-03-20 14:03:29 +00001450 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
1451 memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
danielk19771d850a72004-05-31 08:26:49 +00001452 db->autoCommit = 1;
drhddac25c2007-12-05 01:38:23 +00001453 db->nextAutovac = -1;
danielk1977f653d782008-03-20 11:04:21 +00001454 db->nextPagesize = 0;
drh76fe8032006-07-11 14:17:51 +00001455 db->flags |= SQLITE_ShortColNames
1456#if SQLITE_DEFAULT_FILE_FORMAT<4
1457 | SQLITE_LegacyFileFmt
1458#endif
drh56424db2007-03-27 22:24:11 +00001459#ifdef SQLITE_ENABLE_LOAD_EXTENSION
1460 | SQLITE_LoadExtension
1461#endif
drh76fe8032006-07-11 14:17:51 +00001462 ;
drhf9b596e2004-05-26 16:54:42 +00001463 sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0);
danielk19774ad17132004-05-21 01:47:26 +00001464 sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
drhb9bb7c12006-06-11 23:41:55 +00001465#ifndef SQLITE_OMIT_VIRTUALTABLE
1466 sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
1467#endif
danielk1977da184232006-01-05 11:34:32 +00001468
danielk197795c8a542007-09-01 06:51:27 +00001469 db->pVfs = sqlite3_vfs_find(zVfs);
1470 if( !db->pVfs ){
1471 rc = SQLITE_ERROR;
drh7e8b8482008-01-23 03:03:05 +00001472 db->magic = SQLITE_MAGIC_SICK;
drhafc91042008-02-21 02:09:45 +00001473 sqlite3Error(db, rc, "no such vfs: %s", zVfs);
danielk197795c8a542007-09-01 06:51:27 +00001474 goto opendb_out;
1475 }
1476
danielk19770202b292004-06-09 09:55:16 +00001477 /* Add the default collation sequence BINARY. BINARY works for both UTF-8
1478 ** and UTF-16, so add a version for each to avoid any unnecessary
1479 ** conversions. The only error that can occur here is a malloc() failure.
1480 */
drhafc91042008-02-21 02:09:45 +00001481 createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
1482 createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
1483 createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
1484 createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
drh77db4c02008-03-18 13:01:38 +00001485 if( db->mallocFailed ){
drh7e8b8482008-01-23 03:03:05 +00001486 db->magic = SQLITE_MAGIC_SICK;
danielk19770202b292004-06-09 09:55:16 +00001487 goto opendb_out;
1488 }
drh77db4c02008-03-18 13:01:38 +00001489 db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
1490 assert( db->pDfltColl!=0 );
danielk19770202b292004-06-09 09:55:16 +00001491
1492 /* Also add a UTF-8 case-insensitive collation sequence. */
danielk1977a9808b32007-05-07 09:32:45 +00001493 createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
danielk19770202b292004-06-09 09:55:16 +00001494
drhd64fe2f2005-08-28 17:00:23 +00001495 /* Set flags on the built-in collating sequences */
1496 db->pDfltColl->type = SQLITE_COLL_BINARY;
1497 pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
1498 if( pColl ){
1499 pColl->type = SQLITE_COLL_NOCASE;
1500 }
1501
danielk19774ad17132004-05-21 01:47:26 +00001502 /* Open the backend database driver */
drh33f4e022007-09-03 15:19:34 +00001503 db->openFlags = flags;
1504 rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE,
1505 flags | SQLITE_OPEN_MAIN_DB,
drhc797d4d2007-05-08 01:08:49 +00001506 &db->aDb[0].pBt);
danielk19774ad17132004-05-21 01:47:26 +00001507 if( rc!=SQLITE_OK ){
danielk19774ad17132004-05-21 01:47:26 +00001508 sqlite3Error(db, rc, 0);
drh7e8b8482008-01-23 03:03:05 +00001509 db->magic = SQLITE_MAGIC_SICK;
danielk19774ad17132004-05-21 01:47:26 +00001510 goto opendb_out;
1511 }
drh17435752007-08-16 04:30:38 +00001512 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
1513 db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
danielk197714db2662006-01-09 16:12:04 +00001514
drh03b808a2006-03-13 15:06:05 +00001515
danielk197753c0f742005-03-29 03:10:59 +00001516 /* The default safety_level for the main database is 'full'; for the temp
1517 ** database it is 'NONE'. This matches the pager layer defaults.
1518 */
1519 db->aDb[0].zName = "main";
danielk197791cf71b2004-06-26 06:37:06 +00001520 db->aDb[0].safety_level = 3;
danielk197753c0f742005-03-29 03:10:59 +00001521#ifndef SQLITE_OMIT_TEMPDB
1522 db->aDb[1].zName = "temp";
danielk197791cf71b2004-06-26 06:37:06 +00001523 db->aDb[1].safety_level = 1;
danielk197753c0f742005-03-29 03:10:59 +00001524#endif
1525
danielk1977832a58a2007-06-22 15:21:15 +00001526 db->magic = SQLITE_MAGIC_OPEN;
drh17435752007-08-16 04:30:38 +00001527 if( db->mallocFailed ){
danielk1977832a58a2007-06-22 15:21:15 +00001528 goto opendb_out;
1529 }
1530
danielk19778e227872004-06-07 07:52:17 +00001531 /* Register all built-in functions, but do not attempt to read the
1532 ** database schema yet. This is delayed until the first time the database
1533 ** is accessed.
1534 */
danielk1977832a58a2007-06-22 15:21:15 +00001535 sqlite3Error(db, SQLITE_OK, 0);
1536 sqlite3RegisterBuiltinFunctions(db);
danielk19774ad17132004-05-21 01:47:26 +00001537
drh1409be62006-08-23 20:07:20 +00001538 /* Load automatic extensions - extensions that have been registered
1539 ** using the sqlite3_automatic_extension() API.
1540 */
drhf533acc2006-12-19 18:57:11 +00001541 (void)sqlite3AutoLoadExtensions(db);
danielk1977832a58a2007-06-22 15:21:15 +00001542 if( sqlite3_errcode(db)!=SQLITE_OK ){
1543 goto opendb_out;
1544 }
drh1409be62006-08-23 20:07:20 +00001545
drhaa29c132006-09-02 13:58:06 +00001546#ifdef SQLITE_ENABLE_FTS1
drh17435752007-08-16 04:30:38 +00001547 if( !db->mallocFailed ){
drhaa29c132006-09-02 13:58:06 +00001548 extern int sqlite3Fts1Init(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00001549 rc = sqlite3Fts1Init(db);
drhaa29c132006-09-02 13:58:06 +00001550 }
1551#endif
1552
shessa26cf572006-10-19 20:27:58 +00001553#ifdef SQLITE_ENABLE_FTS2
drh17435752007-08-16 04:30:38 +00001554 if( !db->mallocFailed && rc==SQLITE_OK ){
shessa26cf572006-10-19 20:27:58 +00001555 extern int sqlite3Fts2Init(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00001556 rc = sqlite3Fts2Init(db);
shessa26cf572006-10-19 20:27:58 +00001557 }
1558#endif
1559
shess69c4ae22007-08-20 17:37:47 +00001560#ifdef SQLITE_ENABLE_FTS3
1561 if( !db->mallocFailed && rc==SQLITE_OK ){
shess69c4ae22007-08-20 17:37:47 +00001562 rc = sqlite3Fts3Init(db);
1563 }
1564#endif
1565
danielk197783852ac2007-05-06 16:04:11 +00001566#ifdef SQLITE_ENABLE_ICU
drh17435752007-08-16 04:30:38 +00001567 if( !db->mallocFailed && rc==SQLITE_OK ){
danielk197783852ac2007-05-06 16:04:11 +00001568 extern int sqlite3IcuInit(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00001569 rc = sqlite3IcuInit(db);
danielk197783852ac2007-05-06 16:04:11 +00001570 }
1571#endif
danielk1977ebaecc12008-05-26 18:41:54 +00001572
1573#ifdef SQLITE_ENABLE_RTREE
1574 if( !db->mallocFailed && rc==SQLITE_OK){
danielk1977ebaecc12008-05-26 18:41:54 +00001575 rc = sqlite3RtreeInit(db);
1576 }
1577#endif
1578
danielk1977832a58a2007-06-22 15:21:15 +00001579 sqlite3Error(db, rc, 0);
danielk197783852ac2007-05-06 16:04:11 +00001580
drh8fd5bd32007-04-02 16:40:37 +00001581 /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
1582 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
1583 ** mode. Doing nothing at all also makes NORMAL the default.
1584 */
1585#ifdef SQLITE_DEFAULT_LOCKING_MODE
1586 db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
1587 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
1588 SQLITE_DEFAULT_LOCKING_MODE);
1589#endif
1590
drh633e6d52008-07-28 19:34:53 +00001591 /* Enable the lookaside-malloc subsystem */
drhe9d1c722008-08-04 20:13:26 +00001592 setupLookaside(db, 0, sqlite3Config.szLookaside, sqlite3Config.nLookaside);
drh633e6d52008-07-28 19:34:53 +00001593
danielk19774ad17132004-05-21 01:47:26 +00001594opendb_out:
drhafc91042008-02-21 02:09:45 +00001595 if( db ){
danielk19779a6284c2008-07-10 17:52:49 +00001596 assert( db->mutex!=0 || isThreadsafe==0 || sqlite3Config.bFullMutex==0 );
drhf3a65f72007-08-22 20:18:21 +00001597 sqlite3_mutex_leave(db->mutex);
1598 }
danielk19777ddad962005-12-12 06:53:03 +00001599 if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){
1600 sqlite3_close(db);
1601 db = 0;
danielk197713073932004-06-30 11:54:06 +00001602 }
danielk19774ad17132004-05-21 01:47:26 +00001603 *ppDb = db;
danielk197754f01982006-01-18 15:25:17 +00001604 return sqlite3ApiExit(0, rc);
danielk19774ad17132004-05-21 01:47:26 +00001605}
1606
1607/*
1608** Open a new database handle.
1609*/
danielk197780290862004-05-22 09:21:21 +00001610int sqlite3_open(
danielk19774ad17132004-05-21 01:47:26 +00001611 const char *zFilename,
danielk19774f057f92004-06-08 00:02:33 +00001612 sqlite3 **ppDb
danielk19774ad17132004-05-21 01:47:26 +00001613){
drh605264d2007-08-21 15:13:19 +00001614 return openDatabase(zFilename, ppDb,
1615 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
1616}
1617int sqlite3_open_v2(
drh428e2822007-08-30 16:23:19 +00001618 const char *filename, /* Database filename (UTF-8) */
drh605264d2007-08-21 15:13:19 +00001619 sqlite3 **ppDb, /* OUT: SQLite db handle */
1620 int flags, /* Flags */
1621 const char *zVfs /* Name of VFS module to use */
1622){
1623 return openDatabase(filename, ppDb, flags, zVfs);
danielk197783ab5a82004-05-21 11:39:05 +00001624}
1625
drh6c626082004-11-14 21:56:29 +00001626#ifndef SQLITE_OMIT_UTF16
danielk19774ad17132004-05-21 01:47:26 +00001627/*
1628** Open a new database handle.
1629*/
1630int sqlite3_open16(
1631 const void *zFilename,
danielk19774f057f92004-06-08 00:02:33 +00001632 sqlite3 **ppDb
danielk19774ad17132004-05-21 01:47:26 +00001633){
danielk1977bfd6cce2004-06-18 04:24:54 +00001634 char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
danielk1977bfd6cce2004-06-18 04:24:54 +00001635 sqlite3_value *pVal;
drh40257ff2008-06-13 18:24:27 +00001636 int rc;
danielk19774ad17132004-05-21 01:47:26 +00001637
danielk19777ddad962005-12-12 06:53:03 +00001638 assert( zFilename );
danielk19774ad17132004-05-21 01:47:26 +00001639 assert( ppDb );
danielk1977bfd6cce2004-06-18 04:24:54 +00001640 *ppDb = 0;
drh40257ff2008-06-13 18:24:27 +00001641#ifndef SQLITE_OMIT_AUTOINIT
1642 rc = sqlite3_initialize();
1643 if( rc ) return rc;
1644#endif
danielk19771e536952007-08-16 10:09:01 +00001645 pVal = sqlite3ValueNew(0);
drhb21c8cd2007-08-21 19:33:56 +00001646 sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
1647 zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
danielk1977bfd6cce2004-06-18 04:24:54 +00001648 if( zFilename8 ){
drh605264d2007-08-21 15:13:19 +00001649 rc = openDatabase(zFilename8, ppDb,
1650 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
drhafc91042008-02-21 02:09:45 +00001651 assert( *ppDb || rc==SQLITE_NOMEM );
danielk1977f51bf482008-04-28 16:19:35 +00001652 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
danielk1977fb103a82008-04-03 16:28:24 +00001653 ENC(*ppDb) = SQLITE_UTF16NATIVE;
danielk1977bfd6cce2004-06-18 04:24:54 +00001654 }
drh40257ff2008-06-13 18:24:27 +00001655 }else{
1656 rc = SQLITE_NOMEM;
danielk19774ad17132004-05-21 01:47:26 +00001657 }
danielk19777ddad962005-12-12 06:53:03 +00001658 sqlite3ValueFree(pVal);
danielk19778e227872004-06-07 07:52:17 +00001659
danielk197754f01982006-01-18 15:25:17 +00001660 return sqlite3ApiExit(0, rc);
danielk19774ad17132004-05-21 01:47:26 +00001661}
drh6c626082004-11-14 21:56:29 +00001662#endif /* SQLITE_OMIT_UTF16 */
danielk19774ad17132004-05-21 01:47:26 +00001663
danielk1977106bb232004-05-21 10:08:53 +00001664/*
danielk1977d8123362004-06-12 09:25:12 +00001665** Register a new collation sequence with the database handle db.
1666*/
danielk19770202b292004-06-09 09:55:16 +00001667int sqlite3_create_collation(
1668 sqlite3* db,
1669 const char *zName,
danielk1977466be562004-06-10 02:16:01 +00001670 int enc,
danielk19770202b292004-06-09 09:55:16 +00001671 void* pCtx,
1672 int(*xCompare)(void*,int,const void*,int,const void*)
1673){
danielk19779a30cf62006-01-18 04:26:07 +00001674 int rc;
drhe30f4422007-08-21 16:15:55 +00001675 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00001676 assert( !db->mallocFailed );
danielk1977a9808b32007-05-07 09:32:45 +00001677 rc = createCollation(db, zName, enc, pCtx, xCompare, 0);
drhe30f4422007-08-21 16:15:55 +00001678 rc = sqlite3ApiExit(db, rc);
1679 sqlite3_mutex_leave(db->mutex);
1680 return rc;
danielk1977a9808b32007-05-07 09:32:45 +00001681}
1682
1683/*
1684** Register a new collation sequence with the database handle db.
1685*/
danielk1977a393c032007-05-07 14:58:53 +00001686int sqlite3_create_collation_v2(
danielk1977a9808b32007-05-07 09:32:45 +00001687 sqlite3* db,
1688 const char *zName,
1689 int enc,
1690 void* pCtx,
1691 int(*xCompare)(void*,int,const void*,int,const void*),
1692 void(*xDel)(void*)
1693){
1694 int rc;
drhe30f4422007-08-21 16:15:55 +00001695 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00001696 assert( !db->mallocFailed );
danielk1977a9808b32007-05-07 09:32:45 +00001697 rc = createCollation(db, zName, enc, pCtx, xCompare, xDel);
drhe30f4422007-08-21 16:15:55 +00001698 rc = sqlite3ApiExit(db, rc);
1699 sqlite3_mutex_leave(db->mutex);
1700 return rc;
danielk19770202b292004-06-09 09:55:16 +00001701}
1702
drh6c626082004-11-14 21:56:29 +00001703#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +00001704/*
1705** Register a new collation sequence with the database handle db.
1706*/
danielk19770202b292004-06-09 09:55:16 +00001707int sqlite3_create_collation16(
1708 sqlite3* db,
mihailimbda2e622008-06-23 11:23:14 +00001709 const void *zName,
danielk1977466be562004-06-10 02:16:01 +00001710 int enc,
danielk19770202b292004-06-09 09:55:16 +00001711 void* pCtx,
1712 int(*xCompare)(void*,int,const void*,int,const void*)
1713){
danielk19779a30cf62006-01-18 04:26:07 +00001714 int rc = SQLITE_OK;
drh01495b92008-01-23 12:52:40 +00001715 char *zName8;
drhe30f4422007-08-21 16:15:55 +00001716 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00001717 assert( !db->mallocFailed );
danielk19771e536952007-08-16 10:09:01 +00001718 zName8 = sqlite3Utf16to8(db, zName, -1);
danielk19779a30cf62006-01-18 04:26:07 +00001719 if( zName8 ){
danielk1977a9808b32007-05-07 09:32:45 +00001720 rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
drh633e6d52008-07-28 19:34:53 +00001721 sqlite3DbFree(db, zName8);
danielk19779a30cf62006-01-18 04:26:07 +00001722 }
drhe30f4422007-08-21 16:15:55 +00001723 rc = sqlite3ApiExit(db, rc);
1724 sqlite3_mutex_leave(db->mutex);
1725 return rc;
danielk19770202b292004-06-09 09:55:16 +00001726}
drh6c626082004-11-14 21:56:29 +00001727#endif /* SQLITE_OMIT_UTF16 */
danielk19777cedc8d2004-06-10 10:50:08 +00001728
danielk1977d8123362004-06-12 09:25:12 +00001729/*
1730** Register a collation sequence factory callback with the database handle
1731** db. Replace any previously installed collation sequence factory.
1732*/
danielk19777cedc8d2004-06-10 10:50:08 +00001733int sqlite3_collation_needed(
1734 sqlite3 *db,
1735 void *pCollNeededArg,
1736 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
1737){
drhe30f4422007-08-21 16:15:55 +00001738 sqlite3_mutex_enter(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001739 db->xCollNeeded = xCollNeeded;
1740 db->xCollNeeded16 = 0;
1741 db->pCollNeededArg = pCollNeededArg;
drhe30f4422007-08-21 16:15:55 +00001742 sqlite3_mutex_leave(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001743 return SQLITE_OK;
1744}
danielk1977d8123362004-06-12 09:25:12 +00001745
drh6c626082004-11-14 21:56:29 +00001746#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +00001747/*
1748** Register a collation sequence factory callback with the database handle
1749** db. Replace any previously installed collation sequence factory.
1750*/
danielk19777cedc8d2004-06-10 10:50:08 +00001751int sqlite3_collation_needed16(
1752 sqlite3 *db,
1753 void *pCollNeededArg,
1754 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
1755){
drhe30f4422007-08-21 16:15:55 +00001756 sqlite3_mutex_enter(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001757 db->xCollNeeded = 0;
1758 db->xCollNeeded16 = xCollNeeded16;
1759 db->pCollNeededArg = pCollNeededArg;
drhe30f4422007-08-21 16:15:55 +00001760 sqlite3_mutex_leave(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001761 return SQLITE_OK;
1762}
drh6c626082004-11-14 21:56:29 +00001763#endif /* SQLITE_OMIT_UTF16 */
danielk19776b456a22005-03-21 04:04:02 +00001764
1765#ifndef SQLITE_OMIT_GLOBALRECOVER
1766/*
danielk19777ddad962005-12-12 06:53:03 +00001767** This function is now an anachronism. It used to be used to recover from a
1768** malloc() failure, but SQLite now does this automatically.
danielk19776b456a22005-03-21 04:04:02 +00001769*/
drh7d97efb2007-10-12 19:35:48 +00001770int sqlite3_global_recover(void){
danielk1977261919c2005-12-06 12:52:59 +00001771 return SQLITE_OK;
danielk19776b456a22005-03-21 04:04:02 +00001772}
1773#endif
drh3e1d8e62005-05-26 16:23:34 +00001774
1775/*
1776** Test to see whether or not the database connection is in autocommit
1777** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
1778** by default. Autocommit is disabled by a BEGIN statement and reenabled
1779** by the next COMMIT or ROLLBACK.
1780**
1781******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
1782*/
1783int sqlite3_get_autocommit(sqlite3 *db){
1784 return db->autoCommit;
1785}
drh49285702005-09-17 15:20:26 +00001786
1787#ifdef SQLITE_DEBUG
1788/*
1789** The following routine is subtituted for constant SQLITE_CORRUPT in
1790** debugging builds. This provides a way to set a breakpoint for when
1791** corruption is first detected.
1792*/
1793int sqlite3Corrupt(void){
1794 return SQLITE_CORRUPT;
1795}
1796#endif
drh7c1817e2006-01-10 13:58:48 +00001797
drh6f7adc82006-01-11 21:41:20 +00001798/*
1799** This is a convenience routine that makes sure that all thread-specific
1800** data for this thread has been deallocated.
drhdce8bdb2007-08-16 13:01:44 +00001801**
1802** SQLite no longer uses thread-specific data so this routine is now a
1803** no-op. It is retained for historical compatibility.
drh6f7adc82006-01-11 21:41:20 +00001804*/
1805void sqlite3_thread_cleanup(void){
drh6f7adc82006-01-11 21:41:20 +00001806}
danielk1977deb802c2006-02-09 13:43:28 +00001807
1808/*
1809** Return meta information about a specific column of a database table.
1810** See comment in sqlite3.h (sqlite.h.in) for details.
1811*/
1812#ifdef SQLITE_ENABLE_COLUMN_METADATA
1813int sqlite3_table_column_metadata(
1814 sqlite3 *db, /* Connection handle */
1815 const char *zDbName, /* Database name or NULL */
1816 const char *zTableName, /* Table name */
1817 const char *zColumnName, /* Column name */
1818 char const **pzDataType, /* OUTPUT: Declared data type */
1819 char const **pzCollSeq, /* OUTPUT: Collation sequence name */
1820 int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
1821 int *pPrimaryKey, /* OUTPUT: True if column part of PK */
drh9be07162008-06-16 20:51:15 +00001822 int *pAutoinc /* OUTPUT: True if column is auto-increment */
danielk1977deb802c2006-02-09 13:43:28 +00001823){
1824 int rc;
1825 char *zErrMsg = 0;
1826 Table *pTab = 0;
1827 Column *pCol = 0;
1828 int iCol;
1829
1830 char const *zDataType = 0;
1831 char const *zCollSeq = 0;
1832 int notnull = 0;
1833 int primarykey = 0;
1834 int autoinc = 0;
1835
1836 /* Ensure the database schema has been loaded */
drhe30f4422007-08-21 16:15:55 +00001837 sqlite3_mutex_enter(db->mutex);
drha0af99f2008-04-16 00:49:12 +00001838 (void)sqlite3SafetyOn(db);
drh3cb3edc2008-03-07 21:37:19 +00001839 sqlite3BtreeEnterAll(db);
danielk1977deb802c2006-02-09 13:43:28 +00001840 rc = sqlite3Init(db, &zErrMsg);
drh3cb3edc2008-03-07 21:37:19 +00001841 sqlite3BtreeLeaveAll(db);
danielk1977deb802c2006-02-09 13:43:28 +00001842 if( SQLITE_OK!=rc ){
1843 goto error_out;
1844 }
1845
1846 /* Locate the table in question */
1847 pTab = sqlite3FindTable(db, zTableName, zDbName);
1848 if( !pTab || pTab->pSelect ){
1849 pTab = 0;
1850 goto error_out;
1851 }
1852
1853 /* Find the column for which info is requested */
1854 if( sqlite3IsRowid(zColumnName) ){
1855 iCol = pTab->iPKey;
1856 if( iCol>=0 ){
1857 pCol = &pTab->aCol[iCol];
1858 }
1859 }else{
1860 for(iCol=0; iCol<pTab->nCol; iCol++){
1861 pCol = &pTab->aCol[iCol];
1862 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
1863 break;
1864 }
1865 }
1866 if( iCol==pTab->nCol ){
1867 pTab = 0;
1868 goto error_out;
1869 }
1870 }
1871
1872 /* The following block stores the meta information that will be returned
1873 ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
1874 ** and autoinc. At this point there are two possibilities:
1875 **
1876 ** 1. The specified column name was rowid", "oid" or "_rowid_"
1877 ** and there is no explicitly declared IPK column.
1878 **
1879 ** 2. The table is not a view and the column name identified an
1880 ** explicitly declared column. Copy meta information from *pCol.
1881 */
1882 if( pCol ){
1883 zDataType = pCol->zType;
1884 zCollSeq = pCol->zColl;
drh9be07162008-06-16 20:51:15 +00001885 notnull = pCol->notNull!=0;
1886 primarykey = pCol->isPrimKey!=0;
1887 autoinc = pTab->iPKey==iCol && pTab->autoInc;
danielk1977deb802c2006-02-09 13:43:28 +00001888 }else{
1889 zDataType = "INTEGER";
1890 primarykey = 1;
1891 }
1892 if( !zCollSeq ){
1893 zCollSeq = "BINARY";
1894 }
1895
1896error_out:
drh01495b92008-01-23 12:52:40 +00001897 (void)sqlite3SafetyOff(db);
danielk1977deb802c2006-02-09 13:43:28 +00001898
1899 /* Whether the function call succeeded or failed, set the output parameters
1900 ** to whatever their local counterparts contain. If an error did occur,
1901 ** this has the effect of zeroing all output parameters.
1902 */
1903 if( pzDataType ) *pzDataType = zDataType;
1904 if( pzCollSeq ) *pzCollSeq = zCollSeq;
1905 if( pNotNull ) *pNotNull = notnull;
1906 if( pPrimaryKey ) *pPrimaryKey = primarykey;
1907 if( pAutoinc ) *pAutoinc = autoinc;
1908
1909 if( SQLITE_OK==rc && !pTab ){
drh633e6d52008-07-28 19:34:53 +00001910 sqlite3DbFree(db, zErrMsg);
drh118640b2008-07-16 14:02:32 +00001911 zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
drhf089aa42008-07-08 19:34:06 +00001912 zColumnName);
danielk1977deb802c2006-02-09 13:43:28 +00001913 rc = SQLITE_ERROR;
1914 }
1915 sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
drh633e6d52008-07-28 19:34:53 +00001916 sqlite3DbFree(db, zErrMsg);
drhe30f4422007-08-21 16:15:55 +00001917 rc = sqlite3ApiExit(db, rc);
1918 sqlite3_mutex_leave(db->mutex);
drhf9cb7f52006-06-27 20:06:44 +00001919 return rc;
1920}
drhe30f4422007-08-21 16:15:55 +00001921#endif
drhf9cb7f52006-06-27 20:06:44 +00001922
1923/*
1924** Sleep for a little while. Return the amount of time slept.
1925*/
1926int sqlite3_sleep(int ms){
danielk1977b4b47412007-08-17 15:53:36 +00001927 sqlite3_vfs *pVfs;
drhe30f4422007-08-21 16:15:55 +00001928 int rc;
drhd677b3d2007-08-20 22:48:41 +00001929 pVfs = sqlite3_vfs_find(0);
drh40257ff2008-06-13 18:24:27 +00001930 if( pVfs==0 ) return 0;
danielk1977fee2d252007-08-18 10:59:19 +00001931
1932 /* This function works in milliseconds, but the underlying OsSleep()
1933 ** API uses microseconds. Hence the 1000's.
1934 */
drhe30f4422007-08-21 16:15:55 +00001935 rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
drhe30f4422007-08-21 16:15:55 +00001936 return rc;
drhf9cb7f52006-06-27 20:06:44 +00001937}
drh4ac285a2006-09-15 07:28:50 +00001938
1939/*
1940** Enable or disable the extended result codes.
1941*/
1942int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
drhe30f4422007-08-21 16:15:55 +00001943 sqlite3_mutex_enter(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00001944 db->errMask = onoff ? 0xffffffff : 0xff;
drhe30f4422007-08-21 16:15:55 +00001945 sqlite3_mutex_leave(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00001946 return SQLITE_OK;
1947}
drhcc6bb3e2007-08-31 16:11:35 +00001948
1949/*
1950** Invoke the xFileControl method on a particular database.
1951*/
1952int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
1953 int rc = SQLITE_ERROR;
1954 int iDb;
1955 sqlite3_mutex_enter(db->mutex);
1956 if( zDbName==0 ){
1957 iDb = 0;
1958 }else{
1959 for(iDb=0; iDb<db->nDb; iDb++){
1960 if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
1961 }
1962 }
1963 if( iDb<db->nDb ){
1964 Btree *pBtree = db->aDb[iDb].pBt;
1965 if( pBtree ){
1966 Pager *pPager;
drh55176252008-01-22 14:50:16 +00001967 sqlite3_file *fd;
drhcc6bb3e2007-08-31 16:11:35 +00001968 sqlite3BtreeEnter(pBtree);
1969 pPager = sqlite3BtreePager(pBtree);
drh55176252008-01-22 14:50:16 +00001970 assert( pPager!=0 );
1971 fd = sqlite3PagerFile(pPager);
1972 assert( fd!=0 );
1973 if( fd->pMethods ){
1974 rc = sqlite3OsFileControl(fd, op, pArg);
drhcc6bb3e2007-08-31 16:11:35 +00001975 }
1976 sqlite3BtreeLeave(pBtree);
1977 }
1978 }
1979 sqlite3_mutex_leave(db->mutex);
1980 return rc;
1981}
drhed13d982008-01-31 14:43:24 +00001982
1983/*
1984** Interface to the testing logic.
1985*/
1986int sqlite3_test_control(int op, ...){
drhed13d982008-01-31 14:43:24 +00001987 int rc = 0;
drh3088d592008-03-21 16:45:47 +00001988#ifndef SQLITE_OMIT_BUILTIN_TEST
drh2fa18682008-03-19 14:15:34 +00001989 va_list ap;
drhed13d982008-01-31 14:43:24 +00001990 va_start(ap, op);
1991 switch( op ){
danielk1977d09414c2008-06-19 18:17:49 +00001992
1993 /*
drh984bfaa2008-03-19 16:08:53 +00001994 ** Save the current state of the PRNG.
1995 */
drh2fa18682008-03-19 14:15:34 +00001996 case SQLITE_TESTCTRL_PRNG_SAVE: {
1997 sqlite3PrngSaveState();
1998 break;
1999 }
drh984bfaa2008-03-19 16:08:53 +00002000
2001 /*
2002 ** Restore the state of the PRNG to the last state saved using
2003 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
2004 ** this verb acts like PRNG_RESET.
2005 */
drh2fa18682008-03-19 14:15:34 +00002006 case SQLITE_TESTCTRL_PRNG_RESTORE: {
2007 sqlite3PrngRestoreState();
2008 break;
2009 }
drh984bfaa2008-03-19 16:08:53 +00002010
2011 /*
2012 ** Reset the PRNG back to its uninitialized state. The next call
2013 ** to sqlite3_randomness() will reseed the PRNG using a single call
2014 ** to the xRandomness method of the default VFS.
2015 */
drh2fa18682008-03-19 14:15:34 +00002016 case SQLITE_TESTCTRL_PRNG_RESET: {
2017 sqlite3PrngResetState();
2018 break;
2019 }
drh3088d592008-03-21 16:45:47 +00002020
2021 /*
2022 ** sqlite3_test_control(BITVEC_TEST, size, program)
2023 **
2024 ** Run a test against a Bitvec object of size. The program argument
2025 ** is an array of integers that defines the test. Return -1 on a
2026 ** memory allocation error, 0 on success, or non-zero for an error.
2027 ** See the sqlite3BitvecBuiltinTest() for additional information.
2028 */
2029 case SQLITE_TESTCTRL_BITVEC_TEST: {
2030 int sz = va_arg(ap, int);
2031 int *aProg = va_arg(ap, int*);
2032 rc = sqlite3BitvecBuiltinTest(sz, aProg);
2033 break;
2034 }
danielk19772d1d86f2008-06-20 14:59:51 +00002035
2036 /*
2037 ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
2038 **
2039 ** Register hooks to call to indicate which malloc() failures
2040 ** are benign.
2041 */
2042 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
danielk1977ca026792008-06-23 14:15:52 +00002043 typedef void (*void_function)(void);
2044 void_function xBenignBegin;
2045 void_function xBenignEnd;
2046 xBenignBegin = va_arg(ap, void_function);
2047 xBenignEnd = va_arg(ap, void_function);
danielk19772d1d86f2008-06-20 14:59:51 +00002048 sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
2049 break;
2050 }
drhed13d982008-01-31 14:43:24 +00002051 }
2052 va_end(ap);
drh3088d592008-03-21 16:45:47 +00002053#endif /* SQLITE_OMIT_BUILTIN_TEST */
danielk19777c36d072008-01-31 15:31:01 +00002054 return rc;
drhed13d982008-01-31 14:43:24 +00002055}