blob: a8aba7ed0b4e05ea696812de746037942679c726 [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**
danielk197759633ae2008-08-27 19:01:57 +000017** $Id: main.c,v 1.494 2008/08/27 19:01:58 danielk1977 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;
drh777c5382008-08-21 20:21:34 +0000150 memset(&sqlite3GlobalFunctions, 0, sizeof(sqlite3GlobalFunctions));
drh70a8ca32008-08-21 18:49:27 +0000151 sqlite3RegisterGlobalFunctions();
danielk197771bc31c2008-06-26 08:29:34 +0000152 rc = sqlite3_os_init();
danielk19778c0a7912008-08-20 14:49:23 +0000153 if( rc==SQLITE_OK ){
154 rc = sqlite3PcacheInitialize();
155 sqlite3PCacheBufferSetup(sqlite3Config.pPage, sqlite3Config.szPage,
156 sqlite3Config.nPage);
157 }
danielk197771bc31c2008-06-26 08:29:34 +0000158 inProgress = 0;
159 sqlite3Config.isInit = (rc==SQLITE_OK ? 1 : 0);
drh40257ff2008-06-13 18:24:27 +0000160 }
drh93ed56d2008-08-12 15:21:11 +0000161 sqlite3_mutex_leave(sqlite3Config.pInitMutex);
shanedfb7b372008-07-22 05:13:30 +0000162
drh93ed56d2008-08-12 15:21:11 +0000163 /* Go back under the static mutex and clean up the recursive
164 ** mutex to prevent a resource leak.
165 */
166 sqlite3_mutex_enter(pMaster);
167 sqlite3Config.nRefInitMutex--;
168 if( sqlite3Config.nRefInitMutex<=0 ){
169 assert( sqlite3Config.nRefInitMutex==0 );
170 sqlite3_mutex_free(sqlite3Config.pInitMutex);
171 sqlite3Config.pInitMutex = 0;
172 }
173 sqlite3_mutex_leave(pMaster);
174
175 /* The following is just a sanity check to make sure SQLite has
176 ** been compiled correctly. It is important to run this code, but
177 ** we don't want to run it too often and soak up CPU cycles for no
178 ** reason. So we run it once during initialization.
179 */
shanedfb7b372008-07-22 05:13:30 +0000180#ifndef NDEBUG
181 /* This section of code's only "output" is via assert() statements. */
182 if ( rc==SQLITE_OK ){
183 u64 x = (((u64)1)<<63)-1;
184 double y;
185 assert(sizeof(x)==8);
186 assert(sizeof(x)==sizeof(y));
187 memcpy(&y, &x, 8);
188 assert( sqlite3IsNaN(y) );
189 }
190#endif
191
drh40257ff2008-06-13 18:24:27 +0000192 return rc;
193}
194
195/*
196** Undo the effects of sqlite3_initialize(). Must not be called while
197** there are outstanding database connections or memory allocations or
198** while any part of SQLite is otherwise in use in any thread. This
199** routine is not threadsafe. Not by a long shot.
200*/
201int sqlite3_shutdown(void){
danielk197771bc31c2008-06-26 08:29:34 +0000202 sqlite3Config.isMallocInit = 0;
danielk19778c0a7912008-08-20 14:49:23 +0000203 sqlite3PcacheShutdown();
danielk1977fb437272008-07-08 12:02:35 +0000204 if( sqlite3Config.isInit ){
205 sqlite3_os_end();
206 }
207 if( sqlite3Config.m.xShutdown ){
208 sqlite3MallocEnd();
209 }
210 if( sqlite3Config.mutex.xMutexEnd ){
211 sqlite3MutexEnd();
212 }
danielk1977c0fa4c52008-06-25 17:19:00 +0000213 sqlite3Config.isInit = 0;
drh40257ff2008-06-13 18:24:27 +0000214 return SQLITE_OK;
215}
216
217/*
218** This API allows applications to modify the global configuration of
219** the SQLite library at run-time.
220**
221** This routine should only be called when there are no outstanding
222** database connections or memory allocations. This routine is not
223** threadsafe. Failure to heed these warnings can lead to unpredictable
224** behavior.
225*/
226int sqlite3_config(int op, ...){
227 va_list ap;
228 int rc = SQLITE_OK;
229
230 /* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while
231 ** the SQLite library is in use. */
danielk197771bc31c2008-06-26 08:29:34 +0000232 if( sqlite3Config.isInit ) return SQLITE_MISUSE;
drh40257ff2008-06-13 18:24:27 +0000233
234 va_start(ap, op);
235 switch( op ){
236 case SQLITE_CONFIG_SINGLETHREAD: {
237 /* Disable all mutexing */
238 sqlite3Config.bCoreMutex = 0;
239 sqlite3Config.bFullMutex = 0;
240 break;
241 }
242 case SQLITE_CONFIG_MULTITHREAD: {
243 /* Disable mutexing of database connections */
244 /* Enable mutexing of core data structures */
245 sqlite3Config.bCoreMutex = 1;
246 sqlite3Config.bFullMutex = 0;
247 break;
248 }
249 case SQLITE_CONFIG_SERIALIZED: {
250 /* Enable all mutexing */
251 sqlite3Config.bCoreMutex = 1;
252 sqlite3Config.bFullMutex = 1;
253 break;
254 }
255 case SQLITE_CONFIG_MALLOC: {
256 /* Specify an alternative malloc implementation */
drhfec00ea2008-06-14 16:56:21 +0000257 sqlite3Config.m = *va_arg(ap, sqlite3_mem_methods*);
drh40257ff2008-06-13 18:24:27 +0000258 break;
259 }
drh33589792008-06-18 13:27:46 +0000260 case SQLITE_CONFIG_GETMALLOC: {
danielk197757e5ea92008-06-24 19:02:55 +0000261 /* Retrieve the current malloc() implementation */
drh33589792008-06-18 13:27:46 +0000262 if( sqlite3Config.m.xMalloc==0 ) sqlite3MemSetDefault();
263 *va_arg(ap, sqlite3_mem_methods*) = sqlite3Config.m;
264 break;
265 }
danielk1977b2e36222008-06-17 18:57:49 +0000266 case SQLITE_CONFIG_MUTEX: {
267 /* Specify an alternative mutex implementation */
268 sqlite3Config.mutex = *va_arg(ap, sqlite3_mutex_methods*);
269 break;
270 }
danielk19771a9ed0b2008-06-18 09:45:56 +0000271 case SQLITE_CONFIG_GETMUTEX: {
272 /* Retrieve the current mutex implementation */
273 *va_arg(ap, sqlite3_mutex_methods*) = sqlite3Config.mutex;
274 break;
275 }
drhfec00ea2008-06-14 16:56:21 +0000276 case SQLITE_CONFIG_MEMSTATUS: {
drh40257ff2008-06-13 18:24:27 +0000277 /* Enable or disable the malloc status collection */
278 sqlite3Config.bMemstat = va_arg(ap, int);
279 break;
280 }
drh33589792008-06-18 13:27:46 +0000281 case SQLITE_CONFIG_SCRATCH: {
282 /* Designate a buffer for scratch memory space */
283 sqlite3Config.pScratch = va_arg(ap, void*);
284 sqlite3Config.szScratch = va_arg(ap, int);
285 sqlite3Config.nScratch = va_arg(ap, int);
286 break;
287 }
288 case SQLITE_CONFIG_PAGECACHE: {
289 /* Designate a buffer for scratch memory space */
290 sqlite3Config.pPage = va_arg(ap, void*);
291 sqlite3Config.szPage = va_arg(ap, int);
292 sqlite3Config.nPage = va_arg(ap, int);
293 break;
294 }
danielk19775099be52008-06-27 13:27:03 +0000295
drh5d414832008-07-15 14:47:18 +0000296#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
drh33589792008-06-18 13:27:46 +0000297 case SQLITE_CONFIG_HEAP: {
danielk19775099be52008-06-27 13:27:03 +0000298 /* Designate a buffer for heap memory space */
drh33589792008-06-18 13:27:46 +0000299 sqlite3Config.pHeap = va_arg(ap, void*);
300 sqlite3Config.nHeap = va_arg(ap, int);
301 sqlite3Config.mnReq = va_arg(ap, int);
danielk19775099be52008-06-27 13:27:03 +0000302
drh8a42cbd2008-07-10 18:13:42 +0000303 if( sqlite3Config.pHeap==0 ){
304 /* If the heap pointer is NULL, then restore the malloc implementation
305 ** back to NULL pointers too. This will cause the malloc to go
306 ** back to its default implementation when sqlite3_initialize() is
307 ** run.
308 */
309 memset(&sqlite3Config.m, 0, sizeof(sqlite3Config.m));
310 }else{
311 /* The heap pointer is not NULL, then install one of the
312 ** mem5.c/mem3.c methods. If neither ENABLE_MEMSYS3 nor
313 ** ENABLE_MEMSYS5 is defined, return an error.
314 ** the default case and return an error.
315 */
danielk19775099be52008-06-27 13:27:03 +0000316#ifdef SQLITE_ENABLE_MEMSYS3
drh7830cd42008-07-16 12:25:32 +0000317 sqlite3Config.m = *sqlite3MemGetMemsys3();
drh8a42cbd2008-07-10 18:13:42 +0000318#endif
319#ifdef SQLITE_ENABLE_MEMSYS5
drh7830cd42008-07-16 12:25:32 +0000320 sqlite3Config.m = *sqlite3MemGetMemsys5();
drh8a42cbd2008-07-10 18:13:42 +0000321#endif
drh8a42cbd2008-07-10 18:13:42 +0000322 }
danielk19775099be52008-06-27 13:27:03 +0000323 break;
324 }
drh5d414832008-07-15 14:47:18 +0000325#endif
danielk19775099be52008-06-27 13:27:03 +0000326
danielk19772d340812008-07-24 08:20:40 +0000327#if defined(SQLITE_ENABLE_MEMSYS6)
328 case SQLITE_CONFIG_CHUNKALLOC: {
danielk197731fab4f2008-07-25 08:48:59 +0000329 sqlite3Config.nSmall = va_arg(ap, int);
danielk19772d340812008-07-24 08:20:40 +0000330 sqlite3Config.m = *sqlite3MemGetMemsys6();
331 break;
332 }
333#endif
334
drh633e6d52008-07-28 19:34:53 +0000335 case SQLITE_CONFIG_LOOKASIDE: {
336 sqlite3Config.szLookaside = va_arg(ap, int);
337 sqlite3Config.nLookaside = va_arg(ap, int);
338 break;
339 }
340
drh40257ff2008-06-13 18:24:27 +0000341 default: {
342 rc = SQLITE_ERROR;
343 break;
344 }
345 }
346 va_end(ap);
347 return rc;
348}
349
350/*
drh633e6d52008-07-28 19:34:53 +0000351** Set up the lookaside buffers for a database connection.
352** Return SQLITE_OK on success.
353** If lookaside is already active, return SQLITE_BUSY.
drhe9d1c722008-08-04 20:13:26 +0000354**
355** The sz parameter is the number of bytes in each lookaside slot.
356** The cnt parameter is the number of slots. If pStart is NULL the
357** space for the lookaside memory is obtained from sqlite3_malloc().
358** If pStart is not NULL then it is sz*cnt bytes of memory to use for
359** the lookaside memory.
drh633e6d52008-07-28 19:34:53 +0000360*/
drhe9d1c722008-08-04 20:13:26 +0000361static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
drh633e6d52008-07-28 19:34:53 +0000362 void *pStart;
363 if( db->lookaside.nOut ){
364 return SQLITE_BUSY;
365 }
366 if( sz<0 ) sz = 0;
367 if( cnt<0 ) cnt = 0;
drhe9d1c722008-08-04 20:13:26 +0000368 if( pBuf==0 ){
drh63820332008-08-08 14:33:12 +0000369 sz = (sz + 7)&~7;
drhe9d1c722008-08-04 20:13:26 +0000370 sqlite3BeginBenignMalloc();
371 pStart = sqlite3Malloc( sz*cnt );
372 sqlite3EndBenignMalloc();
373 }else{
drh63820332008-08-08 14:33:12 +0000374 sz = sz&~7;
drhe9d1c722008-08-04 20:13:26 +0000375 pStart = pBuf;
376 }
377 if( db->lookaside.bMalloced ){
378 sqlite3_free(db->lookaside.pStart);
379 }
drh4cfb22f2008-08-01 18:47:01 +0000380 db->lookaside.pStart = pStart;
381 db->lookaside.pFree = 0;
382 db->lookaside.sz = sz;
drhe9d1c722008-08-04 20:13:26 +0000383 db->lookaside.bMalloced = pBuf==0;
drh633e6d52008-07-28 19:34:53 +0000384 if( pStart ){
385 int i;
386 LookasideSlot *p;
drh633e6d52008-07-28 19:34:53 +0000387 p = (LookasideSlot*)pStart;
388 for(i=cnt-1; i>=0; i--){
389 p->pNext = db->lookaside.pFree;
390 db->lookaside.pFree = p;
391 p = (LookasideSlot*)&((u8*)p)[sz];
392 }
393 db->lookaside.pEnd = p;
394 db->lookaside.bEnabled = 1;
drh4cfb22f2008-08-01 18:47:01 +0000395 }else{
396 db->lookaside.pEnd = 0;
397 db->lookaside.bEnabled = 0;
drh633e6d52008-07-28 19:34:53 +0000398 }
399 return SQLITE_OK;
400}
401
402/*
403** Configuration settings for an individual database connection
404*/
405int sqlite3_db_config(sqlite3 *db, int op, ...){
406 va_list ap;
drh6480aad2008-08-01 16:31:14 +0000407 int rc;
drh633e6d52008-07-28 19:34:53 +0000408 va_start(ap, op);
409 switch( op ){
drhe9d1c722008-08-04 20:13:26 +0000410 case SQLITE_DBCONFIG_LOOKASIDE: {
411 void *pBuf = va_arg(ap, void*);
drh633e6d52008-07-28 19:34:53 +0000412 int sz = va_arg(ap, int);
413 int cnt = va_arg(ap, int);
drhe9d1c722008-08-04 20:13:26 +0000414 rc = setupLookaside(db, pBuf, sz, cnt);
drh633e6d52008-07-28 19:34:53 +0000415 break;
416 }
drh6480aad2008-08-01 16:31:14 +0000417 default: {
418 rc = SQLITE_ERROR;
419 break;
420 }
drh633e6d52008-07-28 19:34:53 +0000421 }
422 va_end(ap);
423 return rc;
424}
425
426/*
drhc5499be2008-04-01 15:06:33 +0000427** Routine needed to support the testcase() macro.
428*/
429#ifdef SQLITE_COVERAGE_TEST
430void sqlite3Coverage(int x){
431 static int dummy = 0;
432 dummy += x;
433}
434#endif
435
drha16313e2007-03-30 11:29:32 +0000436
437/*
drh9b5adfa2008-01-20 23:19:56 +0000438** Return true if the buffer z[0..n-1] contains all spaces.
439*/
440static int allSpaces(const char *z, int n){
drh5f3a3672008-04-15 04:02:40 +0000441 while( n>0 && z[n-1]==' ' ){ n--; }
drh9b5adfa2008-01-20 23:19:56 +0000442 return n==0;
443}
444
445/*
drhd3d39e92004-05-20 22:16:29 +0000446** This is the default collating function named "BINARY" which is always
447** available.
drh9b5adfa2008-01-20 23:19:56 +0000448**
449** If the padFlag argument is not NULL then space padding at the end
450** of strings is ignored. This implements the RTRIM collation.
drhd3d39e92004-05-20 22:16:29 +0000451*/
danielk19772c336542005-01-13 02:14:23 +0000452static int binCollFunc(
drh9b5adfa2008-01-20 23:19:56 +0000453 void *padFlag,
drhd3d39e92004-05-20 22:16:29 +0000454 int nKey1, const void *pKey1,
455 int nKey2, const void *pKey2
456){
457 int rc, n;
458 n = nKey1<nKey2 ? nKey1 : nKey2;
459 rc = memcmp(pKey1, pKey2, n);
460 if( rc==0 ){
drh9b5adfa2008-01-20 23:19:56 +0000461 if( padFlag
462 && allSpaces(((char*)pKey1)+n, nKey1-n)
463 && allSpaces(((char*)pKey2)+n, nKey2-n)
464 ){
465 /* Leave rc unchanged at 0 */
466 }else{
467 rc = nKey1 - nKey2;
468 }
drhd3d39e92004-05-20 22:16:29 +0000469 }
470 return rc;
471}
472
473/*
danielk1977dc1bdc42004-06-11 10:51:27 +0000474** Another built-in collating sequence: NOCASE.
475**
476** This collating sequence is intended to be used for "case independant
477** comparison". SQLite's knowledge of upper and lower case equivalents
478** extends only to the 26 characters used in the English language.
479**
480** At the moment there is only a UTF-8 implementation.
danielk19770202b292004-06-09 09:55:16 +0000481*/
482static int nocaseCollatingFunc(
483 void *NotUsed,
484 int nKey1, const void *pKey1,
485 int nKey2, const void *pKey2
486){
487 int r = sqlite3StrNICmp(
drh208f80a2004-08-29 20:08:58 +0000488 (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
danielk19770202b292004-06-09 09:55:16 +0000489 if( 0==r ){
490 r = nKey1-nKey2;
491 }
492 return r;
493}
494
495/*
drhaf9ff332002-01-16 21:00:27 +0000496** Return the ROWID of the most recent insert
497*/
drh9bb575f2004-09-06 17:24:11 +0000498sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
drhaf9ff332002-01-16 21:00:27 +0000499 return db->lastRowid;
500}
501
502/*
danielk197724b03fd2004-05-10 10:34:34 +0000503** Return the number of changes in the most recent call to sqlite3_exec().
drhc8d30ac2002-04-12 10:08:59 +0000504*/
drh9bb575f2004-09-06 17:24:11 +0000505int sqlite3_changes(sqlite3 *db){
drhc8d30ac2002-04-12 10:08:59 +0000506 return db->nChange;
507}
508
rdcf146a772004-02-25 22:51:06 +0000509/*
danielk1977b28af712004-06-21 06:50:26 +0000510** Return the number of changes since the database handle was opened.
rdcf146a772004-02-25 22:51:06 +0000511*/
danielk1977b28af712004-06-21 06:50:26 +0000512int sqlite3_total_changes(sqlite3 *db){
513 return db->nTotalChange;
rdcb0c374f2004-02-20 22:53:38 +0000514}
515
drhc8d30ac2002-04-12 10:08:59 +0000516/*
drh50e5dad2001-09-15 00:57:28 +0000517** Close an existing SQLite database
518*/
drh9bb575f2004-09-06 17:24:11 +0000519int sqlite3_close(sqlite3 *db){
drh8e0a2f92002-02-23 23:45:45 +0000520 HashElem *i;
drh001bbcb2003-03-19 03:14:00 +0000521 int j;
danielk19775c4c7782004-06-16 10:39:23 +0000522
523 if( !db ){
danielk197796d81f92004-06-19 03:33:57 +0000524 return SQLITE_OK;
danielk19775c4c7782004-06-16 10:39:23 +0000525 }
drh7e8b8482008-01-23 03:03:05 +0000526 if( !sqlite3SafetyCheckSickOrOk(db) ){
danielk1977e35ee192004-06-26 09:50:11 +0000527 return SQLITE_MISUSE;
528 }
drh605264d2007-08-21 15:13:19 +0000529 sqlite3_mutex_enter(db->mutex);
danielk1977e35ee192004-06-26 09:50:11 +0000530
danielk19771f723bd2005-05-26 12:37:29 +0000531#ifdef SQLITE_SSE
drh37527852006-03-16 16:19:56 +0000532 {
533 extern void sqlite3SseCleanup(sqlite3*);
534 sqlite3SseCleanup(db);
535 }
danielk19771f723bd2005-05-26 12:37:29 +0000536#endif
537
drhffc13f62006-07-30 20:50:44 +0000538 sqlite3ResetInternalSchema(db, 0);
danielk1977a04a34f2007-04-16 15:06:25 +0000539
danielk197701256832007-04-18 14:24:32 +0000540 /* If a transaction is open, the ResetInternalSchema() call above
541 ** will not have called the xDisconnect() method on any virtual
542 ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
543 ** call will do so. We need to do this before the check for active
544 ** SQL statements below, as the v-table implementation may be storing
545 ** some prepared statements internally.
546 */
547 sqlite3VtabRollback(db);
548
danielk1977a04a34f2007-04-16 15:06:25 +0000549 /* If there are any outstanding VMs, return SQLITE_BUSY. */
danielk197796d81f92004-06-19 03:33:57 +0000550 if( db->pVdbe ){
551 sqlite3Error(db, SQLITE_BUSY,
552 "Unable to close due to unfinalised statements");
drh27641702007-08-22 02:56:42 +0000553 sqlite3_mutex_leave(db->mutex);
danielk197796d81f92004-06-19 03:33:57 +0000554 return SQLITE_BUSY;
555 }
drh7e8b8482008-01-23 03:03:05 +0000556 assert( sqlite3SafetyCheckSickOrOk(db) );
danielk1977e0048402004-06-15 16:51:01 +0000557
drh001bbcb2003-03-19 03:14:00 +0000558 for(j=0; j<db->nDb; j++){
drh4d189ca2004-02-12 18:46:38 +0000559 struct Db *pDb = &db->aDb[j];
560 if( pDb->pBt ){
danielk19774adee202004-05-08 08:23:19 +0000561 sqlite3BtreeClose(pDb->pBt);
drh4d189ca2004-02-12 18:46:38 +0000562 pDb->pBt = 0;
danielk1977311019b2006-01-10 07:14:23 +0000563 if( j!=1 ){
564 pDb->pSchema = 0;
565 }
drh113088e2003-03-20 01:16:58 +0000566 }
drhf57b3392001-10-08 13:22:32 +0000567 }
danielk19774adee202004-05-08 08:23:19 +0000568 sqlite3ResetInternalSchema(db, 0);
drh1c2d8412003-03-31 00:30:47 +0000569 assert( db->nDb<=2 );
570 assert( db->aDb==db->aDbStatic );
drh70a8ca32008-08-21 18:49:27 +0000571 for(j=0; j<ArraySize(db->aFunc.a); j++){
572 FuncDef *pNext, *pHash, *p;
573 for(p=db->aFunc.a[j]; p; p=pHash){
574 pHash = p->pHash;
575 while( p ){
576 pNext = p->pNext;
577 sqlite3DbFree(db, p);
578 p = pNext;
579 }
drh8e0a2f92002-02-23 23:45:45 +0000580 }
581 }
danielk1977d8123362004-06-12 09:25:12 +0000582 for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
danielk1977466be562004-06-10 02:16:01 +0000583 CollSeq *pColl = (CollSeq *)sqliteHashData(i);
danielk1977a9808b32007-05-07 09:32:45 +0000584 /* Invoke any destructors registered for collation sequence user data. */
585 for(j=0; j<3; j++){
586 if( pColl[j].xDel ){
587 pColl[j].xDel(pColl[j].pUser);
588 }
589 }
drh633e6d52008-07-28 19:34:53 +0000590 sqlite3DbFree(db, pColl);
danielk1977466be562004-06-10 02:16:01 +0000591 }
danielk1977d8123362004-06-12 09:25:12 +0000592 sqlite3HashClear(&db->aCollSeq);
drhb9bb7c12006-06-11 23:41:55 +0000593#ifndef SQLITE_OMIT_VIRTUALTABLE
danielk1977d1ab1ba2006-06-15 04:28:13 +0000594 for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
595 Module *pMod = (Module *)sqliteHashData(i);
danielk1977832a58a2007-06-22 15:21:15 +0000596 if( pMod->xDestroy ){
597 pMod->xDestroy(pMod->pAux);
598 }
drh633e6d52008-07-28 19:34:53 +0000599 sqlite3DbFree(db, pMod);
danielk1977d1ab1ba2006-06-15 04:28:13 +0000600 }
drhb9bb7c12006-06-11 23:41:55 +0000601 sqlite3HashClear(&db->aModule);
602#endif
danielk1977466be562004-06-10 02:16:01 +0000603
danielk19776622cce2004-05-20 11:00:52 +0000604 sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
danielk1977bfd6cce2004-06-18 04:24:54 +0000605 if( db->pErr ){
606 sqlite3ValueFree(db->pErr);
607 }
drhf1952c52006-06-08 15:48:00 +0000608 sqlite3CloseExtensions(db);
danielk197796d81f92004-06-19 03:33:57 +0000609
610 db->magic = SQLITE_MAGIC_ERROR;
danielk1977311019b2006-01-10 07:14:23 +0000611
612 /* The temp-database schema is allocated differently from the other schema
613 ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
614 ** So it needs to be freed here. Todo: Why not roll the temp schema into
615 ** the same sqliteMalloc() as the one that allocates the database
616 ** structure?
617 */
drh633e6d52008-07-28 19:34:53 +0000618 sqlite3DbFree(db, db->aDb[1].pSchema);
drh605264d2007-08-21 15:13:19 +0000619 sqlite3_mutex_leave(db->mutex);
drh7e8b8482008-01-23 03:03:05 +0000620 db->magic = SQLITE_MAGIC_CLOSED;
drh605264d2007-08-21 15:13:19 +0000621 sqlite3_mutex_free(db->mutex);
drhe9d1c722008-08-04 20:13:26 +0000622 if( db->lookaside.bMalloced ){
623 sqlite3_free(db->lookaside.pStart);
624 }
drh17435752007-08-16 04:30:38 +0000625 sqlite3_free(db);
danielk197796d81f92004-06-19 03:33:57 +0000626 return SQLITE_OK;
drh75897232000-05-29 14:26:00 +0000627}
628
629/*
drh001bbcb2003-03-19 03:14:00 +0000630** Rollback all database files.
631*/
drh9bb575f2004-09-06 17:24:11 +0000632void sqlite3RollbackAll(sqlite3 *db){
drh001bbcb2003-03-19 03:14:00 +0000633 int i;
danielk1977f3f06bb2005-12-16 15:24:28 +0000634 int inTrans = 0;
drhe30f4422007-08-21 16:15:55 +0000635 assert( sqlite3_mutex_held(db->mutex) );
danielk19772d1d86f2008-06-20 14:59:51 +0000636 sqlite3BeginBenignMalloc();
drh001bbcb2003-03-19 03:14:00 +0000637 for(i=0; i<db->nDb; i++){
638 if( db->aDb[i].pBt ){
danielk1977f3f06bb2005-12-16 15:24:28 +0000639 if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
640 inTrans = 1;
641 }
danielk19774adee202004-05-08 08:23:19 +0000642 sqlite3BtreeRollback(db->aDb[i].pBt);
drh001bbcb2003-03-19 03:14:00 +0000643 db->aDb[i].inTrans = 0;
644 }
645 }
danielk1977a298e902006-06-22 09:53:48 +0000646 sqlite3VtabRollback(db);
danielk19772d1d86f2008-06-20 14:59:51 +0000647 sqlite3EndBenignMalloc();
danielk1977ae72d982007-10-03 08:46:44 +0000648
danielk197771fd80b2005-12-16 06:54:01 +0000649 if( db->flags&SQLITE_InternChanges ){
danielk1977ea4d9e22007-08-13 15:28:33 +0000650 sqlite3ExpirePreparedStatements(db);
danielk197771fd80b2005-12-16 06:54:01 +0000651 sqlite3ResetInternalSchema(db, 0);
652 }
653
654 /* If one has been configured, invoke the rollback-hook callback */
danielk1977f3f06bb2005-12-16 15:24:28 +0000655 if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
danielk197771fd80b2005-12-16 06:54:01 +0000656 db->xRollbackCallback(db->pRollbackArg);
657 }
drh001bbcb2003-03-19 03:14:00 +0000658}
659
660/*
drhc22bd472002-05-10 13:14:07 +0000661** Return a static string that describes the kind of error specified in the
662** argument.
drh247be432002-05-10 05:44:55 +0000663*/
danielk1977f20b21c2004-05-31 23:56:42 +0000664const char *sqlite3ErrStr(int rc){
drhc22bd472002-05-10 13:14:07 +0000665 const char *z;
drh4ac285a2006-09-15 07:28:50 +0000666 switch( rc & 0xff ){
drhc60d0442004-09-30 13:43:13 +0000667 case SQLITE_ROW:
668 case SQLITE_DONE:
drhc22bd472002-05-10 13:14:07 +0000669 case SQLITE_OK: z = "not an error"; break;
670 case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
drhc22bd472002-05-10 13:14:07 +0000671 case SQLITE_PERM: z = "access permission denied"; break;
672 case SQLITE_ABORT: z = "callback requested query abort"; break;
673 case SQLITE_BUSY: z = "database is locked"; break;
674 case SQLITE_LOCKED: z = "database table is locked"; break;
675 case SQLITE_NOMEM: z = "out of memory"; break;
676 case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
677 case SQLITE_INTERRUPT: z = "interrupted"; break;
678 case SQLITE_IOERR: z = "disk I/O error"; break;
679 case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
drh2db0bbc2005-08-11 02:10:18 +0000680 case SQLITE_FULL: z = "database or disk is full"; break;
drhc22bd472002-05-10 13:14:07 +0000681 case SQLITE_CANTOPEN: z = "unable to open database file"; break;
drhc22bd472002-05-10 13:14:07 +0000682 case SQLITE_EMPTY: z = "table contains no data"; break;
683 case SQLITE_SCHEMA: z = "database schema has changed"; break;
drh023ae032007-05-08 12:12:16 +0000684 case SQLITE_TOOBIG: z = "String or BLOB exceeded size limit"; break;
drhc22bd472002-05-10 13:14:07 +0000685 case SQLITE_CONSTRAINT: z = "constraint failed"; break;
686 case SQLITE_MISMATCH: z = "datatype mismatch"; break;
687 case SQLITE_MISUSE: z = "library routine called out of sequence";break;
drh65594042008-05-05 16:56:34 +0000688 case SQLITE_NOLFS: z = "large file support is disabled"; break;
drhed6c8672003-01-12 18:02:16 +0000689 case SQLITE_AUTH: z = "authorization denied"; break;
jplyon892f6712003-06-12 08:59:00 +0000690 case SQLITE_FORMAT: z = "auxiliary database format error"; break;
drhb08153d2004-11-20 20:18:55 +0000691 case SQLITE_RANGE: z = "bind or column index out of range"; break;
drhc602f9a2004-02-12 19:01:04 +0000692 case SQLITE_NOTADB: z = "file is encrypted or is not a database";break;
drhc22bd472002-05-10 13:14:07 +0000693 default: z = "unknown error"; break;
drh247be432002-05-10 05:44:55 +0000694 }
drhc22bd472002-05-10 13:14:07 +0000695 return z;
drh247be432002-05-10 05:44:55 +0000696}
697
698/*
drh2dfbbca2000-07-28 14:32:48 +0000699** This routine implements a busy callback that sleeps and tries
700** again until a timeout value is reached. The timeout value is
701** an integer number of milliseconds passed in as the first
702** argument.
703*/
drhdaffd0e2001-04-11 14:28:42 +0000704static int sqliteDefaultBusyCallback(
drh97903fe2005-05-24 20:19:57 +0000705 void *ptr, /* Database connection */
drh2dfbbca2000-07-28 14:32:48 +0000706 int count /* Number of times table has been busy */
707){
danielk197729bafea2008-06-26 10:41:19 +0000708#if SQLITE_OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
drhee570fa2005-04-28 12:06:05 +0000709 static const u8 delays[] =
710 { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
711 static const u8 totals[] =
712 { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
drhd1bec472004-01-15 13:29:31 +0000713# define NDELAY (sizeof(delays)/sizeof(delays[0]))
danielk1977b4b47412007-08-17 15:53:36 +0000714 sqlite3 *db = (sqlite3 *)ptr;
715 int timeout = db->busyTimeout;
drh97903fe2005-05-24 20:19:57 +0000716 int delay, prior;
drh2dfbbca2000-07-28 14:32:48 +0000717
drhee570fa2005-04-28 12:06:05 +0000718 assert( count>=0 );
719 if( count < NDELAY ){
720 delay = delays[count];
721 prior = totals[count];
drhd1bec472004-01-15 13:29:31 +0000722 }else{
723 delay = delays[NDELAY-1];
drh68cb6192005-05-06 22:05:56 +0000724 prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
drh2dfbbca2000-07-28 14:32:48 +0000725 }
drhd1bec472004-01-15 13:29:31 +0000726 if( prior + delay > timeout ){
727 delay = timeout - prior;
drh2dfbbca2000-07-28 14:32:48 +0000728 if( delay<=0 ) return 0;
729 }
danielk19772a6bdf62007-08-20 16:07:00 +0000730 sqlite3OsSleep(db->pVfs, delay*1000);
drh2dfbbca2000-07-28 14:32:48 +0000731 return 1;
732#else
drh482ea182007-08-20 11:12:40 +0000733 sqlite3 *db = (sqlite3 *)ptr;
drh3f737082005-06-14 02:24:31 +0000734 int timeout = ((sqlite3 *)ptr)->busyTimeout;
drh2dfbbca2000-07-28 14:32:48 +0000735 if( (count+1)*1000 > timeout ){
736 return 0;
737 }
drh482ea182007-08-20 11:12:40 +0000738 sqlite3OsSleep(db->pVfs, 1000000);
drh2dfbbca2000-07-28 14:32:48 +0000739 return 1;
740#endif
741}
742
743/*
drha4afb652005-07-09 02:16:02 +0000744** Invoke the given busy handler.
745**
746** This routine is called when an operation failed with a lock.
747** If this routine returns non-zero, the lock is retried. If it
748** returns 0, the operation aborts with an SQLITE_BUSY error.
749*/
750int sqlite3InvokeBusyHandler(BusyHandler *p){
751 int rc;
drh34004ce2008-07-11 16:15:17 +0000752 if( NEVER(p==0) || p->xFunc==0 || p->nBusy<0 ) return 0;
drha4afb652005-07-09 02:16:02 +0000753 rc = p->xFunc(p->pArg, p->nBusy);
754 if( rc==0 ){
755 p->nBusy = -1;
756 }else{
757 p->nBusy++;
758 }
759 return rc;
760}
761
762/*
drh2dfbbca2000-07-28 14:32:48 +0000763** This routine sets the busy callback for an Sqlite database to the
764** given callback function with the given argument.
765*/
danielk1977f9d64d22004-06-19 08:18:07 +0000766int sqlite3_busy_handler(
767 sqlite3 *db,
danielk19772a764eb2004-06-12 01:43:26 +0000768 int (*xBusy)(void*,int),
drh2dfbbca2000-07-28 14:32:48 +0000769 void *pArg
770){
drhe30f4422007-08-21 16:15:55 +0000771 sqlite3_mutex_enter(db->mutex);
danielk197724162fe2004-06-04 06:22:00 +0000772 db->busyHandler.xFunc = xBusy;
773 db->busyHandler.pArg = pArg;
drha4afb652005-07-09 02:16:02 +0000774 db->busyHandler.nBusy = 0;
drhe30f4422007-08-21 16:15:55 +0000775 sqlite3_mutex_leave(db->mutex);
danielk1977f9d64d22004-06-19 08:18:07 +0000776 return SQLITE_OK;
drh2dfbbca2000-07-28 14:32:48 +0000777}
778
danielk1977348bb5d2003-10-18 09:37:26 +0000779#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
780/*
781** This routine sets the progress callback for an Sqlite database to the
782** given callback function with the given argument. The progress callback will
783** be invoked every nOps opcodes.
784*/
danielk197724b03fd2004-05-10 10:34:34 +0000785void sqlite3_progress_handler(
drh9bb575f2004-09-06 17:24:11 +0000786 sqlite3 *db,
danielk1977348bb5d2003-10-18 09:37:26 +0000787 int nOps,
788 int (*xProgress)(void*),
789 void *pArg
790){
drhbd0b1b52008-07-07 19:52:09 +0000791 sqlite3_mutex_enter(db->mutex);
792 if( nOps>0 ){
793 db->xProgress = xProgress;
794 db->nProgressOps = nOps;
795 db->pProgressArg = pArg;
796 }else{
797 db->xProgress = 0;
798 db->nProgressOps = 0;
799 db->pProgressArg = 0;
danielk1977348bb5d2003-10-18 09:37:26 +0000800 }
drhbd0b1b52008-07-07 19:52:09 +0000801 sqlite3_mutex_leave(db->mutex);
danielk1977348bb5d2003-10-18 09:37:26 +0000802}
803#endif
804
805
drh2dfbbca2000-07-28 14:32:48 +0000806/*
807** This routine installs a default busy handler that waits for the
808** specified number of milliseconds before returning 0.
809*/
danielk1977f9d64d22004-06-19 08:18:07 +0000810int sqlite3_busy_timeout(sqlite3 *db, int ms){
drh2dfbbca2000-07-28 14:32:48 +0000811 if( ms>0 ){
drh97903fe2005-05-24 20:19:57 +0000812 db->busyTimeout = ms;
813 sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
drh2dfbbca2000-07-28 14:32:48 +0000814 }else{
danielk197724b03fd2004-05-10 10:34:34 +0000815 sqlite3_busy_handler(db, 0, 0);
drh2dfbbca2000-07-28 14:32:48 +0000816 }
danielk1977f9d64d22004-06-19 08:18:07 +0000817 return SQLITE_OK;
drh2dfbbca2000-07-28 14:32:48 +0000818}
drh4c504392000-10-16 22:06:40 +0000819
820/*
821** Cause any pending operation to stop at its earliest opportunity.
822*/
drh9bb575f2004-09-06 17:24:11 +0000823void sqlite3_interrupt(sqlite3 *db){
drhbd0b1b52008-07-07 19:52:09 +0000824 db->u1.isInterrupted = 1;
drh4c504392000-10-16 22:06:40 +0000825}
drhfa86c412002-02-02 15:01:15 +0000826
drhfa86c412002-02-02 15:01:15 +0000827
828/*
danielk1977771151b2006-01-17 13:21:40 +0000829** This function is exactly the same as sqlite3_create_function(), except
830** that it is designed to be called by internal code. The difference is
831** that if a malloc() fails in sqlite3_create_function(), an error code
832** is returned and the mallocFailed flag cleared.
drhfa86c412002-02-02 15:01:15 +0000833*/
danielk1977771151b2006-01-17 13:21:40 +0000834int sqlite3CreateFunc(
danielk197765904932004-05-26 06:18:37 +0000835 sqlite3 *db,
836 const char *zFunctionName,
837 int nArg,
danielk1977d8123362004-06-12 09:25:12 +0000838 int enc,
danielk197765904932004-05-26 06:18:37 +0000839 void *pUserData,
840 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
841 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
842 void (*xFinal)(sqlite3_context*)
drh8e0a2f92002-02-23 23:45:45 +0000843){
drh0bce8352002-02-28 00:41:10 +0000844 FuncDef *p;
drh4b59ab52002-08-24 18:24:51 +0000845 int nName;
danielk197765904932004-05-26 06:18:37 +0000846
drhe30f4422007-08-21 16:15:55 +0000847 assert( sqlite3_mutex_held(db->mutex) );
drhc60d0442004-09-30 13:43:13 +0000848 if( zFunctionName==0 ||
danielk1977398eae72004-05-26 06:58:43 +0000849 (xFunc && (xFinal || xStep)) ||
850 (!xFunc && (xFinal && !xStep)) ||
851 (!xFunc && (!xFinal && xStep)) ||
drh24b58dd2008-07-07 14:50:14 +0000852 (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) ||
drh0a687d12008-07-08 14:52:07 +0000853 (255<(nName = sqlite3Strlen(db, zFunctionName))) ){
drhbadf7a72006-06-14 15:35:36 +0000854 sqlite3Error(db, SQLITE_ERROR, "bad parameters");
danielk197765904932004-05-26 06:18:37 +0000855 return SQLITE_ERROR;
856 }
danielk1977d8123362004-06-12 09:25:12 +0000857
danielk197793758c82005-01-21 08:13:14 +0000858#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +0000859 /* If SQLITE_UTF16 is specified as the encoding type, transform this
860 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
861 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
862 **
863 ** If SQLITE_ANY is specified, add three versions of the function
864 ** to the hash table.
865 */
866 if( enc==SQLITE_UTF16 ){
867 enc = SQLITE_UTF16NATIVE;
868 }else if( enc==SQLITE_ANY ){
869 int rc;
danielk1977771151b2006-01-17 13:21:40 +0000870 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
danielk1977f9d64d22004-06-19 08:18:07 +0000871 pUserData, xFunc, xStep, xFinal);
drhe30f4422007-08-21 16:15:55 +0000872 if( rc==SQLITE_OK ){
873 rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
874 pUserData, xFunc, xStep, xFinal);
875 }
876 if( rc!=SQLITE_OK ){
877 return rc;
878 }
danielk1977d8123362004-06-12 09:25:12 +0000879 enc = SQLITE_UTF16BE;
880 }
danielk197793758c82005-01-21 08:13:14 +0000881#else
882 enc = SQLITE_UTF8;
883#endif
danielk19779636c4e2005-01-25 04:27:54 +0000884
885 /* Check if an existing function is being overridden or deleted. If so,
886 ** and there are active VMs, then return SQLITE_BUSY. If a function
887 ** is being overridden/deleted but there are no active VMs, allow the
888 ** operation to continue but invalidate all precompiled statements.
889 */
890 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
891 if( p && p->iPrefEnc==enc && p->nArg==nArg ){
892 if( db->activeVdbeCnt ){
893 sqlite3Error(db, SQLITE_BUSY,
894 "Unable to delete/modify user-function due to active statements");
drh17435752007-08-16 04:30:38 +0000895 assert( !db->mallocFailed );
danielk19779636c4e2005-01-25 04:27:54 +0000896 return SQLITE_BUSY;
897 }else{
898 sqlite3ExpirePreparedStatements(db);
899 }
900 }
danielk197765904932004-05-26 06:18:37 +0000901
danielk1977d8123362004-06-12 09:25:12 +0000902 p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
danielk1977fa18bec2007-09-03 11:04:22 +0000903 assert(p || db->mallocFailed);
904 if( !p ){
905 return SQLITE_NOMEM;
danielk1977771151b2006-01-17 13:21:40 +0000906 }
danielk1977fa18bec2007-09-03 11:04:22 +0000907 p->flags = 0;
908 p->xFunc = xFunc;
909 p->xStep = xStep;
910 p->xFinalize = xFinal;
911 p->pUserData = pUserData;
912 p->nArg = nArg;
danielk197765904932004-05-26 06:18:37 +0000913 return SQLITE_OK;
914}
danielk1977771151b2006-01-17 13:21:40 +0000915
916/*
917** Create new user functions.
918*/
919int sqlite3_create_function(
920 sqlite3 *db,
921 const char *zFunctionName,
922 int nArg,
923 int enc,
924 void *p,
925 void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
926 void (*xStep)(sqlite3_context*,int,sqlite3_value **),
927 void (*xFinal)(sqlite3_context*)
928){
929 int rc;
drhe30f4422007-08-21 16:15:55 +0000930 sqlite3_mutex_enter(db->mutex);
danielk1977771151b2006-01-17 13:21:40 +0000931 rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
drhe30f4422007-08-21 16:15:55 +0000932 rc = sqlite3ApiExit(db, rc);
933 sqlite3_mutex_leave(db->mutex);
934 return rc;
danielk1977771151b2006-01-17 13:21:40 +0000935}
936
danielk197793758c82005-01-21 08:13:14 +0000937#ifndef SQLITE_OMIT_UTF16
danielk197765904932004-05-26 06:18:37 +0000938int sqlite3_create_function16(
939 sqlite3 *db,
940 const void *zFunctionName,
941 int nArg,
942 int eTextRep,
danielk1977771151b2006-01-17 13:21:40 +0000943 void *p,
danielk197765904932004-05-26 06:18:37 +0000944 void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
945 void (*xStep)(sqlite3_context*,int,sqlite3_value**),
946 void (*xFinal)(sqlite3_context*)
947){
948 int rc;
drhaf9a7c22005-12-15 03:04:10 +0000949 char *zFunc8;
drhe30f4422007-08-21 16:15:55 +0000950 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +0000951 assert( !db->mallocFailed );
danielk19771e536952007-08-16 10:09:01 +0000952 zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
danielk1977771151b2006-01-17 13:21:40 +0000953 rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
drh633e6d52008-07-28 19:34:53 +0000954 sqlite3DbFree(db, zFunc8);
drhe30f4422007-08-21 16:15:55 +0000955 rc = sqlite3ApiExit(db, rc);
956 sqlite3_mutex_leave(db->mutex);
957 return rc;
drh8e0a2f92002-02-23 23:45:45 +0000958}
danielk197793758c82005-01-21 08:13:14 +0000959#endif
drhc9b84a12002-06-20 11:36:48 +0000960
drhb7481e72006-09-16 21:45:14 +0000961
962/*
963** Declare that a function has been overloaded by a virtual table.
964**
965** If the function already exists as a regular global function, then
966** this routine is a no-op. If the function does not exist, then create
967** a new one that always throws a run-time error.
968**
969** When virtual tables intend to provide an overloaded function, they
970** should call this routine to make sure the global function exists.
971** A global function must exist in order for name resolution to work
972** properly.
973*/
974int sqlite3_overload_function(
975 sqlite3 *db,
976 const char *zName,
977 int nArg
978){
drh0a687d12008-07-08 14:52:07 +0000979 int nName = sqlite3Strlen(db, zName);
drhe30f4422007-08-21 16:15:55 +0000980 int rc;
981 sqlite3_mutex_enter(db->mutex);
drhb7481e72006-09-16 21:45:14 +0000982 if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
983 sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
984 0, sqlite3InvalidFunction, 0, 0);
985 }
drhe30f4422007-08-21 16:15:55 +0000986 rc = sqlite3ApiExit(db, SQLITE_OK);
987 sqlite3_mutex_leave(db->mutex);
988 return rc;
drhb7481e72006-09-16 21:45:14 +0000989}
990
drh19e2d372005-08-29 23:00:03 +0000991#ifndef SQLITE_OMIT_TRACE
drhc9b84a12002-06-20 11:36:48 +0000992/*
drh18de4822003-01-16 16:28:53 +0000993** Register a trace function. The pArg from the previously registered trace
994** is returned.
995**
996** A NULL trace function means that no tracing is executes. A non-NULL
997** trace is a pointer to a function that is invoked at the start of each
drh19e2d372005-08-29 23:00:03 +0000998** SQL statement.
drh18de4822003-01-16 16:28:53 +0000999*/
drh9bb575f2004-09-06 17:24:11 +00001000void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
drhe30f4422007-08-21 16:15:55 +00001001 void *pOld;
1002 sqlite3_mutex_enter(db->mutex);
1003 pOld = db->pTraceArg;
drh18de4822003-01-16 16:28:53 +00001004 db->xTrace = xTrace;
1005 db->pTraceArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001006 sqlite3_mutex_leave(db->mutex);
drh18de4822003-01-16 16:28:53 +00001007 return pOld;
drh0d1a6432003-04-03 15:46:04 +00001008}
drh19e2d372005-08-29 23:00:03 +00001009/*
1010** Register a profile function. The pArg from the previously registered
1011** profile function is returned.
1012**
1013** A NULL profile function means that no profiling is executes. A non-NULL
1014** profile is a pointer to a function that is invoked at the conclusion of
1015** each SQL statement that is run.
1016*/
1017void *sqlite3_profile(
1018 sqlite3 *db,
1019 void (*xProfile)(void*,const char*,sqlite_uint64),
1020 void *pArg
1021){
drhe30f4422007-08-21 16:15:55 +00001022 void *pOld;
1023 sqlite3_mutex_enter(db->mutex);
1024 pOld = db->pProfileArg;
drh19e2d372005-08-29 23:00:03 +00001025 db->xProfile = xProfile;
1026 db->pProfileArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001027 sqlite3_mutex_leave(db->mutex);
drh19e2d372005-08-29 23:00:03 +00001028 return pOld;
1029}
1030#endif /* SQLITE_OMIT_TRACE */
paulb0208cc2003-04-13 18:26:49 +00001031
drhaa940ea2004-01-15 02:44:03 +00001032/*** EXPERIMENTAL ***
1033**
1034** Register a function to be invoked when a transaction comments.
danielk197771fd80b2005-12-16 06:54:01 +00001035** If the invoked function returns non-zero, then the commit becomes a
drhaa940ea2004-01-15 02:44:03 +00001036** rollback.
1037*/
danielk197724b03fd2004-05-10 10:34:34 +00001038void *sqlite3_commit_hook(
drh9bb575f2004-09-06 17:24:11 +00001039 sqlite3 *db, /* Attach the hook to this database */
drhaa940ea2004-01-15 02:44:03 +00001040 int (*xCallback)(void*), /* Function to invoke on each commit */
1041 void *pArg /* Argument to the function */
1042){
drhe30f4422007-08-21 16:15:55 +00001043 void *pOld;
1044 sqlite3_mutex_enter(db->mutex);
1045 pOld = db->pCommitArg;
drhaa940ea2004-01-15 02:44:03 +00001046 db->xCommitCallback = xCallback;
1047 db->pCommitArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001048 sqlite3_mutex_leave(db->mutex);
drhaa940ea2004-01-15 02:44:03 +00001049 return pOld;
1050}
1051
danielk197794eb6a12005-12-15 15:22:08 +00001052/*
1053** Register a callback to be invoked each time a row is updated,
1054** inserted or deleted using this database connection.
1055*/
danielk197771fd80b2005-12-16 06:54:01 +00001056void *sqlite3_update_hook(
danielk197794eb6a12005-12-15 15:22:08 +00001057 sqlite3 *db, /* Attach the hook to this database */
1058 void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
1059 void *pArg /* Argument to the function */
1060){
drhe30f4422007-08-21 16:15:55 +00001061 void *pRet;
1062 sqlite3_mutex_enter(db->mutex);
1063 pRet = db->pUpdateArg;
danielk197794eb6a12005-12-15 15:22:08 +00001064 db->xUpdateCallback = xCallback;
1065 db->pUpdateArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001066 sqlite3_mutex_leave(db->mutex);
danielk197771fd80b2005-12-16 06:54:01 +00001067 return pRet;
danielk197794eb6a12005-12-15 15:22:08 +00001068}
1069
danielk197771fd80b2005-12-16 06:54:01 +00001070/*
1071** Register a callback to be invoked each time a transaction is rolled
1072** back by this database connection.
1073*/
1074void *sqlite3_rollback_hook(
1075 sqlite3 *db, /* Attach the hook to this database */
1076 void (*xCallback)(void*), /* Callback function */
1077 void *pArg /* Argument to the function */
1078){
drhe30f4422007-08-21 16:15:55 +00001079 void *pRet;
1080 sqlite3_mutex_enter(db->mutex);
1081 pRet = db->pRollbackArg;
danielk197771fd80b2005-12-16 06:54:01 +00001082 db->xRollbackCallback = xCallback;
1083 db->pRollbackArg = pArg;
drhe30f4422007-08-21 16:15:55 +00001084 sqlite3_mutex_leave(db->mutex);
danielk197771fd80b2005-12-16 06:54:01 +00001085 return pRet;
1086}
drhaa940ea2004-01-15 02:44:03 +00001087
paulb0208cc2003-04-13 18:26:49 +00001088/*
drh13bff812003-04-15 01:19:47 +00001089** This routine is called to create a connection to a database BTree
1090** driver. If zFilename is the name of a file, then that file is
1091** opened and used. If zFilename is the magic name ":memory:" then
1092** the database is stored in memory (and is thus forgotten as soon as
1093** the connection is closed.) If zFilename is NULL then the database
drh84bfda42005-07-15 13:05:21 +00001094** is a "virtual" database for transient use only and is deleted as
1095** soon as the connection is closed.
drh90f5ecb2004-07-22 01:19:35 +00001096**
drh84bfda42005-07-15 13:05:21 +00001097** A virtual database can be either a disk file (that is automatically
1098** deleted when the file is closed) or it an be held entirely in memory,
danielk1977b06a0b62008-06-26 10:54:12 +00001099** depending on the values of the SQLITE_TEMP_STORE compile-time macro and the
drh90f5ecb2004-07-22 01:19:35 +00001100** db->temp_store variable, according to the following chart:
1101**
danielk1977b06a0b62008-06-26 10:54:12 +00001102** SQLITE_TEMP_STORE db->temp_store Location of temporary database
1103** ----------------- -------------- ------------------------------
1104** 0 any file
1105** 1 1 file
1106** 1 2 memory
1107** 1 0 file
1108** 2 1 file
1109** 2 2 memory
1110** 2 0 memory
1111** 3 any memory
paulb0208cc2003-04-13 18:26:49 +00001112*/
danielk19774adee202004-05-08 08:23:19 +00001113int sqlite3BtreeFactory(
drh9bb575f2004-09-06 17:24:11 +00001114 const sqlite3 *db, /* Main database when opening aux otherwise 0 */
paulb0208cc2003-04-13 18:26:49 +00001115 const char *zFilename, /* Name of the file containing the BTree database */
1116 int omitJournal, /* if TRUE then do not journal this file */
1117 int nCache, /* How many pages in the page cache */
drh33f4e022007-09-03 15:19:34 +00001118 int vfsFlags, /* Flags passed through to vfsOpen */
danielk19774adee202004-05-08 08:23:19 +00001119 Btree **ppBtree /* Pointer to new Btree object written here */
1120){
drh33f4e022007-09-03 15:19:34 +00001121 int btFlags = 0;
drh90f5ecb2004-07-22 01:19:35 +00001122 int rc;
danielk19774adee202004-05-08 08:23:19 +00001123
drhe30f4422007-08-21 16:15:55 +00001124 assert( sqlite3_mutex_held(db->mutex) );
drheec983e2004-05-08 10:11:36 +00001125 assert( ppBtree != 0);
danielk19774adee202004-05-08 08:23:19 +00001126 if( omitJournal ){
drh33f4e022007-09-03 15:19:34 +00001127 btFlags |= BTREE_OMIT_JOURNAL;
paulb0208cc2003-04-13 18:26:49 +00001128 }
drh7bec5052005-02-06 02:45:41 +00001129 if( db->flags & SQLITE_NoReadlock ){
drh33f4e022007-09-03 15:19:34 +00001130 btFlags |= BTREE_NO_READLOCK;
drh7bec5052005-02-06 02:45:41 +00001131 }
drh90f5ecb2004-07-22 01:19:35 +00001132 if( zFilename==0 ){
danielk1977b06a0b62008-06-26 10:54:12 +00001133#if SQLITE_TEMP_STORE==0
drh22ac46d2004-08-14 18:34:54 +00001134 /* Do nothing */
drh90f5ecb2004-07-22 01:19:35 +00001135#endif
danielk197703aded42004-11-22 05:26:27 +00001136#ifndef SQLITE_OMIT_MEMORYDB
danielk1977b06a0b62008-06-26 10:54:12 +00001137#if SQLITE_TEMP_STORE==1
drh22ac46d2004-08-14 18:34:54 +00001138 if( db->temp_store==2 ) zFilename = ":memory:";
drh90f5ecb2004-07-22 01:19:35 +00001139#endif
danielk1977b06a0b62008-06-26 10:54:12 +00001140#if SQLITE_TEMP_STORE==2
drh22ac46d2004-08-14 18:34:54 +00001141 if( db->temp_store!=1 ) zFilename = ":memory:";
drh90f5ecb2004-07-22 01:19:35 +00001142#endif
danielk1977b06a0b62008-06-26 10:54:12 +00001143#if SQLITE_TEMP_STORE==3
drh22ac46d2004-08-14 18:34:54 +00001144 zFilename = ":memory:";
drh90f5ecb2004-07-22 01:19:35 +00001145#endif
danielk197703aded42004-11-22 05:26:27 +00001146#endif /* SQLITE_OMIT_MEMORYDB */
drh90f5ecb2004-07-22 01:19:35 +00001147 }
danielk19774adee202004-05-08 08:23:19 +00001148
drh33f4e022007-09-03 15:19:34 +00001149 if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 || *zFilename==0) ){
1150 vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
1151 }
1152 rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags);
danielk1977171bfed2008-06-23 09:50:50 +00001153
1154 /* If the B-Tree was successfully opened, set the pager-cache size to the
1155 ** default value. Except, if the call to BtreeOpen() returned a handle
1156 ** open on an existing shared pager-cache, do not change the pager-cache
1157 ** size.
1158 */
1159 if( rc==SQLITE_OK && 0==sqlite3BtreeSchema(*ppBtree, 0, 0) ){
drh90f5ecb2004-07-22 01:19:35 +00001160 sqlite3BtreeSetCacheSize(*ppBtree, nCache);
1161 }
1162 return rc;
paulb0208cc2003-04-13 18:26:49 +00001163}
danielk19774adee202004-05-08 08:23:19 +00001164
danielk19774ad17132004-05-21 01:47:26 +00001165/*
1166** Return UTF-8 encoded English language explanation of the most recent
1167** error.
1168*/
danielk19776622cce2004-05-20 11:00:52 +00001169const char *sqlite3_errmsg(sqlite3 *db){
drhc60d0442004-09-30 13:43:13 +00001170 const char *z;
danielk1977ae7fc492007-03-29 15:00:52 +00001171 if( !db ){
danielk1977f20b21c2004-05-31 23:56:42 +00001172 return sqlite3ErrStr(SQLITE_NOMEM);
danielk19774ad17132004-05-21 01:47:26 +00001173 }
drhd55d57e2008-07-07 17:53:07 +00001174 if( !sqlite3SafetyCheckSickOrOk(db) ){
danielk1977e35ee192004-06-26 09:50:11 +00001175 return sqlite3ErrStr(SQLITE_MISUSE);
1176 }
drh27641702007-08-22 02:56:42 +00001177 sqlite3_mutex_enter(db->mutex);
drh86f8c192007-08-22 00:39:19 +00001178 assert( !db->mallocFailed );
drh2646da72005-12-09 20:02:05 +00001179 z = (char*)sqlite3_value_text(db->pErr);
danielk1977131c8bc2008-05-22 13:56:17 +00001180 assert( !db->mallocFailed );
drhc60d0442004-09-30 13:43:13 +00001181 if( z==0 ){
1182 z = sqlite3ErrStr(db->errCode);
danielk19776622cce2004-05-20 11:00:52 +00001183 }
drhe30f4422007-08-21 16:15:55 +00001184 sqlite3_mutex_leave(db->mutex);
drhc60d0442004-09-30 13:43:13 +00001185 return z;
danielk19776622cce2004-05-20 11:00:52 +00001186}
1187
drh6c626082004-11-14 21:56:29 +00001188#ifndef SQLITE_OMIT_UTF16
danielk19774ad17132004-05-21 01:47:26 +00001189/*
1190** Return UTF-16 encoded English language explanation of the most recent
1191** error.
1192*/
danielk19776622cce2004-05-20 11:00:52 +00001193const void *sqlite3_errmsg16(sqlite3 *db){
danielk1977bfd6cce2004-06-18 04:24:54 +00001194 /* Because all the characters in the string are in the unicode
1195 ** range 0x00-0xFF, if we pad the big-endian string with a
1196 ** zero byte, we can obtain the little-endian string with
1197 ** &big_endian[1].
1198 */
drh57196282004-10-06 15:41:16 +00001199 static const char outOfMemBe[] = {
danielk1977bfd6cce2004-06-18 04:24:54 +00001200 0, 'o', 0, 'u', 0, 't', 0, ' ',
1201 0, 'o', 0, 'f', 0, ' ',
1202 0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
1203 };
drh57196282004-10-06 15:41:16 +00001204 static const char misuseBe [] = {
danielk1977e35ee192004-06-26 09:50:11 +00001205 0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ',
1206 0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ',
1207 0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ',
1208 0, 'o', 0, 'u', 0, 't', 0, ' ',
1209 0, 'o', 0, 'f', 0, ' ',
1210 0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
1211 };
danielk19774ad17132004-05-21 01:47:26 +00001212
drhc60d0442004-09-30 13:43:13 +00001213 const void *z;
danielk1977ae7fc492007-03-29 15:00:52 +00001214 if( !db ){
drhc60d0442004-09-30 13:43:13 +00001215 return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
1216 }
drhd55d57e2008-07-07 17:53:07 +00001217 if( !sqlite3SafetyCheckSickOrOk(db) ){
drhc60d0442004-09-30 13:43:13 +00001218 return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
1219 }
drhe30f4422007-08-21 16:15:55 +00001220 sqlite3_mutex_enter(db->mutex);
1221 assert( !db->mallocFailed );
drhc60d0442004-09-30 13:43:13 +00001222 z = sqlite3_value_text16(db->pErr);
1223 if( z==0 ){
drhb21c8cd2007-08-21 19:33:56 +00001224 sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
drhc60d0442004-09-30 13:43:13 +00001225 SQLITE_UTF8, SQLITE_STATIC);
1226 z = sqlite3_value_text16(db->pErr);
1227 }
danielk1977131c8bc2008-05-22 13:56:17 +00001228 /* A malloc() may have failed within the call to sqlite3_value_text16()
1229 ** above. If this is the case, then the db->mallocFailed flag needs to
1230 ** be cleared before returning. Do this directly, instead of via
1231 ** sqlite3ApiExit(), to avoid setting the database handle error message.
1232 */
1233 db->mallocFailed = 0;
drhe30f4422007-08-21 16:15:55 +00001234 sqlite3_mutex_leave(db->mutex);
drhc60d0442004-09-30 13:43:13 +00001235 return z;
danielk19776622cce2004-05-20 11:00:52 +00001236}
drh6c626082004-11-14 21:56:29 +00001237#endif /* SQLITE_OMIT_UTF16 */
danielk19776622cce2004-05-20 11:00:52 +00001238
drhc60d0442004-09-30 13:43:13 +00001239/*
danielk19777ddad962005-12-12 06:53:03 +00001240** Return the most recent error code generated by an SQLite routine. If NULL is
1241** passed to this function, we assume a malloc() failed during sqlite3_open().
drhc60d0442004-09-30 13:43:13 +00001242*/
danielk19776622cce2004-05-20 11:00:52 +00001243int sqlite3_errcode(sqlite3 *db){
danielk19777c36d072008-01-31 15:31:01 +00001244 if( db && !sqlite3SafetyCheckSickOrOk(db) ){
drhc60d0442004-09-30 13:43:13 +00001245 return SQLITE_MISUSE;
1246 }
drh01495b92008-01-23 12:52:40 +00001247 if( !db || db->mallocFailed ){
1248 return SQLITE_NOMEM;
1249 }
drh4ac285a2006-09-15 07:28:50 +00001250 return db->errCode & db->errMask;
danielk19776622cce2004-05-20 11:00:52 +00001251}
1252
drh0e819f92006-02-01 13:50:41 +00001253/*
1254** Create a new collating function for database "db". The name is zName
1255** and the encoding is enc.
1256*/
danielk19779a30cf62006-01-18 04:26:07 +00001257static int createCollation(
1258 sqlite3* db,
1259 const char *zName,
1260 int enc,
1261 void* pCtx,
danielk1977a9808b32007-05-07 09:32:45 +00001262 int(*xCompare)(void*,int,const void*,int,const void*),
1263 void(*xDel)(void*)
danielk19779a30cf62006-01-18 04:26:07 +00001264){
1265 CollSeq *pColl;
drh7d9bd4e2006-02-16 18:16:36 +00001266 int enc2;
drh0a687d12008-07-08 14:52:07 +00001267 int nName;
danielk19779a30cf62006-01-18 04:26:07 +00001268
drhe30f4422007-08-21 16:15:55 +00001269 assert( sqlite3_mutex_held(db->mutex) );
danielk19779a30cf62006-01-18 04:26:07 +00001270
1271 /* If SQLITE_UTF16 is specified as the encoding type, transform this
1272 ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
1273 ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
1274 */
drh7d9bd4e2006-02-16 18:16:36 +00001275 enc2 = enc & ~SQLITE_UTF16_ALIGNED;
1276 if( enc2==SQLITE_UTF16 ){
1277 enc2 = SQLITE_UTF16NATIVE;
danielk19779a30cf62006-01-18 04:26:07 +00001278 }
drh7d9bd4e2006-02-16 18:16:36 +00001279 if( (enc2&~3)!=0 ){
drhd55d57e2008-07-07 17:53:07 +00001280 return SQLITE_MISUSE;
danielk19779a30cf62006-01-18 04:26:07 +00001281 }
1282
1283 /* Check if this call is removing or replacing an existing collation
1284 ** sequence. If so, and there are active VMs, return busy. If there
1285 ** are no active VMs, invalidate any pre-compiled statements.
1286 */
drh0a687d12008-07-08 14:52:07 +00001287 nName = sqlite3Strlen(db, zName);
1288 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, nName, 0);
danielk19779a30cf62006-01-18 04:26:07 +00001289 if( pColl && pColl->xCmp ){
1290 if( db->activeVdbeCnt ){
1291 sqlite3Error(db, SQLITE_BUSY,
1292 "Unable to delete/modify collation sequence due to active statements");
1293 return SQLITE_BUSY;
1294 }
1295 sqlite3ExpirePreparedStatements(db);
danielk1977a9808b32007-05-07 09:32:45 +00001296
1297 /* If collation sequence pColl was created directly by a call to
1298 ** sqlite3_create_collation, and not generated by synthCollSeq(),
1299 ** then any copies made by synthCollSeq() need to be invalidated.
1300 ** Also, collation destructor - CollSeq.xDel() - function may need
1301 ** to be called.
1302 */
1303 if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
drh0a687d12008-07-08 14:52:07 +00001304 CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, nName);
danielk1977a9808b32007-05-07 09:32:45 +00001305 int j;
1306 for(j=0; j<3; j++){
1307 CollSeq *p = &aColl[j];
1308 if( p->enc==pColl->enc ){
1309 if( p->xDel ){
1310 p->xDel(p->pUser);
1311 }
1312 p->xCmp = 0;
1313 }
1314 }
1315 }
danielk19779a30cf62006-01-18 04:26:07 +00001316 }
1317
drh0a687d12008-07-08 14:52:07 +00001318 pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, nName, 1);
danielk19779a30cf62006-01-18 04:26:07 +00001319 if( pColl ){
1320 pColl->xCmp = xCompare;
1321 pColl->pUser = pCtx;
danielk1977a9808b32007-05-07 09:32:45 +00001322 pColl->xDel = xDel;
drh7d9bd4e2006-02-16 18:16:36 +00001323 pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED);
danielk19779a30cf62006-01-18 04:26:07 +00001324 }
1325 sqlite3Error(db, SQLITE_OK, 0);
1326 return SQLITE_OK;
1327}
1328
1329
danielk19776622cce2004-05-20 11:00:52 +00001330/*
drhbb4957f2008-03-20 14:03:29 +00001331** This array defines hard upper bounds on limit values. The
1332** initializer must be kept in sync with the SQLITE_LIMIT_*
1333** #defines in sqlite3.h.
1334*/
drhb1a6c3c2008-03-20 16:30:17 +00001335static const int aHardLimit[] = {
drhbb4957f2008-03-20 14:03:29 +00001336 SQLITE_MAX_LENGTH,
1337 SQLITE_MAX_SQL_LENGTH,
1338 SQLITE_MAX_COLUMN,
1339 SQLITE_MAX_EXPR_DEPTH,
1340 SQLITE_MAX_COMPOUND_SELECT,
1341 SQLITE_MAX_VDBE_OP,
1342 SQLITE_MAX_FUNCTION_ARG,
1343 SQLITE_MAX_ATTACHED,
drhbb4957f2008-03-20 14:03:29 +00001344 SQLITE_MAX_LIKE_PATTERN_LENGTH,
1345 SQLITE_MAX_VARIABLE_NUMBER,
1346};
1347
1348/*
1349** Make sure the hard limits are set to reasonable values
1350*/
1351#if SQLITE_MAX_LENGTH<100
1352# error SQLITE_MAX_LENGTH must be at least 100
1353#endif
1354#if SQLITE_MAX_SQL_LENGTH<100
1355# error SQLITE_MAX_SQL_LENGTH must be at least 100
1356#endif
1357#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
1358# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
1359#endif
drhbb4957f2008-03-20 14:03:29 +00001360#if SQLITE_MAX_COMPOUND_SELECT<2
1361# error SQLITE_MAX_COMPOUND_SELECT must be at least 2
1362#endif
1363#if SQLITE_MAX_VDBE_OP<40
1364# error SQLITE_MAX_VDBE_OP must be at least 40
1365#endif
drh24b58dd2008-07-07 14:50:14 +00001366#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>127
1367# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 127
drhbb4957f2008-03-20 14:03:29 +00001368#endif
danielk19777b7e23b2008-08-20 16:21:12 +00001369#if SQLITE_MAX_ATTACHED<0 || SQLITE_MAX_ATTACHED>30
1370# error SQLITE_MAX_ATTACHED must be between 0 and 30
drhbb4957f2008-03-20 14:03:29 +00001371#endif
drhbb4957f2008-03-20 14:03:29 +00001372#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
1373# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
1374#endif
1375#if SQLITE_MAX_VARIABLE_NUMBER<1
1376# error SQLITE_MAX_VARIABLE_NUMBER must be at least 1
1377#endif
drh70a8ca32008-08-21 18:49:27 +00001378#if SQLITE_MAX_COLUMN>32767
1379# error SQLITE_MAX_COLUMN must not exceed 32767
1380#endif
drhbb4957f2008-03-20 14:03:29 +00001381
1382
1383/*
1384** Change the value of a limit. Report the old value.
1385** If an invalid limit index is supplied, report -1.
1386** Make no changes but still report the old value if the
1387** new limit is negative.
1388**
1389** A new lower limit does not shrink existing constructs.
1390** It merely prevents new constructs that exceed the limit
1391** from forming.
1392*/
1393int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
1394 int oldLimit;
drh521cc842008-04-15 02:36:33 +00001395 if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
drhbb4957f2008-03-20 14:03:29 +00001396 return -1;
1397 }
1398 oldLimit = db->aLimit[limitId];
1399 if( newLimit>=0 ){
drhf47ce562008-03-20 18:00:49 +00001400 if( newLimit>aHardLimit[limitId] ){
drhbb4957f2008-03-20 14:03:29 +00001401 newLimit = aHardLimit[limitId];
1402 }
1403 db->aLimit[limitId] = newLimit;
1404 }
1405 return oldLimit;
1406}
1407
1408/*
danielk19774ad17132004-05-21 01:47:26 +00001409** This routine does the work of opening a database on behalf of
1410** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
drhee570fa2005-04-28 12:06:05 +00001411** is UTF-8 encoded.
danielk19774ad17132004-05-21 01:47:26 +00001412*/
1413static int openDatabase(
1414 const char *zFilename, /* Database filename UTF-8 encoded */
drh605264d2007-08-21 15:13:19 +00001415 sqlite3 **ppDb, /* OUT: Returned database handle */
1416 unsigned flags, /* Operational flags */
1417 const char *zVfs /* Name of the VFS to use */
danielk19774ad17132004-05-21 01:47:26 +00001418){
1419 sqlite3 *db;
danielk1977da184232006-01-05 11:34:32 +00001420 int rc;
drhd64fe2f2005-08-28 17:00:23 +00001421 CollSeq *pColl;
danielk19779a6284c2008-07-10 17:52:49 +00001422 int isThreadsafe = 1;
danielk19774ad17132004-05-21 01:47:26 +00001423
drh40257ff2008-06-13 18:24:27 +00001424#ifndef SQLITE_OMIT_AUTOINIT
1425 rc = sqlite3_initialize();
1426 if( rc ) return rc;
1427#endif
1428
danielk19779a6284c2008-07-10 17:52:49 +00001429 if( flags&SQLITE_OPEN_NOMUTEX ){
1430 isThreadsafe = 0;
1431 }
1432
drha4267dc2008-02-19 15:20:44 +00001433 /* Remove harmful bits from the flags parameter */
1434 flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
1435 SQLITE_OPEN_MAIN_DB |
1436 SQLITE_OPEN_TEMP_DB |
1437 SQLITE_OPEN_TRANSIENT_DB |
1438 SQLITE_OPEN_MAIN_JOURNAL |
1439 SQLITE_OPEN_TEMP_JOURNAL |
1440 SQLITE_OPEN_SUBJOURNAL |
danielk19779a6284c2008-07-10 17:52:49 +00001441 SQLITE_OPEN_MASTER_JOURNAL |
1442 SQLITE_OPEN_NOMUTEX
drha4267dc2008-02-19 15:20:44 +00001443 );
1444
danielk19774ad17132004-05-21 01:47:26 +00001445 /* Allocate the sqlite data structure */
drh17435752007-08-16 04:30:38 +00001446 db = sqlite3MallocZero( sizeof(sqlite3) );
danielk19774ad17132004-05-21 01:47:26 +00001447 if( db==0 ) goto opendb_out;
danielk19779a6284c2008-07-10 17:52:49 +00001448 if( sqlite3Config.bFullMutex && isThreadsafe ){
danielk197759f8c082008-06-18 17:09:10 +00001449 db->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);
1450 if( db->mutex==0 ){
1451 sqlite3_free(db);
1452 db = 0;
1453 goto opendb_out;
1454 }
drh605264d2007-08-21 15:13:19 +00001455 }
drh27641702007-08-22 02:56:42 +00001456 sqlite3_mutex_enter(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00001457 db->errMask = 0xff;
danielk19774ad17132004-05-21 01:47:26 +00001458 db->priorNewRowid = 0;
danielk19774ad17132004-05-21 01:47:26 +00001459 db->nDb = 2;
drh153c62c2007-08-24 03:51:33 +00001460 db->magic = SQLITE_MAGIC_BUSY;
danielk19774ad17132004-05-21 01:47:26 +00001461 db->aDb = db->aDbStatic;
drh633e6d52008-07-28 19:34:53 +00001462
drhbb4957f2008-03-20 14:03:29 +00001463 assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
1464 memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
danielk19771d850a72004-05-31 08:26:49 +00001465 db->autoCommit = 1;
drhddac25c2007-12-05 01:38:23 +00001466 db->nextAutovac = -1;
danielk1977f653d782008-03-20 11:04:21 +00001467 db->nextPagesize = 0;
drh76fe8032006-07-11 14:17:51 +00001468 db->flags |= SQLITE_ShortColNames
1469#if SQLITE_DEFAULT_FILE_FORMAT<4
1470 | SQLITE_LegacyFileFmt
1471#endif
drh56424db2007-03-27 22:24:11 +00001472#ifdef SQLITE_ENABLE_LOAD_EXTENSION
1473 | SQLITE_LoadExtension
1474#endif
drh76fe8032006-07-11 14:17:51 +00001475 ;
danielk19774ad17132004-05-21 01:47:26 +00001476 sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
drhb9bb7c12006-06-11 23:41:55 +00001477#ifndef SQLITE_OMIT_VIRTUALTABLE
1478 sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
1479#endif
danielk1977da184232006-01-05 11:34:32 +00001480
danielk197795c8a542007-09-01 06:51:27 +00001481 db->pVfs = sqlite3_vfs_find(zVfs);
1482 if( !db->pVfs ){
1483 rc = SQLITE_ERROR;
drhafc91042008-02-21 02:09:45 +00001484 sqlite3Error(db, rc, "no such vfs: %s", zVfs);
danielk197795c8a542007-09-01 06:51:27 +00001485 goto opendb_out;
1486 }
1487
danielk19770202b292004-06-09 09:55:16 +00001488 /* Add the default collation sequence BINARY. BINARY works for both UTF-8
1489 ** and UTF-16, so add a version for each to avoid any unnecessary
1490 ** conversions. The only error that can occur here is a malloc() failure.
1491 */
drhafc91042008-02-21 02:09:45 +00001492 createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
1493 createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
1494 createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
1495 createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
drh77db4c02008-03-18 13:01:38 +00001496 if( db->mallocFailed ){
danielk19770202b292004-06-09 09:55:16 +00001497 goto opendb_out;
1498 }
drh77db4c02008-03-18 13:01:38 +00001499 db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
1500 assert( db->pDfltColl!=0 );
danielk19770202b292004-06-09 09:55:16 +00001501
1502 /* Also add a UTF-8 case-insensitive collation sequence. */
danielk1977a9808b32007-05-07 09:32:45 +00001503 createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
danielk19770202b292004-06-09 09:55:16 +00001504
drhd64fe2f2005-08-28 17:00:23 +00001505 /* Set flags on the built-in collating sequences */
1506 db->pDfltColl->type = SQLITE_COLL_BINARY;
1507 pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
1508 if( pColl ){
1509 pColl->type = SQLITE_COLL_NOCASE;
1510 }
1511
danielk19774ad17132004-05-21 01:47:26 +00001512 /* Open the backend database driver */
drh33f4e022007-09-03 15:19:34 +00001513 db->openFlags = flags;
1514 rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE,
1515 flags | SQLITE_OPEN_MAIN_DB,
drhc797d4d2007-05-08 01:08:49 +00001516 &db->aDb[0].pBt);
danielk19774ad17132004-05-21 01:47:26 +00001517 if( rc!=SQLITE_OK ){
danielk19774ad17132004-05-21 01:47:26 +00001518 sqlite3Error(db, rc, 0);
danielk19774ad17132004-05-21 01:47:26 +00001519 goto opendb_out;
1520 }
drh17435752007-08-16 04:30:38 +00001521 db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
1522 db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
danielk197714db2662006-01-09 16:12:04 +00001523
drh03b808a2006-03-13 15:06:05 +00001524
danielk197753c0f742005-03-29 03:10:59 +00001525 /* The default safety_level for the main database is 'full'; for the temp
1526 ** database it is 'NONE'. This matches the pager layer defaults.
1527 */
1528 db->aDb[0].zName = "main";
danielk197791cf71b2004-06-26 06:37:06 +00001529 db->aDb[0].safety_level = 3;
danielk197753c0f742005-03-29 03:10:59 +00001530#ifndef SQLITE_OMIT_TEMPDB
1531 db->aDb[1].zName = "temp";
danielk197791cf71b2004-06-26 06:37:06 +00001532 db->aDb[1].safety_level = 1;
danielk197753c0f742005-03-29 03:10:59 +00001533#endif
1534
danielk1977832a58a2007-06-22 15:21:15 +00001535 db->magic = SQLITE_MAGIC_OPEN;
drh17435752007-08-16 04:30:38 +00001536 if( db->mallocFailed ){
danielk1977832a58a2007-06-22 15:21:15 +00001537 goto opendb_out;
1538 }
1539
danielk19778e227872004-06-07 07:52:17 +00001540 /* Register all built-in functions, but do not attempt to read the
1541 ** database schema yet. This is delayed until the first time the database
1542 ** is accessed.
1543 */
danielk1977832a58a2007-06-22 15:21:15 +00001544 sqlite3Error(db, SQLITE_OK, 0);
1545 sqlite3RegisterBuiltinFunctions(db);
danielk19774ad17132004-05-21 01:47:26 +00001546
drh1409be62006-08-23 20:07:20 +00001547 /* Load automatic extensions - extensions that have been registered
1548 ** using the sqlite3_automatic_extension() API.
1549 */
drhf533acc2006-12-19 18:57:11 +00001550 (void)sqlite3AutoLoadExtensions(db);
danielk1977832a58a2007-06-22 15:21:15 +00001551 if( sqlite3_errcode(db)!=SQLITE_OK ){
1552 goto opendb_out;
1553 }
drh1409be62006-08-23 20:07:20 +00001554
drhaa29c132006-09-02 13:58:06 +00001555#ifdef SQLITE_ENABLE_FTS1
drh17435752007-08-16 04:30:38 +00001556 if( !db->mallocFailed ){
drhaa29c132006-09-02 13:58:06 +00001557 extern int sqlite3Fts1Init(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00001558 rc = sqlite3Fts1Init(db);
drhaa29c132006-09-02 13:58:06 +00001559 }
1560#endif
1561
shessa26cf572006-10-19 20:27:58 +00001562#ifdef SQLITE_ENABLE_FTS2
drh17435752007-08-16 04:30:38 +00001563 if( !db->mallocFailed && rc==SQLITE_OK ){
shessa26cf572006-10-19 20:27:58 +00001564 extern int sqlite3Fts2Init(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00001565 rc = sqlite3Fts2Init(db);
shessa26cf572006-10-19 20:27:58 +00001566 }
1567#endif
1568
shess69c4ae22007-08-20 17:37:47 +00001569#ifdef SQLITE_ENABLE_FTS3
1570 if( !db->mallocFailed && rc==SQLITE_OK ){
shess69c4ae22007-08-20 17:37:47 +00001571 rc = sqlite3Fts3Init(db);
1572 }
1573#endif
1574
danielk197783852ac2007-05-06 16:04:11 +00001575#ifdef SQLITE_ENABLE_ICU
drh17435752007-08-16 04:30:38 +00001576 if( !db->mallocFailed && rc==SQLITE_OK ){
danielk197783852ac2007-05-06 16:04:11 +00001577 extern int sqlite3IcuInit(sqlite3*);
danielk1977832a58a2007-06-22 15:21:15 +00001578 rc = sqlite3IcuInit(db);
danielk197783852ac2007-05-06 16:04:11 +00001579 }
1580#endif
danielk1977ebaecc12008-05-26 18:41:54 +00001581
1582#ifdef SQLITE_ENABLE_RTREE
1583 if( !db->mallocFailed && rc==SQLITE_OK){
danielk1977ebaecc12008-05-26 18:41:54 +00001584 rc = sqlite3RtreeInit(db);
1585 }
1586#endif
1587
danielk1977832a58a2007-06-22 15:21:15 +00001588 sqlite3Error(db, rc, 0);
danielk197783852ac2007-05-06 16:04:11 +00001589
drh8fd5bd32007-04-02 16:40:37 +00001590 /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
1591 ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
1592 ** mode. Doing nothing at all also makes NORMAL the default.
1593 */
1594#ifdef SQLITE_DEFAULT_LOCKING_MODE
1595 db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
1596 sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
1597 SQLITE_DEFAULT_LOCKING_MODE);
1598#endif
1599
drh633e6d52008-07-28 19:34:53 +00001600 /* Enable the lookaside-malloc subsystem */
drhe9d1c722008-08-04 20:13:26 +00001601 setupLookaside(db, 0, sqlite3Config.szLookaside, sqlite3Config.nLookaside);
drh633e6d52008-07-28 19:34:53 +00001602
danielk19774ad17132004-05-21 01:47:26 +00001603opendb_out:
drhafc91042008-02-21 02:09:45 +00001604 if( db ){
danielk19779a6284c2008-07-10 17:52:49 +00001605 assert( db->mutex!=0 || isThreadsafe==0 || sqlite3Config.bFullMutex==0 );
drhf3a65f72007-08-22 20:18:21 +00001606 sqlite3_mutex_leave(db->mutex);
1607 }
danielk197759633ae2008-08-27 19:01:57 +00001608 rc = sqlite3_errcode(db);
1609 if( rc==SQLITE_NOMEM ){
danielk19777ddad962005-12-12 06:53:03 +00001610 sqlite3_close(db);
1611 db = 0;
danielk197759633ae2008-08-27 19:01:57 +00001612 }else if( rc!=SQLITE_OK ){
1613 db->magic = SQLITE_MAGIC_SICK;
danielk197713073932004-06-30 11:54:06 +00001614 }
danielk19774ad17132004-05-21 01:47:26 +00001615 *ppDb = db;
danielk197754f01982006-01-18 15:25:17 +00001616 return sqlite3ApiExit(0, rc);
danielk19774ad17132004-05-21 01:47:26 +00001617}
1618
1619/*
1620** Open a new database handle.
1621*/
danielk197780290862004-05-22 09:21:21 +00001622int sqlite3_open(
danielk19774ad17132004-05-21 01:47:26 +00001623 const char *zFilename,
danielk19774f057f92004-06-08 00:02:33 +00001624 sqlite3 **ppDb
danielk19774ad17132004-05-21 01:47:26 +00001625){
drh605264d2007-08-21 15:13:19 +00001626 return openDatabase(zFilename, ppDb,
1627 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
1628}
1629int sqlite3_open_v2(
drh428e2822007-08-30 16:23:19 +00001630 const char *filename, /* Database filename (UTF-8) */
drh605264d2007-08-21 15:13:19 +00001631 sqlite3 **ppDb, /* OUT: SQLite db handle */
1632 int flags, /* Flags */
1633 const char *zVfs /* Name of VFS module to use */
1634){
1635 return openDatabase(filename, ppDb, flags, zVfs);
danielk197783ab5a82004-05-21 11:39:05 +00001636}
1637
drh6c626082004-11-14 21:56:29 +00001638#ifndef SQLITE_OMIT_UTF16
danielk19774ad17132004-05-21 01:47:26 +00001639/*
1640** Open a new database handle.
1641*/
1642int sqlite3_open16(
1643 const void *zFilename,
danielk19774f057f92004-06-08 00:02:33 +00001644 sqlite3 **ppDb
danielk19774ad17132004-05-21 01:47:26 +00001645){
danielk1977bfd6cce2004-06-18 04:24:54 +00001646 char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
danielk1977bfd6cce2004-06-18 04:24:54 +00001647 sqlite3_value *pVal;
drh40257ff2008-06-13 18:24:27 +00001648 int rc;
danielk19774ad17132004-05-21 01:47:26 +00001649
danielk19777ddad962005-12-12 06:53:03 +00001650 assert( zFilename );
danielk19774ad17132004-05-21 01:47:26 +00001651 assert( ppDb );
danielk1977bfd6cce2004-06-18 04:24:54 +00001652 *ppDb = 0;
drh40257ff2008-06-13 18:24:27 +00001653#ifndef SQLITE_OMIT_AUTOINIT
1654 rc = sqlite3_initialize();
1655 if( rc ) return rc;
1656#endif
danielk19771e536952007-08-16 10:09:01 +00001657 pVal = sqlite3ValueNew(0);
drhb21c8cd2007-08-21 19:33:56 +00001658 sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
1659 zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
danielk1977bfd6cce2004-06-18 04:24:54 +00001660 if( zFilename8 ){
drh605264d2007-08-21 15:13:19 +00001661 rc = openDatabase(zFilename8, ppDb,
1662 SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
drhafc91042008-02-21 02:09:45 +00001663 assert( *ppDb || rc==SQLITE_NOMEM );
danielk1977f51bf482008-04-28 16:19:35 +00001664 if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
danielk1977fb103a82008-04-03 16:28:24 +00001665 ENC(*ppDb) = SQLITE_UTF16NATIVE;
danielk1977bfd6cce2004-06-18 04:24:54 +00001666 }
drh40257ff2008-06-13 18:24:27 +00001667 }else{
1668 rc = SQLITE_NOMEM;
danielk19774ad17132004-05-21 01:47:26 +00001669 }
danielk19777ddad962005-12-12 06:53:03 +00001670 sqlite3ValueFree(pVal);
danielk19778e227872004-06-07 07:52:17 +00001671
danielk197754f01982006-01-18 15:25:17 +00001672 return sqlite3ApiExit(0, rc);
danielk19774ad17132004-05-21 01:47:26 +00001673}
drh6c626082004-11-14 21:56:29 +00001674#endif /* SQLITE_OMIT_UTF16 */
danielk19774ad17132004-05-21 01:47:26 +00001675
danielk1977106bb232004-05-21 10:08:53 +00001676/*
danielk1977d8123362004-06-12 09:25:12 +00001677** Register a new collation sequence with the database handle db.
1678*/
danielk19770202b292004-06-09 09:55:16 +00001679int sqlite3_create_collation(
1680 sqlite3* db,
1681 const char *zName,
danielk1977466be562004-06-10 02:16:01 +00001682 int enc,
danielk19770202b292004-06-09 09:55:16 +00001683 void* pCtx,
1684 int(*xCompare)(void*,int,const void*,int,const void*)
1685){
danielk19779a30cf62006-01-18 04:26:07 +00001686 int rc;
drhe30f4422007-08-21 16:15:55 +00001687 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00001688 assert( !db->mallocFailed );
danielk1977a9808b32007-05-07 09:32:45 +00001689 rc = createCollation(db, zName, enc, pCtx, xCompare, 0);
drhe30f4422007-08-21 16:15:55 +00001690 rc = sqlite3ApiExit(db, rc);
1691 sqlite3_mutex_leave(db->mutex);
1692 return rc;
danielk1977a9808b32007-05-07 09:32:45 +00001693}
1694
1695/*
1696** Register a new collation sequence with the database handle db.
1697*/
danielk1977a393c032007-05-07 14:58:53 +00001698int sqlite3_create_collation_v2(
danielk1977a9808b32007-05-07 09:32:45 +00001699 sqlite3* db,
1700 const char *zName,
1701 int enc,
1702 void* pCtx,
1703 int(*xCompare)(void*,int,const void*,int,const void*),
1704 void(*xDel)(void*)
1705){
1706 int rc;
drhe30f4422007-08-21 16:15:55 +00001707 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00001708 assert( !db->mallocFailed );
danielk1977a9808b32007-05-07 09:32:45 +00001709 rc = createCollation(db, zName, enc, pCtx, xCompare, xDel);
drhe30f4422007-08-21 16:15:55 +00001710 rc = sqlite3ApiExit(db, rc);
1711 sqlite3_mutex_leave(db->mutex);
1712 return rc;
danielk19770202b292004-06-09 09:55:16 +00001713}
1714
drh6c626082004-11-14 21:56:29 +00001715#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +00001716/*
1717** Register a new collation sequence with the database handle db.
1718*/
danielk19770202b292004-06-09 09:55:16 +00001719int sqlite3_create_collation16(
1720 sqlite3* db,
mihailimbda2e622008-06-23 11:23:14 +00001721 const void *zName,
danielk1977466be562004-06-10 02:16:01 +00001722 int enc,
danielk19770202b292004-06-09 09:55:16 +00001723 void* pCtx,
1724 int(*xCompare)(void*,int,const void*,int,const void*)
1725){
danielk19779a30cf62006-01-18 04:26:07 +00001726 int rc = SQLITE_OK;
drh01495b92008-01-23 12:52:40 +00001727 char *zName8;
drhe30f4422007-08-21 16:15:55 +00001728 sqlite3_mutex_enter(db->mutex);
drh17435752007-08-16 04:30:38 +00001729 assert( !db->mallocFailed );
danielk19771e536952007-08-16 10:09:01 +00001730 zName8 = sqlite3Utf16to8(db, zName, -1);
danielk19779a30cf62006-01-18 04:26:07 +00001731 if( zName8 ){
danielk1977a9808b32007-05-07 09:32:45 +00001732 rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
drh633e6d52008-07-28 19:34:53 +00001733 sqlite3DbFree(db, zName8);
danielk19779a30cf62006-01-18 04:26:07 +00001734 }
drhe30f4422007-08-21 16:15:55 +00001735 rc = sqlite3ApiExit(db, rc);
1736 sqlite3_mutex_leave(db->mutex);
1737 return rc;
danielk19770202b292004-06-09 09:55:16 +00001738}
drh6c626082004-11-14 21:56:29 +00001739#endif /* SQLITE_OMIT_UTF16 */
danielk19777cedc8d2004-06-10 10:50:08 +00001740
danielk1977d8123362004-06-12 09:25:12 +00001741/*
1742** Register a collation sequence factory callback with the database handle
1743** db. Replace any previously installed collation sequence factory.
1744*/
danielk19777cedc8d2004-06-10 10:50:08 +00001745int sqlite3_collation_needed(
1746 sqlite3 *db,
1747 void *pCollNeededArg,
1748 void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
1749){
drhe30f4422007-08-21 16:15:55 +00001750 sqlite3_mutex_enter(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001751 db->xCollNeeded = xCollNeeded;
1752 db->xCollNeeded16 = 0;
1753 db->pCollNeededArg = pCollNeededArg;
drhe30f4422007-08-21 16:15:55 +00001754 sqlite3_mutex_leave(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001755 return SQLITE_OK;
1756}
danielk1977d8123362004-06-12 09:25:12 +00001757
drh6c626082004-11-14 21:56:29 +00001758#ifndef SQLITE_OMIT_UTF16
danielk1977d8123362004-06-12 09:25:12 +00001759/*
1760** Register a collation sequence factory callback with the database handle
1761** db. Replace any previously installed collation sequence factory.
1762*/
danielk19777cedc8d2004-06-10 10:50:08 +00001763int sqlite3_collation_needed16(
1764 sqlite3 *db,
1765 void *pCollNeededArg,
1766 void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
1767){
drhe30f4422007-08-21 16:15:55 +00001768 sqlite3_mutex_enter(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001769 db->xCollNeeded = 0;
1770 db->xCollNeeded16 = xCollNeeded16;
1771 db->pCollNeededArg = pCollNeededArg;
drhe30f4422007-08-21 16:15:55 +00001772 sqlite3_mutex_leave(db->mutex);
danielk19777cedc8d2004-06-10 10:50:08 +00001773 return SQLITE_OK;
1774}
drh6c626082004-11-14 21:56:29 +00001775#endif /* SQLITE_OMIT_UTF16 */
danielk19776b456a22005-03-21 04:04:02 +00001776
1777#ifndef SQLITE_OMIT_GLOBALRECOVER
1778/*
danielk19777ddad962005-12-12 06:53:03 +00001779** This function is now an anachronism. It used to be used to recover from a
1780** malloc() failure, but SQLite now does this automatically.
danielk19776b456a22005-03-21 04:04:02 +00001781*/
drh7d97efb2007-10-12 19:35:48 +00001782int sqlite3_global_recover(void){
danielk1977261919c2005-12-06 12:52:59 +00001783 return SQLITE_OK;
danielk19776b456a22005-03-21 04:04:02 +00001784}
1785#endif
drh3e1d8e62005-05-26 16:23:34 +00001786
1787/*
1788** Test to see whether or not the database connection is in autocommit
1789** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
1790** by default. Autocommit is disabled by a BEGIN statement and reenabled
1791** by the next COMMIT or ROLLBACK.
1792**
1793******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
1794*/
1795int sqlite3_get_autocommit(sqlite3 *db){
1796 return db->autoCommit;
1797}
drh49285702005-09-17 15:20:26 +00001798
1799#ifdef SQLITE_DEBUG
1800/*
1801** The following routine is subtituted for constant SQLITE_CORRUPT in
1802** debugging builds. This provides a way to set a breakpoint for when
1803** corruption is first detected.
1804*/
1805int sqlite3Corrupt(void){
1806 return SQLITE_CORRUPT;
1807}
1808#endif
drh7c1817e2006-01-10 13:58:48 +00001809
drh6f7adc82006-01-11 21:41:20 +00001810/*
1811** This is a convenience routine that makes sure that all thread-specific
1812** data for this thread has been deallocated.
drhdce8bdb2007-08-16 13:01:44 +00001813**
1814** SQLite no longer uses thread-specific data so this routine is now a
1815** no-op. It is retained for historical compatibility.
drh6f7adc82006-01-11 21:41:20 +00001816*/
1817void sqlite3_thread_cleanup(void){
drh6f7adc82006-01-11 21:41:20 +00001818}
danielk1977deb802c2006-02-09 13:43:28 +00001819
1820/*
1821** Return meta information about a specific column of a database table.
1822** See comment in sqlite3.h (sqlite.h.in) for details.
1823*/
1824#ifdef SQLITE_ENABLE_COLUMN_METADATA
1825int sqlite3_table_column_metadata(
1826 sqlite3 *db, /* Connection handle */
1827 const char *zDbName, /* Database name or NULL */
1828 const char *zTableName, /* Table name */
1829 const char *zColumnName, /* Column name */
1830 char const **pzDataType, /* OUTPUT: Declared data type */
1831 char const **pzCollSeq, /* OUTPUT: Collation sequence name */
1832 int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
1833 int *pPrimaryKey, /* OUTPUT: True if column part of PK */
drh9be07162008-06-16 20:51:15 +00001834 int *pAutoinc /* OUTPUT: True if column is auto-increment */
danielk1977deb802c2006-02-09 13:43:28 +00001835){
1836 int rc;
1837 char *zErrMsg = 0;
1838 Table *pTab = 0;
1839 Column *pCol = 0;
1840 int iCol;
1841
1842 char const *zDataType = 0;
1843 char const *zCollSeq = 0;
1844 int notnull = 0;
1845 int primarykey = 0;
1846 int autoinc = 0;
1847
1848 /* Ensure the database schema has been loaded */
drhe30f4422007-08-21 16:15:55 +00001849 sqlite3_mutex_enter(db->mutex);
drha0af99f2008-04-16 00:49:12 +00001850 (void)sqlite3SafetyOn(db);
drh3cb3edc2008-03-07 21:37:19 +00001851 sqlite3BtreeEnterAll(db);
danielk1977deb802c2006-02-09 13:43:28 +00001852 rc = sqlite3Init(db, &zErrMsg);
drh3cb3edc2008-03-07 21:37:19 +00001853 sqlite3BtreeLeaveAll(db);
danielk1977deb802c2006-02-09 13:43:28 +00001854 if( SQLITE_OK!=rc ){
1855 goto error_out;
1856 }
1857
1858 /* Locate the table in question */
1859 pTab = sqlite3FindTable(db, zTableName, zDbName);
1860 if( !pTab || pTab->pSelect ){
1861 pTab = 0;
1862 goto error_out;
1863 }
1864
1865 /* Find the column for which info is requested */
1866 if( sqlite3IsRowid(zColumnName) ){
1867 iCol = pTab->iPKey;
1868 if( iCol>=0 ){
1869 pCol = &pTab->aCol[iCol];
1870 }
1871 }else{
1872 for(iCol=0; iCol<pTab->nCol; iCol++){
1873 pCol = &pTab->aCol[iCol];
1874 if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
1875 break;
1876 }
1877 }
1878 if( iCol==pTab->nCol ){
1879 pTab = 0;
1880 goto error_out;
1881 }
1882 }
1883
1884 /* The following block stores the meta information that will be returned
1885 ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
1886 ** and autoinc. At this point there are two possibilities:
1887 **
1888 ** 1. The specified column name was rowid", "oid" or "_rowid_"
1889 ** and there is no explicitly declared IPK column.
1890 **
1891 ** 2. The table is not a view and the column name identified an
1892 ** explicitly declared column. Copy meta information from *pCol.
1893 */
1894 if( pCol ){
1895 zDataType = pCol->zType;
1896 zCollSeq = pCol->zColl;
drh9be07162008-06-16 20:51:15 +00001897 notnull = pCol->notNull!=0;
1898 primarykey = pCol->isPrimKey!=0;
drh7d10d5a2008-08-20 16:35:10 +00001899 autoinc = pTab->iPKey==iCol && (pTab->tabFlags & TF_Autoincrement)!=0;
danielk1977deb802c2006-02-09 13:43:28 +00001900 }else{
1901 zDataType = "INTEGER";
1902 primarykey = 1;
1903 }
1904 if( !zCollSeq ){
1905 zCollSeq = "BINARY";
1906 }
1907
1908error_out:
drh01495b92008-01-23 12:52:40 +00001909 (void)sqlite3SafetyOff(db);
danielk1977deb802c2006-02-09 13:43:28 +00001910
1911 /* Whether the function call succeeded or failed, set the output parameters
1912 ** to whatever their local counterparts contain. If an error did occur,
1913 ** this has the effect of zeroing all output parameters.
1914 */
1915 if( pzDataType ) *pzDataType = zDataType;
1916 if( pzCollSeq ) *pzCollSeq = zCollSeq;
1917 if( pNotNull ) *pNotNull = notnull;
1918 if( pPrimaryKey ) *pPrimaryKey = primarykey;
1919 if( pAutoinc ) *pAutoinc = autoinc;
1920
1921 if( SQLITE_OK==rc && !pTab ){
drh633e6d52008-07-28 19:34:53 +00001922 sqlite3DbFree(db, zErrMsg);
drh118640b2008-07-16 14:02:32 +00001923 zErrMsg = sqlite3MPrintf(db, "no such table column: %s.%s", zTableName,
drhf089aa42008-07-08 19:34:06 +00001924 zColumnName);
danielk1977deb802c2006-02-09 13:43:28 +00001925 rc = SQLITE_ERROR;
1926 }
1927 sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
drh633e6d52008-07-28 19:34:53 +00001928 sqlite3DbFree(db, zErrMsg);
drhe30f4422007-08-21 16:15:55 +00001929 rc = sqlite3ApiExit(db, rc);
1930 sqlite3_mutex_leave(db->mutex);
drhf9cb7f52006-06-27 20:06:44 +00001931 return rc;
1932}
drhe30f4422007-08-21 16:15:55 +00001933#endif
drhf9cb7f52006-06-27 20:06:44 +00001934
1935/*
1936** Sleep for a little while. Return the amount of time slept.
1937*/
1938int sqlite3_sleep(int ms){
danielk1977b4b47412007-08-17 15:53:36 +00001939 sqlite3_vfs *pVfs;
drhe30f4422007-08-21 16:15:55 +00001940 int rc;
drhd677b3d2007-08-20 22:48:41 +00001941 pVfs = sqlite3_vfs_find(0);
drh40257ff2008-06-13 18:24:27 +00001942 if( pVfs==0 ) return 0;
danielk1977fee2d252007-08-18 10:59:19 +00001943
1944 /* This function works in milliseconds, but the underlying OsSleep()
1945 ** API uses microseconds. Hence the 1000's.
1946 */
drhe30f4422007-08-21 16:15:55 +00001947 rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
drhe30f4422007-08-21 16:15:55 +00001948 return rc;
drhf9cb7f52006-06-27 20:06:44 +00001949}
drh4ac285a2006-09-15 07:28:50 +00001950
1951/*
1952** Enable or disable the extended result codes.
1953*/
1954int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
drhe30f4422007-08-21 16:15:55 +00001955 sqlite3_mutex_enter(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00001956 db->errMask = onoff ? 0xffffffff : 0xff;
drhe30f4422007-08-21 16:15:55 +00001957 sqlite3_mutex_leave(db->mutex);
drh4ac285a2006-09-15 07:28:50 +00001958 return SQLITE_OK;
1959}
drhcc6bb3e2007-08-31 16:11:35 +00001960
1961/*
1962** Invoke the xFileControl method on a particular database.
1963*/
1964int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
1965 int rc = SQLITE_ERROR;
1966 int iDb;
1967 sqlite3_mutex_enter(db->mutex);
1968 if( zDbName==0 ){
1969 iDb = 0;
1970 }else{
1971 for(iDb=0; iDb<db->nDb; iDb++){
1972 if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
1973 }
1974 }
1975 if( iDb<db->nDb ){
1976 Btree *pBtree = db->aDb[iDb].pBt;
1977 if( pBtree ){
1978 Pager *pPager;
drh55176252008-01-22 14:50:16 +00001979 sqlite3_file *fd;
drhcc6bb3e2007-08-31 16:11:35 +00001980 sqlite3BtreeEnter(pBtree);
1981 pPager = sqlite3BtreePager(pBtree);
drh55176252008-01-22 14:50:16 +00001982 assert( pPager!=0 );
1983 fd = sqlite3PagerFile(pPager);
1984 assert( fd!=0 );
1985 if( fd->pMethods ){
1986 rc = sqlite3OsFileControl(fd, op, pArg);
drhcc6bb3e2007-08-31 16:11:35 +00001987 }
1988 sqlite3BtreeLeave(pBtree);
1989 }
1990 }
1991 sqlite3_mutex_leave(db->mutex);
1992 return rc;
1993}
drhed13d982008-01-31 14:43:24 +00001994
1995/*
1996** Interface to the testing logic.
1997*/
1998int sqlite3_test_control(int op, ...){
drhed13d982008-01-31 14:43:24 +00001999 int rc = 0;
drh3088d592008-03-21 16:45:47 +00002000#ifndef SQLITE_OMIT_BUILTIN_TEST
drh2fa18682008-03-19 14:15:34 +00002001 va_list ap;
drhed13d982008-01-31 14:43:24 +00002002 va_start(ap, op);
2003 switch( op ){
danielk1977d09414c2008-06-19 18:17:49 +00002004
2005 /*
drh984bfaa2008-03-19 16:08:53 +00002006 ** Save the current state of the PRNG.
2007 */
drh2fa18682008-03-19 14:15:34 +00002008 case SQLITE_TESTCTRL_PRNG_SAVE: {
2009 sqlite3PrngSaveState();
2010 break;
2011 }
drh984bfaa2008-03-19 16:08:53 +00002012
2013 /*
2014 ** Restore the state of the PRNG to the last state saved using
2015 ** PRNG_SAVE. If PRNG_SAVE has never before been called, then
2016 ** this verb acts like PRNG_RESET.
2017 */
drh2fa18682008-03-19 14:15:34 +00002018 case SQLITE_TESTCTRL_PRNG_RESTORE: {
2019 sqlite3PrngRestoreState();
2020 break;
2021 }
drh984bfaa2008-03-19 16:08:53 +00002022
2023 /*
2024 ** Reset the PRNG back to its uninitialized state. The next call
2025 ** to sqlite3_randomness() will reseed the PRNG using a single call
2026 ** to the xRandomness method of the default VFS.
2027 */
drh2fa18682008-03-19 14:15:34 +00002028 case SQLITE_TESTCTRL_PRNG_RESET: {
2029 sqlite3PrngResetState();
2030 break;
2031 }
drh3088d592008-03-21 16:45:47 +00002032
2033 /*
2034 ** sqlite3_test_control(BITVEC_TEST, size, program)
2035 **
2036 ** Run a test against a Bitvec object of size. The program argument
2037 ** is an array of integers that defines the test. Return -1 on a
2038 ** memory allocation error, 0 on success, or non-zero for an error.
2039 ** See the sqlite3BitvecBuiltinTest() for additional information.
2040 */
2041 case SQLITE_TESTCTRL_BITVEC_TEST: {
2042 int sz = va_arg(ap, int);
2043 int *aProg = va_arg(ap, int*);
2044 rc = sqlite3BitvecBuiltinTest(sz, aProg);
2045 break;
2046 }
danielk19772d1d86f2008-06-20 14:59:51 +00002047
2048 /*
2049 ** sqlite3_test_control(BENIGN_MALLOC_HOOKS, xBegin, xEnd)
2050 **
2051 ** Register hooks to call to indicate which malloc() failures
2052 ** are benign.
2053 */
2054 case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: {
danielk1977ca026792008-06-23 14:15:52 +00002055 typedef void (*void_function)(void);
2056 void_function xBenignBegin;
2057 void_function xBenignEnd;
2058 xBenignBegin = va_arg(ap, void_function);
2059 xBenignEnd = va_arg(ap, void_function);
danielk19772d1d86f2008-06-20 14:59:51 +00002060 sqlite3BenignMallocHooks(xBenignBegin, xBenignEnd);
2061 break;
2062 }
drhed13d982008-01-31 14:43:24 +00002063 }
2064 va_end(ap);
drh3088d592008-03-21 16:45:47 +00002065#endif /* SQLITE_OMIT_BUILTIN_TEST */
danielk19777c36d072008-01-31 15:31:01 +00002066 return rc;
drhed13d982008-01-31 14:43:24 +00002067}