1 : /*
2 : ** 2001 September 15
3 : **
4 : ** The author disclaims copyright to this source code. In place of
5 : ** a legal notice, here is a blessing:
6 : **
7 : ** May you do good and not evil.
8 : ** May you find forgiveness for yourself and forgive others.
9 : ** May you share freely, never taking more than you give.
10 : **
11 : *************************************************************************
12 : ** Main file for the SQLite library. The routines in this file
13 : ** implement the programmer interface to the library. Routines in
14 : ** other files are for internal use by SQLite and should not be
15 : ** accessed by users of the library.
16 : **
17 : ** $Id$
18 : */
19 : #include "sqliteInt.h"
20 : #include "os.h"
21 : #include <ctype.h>
22 :
23 : /*
24 : ** The version of the library
25 : */
26 : const char sqlite3_version[] = SQLITE_VERSION;
27 6 : const char *sqlite3_libversion(void){ return sqlite3_version; }
28 0 : int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
29 :
30 : /*
31 : ** If the following function pointer is not NULL and if
32 : ** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
33 : ** I/O active are written using this function. These messages
34 : ** are intended for debugging activity only.
35 : */
36 : void (*sqlite3_io_trace)(const char*, ...) = 0;
37 :
38 : /*
39 : ** If the following global variable points to a string which is the
40 : ** name of a directory, then that directory will be used to store
41 : ** temporary files.
42 : **
43 : ** See also the "PRAGMA temp_store_directory" SQL command.
44 : */
45 : char *sqlite3_temp_directory = 0;
46 :
47 :
48 : /*
49 : ** This is the default collating function named "BINARY" which is always
50 : ** available.
51 : */
52 : static int binCollFunc(
53 : void *NotUsed,
54 : int nKey1, const void *pKey1,
55 : int nKey2, const void *pKey2
56 188 : ){
57 : int rc, n;
58 188 : n = nKey1<nKey2 ? nKey1 : nKey2;
59 188 : rc = memcmp(pKey1, pKey2, n);
60 188 : if( rc==0 ){
61 120 : rc = nKey1 - nKey2;
62 : }
63 188 : return rc;
64 : }
65 :
66 : /*
67 : ** Another built-in collating sequence: NOCASE.
68 : **
69 : ** This collating sequence is intended to be used for "case independant
70 : ** comparison". SQLite's knowledge of upper and lower case equivalents
71 : ** extends only to the 26 characters used in the English language.
72 : **
73 : ** At the moment there is only a UTF-8 implementation.
74 : */
75 : static int nocaseCollatingFunc(
76 : void *NotUsed,
77 : int nKey1, const void *pKey1,
78 : int nKey2, const void *pKey2
79 0 : ){
80 : int r = sqlite3StrNICmp(
81 0 : (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
82 0 : if( 0==r ){
83 0 : r = nKey1-nKey2;
84 : }
85 0 : return r;
86 : }
87 :
88 : /*
89 : ** Return the ROWID of the most recent insert
90 : */
91 1 : sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
92 1 : return db->lastRowid;
93 : }
94 :
95 : /*
96 : ** Return the number of changes in the most recent call to sqlite3_exec().
97 : */
98 212 : int sqlite3_changes(sqlite3 *db){
99 212 : return db->nChange;
100 : }
101 :
102 : /*
103 : ** Return the number of changes since the database handle was opened.
104 : */
105 0 : int sqlite3_total_changes(sqlite3 *db){
106 0 : return db->nTotalChange;
107 : }
108 :
109 : /*
110 : ** Close an existing SQLite database
111 : */
112 129 : int sqlite3_close(sqlite3 *db){
113 : HashElem *i;
114 : int j;
115 :
116 129 : if( !db ){
117 0 : return SQLITE_OK;
118 : }
119 129 : if( sqlite3SafetyCheck(db) ){
120 0 : return SQLITE_MISUSE;
121 : }
122 :
123 : #ifdef SQLITE_SSE
124 : {
125 : extern void sqlite3SseCleanup(sqlite3*);
126 : sqlite3SseCleanup(db);
127 : }
128 : #endif
129 :
130 129 : sqlite3ResetInternalSchema(db, 0);
131 :
132 : /* If a transaction is open, the ResetInternalSchema() call above
133 : ** will not have called the xDisconnect() method on any virtual
134 : ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
135 : ** call will do so. We need to do this before the check for active
136 : ** SQL statements below, as the v-table implementation may be storing
137 : ** some prepared statements internally.
138 : */
139 129 : sqlite3VtabRollback(db);
140 :
141 : /* If there are any outstanding VMs, return SQLITE_BUSY. */
142 129 : if( db->pVdbe ){
143 0 : sqlite3Error(db, SQLITE_BUSY,
144 : "Unable to close due to unfinalised statements");
145 0 : return SQLITE_BUSY;
146 : }
147 : assert( !sqlite3SafetyCheck(db) );
148 :
149 : /* FIX ME: db->magic may be set to SQLITE_MAGIC_CLOSED if the database
150 : ** cannot be opened for some reason. So this routine needs to run in
151 : ** that case. But maybe there should be an extra magic value for the
152 : ** "failed to open" state.
153 : **
154 : ** TODO: Coverage tests do not test the case where this condition is
155 : ** true. It's hard to see how to cause it without messing with threads.
156 : */
157 129 : if( db->magic!=SQLITE_MAGIC_CLOSED && sqlite3SafetyOn(db) ){
158 : /* printf("DID NOT CLOSE\n"); fflush(stdout); */
159 0 : return SQLITE_ERROR;
160 : }
161 :
162 387 : for(j=0; j<db->nDb; j++){
163 258 : struct Db *pDb = &db->aDb[j];
164 258 : if( pDb->pBt ){
165 129 : sqlite3BtreeClose(pDb->pBt);
166 129 : pDb->pBt = 0;
167 129 : if( j!=1 ){
168 129 : pDb->pSchema = 0;
169 : }
170 : }
171 : }
172 129 : sqlite3ResetInternalSchema(db, 0);
173 : assert( db->nDb<=2 );
174 : assert( db->aDb==db->aDbStatic );
175 5807 : for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
176 : FuncDef *pFunc, *pNext;
177 13162 : for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){
178 7484 : pNext = pFunc->pNext;
179 7484 : sqliteFree(pFunc);
180 : }
181 : }
182 :
183 387 : for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
184 258 : CollSeq *pColl = (CollSeq *)sqliteHashData(i);
185 258 : sqliteFree(pColl);
186 : }
187 129 : sqlite3HashClear(&db->aCollSeq);
188 : #ifndef SQLITE_OMIT_VIRTUALTABLE
189 129 : for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
190 0 : Module *pMod = (Module *)sqliteHashData(i);
191 0 : sqliteFree(pMod);
192 : }
193 129 : sqlite3HashClear(&db->aModule);
194 : #endif
195 :
196 129 : sqlite3HashClear(&db->aFunc);
197 129 : sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
198 129 : if( db->pErr ){
199 129 : sqlite3ValueFree(db->pErr);
200 : }
201 129 : sqlite3CloseExtensions(db);
202 :
203 129 : db->magic = SQLITE_MAGIC_ERROR;
204 :
205 : /* The temp-database schema is allocated differently from the other schema
206 : ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
207 : ** So it needs to be freed here. Todo: Why not roll the temp schema into
208 : ** the same sqliteMalloc() as the one that allocates the database
209 : ** structure?
210 : */
211 129 : sqliteFree(db->aDb[1].pSchema);
212 129 : sqliteFree(db);
213 129 : sqlite3ReleaseThreadData();
214 129 : return SQLITE_OK;
215 : }
216 :
217 : /*
218 : ** Rollback all database files.
219 : */
220 3 : void sqlite3RollbackAll(sqlite3 *db){
221 : int i;
222 3 : int inTrans = 0;
223 9 : for(i=0; i<db->nDb; i++){
224 6 : if( db->aDb[i].pBt ){
225 3 : if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
226 2 : inTrans = 1;
227 : }
228 3 : sqlite3BtreeRollback(db->aDb[i].pBt);
229 3 : db->aDb[i].inTrans = 0;
230 : }
231 : }
232 3 : sqlite3VtabRollback(db);
233 3 : if( db->flags&SQLITE_InternChanges ){
234 0 : sqlite3ResetInternalSchema(db, 0);
235 : }
236 :
237 : /* If one has been configured, invoke the rollback-hook callback */
238 3 : if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
239 0 : db->xRollbackCallback(db->pRollbackArg);
240 : }
241 3 : }
242 :
243 : /*
244 : ** Return a static string that describes the kind of error specified in the
245 : ** argument.
246 : */
247 2 : const char *sqlite3ErrStr(int rc){
248 : const char *z;
249 2 : switch( rc & 0xff ){
250 : case SQLITE_ROW:
251 : case SQLITE_DONE:
252 0 : case SQLITE_OK: z = "not an error"; break;
253 0 : case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
254 0 : case SQLITE_PERM: z = "access permission denied"; break;
255 0 : case SQLITE_ABORT: z = "callback requested query abort"; break;
256 0 : case SQLITE_BUSY: z = "database is locked"; break;
257 1 : case SQLITE_LOCKED: z = "database table is locked"; break;
258 0 : case SQLITE_NOMEM: z = "out of memory"; break;
259 0 : case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
260 0 : case SQLITE_INTERRUPT: z = "interrupted"; break;
261 0 : case SQLITE_IOERR: z = "disk I/O error"; break;
262 0 : case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
263 0 : case SQLITE_FULL: z = "database or disk is full"; break;
264 0 : case SQLITE_CANTOPEN: z = "unable to open database file"; break;
265 0 : case SQLITE_EMPTY: z = "table contains no data"; break;
266 0 : case SQLITE_SCHEMA: z = "database schema has changed"; break;
267 0 : case SQLITE_CONSTRAINT: z = "constraint failed"; break;
268 0 : case SQLITE_MISMATCH: z = "datatype mismatch"; break;
269 0 : case SQLITE_MISUSE: z = "library routine called out of sequence";break;
270 0 : case SQLITE_NOLFS: z = "kernel lacks large file support"; break;
271 0 : case SQLITE_AUTH: z = "authorization denied"; break;
272 0 : case SQLITE_FORMAT: z = "auxiliary database format error"; break;
273 1 : case SQLITE_RANGE: z = "bind or column index out of range"; break;
274 0 : case SQLITE_NOTADB: z = "file is encrypted or is not a database";break;
275 0 : default: z = "unknown error"; break;
276 : }
277 2 : return z;
278 : }
279 :
280 : /*
281 : ** This routine implements a busy callback that sleeps and tries
282 : ** again until a timeout value is reached. The timeout value is
283 : ** an integer number of milliseconds passed in as the first
284 : ** argument.
285 : */
286 : static int sqliteDefaultBusyCallback(
287 : void *ptr, /* Database connection */
288 : int count /* Number of times table has been busy */
289 0 : ){
290 : #if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
291 : static const u8 delays[] =
292 : { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
293 : static const u8 totals[] =
294 : { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
295 : # define NDELAY (sizeof(delays)/sizeof(delays[0]))
296 : int timeout = ((sqlite3 *)ptr)->busyTimeout;
297 : int delay, prior;
298 :
299 : assert( count>=0 );
300 : if( count < NDELAY ){
301 : delay = delays[count];
302 : prior = totals[count];
303 : }else{
304 : delay = delays[NDELAY-1];
305 : prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
306 : }
307 : if( prior + delay > timeout ){
308 : delay = timeout - prior;
309 : if( delay<=0 ) return 0;
310 : }
311 : sqlite3OsSleep(delay);
312 : return 1;
313 : #else
314 0 : int timeout = ((sqlite3 *)ptr)->busyTimeout;
315 0 : if( (count+1)*1000 > timeout ){
316 0 : return 0;
317 : }
318 0 : sqlite3OsSleep(1000);
319 0 : return 1;
320 : #endif
321 : }
322 :
323 : /*
324 : ** Invoke the given busy handler.
325 : **
326 : ** This routine is called when an operation failed with a lock.
327 : ** If this routine returns non-zero, the lock is retried. If it
328 : ** returns 0, the operation aborts with an SQLITE_BUSY error.
329 : */
330 0 : int sqlite3InvokeBusyHandler(BusyHandler *p){
331 : int rc;
332 0 : if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0;
333 0 : rc = p->xFunc(p->pArg, p->nBusy);
334 0 : if( rc==0 ){
335 0 : p->nBusy = -1;
336 : }else{
337 0 : p->nBusy++;
338 : }
339 0 : return rc;
340 : }
341 :
342 : /*
343 : ** This routine sets the busy callback for an Sqlite database to the
344 : ** given callback function with the given argument.
345 : */
346 : int sqlite3_busy_handler(
347 : sqlite3 *db,
348 : int (*xBusy)(void*,int),
349 : void *pArg
350 148 : ){
351 148 : if( sqlite3SafetyCheck(db) ){
352 0 : return SQLITE_MISUSE;
353 : }
354 148 : db->busyHandler.xFunc = xBusy;
355 148 : db->busyHandler.pArg = pArg;
356 148 : db->busyHandler.nBusy = 0;
357 148 : return SQLITE_OK;
358 : }
359 :
360 : #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
361 : /*
362 : ** This routine sets the progress callback for an Sqlite database to the
363 : ** given callback function with the given argument. The progress callback will
364 : ** be invoked every nOps opcodes.
365 : */
366 : void sqlite3_progress_handler(
367 : sqlite3 *db,
368 : int nOps,
369 : int (*xProgress)(void*),
370 : void *pArg
371 0 : ){
372 0 : if( !sqlite3SafetyCheck(db) ){
373 0 : if( nOps>0 ){
374 0 : db->xProgress = xProgress;
375 0 : db->nProgressOps = nOps;
376 0 : db->pProgressArg = pArg;
377 : }else{
378 0 : db->xProgress = 0;
379 0 : db->nProgressOps = 0;
380 0 : db->pProgressArg = 0;
381 : }
382 : }
383 0 : }
384 : #endif
385 :
386 :
387 : /*
388 : ** This routine installs a default busy handler that waits for the
389 : ** specified number of milliseconds before returning 0.
390 : */
391 148 : int sqlite3_busy_timeout(sqlite3 *db, int ms){
392 148 : if( sqlite3SafetyCheck(db) ){
393 0 : return SQLITE_MISUSE;
394 : }
395 148 : if( ms>0 ){
396 136 : db->busyTimeout = ms;
397 136 : sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
398 : }else{
399 12 : sqlite3_busy_handler(db, 0, 0);
400 : }
401 148 : return SQLITE_OK;
402 : }
403 :
404 : /*
405 : ** Cause any pending operation to stop at its earliest opportunity.
406 : */
407 0 : void sqlite3_interrupt(sqlite3 *db){
408 0 : if( db && (db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_BUSY) ){
409 0 : db->u1.isInterrupted = 1;
410 : }
411 0 : }
412 :
413 : /*
414 : ** Memory allocation routines that use SQLites internal memory
415 : ** memory allocator. Depending on how SQLite is compiled, the
416 : ** internal memory allocator might be just an alias for the
417 : ** system default malloc/realloc/free. Or the built-in allocator
418 : ** might do extra stuff like put sentinals around buffers to
419 : ** check for overruns or look for memory leaks.
420 : **
421 : ** Use sqlite3_free() to free memory returned by sqlite3_mprintf().
422 : */
423 309 : void sqlite3_free(void *p){ if( p ) sqlite3OsFree(p); }
424 309 : void *sqlite3_malloc(int nByte){ return nByte>0 ? sqlite3OsMalloc(nByte) : 0; }
425 0 : void *sqlite3_realloc(void *pOld, int nByte){
426 0 : if( pOld ){
427 0 : if( nByte>0 ){
428 0 : return sqlite3OsRealloc(pOld, nByte);
429 : }else{
430 0 : sqlite3OsFree(pOld);
431 0 : return 0;
432 : }
433 : }else{
434 0 : return sqlite3_malloc(nByte);
435 : }
436 : }
437 :
438 : /*
439 : ** This function is exactly the same as sqlite3_create_function(), except
440 : ** that it is designed to be called by internal code. The difference is
441 : ** that if a malloc() fails in sqlite3_create_function(), an error code
442 : ** is returned and the mallocFailed flag cleared.
443 : */
444 : int sqlite3CreateFunc(
445 : sqlite3 *db,
446 : const char *zFunctionName,
447 : int nArg,
448 : int enc,
449 : void *pUserData,
450 : void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
451 : void (*xStep)(sqlite3_context*,int,sqlite3_value **),
452 : void (*xFinal)(sqlite3_context*)
453 7544 : ){
454 : FuncDef *p;
455 : int nName;
456 :
457 7544 : if( sqlite3SafetyCheck(db) ){
458 0 : return SQLITE_MISUSE;
459 : }
460 7544 : if( zFunctionName==0 ||
461 : (xFunc && (xFinal || xStep)) ||
462 : (!xFunc && (xFinal && !xStep)) ||
463 : (!xFunc && (!xFinal && xStep)) ||
464 : (nArg<-1 || nArg>127) ||
465 : (255<(nName = strlen(zFunctionName))) ){
466 0 : sqlite3Error(db, SQLITE_ERROR, "bad parameters");
467 0 : return SQLITE_ERROR;
468 : }
469 :
470 : #ifndef SQLITE_OMIT_UTF16
471 : /* If SQLITE_UTF16 is specified as the encoding type, transform this
472 : ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
473 : ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
474 : **
475 : ** If SQLITE_ANY is specified, add three versions of the function
476 : ** to the hash table.
477 : */
478 7544 : if( enc==SQLITE_UTF16 ){
479 0 : enc = SQLITE_UTF16NATIVE;
480 7544 : }else if( enc==SQLITE_ANY ){
481 : int rc;
482 0 : rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
483 : pUserData, xFunc, xStep, xFinal);
484 0 : if( rc!=SQLITE_OK ) return rc;
485 0 : rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
486 : pUserData, xFunc, xStep, xFinal);
487 0 : if( rc!=SQLITE_OK ) return rc;
488 0 : enc = SQLITE_UTF16BE;
489 : }
490 : #else
491 : enc = SQLITE_UTF8;
492 : #endif
493 :
494 : /* Check if an existing function is being overridden or deleted. If so,
495 : ** and there are active VMs, then return SQLITE_BUSY. If a function
496 : ** is being overridden/deleted but there are no active VMs, allow the
497 : ** operation to continue but invalidate all precompiled statements.
498 : */
499 7544 : p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
500 7544 : if( p && p->iPrefEnc==enc && p->nArg==nArg ){
501 2 : if( db->activeVdbeCnt ){
502 0 : sqlite3Error(db, SQLITE_BUSY,
503 : "Unable to delete/modify user-function due to active statements");
504 : assert( !sqlite3MallocFailed() );
505 0 : return SQLITE_BUSY;
506 : }else{
507 2 : sqlite3ExpirePreparedStatements(db);
508 : }
509 : }
510 :
511 7544 : p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
512 7544 : if( p ){
513 7544 : p->flags = 0;
514 7544 : p->xFunc = xFunc;
515 7544 : p->xStep = xStep;
516 7544 : p->xFinalize = xFinal;
517 7544 : p->pUserData = pUserData;
518 7544 : p->nArg = nArg;
519 : }
520 7544 : return SQLITE_OK;
521 : }
522 :
523 : /*
524 : ** Create new user functions.
525 : */
526 : int sqlite3_create_function(
527 : sqlite3 *db,
528 : const char *zFunctionName,
529 : int nArg,
530 : int enc,
531 : void *p,
532 : void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
533 : void (*xStep)(sqlite3_context*,int,sqlite3_value **),
534 : void (*xFinal)(sqlite3_context*)
535 4 : ){
536 : int rc;
537 : assert( !sqlite3MallocFailed() );
538 4 : rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
539 :
540 4 : return sqlite3ApiExit(db, rc);
541 : }
542 :
543 : #ifndef SQLITE_OMIT_UTF16
544 : int sqlite3_create_function16(
545 : sqlite3 *db,
546 : const void *zFunctionName,
547 : int nArg,
548 : int eTextRep,
549 : void *p,
550 : void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
551 : void (*xStep)(sqlite3_context*,int,sqlite3_value**),
552 : void (*xFinal)(sqlite3_context*)
553 0 : ){
554 : int rc;
555 : char *zFunc8;
556 : assert( !sqlite3MallocFailed() );
557 :
558 0 : zFunc8 = sqlite3utf16to8(zFunctionName, -1);
559 0 : rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
560 0 : sqliteFree(zFunc8);
561 :
562 0 : return sqlite3ApiExit(db, rc);
563 : }
564 : #endif
565 :
566 :
567 : /*
568 : ** Declare that a function has been overloaded by a virtual table.
569 : **
570 : ** If the function already exists as a regular global function, then
571 : ** this routine is a no-op. If the function does not exist, then create
572 : ** a new one that always throws a run-time error.
573 : **
574 : ** When virtual tables intend to provide an overloaded function, they
575 : ** should call this routine to make sure the global function exists.
576 : ** A global function must exist in order for name resolution to work
577 : ** properly.
578 : */
579 : int sqlite3_overload_function(
580 : sqlite3 *db,
581 : const char *zName,
582 : int nArg
583 130 : ){
584 130 : int nName = strlen(zName);
585 130 : if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
586 130 : sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
587 : 0, sqlite3InvalidFunction, 0, 0);
588 : }
589 130 : return sqlite3ApiExit(db, SQLITE_OK);
590 : }
591 :
592 : #ifndef SQLITE_OMIT_TRACE
593 : /*
594 : ** Register a trace function. The pArg from the previously registered trace
595 : ** is returned.
596 : **
597 : ** A NULL trace function means that no tracing is executes. A non-NULL
598 : ** trace is a pointer to a function that is invoked at the start of each
599 : ** SQL statement.
600 : */
601 0 : void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
602 0 : void *pOld = db->pTraceArg;
603 0 : db->xTrace = xTrace;
604 0 : db->pTraceArg = pArg;
605 0 : return pOld;
606 : }
607 : /*
608 : ** Register a profile function. The pArg from the previously registered
609 : ** profile function is returned.
610 : **
611 : ** A NULL profile function means that no profiling is executes. A non-NULL
612 : ** profile is a pointer to a function that is invoked at the conclusion of
613 : ** each SQL statement that is run.
614 : */
615 : void *sqlite3_profile(
616 : sqlite3 *db,
617 : void (*xProfile)(void*,const char*,sqlite_uint64),
618 : void *pArg
619 0 : ){
620 0 : void *pOld = db->pProfileArg;
621 0 : db->xProfile = xProfile;
622 0 : db->pProfileArg = pArg;
623 0 : return pOld;
624 : }
625 : #endif /* SQLITE_OMIT_TRACE */
626 :
627 : /*** EXPERIMENTAL ***
628 : **
629 : ** Register a function to be invoked when a transaction comments.
630 : ** If the invoked function returns non-zero, then the commit becomes a
631 : ** rollback.
632 : */
633 : void *sqlite3_commit_hook(
634 : sqlite3 *db, /* Attach the hook to this database */
635 : int (*xCallback)(void*), /* Function to invoke on each commit */
636 : void *pArg /* Argument to the function */
637 0 : ){
638 0 : void *pOld = db->pCommitArg;
639 0 : db->xCommitCallback = xCallback;
640 0 : db->pCommitArg = pArg;
641 0 : return pOld;
642 : }
643 :
644 : /*
645 : ** Register a callback to be invoked each time a row is updated,
646 : ** inserted or deleted using this database connection.
647 : */
648 : void *sqlite3_update_hook(
649 : sqlite3 *db, /* Attach the hook to this database */
650 : void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
651 : void *pArg /* Argument to the function */
652 0 : ){
653 0 : void *pRet = db->pUpdateArg;
654 0 : db->xUpdateCallback = xCallback;
655 0 : db->pUpdateArg = pArg;
656 0 : return pRet;
657 : }
658 :
659 : /*
660 : ** Register a callback to be invoked each time a transaction is rolled
661 : ** back by this database connection.
662 : */
663 : void *sqlite3_rollback_hook(
664 : sqlite3 *db, /* Attach the hook to this database */
665 : void (*xCallback)(void*), /* Callback function */
666 : void *pArg /* Argument to the function */
667 0 : ){
668 0 : void *pRet = db->pRollbackArg;
669 0 : db->xRollbackCallback = xCallback;
670 0 : db->pRollbackArg = pArg;
671 0 : return pRet;
672 : }
673 :
674 : /*
675 : ** This routine is called to create a connection to a database BTree
676 : ** driver. If zFilename is the name of a file, then that file is
677 : ** opened and used. If zFilename is the magic name ":memory:" then
678 : ** the database is stored in memory (and is thus forgotten as soon as
679 : ** the connection is closed.) If zFilename is NULL then the database
680 : ** is a "virtual" database for transient use only and is deleted as
681 : ** soon as the connection is closed.
682 : **
683 : ** A virtual database can be either a disk file (that is automatically
684 : ** deleted when the file is closed) or it an be held entirely in memory,
685 : ** depending on the values of the TEMP_STORE compile-time macro and the
686 : ** db->temp_store variable, according to the following chart:
687 : **
688 : ** TEMP_STORE db->temp_store Location of temporary database
689 : ** ---------- -------------- ------------------------------
690 : ** 0 any file
691 : ** 1 1 file
692 : ** 1 2 memory
693 : ** 1 0 file
694 : ** 2 1 file
695 : ** 2 2 memory
696 : ** 2 0 memory
697 : ** 3 any memory
698 : */
699 : int sqlite3BtreeFactory(
700 : const sqlite3 *db, /* Main database when opening aux otherwise 0 */
701 : const char *zFilename, /* Name of the file containing the BTree database */
702 : int omitJournal, /* if TRUE then do not journal this file */
703 : int nCache, /* How many pages in the page cache */
704 : Btree **ppBtree /* Pointer to new Btree object written here */
705 130 : ){
706 130 : int btree_flags = 0;
707 : int rc;
708 :
709 : assert( ppBtree != 0);
710 130 : if( omitJournal ){
711 0 : btree_flags |= BTREE_OMIT_JOURNAL;
712 : }
713 130 : if( db->flags & SQLITE_NoReadlock ){
714 0 : btree_flags |= BTREE_NO_READLOCK;
715 : }
716 130 : if( zFilename==0 ){
717 : #if TEMP_STORE==0
718 : /* Do nothing */
719 : #endif
720 : #ifndef SQLITE_OMIT_MEMORYDB
721 : #if TEMP_STORE==1
722 0 : if( db->temp_store==2 ) zFilename = ":memory:";
723 : #endif
724 : #if TEMP_STORE==2
725 : if( db->temp_store!=1 ) zFilename = ":memory:";
726 : #endif
727 : #if TEMP_STORE==3
728 : zFilename = ":memory:";
729 : #endif
730 : #endif /* SQLITE_OMIT_MEMORYDB */
731 : }
732 :
733 130 : rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btree_flags);
734 130 : if( rc==SQLITE_OK ){
735 130 : sqlite3BtreeSetBusyHandler(*ppBtree, (void*)&db->busyHandler);
736 130 : sqlite3BtreeSetCacheSize(*ppBtree, nCache);
737 : }
738 130 : return rc;
739 : }
740 :
741 : /*
742 : ** Return UTF-8 encoded English language explanation of the most recent
743 : ** error.
744 : */
745 930 : const char *sqlite3_errmsg(sqlite3 *db){
746 : const char *z;
747 : assert( !sqlite3MallocFailed() );
748 930 : if( !db ){
749 0 : return sqlite3ErrStr(SQLITE_NOMEM);
750 : }
751 930 : if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){
752 0 : return sqlite3ErrStr(SQLITE_MISUSE);
753 : }
754 930 : z = (char*)sqlite3_value_text(db->pErr);
755 930 : if( z==0 ){
756 2 : z = sqlite3ErrStr(db->errCode);
757 : }
758 930 : return z;
759 : }
760 :
761 : #ifndef SQLITE_OMIT_UTF16
762 : /*
763 : ** Return UTF-16 encoded English language explanation of the most recent
764 : ** error.
765 : */
766 0 : const void *sqlite3_errmsg16(sqlite3 *db){
767 : /* Because all the characters in the string are in the unicode
768 : ** range 0x00-0xFF, if we pad the big-endian string with a
769 : ** zero byte, we can obtain the little-endian string with
770 : ** &big_endian[1].
771 : */
772 : static const char outOfMemBe[] = {
773 : 0, 'o', 0, 'u', 0, 't', 0, ' ',
774 : 0, 'o', 0, 'f', 0, ' ',
775 : 0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
776 : };
777 : static const char misuseBe [] = {
778 : 0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ',
779 : 0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ',
780 : 0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ',
781 : 0, 'o', 0, 'u', 0, 't', 0, ' ',
782 : 0, 'o', 0, 'f', 0, ' ',
783 : 0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
784 : };
785 :
786 : const void *z;
787 : assert( !sqlite3MallocFailed() );
788 0 : if( !db ){
789 0 : return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
790 : }
791 0 : if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){
792 0 : return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
793 : }
794 0 : z = sqlite3_value_text16(db->pErr);
795 0 : if( z==0 ){
796 0 : sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
797 : SQLITE_UTF8, SQLITE_STATIC);
798 0 : z = sqlite3_value_text16(db->pErr);
799 : }
800 0 : sqlite3ApiExit(0, 0);
801 0 : return z;
802 : }
803 : #endif /* SQLITE_OMIT_UTF16 */
804 :
805 : /*
806 : ** Return the most recent error code generated by an SQLite routine. If NULL is
807 : ** passed to this function, we assume a malloc() failed during sqlite3_open().
808 : */
809 751 : int sqlite3_errcode(sqlite3 *db){
810 751 : if( !db || sqlite3MallocFailed() ){
811 0 : return SQLITE_NOMEM;
812 : }
813 751 : if( sqlite3SafetyCheck(db) ){
814 0 : return SQLITE_MISUSE;
815 : }
816 751 : return db->errCode & db->errMask;
817 : }
818 :
819 : /*
820 : ** Create a new collating function for database "db". The name is zName
821 : ** and the encoding is enc.
822 : */
823 : static int createCollation(
824 : sqlite3* db,
825 : const char *zName,
826 : int enc,
827 : void* pCtx,
828 : int(*xCompare)(void*,int,const void*,int,const void*)
829 520 : ){
830 : CollSeq *pColl;
831 : int enc2;
832 :
833 520 : if( sqlite3SafetyCheck(db) ){
834 0 : return SQLITE_MISUSE;
835 : }
836 :
837 : /* If SQLITE_UTF16 is specified as the encoding type, transform this
838 : ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
839 : ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
840 : */
841 520 : enc2 = enc & ~SQLITE_UTF16_ALIGNED;
842 520 : if( enc2==SQLITE_UTF16 ){
843 0 : enc2 = SQLITE_UTF16NATIVE;
844 : }
845 :
846 520 : if( (enc2&~3)!=0 ){
847 0 : sqlite3Error(db, SQLITE_ERROR, "unknown encoding");
848 0 : return SQLITE_ERROR;
849 : }
850 :
851 : /* Check if this call is removing or replacing an existing collation
852 : ** sequence. If so, and there are active VMs, return busy. If there
853 : ** are no active VMs, invalidate any pre-compiled statements.
854 : */
855 520 : pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 0);
856 520 : if( pColl && pColl->xCmp ){
857 0 : if( db->activeVdbeCnt ){
858 0 : sqlite3Error(db, SQLITE_BUSY,
859 : "Unable to delete/modify collation sequence due to active statements");
860 0 : return SQLITE_BUSY;
861 : }
862 0 : sqlite3ExpirePreparedStatements(db);
863 : }
864 :
865 520 : pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 1);
866 520 : if( pColl ){
867 520 : pColl->xCmp = xCompare;
868 520 : pColl->pUser = pCtx;
869 520 : pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED);
870 : }
871 520 : sqlite3Error(db, SQLITE_OK, 0);
872 520 : return SQLITE_OK;
873 : }
874 :
875 :
876 : /*
877 : ** This routine does the work of opening a database on behalf of
878 : ** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
879 : ** is UTF-8 encoded.
880 : */
881 : static int openDatabase(
882 : const char *zFilename, /* Database filename UTF-8 encoded */
883 : sqlite3 **ppDb /* OUT: Returned database handle */
884 130 : ){
885 : sqlite3 *db;
886 : int rc;
887 : CollSeq *pColl;
888 :
889 : assert( !sqlite3MallocFailed() );
890 :
891 : /* Allocate the sqlite data structure */
892 130 : db = sqliteMalloc( sizeof(sqlite3) );
893 130 : if( db==0 ) goto opendb_out;
894 130 : db->errMask = 0xff;
895 130 : db->priorNewRowid = 0;
896 130 : db->magic = SQLITE_MAGIC_BUSY;
897 130 : db->nDb = 2;
898 130 : db->aDb = db->aDbStatic;
899 130 : db->autoCommit = 1;
900 130 : db->flags |= SQLITE_ShortColNames
901 : #if SQLITE_DEFAULT_FILE_FORMAT<4
902 : | SQLITE_LegacyFileFmt
903 : #endif
904 : #ifdef SQLITE_ENABLE_LOAD_EXTENSION
905 : | SQLITE_LoadExtension
906 : #endif
907 : ;
908 130 : sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0);
909 130 : sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
910 : #ifndef SQLITE_OMIT_VIRTUALTABLE
911 130 : sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
912 : #endif
913 :
914 : /* Add the default collation sequence BINARY. BINARY works for both UTF-8
915 : ** and UTF-16, so add a version for each to avoid any unnecessary
916 : ** conversions. The only error that can occur here is a malloc() failure.
917 : */
918 130 : if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc) ||
919 : createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc) ||
920 : createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc) ||
921 : (db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0
922 : ){
923 : assert( sqlite3MallocFailed() );
924 0 : db->magic = SQLITE_MAGIC_CLOSED;
925 0 : goto opendb_out;
926 : }
927 :
928 : /* Also add a UTF-8 case-insensitive collation sequence. */
929 130 : createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc);
930 :
931 : /* Set flags on the built-in collating sequences */
932 130 : db->pDfltColl->type = SQLITE_COLL_BINARY;
933 130 : pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
934 130 : if( pColl ){
935 130 : pColl->type = SQLITE_COLL_NOCASE;
936 : }
937 :
938 : /* Open the backend database driver */
939 130 : rc = sqlite3BtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);
940 130 : if( rc!=SQLITE_OK ){
941 0 : sqlite3Error(db, rc, 0);
942 0 : db->magic = SQLITE_MAGIC_CLOSED;
943 0 : goto opendb_out;
944 : }
945 130 : db->aDb[0].pSchema = sqlite3SchemaGet(db->aDb[0].pBt);
946 130 : db->aDb[1].pSchema = sqlite3SchemaGet(0);
947 :
948 :
949 : /* The default safety_level for the main database is 'full'; for the temp
950 : ** database it is 'NONE'. This matches the pager layer defaults.
951 : */
952 130 : db->aDb[0].zName = "main";
953 130 : db->aDb[0].safety_level = 3;
954 : #ifndef SQLITE_OMIT_TEMPDB
955 130 : db->aDb[1].zName = "temp";
956 130 : db->aDb[1].safety_level = 1;
957 : #endif
958 :
959 : /* Register all built-in functions, but do not attempt to read the
960 : ** database schema yet. This is delayed until the first time the database
961 : ** is accessed.
962 : */
963 130 : if( !sqlite3MallocFailed() ){
964 130 : sqlite3Error(db, SQLITE_OK, 0);
965 130 : sqlite3RegisterBuiltinFunctions(db);
966 : }
967 130 : db->magic = SQLITE_MAGIC_OPEN;
968 :
969 : /* Load automatic extensions - extensions that have been registered
970 : ** using the sqlite3_automatic_extension() API.
971 : */
972 130 : (void)sqlite3AutoLoadExtensions(db);
973 :
974 : #ifdef SQLITE_ENABLE_FTS1
975 : {
976 : extern int sqlite3Fts1Init(sqlite3*);
977 : sqlite3Fts1Init(db);
978 : }
979 : #endif
980 :
981 : #ifdef SQLITE_ENABLE_FTS2
982 : {
983 : extern int sqlite3Fts2Init(sqlite3*);
984 : sqlite3Fts2Init(db);
985 : }
986 : #endif
987 :
988 : /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
989 : ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
990 : ** mode. Doing nothing at all also makes NORMAL the default.
991 : */
992 : #ifdef SQLITE_DEFAULT_LOCKING_MODE
993 : db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
994 : sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
995 : SQLITE_DEFAULT_LOCKING_MODE);
996 : #endif
997 :
998 130 : opendb_out:
999 130 : if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){
1000 0 : sqlite3_close(db);
1001 0 : db = 0;
1002 : }
1003 130 : *ppDb = db;
1004 130 : return sqlite3ApiExit(0, rc);
1005 : }
1006 :
1007 : /*
1008 : ** Open a new database handle.
1009 : */
1010 : int sqlite3_open(
1011 : const char *zFilename,
1012 : sqlite3 **ppDb
1013 130 : ){
1014 130 : return openDatabase(zFilename, ppDb);
1015 : }
1016 :
1017 : #ifndef SQLITE_OMIT_UTF16
1018 : /*
1019 : ** Open a new database handle.
1020 : */
1021 : int sqlite3_open16(
1022 : const void *zFilename,
1023 : sqlite3 **ppDb
1024 0 : ){
1025 : char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
1026 0 : int rc = SQLITE_OK;
1027 : sqlite3_value *pVal;
1028 :
1029 : assert( zFilename );
1030 : assert( ppDb );
1031 0 : *ppDb = 0;
1032 0 : pVal = sqlite3ValueNew();
1033 0 : sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
1034 0 : zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
1035 0 : if( zFilename8 ){
1036 0 : rc = openDatabase(zFilename8, ppDb);
1037 0 : if( rc==SQLITE_OK && *ppDb ){
1038 0 : rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);
1039 0 : if( rc!=SQLITE_OK ){
1040 0 : sqlite3_close(*ppDb);
1041 0 : *ppDb = 0;
1042 : }
1043 : }
1044 : }
1045 0 : sqlite3ValueFree(pVal);
1046 :
1047 0 : return sqlite3ApiExit(0, rc);
1048 : }
1049 : #endif /* SQLITE_OMIT_UTF16 */
1050 :
1051 : /*
1052 : ** The following routine destroys a virtual machine that is created by
1053 : ** the sqlite3_compile() routine. The integer returned is an SQLITE_
1054 : ** success/failure code that describes the result of executing the virtual
1055 : ** machine.
1056 : **
1057 : ** This routine sets the error code and string returned by
1058 : ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
1059 : */
1060 929 : int sqlite3_finalize(sqlite3_stmt *pStmt){
1061 : int rc;
1062 929 : if( pStmt==0 ){
1063 310 : rc = SQLITE_OK;
1064 : }else{
1065 619 : rc = sqlite3VdbeFinalize((Vdbe*)pStmt);
1066 : }
1067 929 : return rc;
1068 : }
1069 :
1070 : /*
1071 : ** Terminate the current execution of an SQL statement and reset it
1072 : ** back to its starting state so that it can be reused. A success code from
1073 : ** the prior execution is returned.
1074 : **
1075 : ** This routine sets the error code and string returned by
1076 : ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
1077 : */
1078 178 : int sqlite3_reset(sqlite3_stmt *pStmt){
1079 : int rc;
1080 178 : if( pStmt==0 ){
1081 0 : rc = SQLITE_OK;
1082 : }else{
1083 178 : rc = sqlite3VdbeReset((Vdbe*)pStmt);
1084 178 : sqlite3VdbeMakeReady((Vdbe*)pStmt, -1, 0, 0, 0);
1085 : assert( (rc & (sqlite3_db_handle(pStmt)->errMask))==rc );
1086 : }
1087 178 : return rc;
1088 : }
1089 :
1090 : /*
1091 : ** Register a new collation sequence with the database handle db.
1092 : */
1093 : int sqlite3_create_collation(
1094 : sqlite3* db,
1095 : const char *zName,
1096 : int enc,
1097 : void* pCtx,
1098 : int(*xCompare)(void*,int,const void*,int,const void*)
1099 0 : ){
1100 : int rc;
1101 : assert( !sqlite3MallocFailed() );
1102 0 : rc = createCollation(db, zName, enc, pCtx, xCompare);
1103 0 : return sqlite3ApiExit(db, rc);
1104 : }
1105 :
1106 : #ifndef SQLITE_OMIT_UTF16
1107 : /*
1108 : ** Register a new collation sequence with the database handle db.
1109 : */
1110 : int sqlite3_create_collation16(
1111 : sqlite3* db,
1112 : const char *zName,
1113 : int enc,
1114 : void* pCtx,
1115 : int(*xCompare)(void*,int,const void*,int,const void*)
1116 0 : ){
1117 0 : int rc = SQLITE_OK;
1118 : char *zName8;
1119 : assert( !sqlite3MallocFailed() );
1120 0 : zName8 = sqlite3utf16to8(zName, -1);
1121 0 : if( zName8 ){
1122 0 : rc = createCollation(db, zName8, enc, pCtx, xCompare);
1123 0 : sqliteFree(zName8);
1124 : }
1125 0 : return sqlite3ApiExit(db, rc);
1126 : }
1127 : #endif /* SQLITE_OMIT_UTF16 */
1128 :
1129 : /*
1130 : ** Register a collation sequence factory callback with the database handle
1131 : ** db. Replace any previously installed collation sequence factory.
1132 : */
1133 : int sqlite3_collation_needed(
1134 : sqlite3 *db,
1135 : void *pCollNeededArg,
1136 : void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
1137 0 : ){
1138 0 : if( sqlite3SafetyCheck(db) ){
1139 0 : return SQLITE_MISUSE;
1140 : }
1141 0 : db->xCollNeeded = xCollNeeded;
1142 0 : db->xCollNeeded16 = 0;
1143 0 : db->pCollNeededArg = pCollNeededArg;
1144 0 : return SQLITE_OK;
1145 : }
1146 :
1147 : #ifndef SQLITE_OMIT_UTF16
1148 : /*
1149 : ** Register a collation sequence factory callback with the database handle
1150 : ** db. Replace any previously installed collation sequence factory.
1151 : */
1152 : int sqlite3_collation_needed16(
1153 : sqlite3 *db,
1154 : void *pCollNeededArg,
1155 : void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
1156 0 : ){
1157 0 : if( sqlite3SafetyCheck(db) ){
1158 0 : return SQLITE_MISUSE;
1159 : }
1160 0 : db->xCollNeeded = 0;
1161 0 : db->xCollNeeded16 = xCollNeeded16;
1162 0 : db->pCollNeededArg = pCollNeededArg;
1163 0 : return SQLITE_OK;
1164 : }
1165 : #endif /* SQLITE_OMIT_UTF16 */
1166 :
1167 : #ifndef SQLITE_OMIT_GLOBALRECOVER
1168 : /*
1169 : ** This function is now an anachronism. It used to be used to recover from a
1170 : ** malloc() failure, but SQLite now does this automatically.
1171 : */
1172 0 : int sqlite3_global_recover(){
1173 0 : return SQLITE_OK;
1174 : }
1175 : #endif
1176 :
1177 : /*
1178 : ** Test to see whether or not the database connection is in autocommit
1179 : ** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
1180 : ** by default. Autocommit is disabled by a BEGIN statement and reenabled
1181 : ** by the next COMMIT or ROLLBACK.
1182 : **
1183 : ******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
1184 : */
1185 0 : int sqlite3_get_autocommit(sqlite3 *db){
1186 0 : return db->autoCommit;
1187 : }
1188 :
1189 : #ifdef SQLITE_DEBUG
1190 : /*
1191 : ** The following routine is subtituted for constant SQLITE_CORRUPT in
1192 : ** debugging builds. This provides a way to set a breakpoint for when
1193 : ** corruption is first detected.
1194 : */
1195 : int sqlite3Corrupt(void){
1196 : return SQLITE_CORRUPT;
1197 : }
1198 : #endif
1199 :
1200 :
1201 : #ifndef SQLITE_OMIT_SHARED_CACHE
1202 : /*
1203 : ** Enable or disable the shared pager and schema features for the
1204 : ** current thread.
1205 : **
1206 : ** This routine should only be called when there are no open
1207 : ** database connections.
1208 : */
1209 0 : int sqlite3_enable_shared_cache(int enable){
1210 0 : ThreadData *pTd = sqlite3ThreadData();
1211 0 : if( pTd ){
1212 : /* It is only legal to call sqlite3_enable_shared_cache() when there
1213 : ** are no currently open b-trees that were opened by the calling thread.
1214 : ** This condition is only easy to detect if the shared-cache were
1215 : ** previously enabled (and is being disabled).
1216 : */
1217 0 : if( pTd->pBtree && !enable ){
1218 : assert( pTd->useSharedData );
1219 0 : return SQLITE_MISUSE;
1220 : }
1221 :
1222 0 : pTd->useSharedData = enable;
1223 0 : sqlite3ReleaseThreadData();
1224 : }
1225 0 : return sqlite3ApiExit(0, SQLITE_OK);
1226 : }
1227 : #endif
1228 :
1229 : /*
1230 : ** This is a convenience routine that makes sure that all thread-specific
1231 : ** data for this thread has been deallocated.
1232 : */
1233 0 : void sqlite3_thread_cleanup(void){
1234 0 : ThreadData *pTd = sqlite3OsThreadSpecificData(0);
1235 0 : if( pTd ){
1236 0 : memset(pTd, 0, sizeof(*pTd));
1237 0 : sqlite3OsThreadSpecificData(-1);
1238 : }
1239 0 : }
1240 :
1241 : /*
1242 : ** Return meta information about a specific column of a database table.
1243 : ** See comment in sqlite3.h (sqlite.h.in) for details.
1244 : */
1245 : #ifdef SQLITE_ENABLE_COLUMN_METADATA
1246 : int sqlite3_table_column_metadata(
1247 : sqlite3 *db, /* Connection handle */
1248 : const char *zDbName, /* Database name or NULL */
1249 : const char *zTableName, /* Table name */
1250 : const char *zColumnName, /* Column name */
1251 : char const **pzDataType, /* OUTPUT: Declared data type */
1252 : char const **pzCollSeq, /* OUTPUT: Collation sequence name */
1253 : int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
1254 : int *pPrimaryKey, /* OUTPUT: True if column part of PK */
1255 : int *pAutoinc /* OUTPUT: True if colums is auto-increment */
1256 : ){
1257 : int rc;
1258 : char *zErrMsg = 0;
1259 : Table *pTab = 0;
1260 : Column *pCol = 0;
1261 : int iCol;
1262 :
1263 : char const *zDataType = 0;
1264 : char const *zCollSeq = 0;
1265 : int notnull = 0;
1266 : int primarykey = 0;
1267 : int autoinc = 0;
1268 :
1269 : /* Ensure the database schema has been loaded */
1270 : if( sqlite3SafetyOn(db) ){
1271 : return SQLITE_MISUSE;
1272 : }
1273 : rc = sqlite3Init(db, &zErrMsg);
1274 : if( SQLITE_OK!=rc ){
1275 : goto error_out;
1276 : }
1277 :
1278 : /* Locate the table in question */
1279 : pTab = sqlite3FindTable(db, zTableName, zDbName);
1280 : if( !pTab || pTab->pSelect ){
1281 : pTab = 0;
1282 : goto error_out;
1283 : }
1284 :
1285 : /* Find the column for which info is requested */
1286 : if( sqlite3IsRowid(zColumnName) ){
1287 : iCol = pTab->iPKey;
1288 : if( iCol>=0 ){
1289 : pCol = &pTab->aCol[iCol];
1290 : }
1291 : }else{
1292 : for(iCol=0; iCol<pTab->nCol; iCol++){
1293 : pCol = &pTab->aCol[iCol];
1294 : if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
1295 : break;
1296 : }
1297 : }
1298 : if( iCol==pTab->nCol ){
1299 : pTab = 0;
1300 : goto error_out;
1301 : }
1302 : }
1303 :
1304 : /* The following block stores the meta information that will be returned
1305 : ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
1306 : ** and autoinc. At this point there are two possibilities:
1307 : **
1308 : ** 1. The specified column name was rowid", "oid" or "_rowid_"
1309 : ** and there is no explicitly declared IPK column.
1310 : **
1311 : ** 2. The table is not a view and the column name identified an
1312 : ** explicitly declared column. Copy meta information from *pCol.
1313 : */
1314 : if( pCol ){
1315 : zDataType = pCol->zType;
1316 : zCollSeq = pCol->zColl;
1317 : notnull = (pCol->notNull?1:0);
1318 : primarykey = (pCol->isPrimKey?1:0);
1319 : autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0);
1320 : }else{
1321 : zDataType = "INTEGER";
1322 : primarykey = 1;
1323 : }
1324 : if( !zCollSeq ){
1325 : zCollSeq = "BINARY";
1326 : }
1327 :
1328 : error_out:
1329 : if( sqlite3SafetyOff(db) ){
1330 : rc = SQLITE_MISUSE;
1331 : }
1332 :
1333 : /* Whether the function call succeeded or failed, set the output parameters
1334 : ** to whatever their local counterparts contain. If an error did occur,
1335 : ** this has the effect of zeroing all output parameters.
1336 : */
1337 : if( pzDataType ) *pzDataType = zDataType;
1338 : if( pzCollSeq ) *pzCollSeq = zCollSeq;
1339 : if( pNotNull ) *pNotNull = notnull;
1340 : if( pPrimaryKey ) *pPrimaryKey = primarykey;
1341 : if( pAutoinc ) *pAutoinc = autoinc;
1342 :
1343 : if( SQLITE_OK==rc && !pTab ){
1344 : sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".",
1345 : zColumnName, 0);
1346 : rc = SQLITE_ERROR;
1347 : }
1348 : sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
1349 : sqliteFree(zErrMsg);
1350 : return sqlite3ApiExit(db, rc);
1351 : }
1352 : #endif
1353 :
1354 : /*
1355 : ** Set all the parameters in the compiled SQL statement to NULL.
1356 : */
1357 0 : int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
1358 : int i;
1359 0 : int rc = SQLITE_OK;
1360 0 : for(i=1; rc==SQLITE_OK && i<=sqlite3_bind_parameter_count(pStmt); i++){
1361 0 : rc = sqlite3_bind_null(pStmt, i);
1362 : }
1363 0 : return rc;
1364 : }
1365 :
1366 : /*
1367 : ** Sleep for a little while. Return the amount of time slept.
1368 : */
1369 0 : int sqlite3_sleep(int ms){
1370 0 : return sqlite3OsSleep(ms);
1371 : }
1372 :
1373 : /*
1374 : ** Enable or disable the extended result codes.
1375 : */
1376 0 : int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
1377 0 : db->errMask = onoff ? 0xffffffff : 0xff;
1378 0 : return SQLITE_OK;
1379 : }
|
