1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/extensions/sqlite/sqlite-source/main.c Sun Mar 30 07:00:22 2008 +0000
1.3 @@ -0,0 +1,1485 @@
1.4 +/*
1.5 +** 2001 September 15
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +** Main file for the SQLite library. The routines in this file
1.16 +** implement the programmer interface to the library. Routines in
1.17 +** other files are for internal use by SQLite and should not be
1.18 +** accessed by users of the library.
1.19 +**
1.20 +** $Id$
1.21 +*/
1.22 +#include "sqliteInt.h"
1.23 +#include <ctype.h>
1.24 +
1.25 +/*
1.26 +** The version of the library
1.27 +*/
1.28 +const char sqlite3_version[] = SQLITE_VERSION;
1.29 +const char *sqlite3_libversion(void){ return sqlite3_version; }
1.30 +int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
1.31 +int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
1.32 +
1.33 +/*
1.34 +** If the following function pointer is not NULL and if
1.35 +** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
1.36 +** I/O active are written using this function. These messages
1.37 +** are intended for debugging activity only.
1.38 +*/
1.39 +void (*sqlite3_io_trace)(const char*, ...) = 0;
1.40 +
1.41 +/*
1.42 +** If the following global variable points to a string which is the
1.43 +** name of a directory, then that directory will be used to store
1.44 +** temporary files.
1.45 +**
1.46 +** See also the "PRAGMA temp_store_directory" SQL command.
1.47 +*/
1.48 +char *sqlite3_temp_directory = 0;
1.49 +
1.50 +
1.51 +/*
1.52 +** This is the default collating function named "BINARY" which is always
1.53 +** available.
1.54 +*/
1.55 +static int binCollFunc(
1.56 + void *NotUsed,
1.57 + int nKey1, const void *pKey1,
1.58 + int nKey2, const void *pKey2
1.59 +){
1.60 + int rc, n;
1.61 + n = nKey1<nKey2 ? nKey1 : nKey2;
1.62 + rc = memcmp(pKey1, pKey2, n);
1.63 + if( rc==0 ){
1.64 + rc = nKey1 - nKey2;
1.65 + }
1.66 + return rc;
1.67 +}
1.68 +
1.69 +/*
1.70 +** Another built-in collating sequence: NOCASE.
1.71 +**
1.72 +** This collating sequence is intended to be used for "case independant
1.73 +** comparison". SQLite's knowledge of upper and lower case equivalents
1.74 +** extends only to the 26 characters used in the English language.
1.75 +**
1.76 +** At the moment there is only a UTF-8 implementation.
1.77 +*/
1.78 +static int nocaseCollatingFunc(
1.79 + void *NotUsed,
1.80 + int nKey1, const void *pKey1,
1.81 + int nKey2, const void *pKey2
1.82 +){
1.83 + int r = sqlite3StrNICmp(
1.84 + (const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
1.85 + if( 0==r ){
1.86 + r = nKey1-nKey2;
1.87 + }
1.88 + return r;
1.89 +}
1.90 +
1.91 +/*
1.92 +** Return the ROWID of the most recent insert
1.93 +*/
1.94 +sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
1.95 + return db->lastRowid;
1.96 +}
1.97 +
1.98 +/*
1.99 +** Return the number of changes in the most recent call to sqlite3_exec().
1.100 +*/
1.101 +int sqlite3_changes(sqlite3 *db){
1.102 + return db->nChange;
1.103 +}
1.104 +
1.105 +/*
1.106 +** Return the number of changes since the database handle was opened.
1.107 +*/
1.108 +int sqlite3_total_changes(sqlite3 *db){
1.109 + return db->nTotalChange;
1.110 +}
1.111 +
1.112 +/*
1.113 +** Close an existing SQLite database
1.114 +*/
1.115 +int sqlite3_close(sqlite3 *db){
1.116 + HashElem *i;
1.117 + int j;
1.118 +
1.119 + if( !db ){
1.120 + return SQLITE_OK;
1.121 + }
1.122 + if( sqlite3SafetyCheck(db) ){
1.123 + return SQLITE_MISUSE;
1.124 + }
1.125 + sqlite3_mutex_enter(db->mutex);
1.126 +
1.127 +#ifdef SQLITE_SSE
1.128 + {
1.129 + extern void sqlite3SseCleanup(sqlite3*);
1.130 + sqlite3SseCleanup(db);
1.131 + }
1.132 +#endif
1.133 +
1.134 + sqlite3ResetInternalSchema(db, 0);
1.135 +
1.136 + /* If a transaction is open, the ResetInternalSchema() call above
1.137 + ** will not have called the xDisconnect() method on any virtual
1.138 + ** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
1.139 + ** call will do so. We need to do this before the check for active
1.140 + ** SQL statements below, as the v-table implementation may be storing
1.141 + ** some prepared statements internally.
1.142 + */
1.143 + sqlite3VtabRollback(db);
1.144 +
1.145 + /* If there are any outstanding VMs, return SQLITE_BUSY. */
1.146 + if( db->pVdbe ){
1.147 + sqlite3Error(db, SQLITE_BUSY,
1.148 + "Unable to close due to unfinalised statements");
1.149 + sqlite3_mutex_leave(db->mutex);
1.150 + return SQLITE_BUSY;
1.151 + }
1.152 + assert( !sqlite3SafetyCheck(db) );
1.153 +
1.154 + /* FIX ME: db->magic may be set to SQLITE_MAGIC_CLOSED if the database
1.155 + ** cannot be opened for some reason. So this routine needs to run in
1.156 + ** that case. But maybe there should be an extra magic value for the
1.157 + ** "failed to open" state.
1.158 + **
1.159 + ** TODO: Coverage tests do not test the case where this condition is
1.160 + ** true. It's hard to see how to cause it without messing with threads.
1.161 + */
1.162 + if( db->magic!=SQLITE_MAGIC_CLOSED && sqlite3SafetyOn(db) ){
1.163 + /* printf("DID NOT CLOSE\n"); fflush(stdout); */
1.164 + sqlite3_mutex_leave(db->mutex);
1.165 + return SQLITE_ERROR;
1.166 + }
1.167 +
1.168 + for(j=0; j<db->nDb; j++){
1.169 + struct Db *pDb = &db->aDb[j];
1.170 + if( pDb->pBt ){
1.171 + sqlite3BtreeClose(pDb->pBt);
1.172 + pDb->pBt = 0;
1.173 + if( j!=1 ){
1.174 + pDb->pSchema = 0;
1.175 + }
1.176 + }
1.177 + }
1.178 + sqlite3ResetInternalSchema(db, 0);
1.179 + assert( db->nDb<=2 );
1.180 + assert( db->aDb==db->aDbStatic );
1.181 + for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
1.182 + FuncDef *pFunc, *pNext;
1.183 + for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){
1.184 + pNext = pFunc->pNext;
1.185 + sqlite3_free(pFunc);
1.186 + }
1.187 + }
1.188 +
1.189 + for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
1.190 + CollSeq *pColl = (CollSeq *)sqliteHashData(i);
1.191 + /* Invoke any destructors registered for collation sequence user data. */
1.192 + for(j=0; j<3; j++){
1.193 + if( pColl[j].xDel ){
1.194 + pColl[j].xDel(pColl[j].pUser);
1.195 + }
1.196 + }
1.197 + sqlite3_free(pColl);
1.198 + }
1.199 + sqlite3HashClear(&db->aCollSeq);
1.200 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.201 + for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
1.202 + Module *pMod = (Module *)sqliteHashData(i);
1.203 + if( pMod->xDestroy ){
1.204 + pMod->xDestroy(pMod->pAux);
1.205 + }
1.206 + sqlite3_free(pMod);
1.207 + }
1.208 + sqlite3HashClear(&db->aModule);
1.209 +#endif
1.210 +
1.211 + sqlite3HashClear(&db->aFunc);
1.212 + sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
1.213 + if( db->pErr ){
1.214 + sqlite3ValueFree(db->pErr);
1.215 + }
1.216 + sqlite3CloseExtensions(db);
1.217 +
1.218 + db->magic = SQLITE_MAGIC_ERROR;
1.219 +
1.220 + /* The temp-database schema is allocated differently from the other schema
1.221 + ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
1.222 + ** So it needs to be freed here. Todo: Why not roll the temp schema into
1.223 + ** the same sqliteMalloc() as the one that allocates the database
1.224 + ** structure?
1.225 + */
1.226 + sqlite3_free(db->aDb[1].pSchema);
1.227 + sqlite3_mutex_leave(db->mutex);
1.228 + sqlite3_mutex_free(db->mutex);
1.229 + sqlite3_free(db);
1.230 + return SQLITE_OK;
1.231 +}
1.232 +
1.233 +/*
1.234 +** Rollback all database files.
1.235 +*/
1.236 +void sqlite3RollbackAll(sqlite3 *db){
1.237 + int i;
1.238 + int inTrans = 0;
1.239 + assert( sqlite3_mutex_held(db->mutex) );
1.240 + sqlite3MallocEnterBenignBlock(1); /* Enter benign region */
1.241 + for(i=0; i<db->nDb; i++){
1.242 + if( db->aDb[i].pBt ){
1.243 + if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
1.244 + inTrans = 1;
1.245 + }
1.246 + sqlite3BtreeRollback(db->aDb[i].pBt);
1.247 + db->aDb[i].inTrans = 0;
1.248 + }
1.249 + }
1.250 + sqlite3VtabRollback(db);
1.251 + sqlite3MallocLeaveBenignBlock(); /* Leave benign region */
1.252 +
1.253 + if( db->flags&SQLITE_InternChanges ){
1.254 + sqlite3ExpirePreparedStatements(db);
1.255 + sqlite3ResetInternalSchema(db, 0);
1.256 + }
1.257 +
1.258 + /* If one has been configured, invoke the rollback-hook callback */
1.259 + if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
1.260 + db->xRollbackCallback(db->pRollbackArg);
1.261 + }
1.262 +}
1.263 +
1.264 +/*
1.265 +** Return a static string that describes the kind of error specified in the
1.266 +** argument.
1.267 +*/
1.268 +const char *sqlite3ErrStr(int rc){
1.269 + const char *z;
1.270 + switch( rc & 0xff ){
1.271 + case SQLITE_ROW:
1.272 + case SQLITE_DONE:
1.273 + case SQLITE_OK: z = "not an error"; break;
1.274 + case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
1.275 + case SQLITE_PERM: z = "access permission denied"; break;
1.276 + case SQLITE_ABORT: z = "callback requested query abort"; break;
1.277 + case SQLITE_BUSY: z = "database is locked"; break;
1.278 + case SQLITE_LOCKED: z = "database table is locked"; break;
1.279 + case SQLITE_NOMEM: z = "out of memory"; break;
1.280 + case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
1.281 + case SQLITE_INTERRUPT: z = "interrupted"; break;
1.282 + case SQLITE_IOERR: z = "disk I/O error"; break;
1.283 + case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
1.284 + case SQLITE_FULL: z = "database or disk is full"; break;
1.285 + case SQLITE_CANTOPEN: z = "unable to open database file"; break;
1.286 + case SQLITE_EMPTY: z = "table contains no data"; break;
1.287 + case SQLITE_SCHEMA: z = "database schema has changed"; break;
1.288 + case SQLITE_TOOBIG: z = "String or BLOB exceeded size limit"; break;
1.289 + case SQLITE_CONSTRAINT: z = "constraint failed"; break;
1.290 + case SQLITE_MISMATCH: z = "datatype mismatch"; break;
1.291 + case SQLITE_MISUSE: z = "library routine called out of sequence";break;
1.292 + case SQLITE_NOLFS: z = "kernel lacks large file support"; break;
1.293 + case SQLITE_AUTH: z = "authorization denied"; break;
1.294 + case SQLITE_FORMAT: z = "auxiliary database format error"; break;
1.295 + case SQLITE_RANGE: z = "bind or column index out of range"; break;
1.296 + case SQLITE_NOTADB: z = "file is encrypted or is not a database";break;
1.297 + default: z = "unknown error"; break;
1.298 + }
1.299 + return z;
1.300 +}
1.301 +
1.302 +/*
1.303 +** This routine implements a busy callback that sleeps and tries
1.304 +** again until a timeout value is reached. The timeout value is
1.305 +** an integer number of milliseconds passed in as the first
1.306 +** argument.
1.307 +*/
1.308 +static int sqliteDefaultBusyCallback(
1.309 + void *ptr, /* Database connection */
1.310 + int count /* Number of times table has been busy */
1.311 +){
1.312 +#if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
1.313 + static const u8 delays[] =
1.314 + { 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
1.315 + static const u8 totals[] =
1.316 + { 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
1.317 +# define NDELAY (sizeof(delays)/sizeof(delays[0]))
1.318 + sqlite3 *db = (sqlite3 *)ptr;
1.319 + int timeout = db->busyTimeout;
1.320 + int delay, prior;
1.321 +
1.322 + assert( count>=0 );
1.323 + if( count < NDELAY ){
1.324 + delay = delays[count];
1.325 + prior = totals[count];
1.326 + }else{
1.327 + delay = delays[NDELAY-1];
1.328 + prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
1.329 + }
1.330 + if( prior + delay > timeout ){
1.331 + delay = timeout - prior;
1.332 + if( delay<=0 ) return 0;
1.333 + }
1.334 + sqlite3OsSleep(db->pVfs, delay*1000);
1.335 + return 1;
1.336 +#else
1.337 + sqlite3 *db = (sqlite3 *)ptr;
1.338 + int timeout = ((sqlite3 *)ptr)->busyTimeout;
1.339 + if( (count+1)*1000 > timeout ){
1.340 + return 0;
1.341 + }
1.342 + sqlite3OsSleep(db->pVfs, 1000000);
1.343 + return 1;
1.344 +#endif
1.345 +}
1.346 +
1.347 +/*
1.348 +** Invoke the given busy handler.
1.349 +**
1.350 +** This routine is called when an operation failed with a lock.
1.351 +** If this routine returns non-zero, the lock is retried. If it
1.352 +** returns 0, the operation aborts with an SQLITE_BUSY error.
1.353 +*/
1.354 +int sqlite3InvokeBusyHandler(BusyHandler *p){
1.355 + int rc;
1.356 + if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0;
1.357 + rc = p->xFunc(p->pArg, p->nBusy);
1.358 + if( rc==0 ){
1.359 + p->nBusy = -1;
1.360 + }else{
1.361 + p->nBusy++;
1.362 + }
1.363 + return rc;
1.364 +}
1.365 +
1.366 +/*
1.367 +** This routine sets the busy callback for an Sqlite database to the
1.368 +** given callback function with the given argument.
1.369 +*/
1.370 +int sqlite3_busy_handler(
1.371 + sqlite3 *db,
1.372 + int (*xBusy)(void*,int),
1.373 + void *pArg
1.374 +){
1.375 + if( sqlite3SafetyCheck(db) ){
1.376 + return SQLITE_MISUSE;
1.377 + }
1.378 + sqlite3_mutex_enter(db->mutex);
1.379 + db->busyHandler.xFunc = xBusy;
1.380 + db->busyHandler.pArg = pArg;
1.381 + db->busyHandler.nBusy = 0;
1.382 + sqlite3_mutex_leave(db->mutex);
1.383 + return SQLITE_OK;
1.384 +}
1.385 +
1.386 +#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
1.387 +/*
1.388 +** This routine sets the progress callback for an Sqlite database to the
1.389 +** given callback function with the given argument. The progress callback will
1.390 +** be invoked every nOps opcodes.
1.391 +*/
1.392 +void sqlite3_progress_handler(
1.393 + sqlite3 *db,
1.394 + int nOps,
1.395 + int (*xProgress)(void*),
1.396 + void *pArg
1.397 +){
1.398 + if( !sqlite3SafetyCheck(db) ){
1.399 + sqlite3_mutex_enter(db->mutex);
1.400 + if( nOps>0 ){
1.401 + db->xProgress = xProgress;
1.402 + db->nProgressOps = nOps;
1.403 + db->pProgressArg = pArg;
1.404 + }else{
1.405 + db->xProgress = 0;
1.406 + db->nProgressOps = 0;
1.407 + db->pProgressArg = 0;
1.408 + }
1.409 + sqlite3_mutex_leave(db->mutex);
1.410 + }
1.411 +}
1.412 +#endif
1.413 +
1.414 +
1.415 +/*
1.416 +** This routine installs a default busy handler that waits for the
1.417 +** specified number of milliseconds before returning 0.
1.418 +*/
1.419 +int sqlite3_busy_timeout(sqlite3 *db, int ms){
1.420 + if( sqlite3SafetyCheck(db) ){
1.421 + return SQLITE_MISUSE;
1.422 + }
1.423 + if( ms>0 ){
1.424 + db->busyTimeout = ms;
1.425 + sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
1.426 + }else{
1.427 + sqlite3_busy_handler(db, 0, 0);
1.428 + }
1.429 + return SQLITE_OK;
1.430 +}
1.431 +
1.432 +/*
1.433 +** Cause any pending operation to stop at its earliest opportunity.
1.434 +*/
1.435 +void sqlite3_interrupt(sqlite3 *db){
1.436 + if( db && (db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_BUSY) ){
1.437 + db->u1.isInterrupted = 1;
1.438 + }
1.439 +}
1.440 +
1.441 +
1.442 +/*
1.443 +** This function is exactly the same as sqlite3_create_function(), except
1.444 +** that it is designed to be called by internal code. The difference is
1.445 +** that if a malloc() fails in sqlite3_create_function(), an error code
1.446 +** is returned and the mallocFailed flag cleared.
1.447 +*/
1.448 +int sqlite3CreateFunc(
1.449 + sqlite3 *db,
1.450 + const char *zFunctionName,
1.451 + int nArg,
1.452 + int enc,
1.453 + void *pUserData,
1.454 + void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
1.455 + void (*xStep)(sqlite3_context*,int,sqlite3_value **),
1.456 + void (*xFinal)(sqlite3_context*)
1.457 +){
1.458 + FuncDef *p;
1.459 + int nName;
1.460 +
1.461 + assert( sqlite3_mutex_held(db->mutex) );
1.462 + if( sqlite3SafetyCheck(db) ){
1.463 + return SQLITE_MISUSE;
1.464 + }
1.465 + if( zFunctionName==0 ||
1.466 + (xFunc && (xFinal || xStep)) ||
1.467 + (!xFunc && (xFinal && !xStep)) ||
1.468 + (!xFunc && (!xFinal && xStep)) ||
1.469 + (nArg<-1 || nArg>127) ||
1.470 + (255<(nName = strlen(zFunctionName))) ){
1.471 + sqlite3Error(db, SQLITE_ERROR, "bad parameters");
1.472 + return SQLITE_ERROR;
1.473 + }
1.474 +
1.475 +#ifndef SQLITE_OMIT_UTF16
1.476 + /* If SQLITE_UTF16 is specified as the encoding type, transform this
1.477 + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
1.478 + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
1.479 + **
1.480 + ** If SQLITE_ANY is specified, add three versions of the function
1.481 + ** to the hash table.
1.482 + */
1.483 + if( enc==SQLITE_UTF16 ){
1.484 + enc = SQLITE_UTF16NATIVE;
1.485 + }else if( enc==SQLITE_ANY ){
1.486 + int rc;
1.487 + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
1.488 + pUserData, xFunc, xStep, xFinal);
1.489 + if( rc==SQLITE_OK ){
1.490 + rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
1.491 + pUserData, xFunc, xStep, xFinal);
1.492 + }
1.493 + if( rc!=SQLITE_OK ){
1.494 + return rc;
1.495 + }
1.496 + enc = SQLITE_UTF16BE;
1.497 + }
1.498 +#else
1.499 + enc = SQLITE_UTF8;
1.500 +#endif
1.501 +
1.502 + /* Check if an existing function is being overridden or deleted. If so,
1.503 + ** and there are active VMs, then return SQLITE_BUSY. If a function
1.504 + ** is being overridden/deleted but there are no active VMs, allow the
1.505 + ** operation to continue but invalidate all precompiled statements.
1.506 + */
1.507 + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
1.508 + if( p && p->iPrefEnc==enc && p->nArg==nArg ){
1.509 + if( db->activeVdbeCnt ){
1.510 + sqlite3Error(db, SQLITE_BUSY,
1.511 + "Unable to delete/modify user-function due to active statements");
1.512 + assert( !db->mallocFailed );
1.513 + return SQLITE_BUSY;
1.514 + }else{
1.515 + sqlite3ExpirePreparedStatements(db);
1.516 + }
1.517 + }
1.518 +
1.519 + p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
1.520 + assert(p || db->mallocFailed);
1.521 + if( !p ){
1.522 + return SQLITE_NOMEM;
1.523 + }
1.524 + p->flags = 0;
1.525 + p->xFunc = xFunc;
1.526 + p->xStep = xStep;
1.527 + p->xFinalize = xFinal;
1.528 + p->pUserData = pUserData;
1.529 + p->nArg = nArg;
1.530 + return SQLITE_OK;
1.531 +}
1.532 +
1.533 +/*
1.534 +** Create new user functions.
1.535 +*/
1.536 +int sqlite3_create_function(
1.537 + sqlite3 *db,
1.538 + const char *zFunctionName,
1.539 + int nArg,
1.540 + int enc,
1.541 + void *p,
1.542 + void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
1.543 + void (*xStep)(sqlite3_context*,int,sqlite3_value **),
1.544 + void (*xFinal)(sqlite3_context*)
1.545 +){
1.546 + int rc;
1.547 + sqlite3_mutex_enter(db->mutex);
1.548 + assert( !db->mallocFailed );
1.549 + rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
1.550 + rc = sqlite3ApiExit(db, rc);
1.551 + sqlite3_mutex_leave(db->mutex);
1.552 + return rc;
1.553 +}
1.554 +
1.555 +#ifndef SQLITE_OMIT_UTF16
1.556 +int sqlite3_create_function16(
1.557 + sqlite3 *db,
1.558 + const void *zFunctionName,
1.559 + int nArg,
1.560 + int eTextRep,
1.561 + void *p,
1.562 + void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
1.563 + void (*xStep)(sqlite3_context*,int,sqlite3_value**),
1.564 + void (*xFinal)(sqlite3_context*)
1.565 +){
1.566 + int rc;
1.567 + char *zFunc8;
1.568 + sqlite3_mutex_enter(db->mutex);
1.569 + assert( !db->mallocFailed );
1.570 + zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
1.571 + rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
1.572 + sqlite3_free(zFunc8);
1.573 + rc = sqlite3ApiExit(db, rc);
1.574 + sqlite3_mutex_leave(db->mutex);
1.575 + return rc;
1.576 +}
1.577 +#endif
1.578 +
1.579 +
1.580 +/*
1.581 +** Declare that a function has been overloaded by a virtual table.
1.582 +**
1.583 +** If the function already exists as a regular global function, then
1.584 +** this routine is a no-op. If the function does not exist, then create
1.585 +** a new one that always throws a run-time error.
1.586 +**
1.587 +** When virtual tables intend to provide an overloaded function, they
1.588 +** should call this routine to make sure the global function exists.
1.589 +** A global function must exist in order for name resolution to work
1.590 +** properly.
1.591 +*/
1.592 +int sqlite3_overload_function(
1.593 + sqlite3 *db,
1.594 + const char *zName,
1.595 + int nArg
1.596 +){
1.597 + int nName = strlen(zName);
1.598 + int rc;
1.599 + sqlite3_mutex_enter(db->mutex);
1.600 + if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
1.601 + sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
1.602 + 0, sqlite3InvalidFunction, 0, 0);
1.603 + }
1.604 + rc = sqlite3ApiExit(db, SQLITE_OK);
1.605 + sqlite3_mutex_leave(db->mutex);
1.606 + return rc;
1.607 +}
1.608 +
1.609 +#ifndef SQLITE_OMIT_TRACE
1.610 +/*
1.611 +** Register a trace function. The pArg from the previously registered trace
1.612 +** is returned.
1.613 +**
1.614 +** A NULL trace function means that no tracing is executes. A non-NULL
1.615 +** trace is a pointer to a function that is invoked at the start of each
1.616 +** SQL statement.
1.617 +*/
1.618 +void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
1.619 + void *pOld;
1.620 + sqlite3_mutex_enter(db->mutex);
1.621 + pOld = db->pTraceArg;
1.622 + db->xTrace = xTrace;
1.623 + db->pTraceArg = pArg;
1.624 + sqlite3_mutex_leave(db->mutex);
1.625 + return pOld;
1.626 +}
1.627 +/*
1.628 +** Register a profile function. The pArg from the previously registered
1.629 +** profile function is returned.
1.630 +**
1.631 +** A NULL profile function means that no profiling is executes. A non-NULL
1.632 +** profile is a pointer to a function that is invoked at the conclusion of
1.633 +** each SQL statement that is run.
1.634 +*/
1.635 +void *sqlite3_profile(
1.636 + sqlite3 *db,
1.637 + void (*xProfile)(void*,const char*,sqlite_uint64),
1.638 + void *pArg
1.639 +){
1.640 + void *pOld;
1.641 + sqlite3_mutex_enter(db->mutex);
1.642 + pOld = db->pProfileArg;
1.643 + db->xProfile = xProfile;
1.644 + db->pProfileArg = pArg;
1.645 + sqlite3_mutex_leave(db->mutex);
1.646 + return pOld;
1.647 +}
1.648 +#endif /* SQLITE_OMIT_TRACE */
1.649 +
1.650 +/*** EXPERIMENTAL ***
1.651 +**
1.652 +** Register a function to be invoked when a transaction comments.
1.653 +** If the invoked function returns non-zero, then the commit becomes a
1.654 +** rollback.
1.655 +*/
1.656 +void *sqlite3_commit_hook(
1.657 + sqlite3 *db, /* Attach the hook to this database */
1.658 + int (*xCallback)(void*), /* Function to invoke on each commit */
1.659 + void *pArg /* Argument to the function */
1.660 +){
1.661 + void *pOld;
1.662 + sqlite3_mutex_enter(db->mutex);
1.663 + pOld = db->pCommitArg;
1.664 + db->xCommitCallback = xCallback;
1.665 + db->pCommitArg = pArg;
1.666 + sqlite3_mutex_leave(db->mutex);
1.667 + return pOld;
1.668 +}
1.669 +
1.670 +/*
1.671 +** Register a callback to be invoked each time a row is updated,
1.672 +** inserted or deleted using this database connection.
1.673 +*/
1.674 +void *sqlite3_update_hook(
1.675 + sqlite3 *db, /* Attach the hook to this database */
1.676 + void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
1.677 + void *pArg /* Argument to the function */
1.678 +){
1.679 + void *pRet;
1.680 + sqlite3_mutex_enter(db->mutex);
1.681 + pRet = db->pUpdateArg;
1.682 + db->xUpdateCallback = xCallback;
1.683 + db->pUpdateArg = pArg;
1.684 + sqlite3_mutex_leave(db->mutex);
1.685 + return pRet;
1.686 +}
1.687 +
1.688 +/*
1.689 +** Register a callback to be invoked each time a transaction is rolled
1.690 +** back by this database connection.
1.691 +*/
1.692 +void *sqlite3_rollback_hook(
1.693 + sqlite3 *db, /* Attach the hook to this database */
1.694 + void (*xCallback)(void*), /* Callback function */
1.695 + void *pArg /* Argument to the function */
1.696 +){
1.697 + void *pRet;
1.698 + sqlite3_mutex_enter(db->mutex);
1.699 + pRet = db->pRollbackArg;
1.700 + db->xRollbackCallback = xCallback;
1.701 + db->pRollbackArg = pArg;
1.702 + sqlite3_mutex_leave(db->mutex);
1.703 + return pRet;
1.704 +}
1.705 +
1.706 +/*
1.707 +** This routine is called to create a connection to a database BTree
1.708 +** driver. If zFilename is the name of a file, then that file is
1.709 +** opened and used. If zFilename is the magic name ":memory:" then
1.710 +** the database is stored in memory (and is thus forgotten as soon as
1.711 +** the connection is closed.) If zFilename is NULL then the database
1.712 +** is a "virtual" database for transient use only and is deleted as
1.713 +** soon as the connection is closed.
1.714 +**
1.715 +** A virtual database can be either a disk file (that is automatically
1.716 +** deleted when the file is closed) or it an be held entirely in memory,
1.717 +** depending on the values of the TEMP_STORE compile-time macro and the
1.718 +** db->temp_store variable, according to the following chart:
1.719 +**
1.720 +** TEMP_STORE db->temp_store Location of temporary database
1.721 +** ---------- -------------- ------------------------------
1.722 +** 0 any file
1.723 +** 1 1 file
1.724 +** 1 2 memory
1.725 +** 1 0 file
1.726 +** 2 1 file
1.727 +** 2 2 memory
1.728 +** 2 0 memory
1.729 +** 3 any memory
1.730 +*/
1.731 +int sqlite3BtreeFactory(
1.732 + const sqlite3 *db, /* Main database when opening aux otherwise 0 */
1.733 + const char *zFilename, /* Name of the file containing the BTree database */
1.734 + int omitJournal, /* if TRUE then do not journal this file */
1.735 + int nCache, /* How many pages in the page cache */
1.736 + int vfsFlags, /* Flags passed through to vfsOpen */
1.737 + Btree **ppBtree /* Pointer to new Btree object written here */
1.738 +){
1.739 + int btFlags = 0;
1.740 + int rc;
1.741 +
1.742 + assert( sqlite3_mutex_held(db->mutex) );
1.743 + assert( ppBtree != 0);
1.744 + if( omitJournal ){
1.745 + btFlags |= BTREE_OMIT_JOURNAL;
1.746 + }
1.747 + if( db->flags & SQLITE_NoReadlock ){
1.748 + btFlags |= BTREE_NO_READLOCK;
1.749 + }
1.750 + if( zFilename==0 ){
1.751 +#if TEMP_STORE==0
1.752 + /* Do nothing */
1.753 +#endif
1.754 +#ifndef SQLITE_OMIT_MEMORYDB
1.755 +#if TEMP_STORE==1
1.756 + if( db->temp_store==2 ) zFilename = ":memory:";
1.757 +#endif
1.758 +#if TEMP_STORE==2
1.759 + if( db->temp_store!=1 ) zFilename = ":memory:";
1.760 +#endif
1.761 +#if TEMP_STORE==3
1.762 + zFilename = ":memory:";
1.763 +#endif
1.764 +#endif /* SQLITE_OMIT_MEMORYDB */
1.765 + }
1.766 +
1.767 + if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 || *zFilename==0) ){
1.768 + vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
1.769 + }
1.770 + rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags);
1.771 + if( rc==SQLITE_OK ){
1.772 + sqlite3BtreeSetBusyHandler(*ppBtree, (void*)&db->busyHandler);
1.773 + sqlite3BtreeSetCacheSize(*ppBtree, nCache);
1.774 + }
1.775 + return rc;
1.776 +}
1.777 +
1.778 +/*
1.779 +** Return UTF-8 encoded English language explanation of the most recent
1.780 +** error.
1.781 +*/
1.782 +const char *sqlite3_errmsg(sqlite3 *db){
1.783 + const char *z;
1.784 + if( !db ){
1.785 + return sqlite3ErrStr(SQLITE_NOMEM);
1.786 + }
1.787 + if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){
1.788 + return sqlite3ErrStr(SQLITE_MISUSE);
1.789 + }
1.790 + sqlite3_mutex_enter(db->mutex);
1.791 + assert( !db->mallocFailed );
1.792 + z = (char*)sqlite3_value_text(db->pErr);
1.793 + if( z==0 ){
1.794 + z = sqlite3ErrStr(db->errCode);
1.795 + }
1.796 + sqlite3_mutex_leave(db->mutex);
1.797 + return z;
1.798 +}
1.799 +
1.800 +#ifndef SQLITE_OMIT_UTF16
1.801 +/*
1.802 +** Return UTF-16 encoded English language explanation of the most recent
1.803 +** error.
1.804 +*/
1.805 +const void *sqlite3_errmsg16(sqlite3 *db){
1.806 + /* Because all the characters in the string are in the unicode
1.807 + ** range 0x00-0xFF, if we pad the big-endian string with a
1.808 + ** zero byte, we can obtain the little-endian string with
1.809 + ** &big_endian[1].
1.810 + */
1.811 + static const char outOfMemBe[] = {
1.812 + 0, 'o', 0, 'u', 0, 't', 0, ' ',
1.813 + 0, 'o', 0, 'f', 0, ' ',
1.814 + 0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
1.815 + };
1.816 + static const char misuseBe [] = {
1.817 + 0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ',
1.818 + 0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ',
1.819 + 0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ',
1.820 + 0, 'o', 0, 'u', 0, 't', 0, ' ',
1.821 + 0, 'o', 0, 'f', 0, ' ',
1.822 + 0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
1.823 + };
1.824 +
1.825 + const void *z;
1.826 + if( !db ){
1.827 + return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
1.828 + }
1.829 + if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){
1.830 + return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
1.831 + }
1.832 + sqlite3_mutex_enter(db->mutex);
1.833 + assert( !db->mallocFailed );
1.834 + z = sqlite3_value_text16(db->pErr);
1.835 + if( z==0 ){
1.836 + sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
1.837 + SQLITE_UTF8, SQLITE_STATIC);
1.838 + z = sqlite3_value_text16(db->pErr);
1.839 + }
1.840 + sqlite3ApiExit(0, 0);
1.841 + sqlite3_mutex_leave(db->mutex);
1.842 + return z;
1.843 +}
1.844 +#endif /* SQLITE_OMIT_UTF16 */
1.845 +
1.846 +/*
1.847 +** Return the most recent error code generated by an SQLite routine. If NULL is
1.848 +** passed to this function, we assume a malloc() failed during sqlite3_open().
1.849 +*/
1.850 +int sqlite3_errcode(sqlite3 *db){
1.851 + if( !db || db->mallocFailed ){
1.852 + return SQLITE_NOMEM;
1.853 + }
1.854 + if( sqlite3SafetyCheck(db) ){
1.855 + return SQLITE_MISUSE;
1.856 + }
1.857 + return db->errCode & db->errMask;
1.858 +}
1.859 +
1.860 +/*
1.861 +** Create a new collating function for database "db". The name is zName
1.862 +** and the encoding is enc.
1.863 +*/
1.864 +static int createCollation(
1.865 + sqlite3* db,
1.866 + const char *zName,
1.867 + int enc,
1.868 + void* pCtx,
1.869 + int(*xCompare)(void*,int,const void*,int,const void*),
1.870 + void(*xDel)(void*)
1.871 +){
1.872 + CollSeq *pColl;
1.873 + int enc2;
1.874 +
1.875 + if( sqlite3SafetyCheck(db) ){
1.876 + return SQLITE_MISUSE;
1.877 + }
1.878 + assert( sqlite3_mutex_held(db->mutex) );
1.879 +
1.880 + /* If SQLITE_UTF16 is specified as the encoding type, transform this
1.881 + ** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
1.882 + ** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
1.883 + */
1.884 + enc2 = enc & ~SQLITE_UTF16_ALIGNED;
1.885 + if( enc2==SQLITE_UTF16 ){
1.886 + enc2 = SQLITE_UTF16NATIVE;
1.887 + }
1.888 +
1.889 + if( (enc2&~3)!=0 ){
1.890 + sqlite3Error(db, SQLITE_ERROR, "unknown encoding");
1.891 + return SQLITE_ERROR;
1.892 + }
1.893 +
1.894 + /* Check if this call is removing or replacing an existing collation
1.895 + ** sequence. If so, and there are active VMs, return busy. If there
1.896 + ** are no active VMs, invalidate any pre-compiled statements.
1.897 + */
1.898 + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 0);
1.899 + if( pColl && pColl->xCmp ){
1.900 + if( db->activeVdbeCnt ){
1.901 + sqlite3Error(db, SQLITE_BUSY,
1.902 + "Unable to delete/modify collation sequence due to active statements");
1.903 + return SQLITE_BUSY;
1.904 + }
1.905 + sqlite3ExpirePreparedStatements(db);
1.906 +
1.907 + /* If collation sequence pColl was created directly by a call to
1.908 + ** sqlite3_create_collation, and not generated by synthCollSeq(),
1.909 + ** then any copies made by synthCollSeq() need to be invalidated.
1.910 + ** Also, collation destructor - CollSeq.xDel() - function may need
1.911 + ** to be called.
1.912 + */
1.913 + if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
1.914 + CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, strlen(zName));
1.915 + int j;
1.916 + for(j=0; j<3; j++){
1.917 + CollSeq *p = &aColl[j];
1.918 + if( p->enc==pColl->enc ){
1.919 + if( p->xDel ){
1.920 + p->xDel(p->pUser);
1.921 + }
1.922 + p->xCmp = 0;
1.923 + }
1.924 + }
1.925 + }
1.926 + }
1.927 +
1.928 + pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 1);
1.929 + if( pColl ){
1.930 + pColl->xCmp = xCompare;
1.931 + pColl->pUser = pCtx;
1.932 + pColl->xDel = xDel;
1.933 + pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED);
1.934 + }
1.935 + sqlite3Error(db, SQLITE_OK, 0);
1.936 + return SQLITE_OK;
1.937 +}
1.938 +
1.939 +
1.940 +/*
1.941 +** This routine does the work of opening a database on behalf of
1.942 +** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
1.943 +** is UTF-8 encoded.
1.944 +*/
1.945 +static int openDatabase(
1.946 + const char *zFilename, /* Database filename UTF-8 encoded */
1.947 + sqlite3 **ppDb, /* OUT: Returned database handle */
1.948 + unsigned flags, /* Operational flags */
1.949 + const char *zVfs /* Name of the VFS to use */
1.950 +){
1.951 + sqlite3 *db;
1.952 + int rc;
1.953 + CollSeq *pColl;
1.954 +
1.955 + /* Allocate the sqlite data structure */
1.956 + db = sqlite3MallocZero( sizeof(sqlite3) );
1.957 + if( db==0 ) goto opendb_out;
1.958 + db->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
1.959 + if( db->mutex==0 ){
1.960 + sqlite3_free(db);
1.961 + db = 0;
1.962 + goto opendb_out;
1.963 + }
1.964 + sqlite3_mutex_enter(db->mutex);
1.965 + db->errMask = 0xff;
1.966 + db->priorNewRowid = 0;
1.967 + db->nDb = 2;
1.968 + db->magic = SQLITE_MAGIC_BUSY;
1.969 + db->aDb = db->aDbStatic;
1.970 + db->autoCommit = 1;
1.971 + db->flags |= SQLITE_ShortColNames
1.972 +#if SQLITE_DEFAULT_FILE_FORMAT<4
1.973 + | SQLITE_LegacyFileFmt
1.974 +#endif
1.975 +#ifdef SQLITE_ENABLE_LOAD_EXTENSION
1.976 + | SQLITE_LoadExtension
1.977 +#endif
1.978 + ;
1.979 + sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0);
1.980 + sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
1.981 +#ifndef SQLITE_OMIT_VIRTUALTABLE
1.982 + sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
1.983 +#endif
1.984 +
1.985 + db->pVfs = sqlite3_vfs_find(zVfs);
1.986 + if( !db->pVfs ){
1.987 + rc = SQLITE_ERROR;
1.988 + db->magic = SQLITE_MAGIC_CLOSED;
1.989 + sqlite3Error(db, rc, "no such vfs: %s", (zVfs?zVfs:"(null)"));
1.990 + goto opendb_out;
1.991 + }
1.992 +
1.993 + /* Add the default collation sequence BINARY. BINARY works for both UTF-8
1.994 + ** and UTF-16, so add a version for each to avoid any unnecessary
1.995 + ** conversions. The only error that can occur here is a malloc() failure.
1.996 + */
1.997 + if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0) ||
1.998 + createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0) ||
1.999 + createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0) ||
1.1000 + (db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0
1.1001 + ){
1.1002 + assert( db->mallocFailed );
1.1003 + db->magic = SQLITE_MAGIC_CLOSED;
1.1004 + goto opendb_out;
1.1005 + }
1.1006 +
1.1007 + /* Also add a UTF-8 case-insensitive collation sequence. */
1.1008 + createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
1.1009 +
1.1010 + /* Set flags on the built-in collating sequences */
1.1011 + db->pDfltColl->type = SQLITE_COLL_BINARY;
1.1012 + pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
1.1013 + if( pColl ){
1.1014 + pColl->type = SQLITE_COLL_NOCASE;
1.1015 + }
1.1016 +
1.1017 + /* Open the backend database driver */
1.1018 + db->openFlags = flags;
1.1019 + rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE,
1.1020 + flags | SQLITE_OPEN_MAIN_DB,
1.1021 + &db->aDb[0].pBt);
1.1022 + if( rc!=SQLITE_OK ){
1.1023 + sqlite3Error(db, rc, 0);
1.1024 + db->magic = SQLITE_MAGIC_CLOSED;
1.1025 + goto opendb_out;
1.1026 + }
1.1027 + db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
1.1028 + db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
1.1029 +
1.1030 +
1.1031 + /* The default safety_level for the main database is 'full'; for the temp
1.1032 + ** database it is 'NONE'. This matches the pager layer defaults.
1.1033 + */
1.1034 + db->aDb[0].zName = "main";
1.1035 + db->aDb[0].safety_level = 3;
1.1036 +#ifndef SQLITE_OMIT_TEMPDB
1.1037 + db->aDb[1].zName = "temp";
1.1038 + db->aDb[1].safety_level = 1;
1.1039 +#endif
1.1040 +
1.1041 + db->magic = SQLITE_MAGIC_OPEN;
1.1042 + if( db->mallocFailed ){
1.1043 + goto opendb_out;
1.1044 + }
1.1045 +
1.1046 + /* Register all built-in functions, but do not attempt to read the
1.1047 + ** database schema yet. This is delayed until the first time the database
1.1048 + ** is accessed.
1.1049 + */
1.1050 + sqlite3Error(db, SQLITE_OK, 0);
1.1051 + sqlite3RegisterBuiltinFunctions(db);
1.1052 +
1.1053 + /* Load automatic extensions - extensions that have been registered
1.1054 + ** using the sqlite3_automatic_extension() API.
1.1055 + */
1.1056 + (void)sqlite3AutoLoadExtensions(db);
1.1057 + if( sqlite3_errcode(db)!=SQLITE_OK ){
1.1058 + goto opendb_out;
1.1059 + }
1.1060 +
1.1061 +#ifdef SQLITE_ENABLE_FTS1
1.1062 + if( !db->mallocFailed ){
1.1063 + extern int sqlite3Fts1Init(sqlite3*);
1.1064 + rc = sqlite3Fts1Init(db);
1.1065 + }
1.1066 +#endif
1.1067 +
1.1068 +#ifdef SQLITE_ENABLE_FTS2
1.1069 + if( !db->mallocFailed && rc==SQLITE_OK ){
1.1070 + extern int sqlite3Fts2Init(sqlite3*);
1.1071 + rc = sqlite3Fts2Init(db);
1.1072 + }
1.1073 +#endif
1.1074 +
1.1075 +#ifdef SQLITE_ENABLE_FTS3
1.1076 + if( !db->mallocFailed && rc==SQLITE_OK ){
1.1077 + extern int sqlite3Fts3Init(sqlite3*);
1.1078 + rc = sqlite3Fts3Init(db);
1.1079 + }
1.1080 +#endif
1.1081 +
1.1082 +#ifdef SQLITE_ENABLE_ICU
1.1083 + if( !db->mallocFailed && rc==SQLITE_OK ){
1.1084 + extern int sqlite3IcuInit(sqlite3*);
1.1085 + rc = sqlite3IcuInit(db);
1.1086 + }
1.1087 +#endif
1.1088 + sqlite3Error(db, rc, 0);
1.1089 +
1.1090 + /* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
1.1091 + ** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
1.1092 + ** mode. Doing nothing at all also makes NORMAL the default.
1.1093 + */
1.1094 +#ifdef SQLITE_DEFAULT_LOCKING_MODE
1.1095 + db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
1.1096 + sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
1.1097 + SQLITE_DEFAULT_LOCKING_MODE);
1.1098 +#endif
1.1099 +
1.1100 +opendb_out:
1.1101 + if( db && db->mutex ){
1.1102 + sqlite3_mutex_leave(db->mutex);
1.1103 + }
1.1104 + if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){
1.1105 + sqlite3_close(db);
1.1106 + db = 0;
1.1107 + }
1.1108 + *ppDb = db;
1.1109 + return sqlite3ApiExit(0, rc);
1.1110 +}
1.1111 +
1.1112 +/*
1.1113 +** Open a new database handle.
1.1114 +*/
1.1115 +int sqlite3_open(
1.1116 + const char *zFilename,
1.1117 + sqlite3 **ppDb
1.1118 +){
1.1119 + return openDatabase(zFilename, ppDb,
1.1120 + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
1.1121 +}
1.1122 +int sqlite3_open_v2(
1.1123 + const char *filename, /* Database filename (UTF-8) */
1.1124 + sqlite3 **ppDb, /* OUT: SQLite db handle */
1.1125 + int flags, /* Flags */
1.1126 + const char *zVfs /* Name of VFS module to use */
1.1127 +){
1.1128 + return openDatabase(filename, ppDb, flags, zVfs);
1.1129 +}
1.1130 +
1.1131 +#ifndef SQLITE_OMIT_UTF16
1.1132 +/*
1.1133 +** Open a new database handle.
1.1134 +*/
1.1135 +int sqlite3_open16(
1.1136 + const void *zFilename,
1.1137 + sqlite3 **ppDb
1.1138 +){
1.1139 + char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
1.1140 + sqlite3_value *pVal;
1.1141 + int rc = SQLITE_NOMEM;
1.1142 +
1.1143 + assert( zFilename );
1.1144 + assert( ppDb );
1.1145 + *ppDb = 0;
1.1146 + pVal = sqlite3ValueNew(0);
1.1147 + sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
1.1148 + zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
1.1149 + if( zFilename8 ){
1.1150 + rc = openDatabase(zFilename8, ppDb,
1.1151 + SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
1.1152 + if( rc==SQLITE_OK && *ppDb ){
1.1153 + rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);
1.1154 + if( rc!=SQLITE_OK ){
1.1155 + sqlite3_close(*ppDb);
1.1156 + *ppDb = 0;
1.1157 + }
1.1158 + }
1.1159 + }
1.1160 + sqlite3ValueFree(pVal);
1.1161 +
1.1162 + return sqlite3ApiExit(0, rc);
1.1163 +}
1.1164 +#endif /* SQLITE_OMIT_UTF16 */
1.1165 +
1.1166 +/*
1.1167 +** Register a new collation sequence with the database handle db.
1.1168 +*/
1.1169 +int sqlite3_create_collation(
1.1170 + sqlite3* db,
1.1171 + const char *zName,
1.1172 + int enc,
1.1173 + void* pCtx,
1.1174 + int(*xCompare)(void*,int,const void*,int,const void*)
1.1175 +){
1.1176 + int rc;
1.1177 + sqlite3_mutex_enter(db->mutex);
1.1178 + assert( !db->mallocFailed );
1.1179 + rc = createCollation(db, zName, enc, pCtx, xCompare, 0);
1.1180 + rc = sqlite3ApiExit(db, rc);
1.1181 + sqlite3_mutex_leave(db->mutex);
1.1182 + return rc;
1.1183 +}
1.1184 +
1.1185 +/*
1.1186 +** Register a new collation sequence with the database handle db.
1.1187 +*/
1.1188 +int sqlite3_create_collation_v2(
1.1189 + sqlite3* db,
1.1190 + const char *zName,
1.1191 + int enc,
1.1192 + void* pCtx,
1.1193 + int(*xCompare)(void*,int,const void*,int,const void*),
1.1194 + void(*xDel)(void*)
1.1195 +){
1.1196 + int rc;
1.1197 + sqlite3_mutex_enter(db->mutex);
1.1198 + assert( !db->mallocFailed );
1.1199 + rc = createCollation(db, zName, enc, pCtx, xCompare, xDel);
1.1200 + rc = sqlite3ApiExit(db, rc);
1.1201 + sqlite3_mutex_leave(db->mutex);
1.1202 + return rc;
1.1203 +}
1.1204 +
1.1205 +#ifndef SQLITE_OMIT_UTF16
1.1206 +/*
1.1207 +** Register a new collation sequence with the database handle db.
1.1208 +*/
1.1209 +int sqlite3_create_collation16(
1.1210 + sqlite3* db,
1.1211 + const char *zName,
1.1212 + int enc,
1.1213 + void* pCtx,
1.1214 + int(*xCompare)(void*,int,const void*,int,const void*)
1.1215 +){
1.1216 + int rc = SQLITE_OK;
1.1217 + char *zName8;
1.1218 + sqlite3_mutex_enter(db->mutex);
1.1219 + assert( !db->mallocFailed );
1.1220 + zName8 = sqlite3Utf16to8(db, zName, -1);
1.1221 + if( zName8 ){
1.1222 + rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
1.1223 + sqlite3_free(zName8);
1.1224 + }
1.1225 + rc = sqlite3ApiExit(db, rc);
1.1226 + sqlite3_mutex_leave(db->mutex);
1.1227 + return rc;
1.1228 +}
1.1229 +#endif /* SQLITE_OMIT_UTF16 */
1.1230 +
1.1231 +/*
1.1232 +** Register a collation sequence factory callback with the database handle
1.1233 +** db. Replace any previously installed collation sequence factory.
1.1234 +*/
1.1235 +int sqlite3_collation_needed(
1.1236 + sqlite3 *db,
1.1237 + void *pCollNeededArg,
1.1238 + void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
1.1239 +){
1.1240 + if( sqlite3SafetyCheck(db) ){
1.1241 + return SQLITE_MISUSE;
1.1242 + }
1.1243 + sqlite3_mutex_enter(db->mutex);
1.1244 + db->xCollNeeded = xCollNeeded;
1.1245 + db->xCollNeeded16 = 0;
1.1246 + db->pCollNeededArg = pCollNeededArg;
1.1247 + sqlite3_mutex_leave(db->mutex);
1.1248 + return SQLITE_OK;
1.1249 +}
1.1250 +
1.1251 +#ifndef SQLITE_OMIT_UTF16
1.1252 +/*
1.1253 +** Register a collation sequence factory callback with the database handle
1.1254 +** db. Replace any previously installed collation sequence factory.
1.1255 +*/
1.1256 +int sqlite3_collation_needed16(
1.1257 + sqlite3 *db,
1.1258 + void *pCollNeededArg,
1.1259 + void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
1.1260 +){
1.1261 + if( sqlite3SafetyCheck(db) ){
1.1262 + return SQLITE_MISUSE;
1.1263 + }
1.1264 + sqlite3_mutex_enter(db->mutex);
1.1265 + db->xCollNeeded = 0;
1.1266 + db->xCollNeeded16 = xCollNeeded16;
1.1267 + db->pCollNeededArg = pCollNeededArg;
1.1268 + sqlite3_mutex_leave(db->mutex);
1.1269 + return SQLITE_OK;
1.1270 +}
1.1271 +#endif /* SQLITE_OMIT_UTF16 */
1.1272 +
1.1273 +#ifndef SQLITE_OMIT_GLOBALRECOVER
1.1274 +/*
1.1275 +** This function is now an anachronism. It used to be used to recover from a
1.1276 +** malloc() failure, but SQLite now does this automatically.
1.1277 +*/
1.1278 +int sqlite3_global_recover(){
1.1279 + return SQLITE_OK;
1.1280 +}
1.1281 +#endif
1.1282 +
1.1283 +/*
1.1284 +** Test to see whether or not the database connection is in autocommit
1.1285 +** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
1.1286 +** by default. Autocommit is disabled by a BEGIN statement and reenabled
1.1287 +** by the next COMMIT or ROLLBACK.
1.1288 +**
1.1289 +******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
1.1290 +*/
1.1291 +int sqlite3_get_autocommit(sqlite3 *db){
1.1292 + return db->autoCommit;
1.1293 +}
1.1294 +
1.1295 +#ifdef SQLITE_DEBUG
1.1296 +/*
1.1297 +** The following routine is subtituted for constant SQLITE_CORRUPT in
1.1298 +** debugging builds. This provides a way to set a breakpoint for when
1.1299 +** corruption is first detected.
1.1300 +*/
1.1301 +int sqlite3Corrupt(void){
1.1302 + return SQLITE_CORRUPT;
1.1303 +}
1.1304 +#endif
1.1305 +
1.1306 +/*
1.1307 +** This is a convenience routine that makes sure that all thread-specific
1.1308 +** data for this thread has been deallocated.
1.1309 +**
1.1310 +** SQLite no longer uses thread-specific data so this routine is now a
1.1311 +** no-op. It is retained for historical compatibility.
1.1312 +*/
1.1313 +void sqlite3_thread_cleanup(void){
1.1314 +}
1.1315 +
1.1316 +/*
1.1317 +** Return meta information about a specific column of a database table.
1.1318 +** See comment in sqlite3.h (sqlite.h.in) for details.
1.1319 +*/
1.1320 +#ifdef SQLITE_ENABLE_COLUMN_METADATA
1.1321 +int sqlite3_table_column_metadata(
1.1322 + sqlite3 *db, /* Connection handle */
1.1323 + const char *zDbName, /* Database name or NULL */
1.1324 + const char *zTableName, /* Table name */
1.1325 + const char *zColumnName, /* Column name */
1.1326 + char const **pzDataType, /* OUTPUT: Declared data type */
1.1327 + char const **pzCollSeq, /* OUTPUT: Collation sequence name */
1.1328 + int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
1.1329 + int *pPrimaryKey, /* OUTPUT: True if column part of PK */
1.1330 + int *pAutoinc /* OUTPUT: True if colums is auto-increment */
1.1331 +){
1.1332 + int rc;
1.1333 + char *zErrMsg = 0;
1.1334 + Table *pTab = 0;
1.1335 + Column *pCol = 0;
1.1336 + int iCol;
1.1337 +
1.1338 + char const *zDataType = 0;
1.1339 + char const *zCollSeq = 0;
1.1340 + int notnull = 0;
1.1341 + int primarykey = 0;
1.1342 + int autoinc = 0;
1.1343 +
1.1344 + /* Ensure the database schema has been loaded */
1.1345 + if( sqlite3SafetyOn(db) ){
1.1346 + return SQLITE_MISUSE;
1.1347 + }
1.1348 + sqlite3_mutex_enter(db->mutex);
1.1349 + rc = sqlite3Init(db, &zErrMsg);
1.1350 + if( SQLITE_OK!=rc ){
1.1351 + goto error_out;
1.1352 + }
1.1353 +
1.1354 + /* Locate the table in question */
1.1355 + pTab = sqlite3FindTable(db, zTableName, zDbName);
1.1356 + if( !pTab || pTab->pSelect ){
1.1357 + pTab = 0;
1.1358 + goto error_out;
1.1359 + }
1.1360 +
1.1361 + /* Find the column for which info is requested */
1.1362 + if( sqlite3IsRowid(zColumnName) ){
1.1363 + iCol = pTab->iPKey;
1.1364 + if( iCol>=0 ){
1.1365 + pCol = &pTab->aCol[iCol];
1.1366 + }
1.1367 + }else{
1.1368 + for(iCol=0; iCol<pTab->nCol; iCol++){
1.1369 + pCol = &pTab->aCol[iCol];
1.1370 + if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
1.1371 + break;
1.1372 + }
1.1373 + }
1.1374 + if( iCol==pTab->nCol ){
1.1375 + pTab = 0;
1.1376 + goto error_out;
1.1377 + }
1.1378 + }
1.1379 +
1.1380 + /* The following block stores the meta information that will be returned
1.1381 + ** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
1.1382 + ** and autoinc. At this point there are two possibilities:
1.1383 + **
1.1384 + ** 1. The specified column name was rowid", "oid" or "_rowid_"
1.1385 + ** and there is no explicitly declared IPK column.
1.1386 + **
1.1387 + ** 2. The table is not a view and the column name identified an
1.1388 + ** explicitly declared column. Copy meta information from *pCol.
1.1389 + */
1.1390 + if( pCol ){
1.1391 + zDataType = pCol->zType;
1.1392 + zCollSeq = pCol->zColl;
1.1393 + notnull = (pCol->notNull?1:0);
1.1394 + primarykey = (pCol->isPrimKey?1:0);
1.1395 + autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0);
1.1396 + }else{
1.1397 + zDataType = "INTEGER";
1.1398 + primarykey = 1;
1.1399 + }
1.1400 + if( !zCollSeq ){
1.1401 + zCollSeq = "BINARY";
1.1402 + }
1.1403 +
1.1404 +error_out:
1.1405 + if( sqlite3SafetyOff(db) ){
1.1406 + rc = SQLITE_MISUSE;
1.1407 + }
1.1408 +
1.1409 + /* Whether the function call succeeded or failed, set the output parameters
1.1410 + ** to whatever their local counterparts contain. If an error did occur,
1.1411 + ** this has the effect of zeroing all output parameters.
1.1412 + */
1.1413 + if( pzDataType ) *pzDataType = zDataType;
1.1414 + if( pzCollSeq ) *pzCollSeq = zCollSeq;
1.1415 + if( pNotNull ) *pNotNull = notnull;
1.1416 + if( pPrimaryKey ) *pPrimaryKey = primarykey;
1.1417 + if( pAutoinc ) *pAutoinc = autoinc;
1.1418 +
1.1419 + if( SQLITE_OK==rc && !pTab ){
1.1420 + sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".",
1.1421 + zColumnName, 0);
1.1422 + rc = SQLITE_ERROR;
1.1423 + }
1.1424 + sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
1.1425 + sqlite3_free(zErrMsg);
1.1426 + rc = sqlite3ApiExit(db, rc);
1.1427 + sqlite3_mutex_leave(db->mutex);
1.1428 + return rc;
1.1429 +}
1.1430 +#endif
1.1431 +
1.1432 +/*
1.1433 +** Sleep for a little while. Return the amount of time slept.
1.1434 +*/
1.1435 +int sqlite3_sleep(int ms){
1.1436 + sqlite3_vfs *pVfs;
1.1437 + int rc;
1.1438 + pVfs = sqlite3_vfs_find(0);
1.1439 +
1.1440 + /* This function works in milliseconds, but the underlying OsSleep()
1.1441 + ** API uses microseconds. Hence the 1000's.
1.1442 + */
1.1443 + rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
1.1444 + return rc;
1.1445 +}
1.1446 +
1.1447 +/*
1.1448 +** Enable or disable the extended result codes.
1.1449 +*/
1.1450 +int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
1.1451 + sqlite3_mutex_enter(db->mutex);
1.1452 + db->errMask = onoff ? 0xffffffff : 0xff;
1.1453 + sqlite3_mutex_leave(db->mutex);
1.1454 + return SQLITE_OK;
1.1455 +}
1.1456 +
1.1457 +/*
1.1458 +** Invoke the xFileControl method on a particular database.
1.1459 +*/
1.1460 +int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
1.1461 + int rc = SQLITE_ERROR;
1.1462 + int iDb;
1.1463 + sqlite3_mutex_enter(db->mutex);
1.1464 + if( zDbName==0 ){
1.1465 + iDb = 0;
1.1466 + }else{
1.1467 + for(iDb=0; iDb<db->nDb; iDb++){
1.1468 + if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
1.1469 + }
1.1470 + }
1.1471 + if( iDb<db->nDb ){
1.1472 + Btree *pBtree = db->aDb[iDb].pBt;
1.1473 + if( pBtree ){
1.1474 + Pager *pPager;
1.1475 + sqlite3BtreeEnter(pBtree);
1.1476 + pPager = sqlite3BtreePager(pBtree);
1.1477 + if( pPager ){
1.1478 + sqlite3_file *fd = sqlite3PagerFile(pPager);
1.1479 + if( fd ){
1.1480 + rc = sqlite3OsFileControl(fd, op, pArg);
1.1481 + }
1.1482 + }
1.1483 + sqlite3BtreeLeave(pBtree);
1.1484 + }
1.1485 + }
1.1486 + sqlite3_mutex_leave(db->mutex);
1.1487 + return rc;
1.1488 +}
