monotone

monotone Mtn Source Tree

Root/sqlite/main.c

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

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status