2000-05-29 18:26:00 +04:00
|
|
|
/*
|
2001-09-16 04:13:26 +04:00
|
|
|
** 2001 September 15
|
2000-05-29 18:26:00 +04:00
|
|
|
**
|
2001-09-16 04:13:26 +04:00
|
|
|
** The author disclaims copyright to this source code. In place of
|
|
|
|
** a legal notice, here is a blessing:
|
2000-05-29 18:26:00 +04:00
|
|
|
**
|
2001-09-16 04:13:26 +04:00
|
|
|
** May you do good and not evil.
|
|
|
|
** May you find forgiveness for yourself and forgive others.
|
|
|
|
** May you share freely, never taking more than you give.
|
2000-05-29 18:26:00 +04:00
|
|
|
**
|
|
|
|
*************************************************************************
|
|
|
|
** Main file for the SQLite library. The routines in this file
|
|
|
|
** implement the programmer interface to the library. Routines in
|
|
|
|
** other files are for internal use by SQLite and should not be
|
|
|
|
** accessed by users of the library.
|
|
|
|
**
|
2008-05-26 22:41:54 +04:00
|
|
|
** $Id: main.c,v 1.441 2008/05/26 18:41:54 danielk1977 Exp $
|
2000-05-29 18:26:00 +04:00
|
|
|
*/
|
|
|
|
#include "sqliteInt.h"
|
2002-05-15 18:17:44 +04:00
|
|
|
#include <ctype.h>
|
2008-01-31 16:35:48 +03:00
|
|
|
#ifdef SQLITE_ENABLE_FTS3
|
|
|
|
# include "fts3.h"
|
|
|
|
#endif
|
2000-05-29 18:26:00 +04:00
|
|
|
|
2000-08-22 17:40:18 +04:00
|
|
|
/*
|
|
|
|
** The version of the library
|
|
|
|
*/
|
2004-05-10 14:34:34 +04:00
|
|
|
const char sqlite3_version[] = SQLITE_VERSION;
|
2004-08-28 20:19:00 +04:00
|
|
|
const char *sqlite3_libversion(void){ return sqlite3_version; }
|
2005-02-05 10:33:34 +03:00
|
|
|
int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }
|
2007-08-31 00:09:48 +04:00
|
|
|
int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }
|
2000-08-22 17:40:18 +04:00
|
|
|
|
2008-05-01 21:03:49 +04:00
|
|
|
#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)
|
2007-02-28 07:47:26 +03:00
|
|
|
/*
|
|
|
|
** If the following function pointer is not NULL and if
|
|
|
|
** SQLITE_ENABLE_IOTRACE is enabled, then messages describing
|
|
|
|
** I/O active are written using this function. These messages
|
|
|
|
** are intended for debugging activity only.
|
|
|
|
*/
|
2008-03-04 20:45:01 +03:00
|
|
|
void (*sqlite3IoTrace)(const char*, ...) = 0;
|
2008-05-01 21:03:49 +04:00
|
|
|
#endif
|
2007-02-28 07:47:26 +03:00
|
|
|
|
2007-03-30 15:29:32 +04:00
|
|
|
/*
|
|
|
|
** If the following global variable points to a string which is the
|
|
|
|
** name of a directory, then that directory will be used to store
|
|
|
|
** temporary files.
|
|
|
|
**
|
|
|
|
** See also the "PRAGMA temp_store_directory" SQL command.
|
|
|
|
*/
|
|
|
|
char *sqlite3_temp_directory = 0;
|
|
|
|
|
2008-04-01 19:06:33 +04:00
|
|
|
/*
|
|
|
|
** Routine needed to support the testcase() macro.
|
|
|
|
*/
|
|
|
|
#ifdef SQLITE_COVERAGE_TEST
|
|
|
|
void sqlite3Coverage(int x){
|
|
|
|
static int dummy = 0;
|
|
|
|
dummy += x;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-03-30 15:29:32 +04:00
|
|
|
|
2008-01-21 02:19:56 +03:00
|
|
|
/*
|
|
|
|
** Return true if the buffer z[0..n-1] contains all spaces.
|
|
|
|
*/
|
|
|
|
static int allSpaces(const char *z, int n){
|
2008-04-15 08:02:40 +04:00
|
|
|
while( n>0 && z[n-1]==' ' ){ n--; }
|
2008-01-21 02:19:56 +03:00
|
|
|
return n==0;
|
|
|
|
}
|
|
|
|
|
2004-05-21 02:16:29 +04:00
|
|
|
/*
|
|
|
|
** This is the default collating function named "BINARY" which is always
|
|
|
|
** available.
|
2008-01-21 02:19:56 +03:00
|
|
|
**
|
|
|
|
** If the padFlag argument is not NULL then space padding at the end
|
|
|
|
** of strings is ignored. This implements the RTRIM collation.
|
2004-05-21 02:16:29 +04:00
|
|
|
*/
|
2005-01-13 05:14:23 +03:00
|
|
|
static int binCollFunc(
|
2008-01-21 02:19:56 +03:00
|
|
|
void *padFlag,
|
2004-05-21 02:16:29 +04:00
|
|
|
int nKey1, const void *pKey1,
|
|
|
|
int nKey2, const void *pKey2
|
|
|
|
){
|
|
|
|
int rc, n;
|
|
|
|
n = nKey1<nKey2 ? nKey1 : nKey2;
|
|
|
|
rc = memcmp(pKey1, pKey2, n);
|
|
|
|
if( rc==0 ){
|
2008-01-21 02:19:56 +03:00
|
|
|
if( padFlag
|
|
|
|
&& allSpaces(((char*)pKey1)+n, nKey1-n)
|
|
|
|
&& allSpaces(((char*)pKey2)+n, nKey2-n)
|
|
|
|
){
|
|
|
|
/* Leave rc unchanged at 0 */
|
|
|
|
}else{
|
|
|
|
rc = nKey1 - nKey2;
|
|
|
|
}
|
2004-05-21 02:16:29 +04:00
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2004-06-09 13:55:16 +04:00
|
|
|
/*
|
2004-06-11 14:51:27 +04:00
|
|
|
** Another built-in collating sequence: NOCASE.
|
|
|
|
**
|
|
|
|
** This collating sequence is intended to be used for "case independant
|
|
|
|
** comparison". SQLite's knowledge of upper and lower case equivalents
|
|
|
|
** extends only to the 26 characters used in the English language.
|
|
|
|
**
|
|
|
|
** At the moment there is only a UTF-8 implementation.
|
2004-06-09 13:55:16 +04:00
|
|
|
*/
|
|
|
|
static int nocaseCollatingFunc(
|
|
|
|
void *NotUsed,
|
|
|
|
int nKey1, const void *pKey1,
|
|
|
|
int nKey2, const void *pKey2
|
|
|
|
){
|
|
|
|
int r = sqlite3StrNICmp(
|
2004-08-30 00:08:58 +04:00
|
|
|
(const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);
|
2004-06-09 13:55:16 +04:00
|
|
|
if( 0==r ){
|
|
|
|
r = nKey1-nKey2;
|
|
|
|
}
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2002-01-17 00:00:27 +03:00
|
|
|
/*
|
|
|
|
** Return the ROWID of the most recent insert
|
|
|
|
*/
|
2004-09-06 21:24:11 +04:00
|
|
|
sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){
|
2002-01-17 00:00:27 +03:00
|
|
|
return db->lastRowid;
|
|
|
|
}
|
|
|
|
|
2002-04-12 14:08:59 +04:00
|
|
|
/*
|
2004-05-10 14:34:34 +04:00
|
|
|
** Return the number of changes in the most recent call to sqlite3_exec().
|
2002-04-12 14:08:59 +04:00
|
|
|
*/
|
2004-09-06 21:24:11 +04:00
|
|
|
int sqlite3_changes(sqlite3 *db){
|
2002-04-12 14:08:59 +04:00
|
|
|
return db->nChange;
|
|
|
|
}
|
|
|
|
|
2004-02-26 01:51:06 +03:00
|
|
|
/*
|
2004-06-21 10:50:26 +04:00
|
|
|
** Return the number of changes since the database handle was opened.
|
2004-02-26 01:51:06 +03:00
|
|
|
*/
|
2004-06-21 10:50:26 +04:00
|
|
|
int sqlite3_total_changes(sqlite3 *db){
|
|
|
|
return db->nTotalChange;
|
2004-02-21 01:53:38 +03:00
|
|
|
}
|
|
|
|
|
2001-09-15 04:57:28 +04:00
|
|
|
/*
|
|
|
|
** Close an existing SQLite database
|
|
|
|
*/
|
2004-09-06 21:24:11 +04:00
|
|
|
int sqlite3_close(sqlite3 *db){
|
2002-02-24 02:45:45 +03:00
|
|
|
HashElem *i;
|
2003-03-19 06:14:00 +03:00
|
|
|
int j;
|
2004-06-16 14:39:23 +04:00
|
|
|
|
|
|
|
if( !db ){
|
2004-06-19 07:33:57 +04:00
|
|
|
return SQLITE_OK;
|
2004-06-16 14:39:23 +04:00
|
|
|
}
|
2008-01-23 06:03:05 +03:00
|
|
|
if( !sqlite3SafetyCheckSickOrOk(db) ){
|
2004-06-26 13:50:11 +04:00
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
2007-08-21 19:13:19 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2004-06-26 13:50:11 +04:00
|
|
|
|
2005-05-26 16:37:29 +04:00
|
|
|
#ifdef SQLITE_SSE
|
2006-03-16 19:19:56 +03:00
|
|
|
{
|
|
|
|
extern void sqlite3SseCleanup(sqlite3*);
|
|
|
|
sqlite3SseCleanup(db);
|
|
|
|
}
|
2005-05-26 16:37:29 +04:00
|
|
|
#endif
|
|
|
|
|
2006-07-31 00:50:44 +04:00
|
|
|
sqlite3ResetInternalSchema(db, 0);
|
2007-04-16 19:06:25 +04:00
|
|
|
|
2007-04-18 18:24:32 +04:00
|
|
|
/* If a transaction is open, the ResetInternalSchema() call above
|
|
|
|
** will not have called the xDisconnect() method on any virtual
|
|
|
|
** tables in the db->aVTrans[] array. The following sqlite3VtabRollback()
|
|
|
|
** call will do so. We need to do this before the check for active
|
|
|
|
** SQL statements below, as the v-table implementation may be storing
|
|
|
|
** some prepared statements internally.
|
|
|
|
*/
|
|
|
|
sqlite3VtabRollback(db);
|
|
|
|
|
2007-04-16 19:06:25 +04:00
|
|
|
/* If there are any outstanding VMs, return SQLITE_BUSY. */
|
2004-06-19 07:33:57 +04:00
|
|
|
if( db->pVdbe ){
|
|
|
|
sqlite3Error(db, SQLITE_BUSY,
|
|
|
|
"Unable to close due to unfinalised statements");
|
2007-08-22 06:56:42 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2004-06-19 07:33:57 +04:00
|
|
|
return SQLITE_BUSY;
|
|
|
|
}
|
2008-01-23 06:03:05 +03:00
|
|
|
assert( sqlite3SafetyCheckSickOrOk(db) );
|
2004-06-15 20:51:01 +04:00
|
|
|
|
2003-03-19 06:14:00 +03:00
|
|
|
for(j=0; j<db->nDb; j++){
|
2004-02-12 21:46:38 +03:00
|
|
|
struct Db *pDb = &db->aDb[j];
|
|
|
|
if( pDb->pBt ){
|
2004-05-08 12:23:19 +04:00
|
|
|
sqlite3BtreeClose(pDb->pBt);
|
2004-02-12 21:46:38 +03:00
|
|
|
pDb->pBt = 0;
|
2006-01-10 10:14:23 +03:00
|
|
|
if( j!=1 ){
|
|
|
|
pDb->pSchema = 0;
|
|
|
|
}
|
2003-03-20 04:16:58 +03:00
|
|
|
}
|
2001-10-08 17:22:32 +04:00
|
|
|
}
|
2004-05-08 12:23:19 +04:00
|
|
|
sqlite3ResetInternalSchema(db, 0);
|
2003-03-31 04:30:47 +04:00
|
|
|
assert( db->nDb<=2 );
|
|
|
|
assert( db->aDb==db->aDbStatic );
|
2002-02-28 03:41:10 +03:00
|
|
|
for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){
|
|
|
|
FuncDef *pFunc, *pNext;
|
|
|
|
for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){
|
2002-02-24 02:45:45 +03:00
|
|
|
pNext = pFunc->pNext;
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(pFunc);
|
2002-02-24 02:45:45 +03:00
|
|
|
}
|
|
|
|
}
|
2004-06-10 06:16:01 +04:00
|
|
|
|
2004-06-12 13:25:12 +04:00
|
|
|
for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){
|
2004-06-10 06:16:01 +04:00
|
|
|
CollSeq *pColl = (CollSeq *)sqliteHashData(i);
|
2007-05-07 13:32:45 +04:00
|
|
|
/* Invoke any destructors registered for collation sequence user data. */
|
|
|
|
for(j=0; j<3; j++){
|
|
|
|
if( pColl[j].xDel ){
|
|
|
|
pColl[j].xDel(pColl[j].pUser);
|
|
|
|
}
|
|
|
|
}
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(pColl);
|
2004-06-10 06:16:01 +04:00
|
|
|
}
|
2004-06-12 13:25:12 +04:00
|
|
|
sqlite3HashClear(&db->aCollSeq);
|
2006-06-12 03:41:55 +04:00
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
2006-06-15 08:28:13 +04:00
|
|
|
for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){
|
|
|
|
Module *pMod = (Module *)sqliteHashData(i);
|
2007-06-22 19:21:15 +04:00
|
|
|
if( pMod->xDestroy ){
|
|
|
|
pMod->xDestroy(pMod->pAux);
|
|
|
|
}
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(pMod);
|
2006-06-15 08:28:13 +04:00
|
|
|
}
|
2006-06-12 03:41:55 +04:00
|
|
|
sqlite3HashClear(&db->aModule);
|
|
|
|
#endif
|
2004-06-10 06:16:01 +04:00
|
|
|
|
2004-05-08 12:23:19 +04:00
|
|
|
sqlite3HashClear(&db->aFunc);
|
2004-05-20 15:00:52 +04:00
|
|
|
sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */
|
2004-06-18 08:24:54 +04:00
|
|
|
if( db->pErr ){
|
|
|
|
sqlite3ValueFree(db->pErr);
|
|
|
|
}
|
2006-06-08 19:48:00 +04:00
|
|
|
sqlite3CloseExtensions(db);
|
2004-06-19 07:33:57 +04:00
|
|
|
|
|
|
|
db->magic = SQLITE_MAGIC_ERROR;
|
2006-01-10 10:14:23 +03:00
|
|
|
|
|
|
|
/* The temp-database schema is allocated differently from the other schema
|
|
|
|
** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
|
|
|
|
** So it needs to be freed here. Todo: Why not roll the temp schema into
|
|
|
|
** the same sqliteMalloc() as the one that allocates the database
|
|
|
|
** structure?
|
|
|
|
*/
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(db->aDb[1].pSchema);
|
2007-08-21 19:13:19 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2008-01-23 06:03:05 +03:00
|
|
|
db->magic = SQLITE_MAGIC_CLOSED;
|
2007-08-21 19:13:19 +04:00
|
|
|
sqlite3_mutex_free(db->mutex);
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(db);
|
2004-06-19 07:33:57 +04:00
|
|
|
return SQLITE_OK;
|
2000-05-29 18:26:00 +04:00
|
|
|
}
|
|
|
|
|
2003-03-19 06:14:00 +03:00
|
|
|
/*
|
|
|
|
** Rollback all database files.
|
|
|
|
*/
|
2004-09-06 21:24:11 +04:00
|
|
|
void sqlite3RollbackAll(sqlite3 *db){
|
2003-03-19 06:14:00 +03:00
|
|
|
int i;
|
2005-12-16 18:24:28 +03:00
|
|
|
int inTrans = 0;
|
2007-08-21 20:15:55 +04:00
|
|
|
assert( sqlite3_mutex_held(db->mutex) );
|
2008-05-13 17:27:33 +04:00
|
|
|
sqlite3FaultBeginBenign(SQLITE_FAULTINJECTOR_MALLOC);
|
2003-03-19 06:14:00 +03:00
|
|
|
for(i=0; i<db->nDb; i++){
|
|
|
|
if( db->aDb[i].pBt ){
|
2005-12-16 18:24:28 +03:00
|
|
|
if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){
|
|
|
|
inTrans = 1;
|
|
|
|
}
|
2004-05-08 12:23:19 +04:00
|
|
|
sqlite3BtreeRollback(db->aDb[i].pBt);
|
2003-03-19 06:14:00 +03:00
|
|
|
db->aDb[i].inTrans = 0;
|
|
|
|
}
|
|
|
|
}
|
2006-06-22 13:53:48 +04:00
|
|
|
sqlite3VtabRollback(db);
|
2008-05-13 17:27:33 +04:00
|
|
|
sqlite3FaultEndBenign(SQLITE_FAULTINJECTOR_MALLOC);
|
2007-10-03 12:46:44 +04:00
|
|
|
|
2005-12-16 09:54:01 +03:00
|
|
|
if( db->flags&SQLITE_InternChanges ){
|
2007-08-13 19:28:33 +04:00
|
|
|
sqlite3ExpirePreparedStatements(db);
|
2005-12-16 09:54:01 +03:00
|
|
|
sqlite3ResetInternalSchema(db, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* If one has been configured, invoke the rollback-hook callback */
|
2005-12-16 18:24:28 +03:00
|
|
|
if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){
|
2005-12-16 09:54:01 +03:00
|
|
|
db->xRollbackCallback(db->pRollbackArg);
|
|
|
|
}
|
2003-03-19 06:14:00 +03:00
|
|
|
}
|
|
|
|
|
2002-05-10 09:44:55 +04:00
|
|
|
/*
|
2002-05-10 17:14:07 +04:00
|
|
|
** Return a static string that describes the kind of error specified in the
|
|
|
|
** argument.
|
2002-05-10 09:44:55 +04:00
|
|
|
*/
|
2004-06-01 03:56:42 +04:00
|
|
|
const char *sqlite3ErrStr(int rc){
|
2002-05-10 17:14:07 +04:00
|
|
|
const char *z;
|
2006-09-15 11:28:50 +04:00
|
|
|
switch( rc & 0xff ){
|
2004-09-30 17:43:13 +04:00
|
|
|
case SQLITE_ROW:
|
|
|
|
case SQLITE_DONE:
|
2002-05-10 17:14:07 +04:00
|
|
|
case SQLITE_OK: z = "not an error"; break;
|
|
|
|
case SQLITE_ERROR: z = "SQL logic error or missing database"; break;
|
|
|
|
case SQLITE_PERM: z = "access permission denied"; break;
|
|
|
|
case SQLITE_ABORT: z = "callback requested query abort"; break;
|
|
|
|
case SQLITE_BUSY: z = "database is locked"; break;
|
|
|
|
case SQLITE_LOCKED: z = "database table is locked"; break;
|
|
|
|
case SQLITE_NOMEM: z = "out of memory"; break;
|
|
|
|
case SQLITE_READONLY: z = "attempt to write a readonly database"; break;
|
|
|
|
case SQLITE_INTERRUPT: z = "interrupted"; break;
|
|
|
|
case SQLITE_IOERR: z = "disk I/O error"; break;
|
|
|
|
case SQLITE_CORRUPT: z = "database disk image is malformed"; break;
|
2005-08-11 06:10:18 +04:00
|
|
|
case SQLITE_FULL: z = "database or disk is full"; break;
|
2002-05-10 17:14:07 +04:00
|
|
|
case SQLITE_CANTOPEN: z = "unable to open database file"; break;
|
|
|
|
case SQLITE_EMPTY: z = "table contains no data"; break;
|
|
|
|
case SQLITE_SCHEMA: z = "database schema has changed"; break;
|
2007-05-08 16:12:16 +04:00
|
|
|
case SQLITE_TOOBIG: z = "String or BLOB exceeded size limit"; break;
|
2002-05-10 17:14:07 +04:00
|
|
|
case SQLITE_CONSTRAINT: z = "constraint failed"; break;
|
|
|
|
case SQLITE_MISMATCH: z = "datatype mismatch"; break;
|
|
|
|
case SQLITE_MISUSE: z = "library routine called out of sequence";break;
|
2008-05-05 20:56:34 +04:00
|
|
|
case SQLITE_NOLFS: z = "large file support is disabled"; break;
|
2003-01-12 21:02:16 +03:00
|
|
|
case SQLITE_AUTH: z = "authorization denied"; break;
|
2003-06-12 12:59:00 +04:00
|
|
|
case SQLITE_FORMAT: z = "auxiliary database format error"; break;
|
2004-11-20 23:18:55 +03:00
|
|
|
case SQLITE_RANGE: z = "bind or column index out of range"; break;
|
2004-02-12 22:01:04 +03:00
|
|
|
case SQLITE_NOTADB: z = "file is encrypted or is not a database";break;
|
2002-05-10 17:14:07 +04:00
|
|
|
default: z = "unknown error"; break;
|
2002-05-10 09:44:55 +04:00
|
|
|
}
|
2002-05-10 17:14:07 +04:00
|
|
|
return z;
|
2002-05-10 09:44:55 +04:00
|
|
|
}
|
|
|
|
|
2000-07-28 18:32:48 +04:00
|
|
|
/*
|
|
|
|
** This routine implements a busy callback that sleeps and tries
|
|
|
|
** again until a timeout value is reached. The timeout value is
|
|
|
|
** an integer number of milliseconds passed in as the first
|
|
|
|
** argument.
|
|
|
|
*/
|
2001-04-11 18:28:42 +04:00
|
|
|
static int sqliteDefaultBusyCallback(
|
2005-05-25 00:19:57 +04:00
|
|
|
void *ptr, /* Database connection */
|
2000-07-28 18:32:48 +04:00
|
|
|
int count /* Number of times table has been busy */
|
|
|
|
){
|
2006-03-03 23:54:41 +03:00
|
|
|
#if OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)
|
2005-04-28 16:06:05 +04:00
|
|
|
static const u8 delays[] =
|
|
|
|
{ 1, 2, 5, 10, 15, 20, 25, 25, 25, 50, 50, 100 };
|
|
|
|
static const u8 totals[] =
|
|
|
|
{ 0, 1, 3, 8, 18, 33, 53, 78, 103, 128, 178, 228 };
|
2004-01-15 16:29:31 +03:00
|
|
|
# define NDELAY (sizeof(delays)/sizeof(delays[0]))
|
2007-08-17 19:53:36 +04:00
|
|
|
sqlite3 *db = (sqlite3 *)ptr;
|
|
|
|
int timeout = db->busyTimeout;
|
2005-05-25 00:19:57 +04:00
|
|
|
int delay, prior;
|
2000-07-28 18:32:48 +04:00
|
|
|
|
2005-04-28 16:06:05 +04:00
|
|
|
assert( count>=0 );
|
|
|
|
if( count < NDELAY ){
|
|
|
|
delay = delays[count];
|
|
|
|
prior = totals[count];
|
2004-01-15 16:29:31 +03:00
|
|
|
}else{
|
|
|
|
delay = delays[NDELAY-1];
|
2005-05-07 02:05:56 +04:00
|
|
|
prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));
|
2000-07-28 18:32:48 +04:00
|
|
|
}
|
2004-01-15 16:29:31 +03:00
|
|
|
if( prior + delay > timeout ){
|
|
|
|
delay = timeout - prior;
|
2000-07-28 18:32:48 +04:00
|
|
|
if( delay<=0 ) return 0;
|
|
|
|
}
|
2007-08-20 20:07:00 +04:00
|
|
|
sqlite3OsSleep(db->pVfs, delay*1000);
|
2000-07-28 18:32:48 +04:00
|
|
|
return 1;
|
|
|
|
#else
|
2007-08-20 15:12:40 +04:00
|
|
|
sqlite3 *db = (sqlite3 *)ptr;
|
2005-06-14 06:24:31 +04:00
|
|
|
int timeout = ((sqlite3 *)ptr)->busyTimeout;
|
2000-07-28 18:32:48 +04:00
|
|
|
if( (count+1)*1000 > timeout ){
|
|
|
|
return 0;
|
|
|
|
}
|
2007-08-20 15:12:40 +04:00
|
|
|
sqlite3OsSleep(db->pVfs, 1000000);
|
2000-07-28 18:32:48 +04:00
|
|
|
return 1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2005-07-09 06:16:02 +04:00
|
|
|
/*
|
|
|
|
** Invoke the given busy handler.
|
|
|
|
**
|
|
|
|
** This routine is called when an operation failed with a lock.
|
|
|
|
** If this routine returns non-zero, the lock is retried. If it
|
|
|
|
** returns 0, the operation aborts with an SQLITE_BUSY error.
|
|
|
|
*/
|
|
|
|
int sqlite3InvokeBusyHandler(BusyHandler *p){
|
|
|
|
int rc;
|
|
|
|
if( p==0 || p->xFunc==0 || p->nBusy<0 ) return 0;
|
|
|
|
rc = p->xFunc(p->pArg, p->nBusy);
|
|
|
|
if( rc==0 ){
|
|
|
|
p->nBusy = -1;
|
|
|
|
}else{
|
|
|
|
p->nBusy++;
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2000-07-28 18:32:48 +04:00
|
|
|
/*
|
|
|
|
** This routine sets the busy callback for an Sqlite database to the
|
|
|
|
** given callback function with the given argument.
|
|
|
|
*/
|
2004-06-19 12:18:07 +04:00
|
|
|
int sqlite3_busy_handler(
|
|
|
|
sqlite3 *db,
|
2004-06-12 05:43:26 +04:00
|
|
|
int (*xBusy)(void*,int),
|
2000-07-28 18:32:48 +04:00
|
|
|
void *pArg
|
|
|
|
){
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2004-06-04 10:22:00 +04:00
|
|
|
db->busyHandler.xFunc = xBusy;
|
|
|
|
db->busyHandler.pArg = pArg;
|
2005-07-09 06:16:02 +04:00
|
|
|
db->busyHandler.nBusy = 0;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2004-06-19 12:18:07 +04:00
|
|
|
return SQLITE_OK;
|
2000-07-28 18:32:48 +04:00
|
|
|
}
|
|
|
|
|
2003-10-18 13:37:26 +04:00
|
|
|
#ifndef SQLITE_OMIT_PROGRESS_CALLBACK
|
|
|
|
/*
|
|
|
|
** This routine sets the progress callback for an Sqlite database to the
|
|
|
|
** given callback function with the given argument. The progress callback will
|
|
|
|
** be invoked every nOps opcodes.
|
|
|
|
*/
|
2004-05-10 14:34:34 +04:00
|
|
|
void sqlite3_progress_handler(
|
2004-09-06 21:24:11 +04:00
|
|
|
sqlite3 *db,
|
2003-10-18 13:37:26 +04:00
|
|
|
int nOps,
|
|
|
|
int (*xProgress)(void*),
|
|
|
|
void *pArg
|
|
|
|
){
|
2008-01-23 06:03:05 +03:00
|
|
|
if( sqlite3SafetyCheckOk(db) ){
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2004-09-30 17:43:13 +04:00
|
|
|
if( nOps>0 ){
|
|
|
|
db->xProgress = xProgress;
|
|
|
|
db->nProgressOps = nOps;
|
|
|
|
db->pProgressArg = pArg;
|
|
|
|
}else{
|
|
|
|
db->xProgress = 0;
|
|
|
|
db->nProgressOps = 0;
|
|
|
|
db->pProgressArg = 0;
|
|
|
|
}
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2003-10-18 13:37:26 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2000-07-28 18:32:48 +04:00
|
|
|
/*
|
|
|
|
** This routine installs a default busy handler that waits for the
|
|
|
|
** specified number of milliseconds before returning 0.
|
|
|
|
*/
|
2004-06-19 12:18:07 +04:00
|
|
|
int sqlite3_busy_timeout(sqlite3 *db, int ms){
|
2000-07-28 18:32:48 +04:00
|
|
|
if( ms>0 ){
|
2005-05-25 00:19:57 +04:00
|
|
|
db->busyTimeout = ms;
|
|
|
|
sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);
|
2000-07-28 18:32:48 +04:00
|
|
|
}else{
|
2004-05-10 14:34:34 +04:00
|
|
|
sqlite3_busy_handler(db, 0, 0);
|
2000-07-28 18:32:48 +04:00
|
|
|
}
|
2004-06-19 12:18:07 +04:00
|
|
|
return SQLITE_OK;
|
2000-07-28 18:32:48 +04:00
|
|
|
}
|
2000-10-17 02:06:40 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Cause any pending operation to stop at its earliest opportunity.
|
|
|
|
*/
|
2004-09-06 21:24:11 +04:00
|
|
|
void sqlite3_interrupt(sqlite3 *db){
|
2008-01-23 06:03:05 +03:00
|
|
|
if( sqlite3SafetyCheckOk(db) ){
|
2006-07-26 05:39:30 +04:00
|
|
|
db->u1.isInterrupted = 1;
|
2004-09-30 17:43:13 +04:00
|
|
|
}
|
2000-10-17 02:06:40 +04:00
|
|
|
}
|
2002-02-02 18:01:15 +03:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
2006-01-17 16:21:40 +03:00
|
|
|
** This function is exactly the same as sqlite3_create_function(), except
|
|
|
|
** that it is designed to be called by internal code. The difference is
|
|
|
|
** that if a malloc() fails in sqlite3_create_function(), an error code
|
|
|
|
** is returned and the mallocFailed flag cleared.
|
2002-02-02 18:01:15 +03:00
|
|
|
*/
|
2006-01-17 16:21:40 +03:00
|
|
|
int sqlite3CreateFunc(
|
2004-05-26 10:18:37 +04:00
|
|
|
sqlite3 *db,
|
|
|
|
const char *zFunctionName,
|
|
|
|
int nArg,
|
2004-06-12 13:25:12 +04:00
|
|
|
int enc,
|
2004-05-26 10:18:37 +04:00
|
|
|
void *pUserData,
|
|
|
|
void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
|
|
|
|
void (*xStep)(sqlite3_context*,int,sqlite3_value **),
|
|
|
|
void (*xFinal)(sqlite3_context*)
|
2002-02-24 02:45:45 +03:00
|
|
|
){
|
2002-02-28 03:41:10 +03:00
|
|
|
FuncDef *p;
|
2002-08-24 22:24:51 +04:00
|
|
|
int nName;
|
2004-05-26 10:18:37 +04:00
|
|
|
|
2007-08-21 20:15:55 +04:00
|
|
|
assert( sqlite3_mutex_held(db->mutex) );
|
2004-09-30 17:43:13 +04:00
|
|
|
if( zFunctionName==0 ||
|
2004-05-26 10:58:43 +04:00
|
|
|
(xFunc && (xFinal || xStep)) ||
|
|
|
|
(!xFunc && (xFinal && !xStep)) ||
|
|
|
|
(!xFunc && (!xFinal && xStep)) ||
|
|
|
|
(nArg<-1 || nArg>127) ||
|
|
|
|
(255<(nName = strlen(zFunctionName))) ){
|
2006-06-14 19:35:36 +04:00
|
|
|
sqlite3Error(db, SQLITE_ERROR, "bad parameters");
|
2004-05-26 10:18:37 +04:00
|
|
|
return SQLITE_ERROR;
|
|
|
|
}
|
2004-06-12 13:25:12 +04:00
|
|
|
|
2005-01-21 11:13:14 +03:00
|
|
|
#ifndef SQLITE_OMIT_UTF16
|
2004-06-12 13:25:12 +04:00
|
|
|
/* If SQLITE_UTF16 is specified as the encoding type, transform this
|
|
|
|
** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
|
|
|
|
** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
|
|
|
|
**
|
|
|
|
** If SQLITE_ANY is specified, add three versions of the function
|
|
|
|
** to the hash table.
|
|
|
|
*/
|
|
|
|
if( enc==SQLITE_UTF16 ){
|
|
|
|
enc = SQLITE_UTF16NATIVE;
|
|
|
|
}else if( enc==SQLITE_ANY ){
|
|
|
|
int rc;
|
2006-01-17 16:21:40 +03:00
|
|
|
rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,
|
2004-06-19 12:18:07 +04:00
|
|
|
pUserData, xFunc, xStep, xFinal);
|
2007-08-21 20:15:55 +04:00
|
|
|
if( rc==SQLITE_OK ){
|
|
|
|
rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
|
|
|
|
pUserData, xFunc, xStep, xFinal);
|
|
|
|
}
|
|
|
|
if( rc!=SQLITE_OK ){
|
|
|
|
return rc;
|
|
|
|
}
|
2004-06-12 13:25:12 +04:00
|
|
|
enc = SQLITE_UTF16BE;
|
|
|
|
}
|
2005-01-21 11:13:14 +03:00
|
|
|
#else
|
|
|
|
enc = SQLITE_UTF8;
|
|
|
|
#endif
|
2005-01-25 07:27:54 +03:00
|
|
|
|
|
|
|
/* Check if an existing function is being overridden or deleted. If so,
|
|
|
|
** and there are active VMs, then return SQLITE_BUSY. If a function
|
|
|
|
** is being overridden/deleted but there are no active VMs, allow the
|
|
|
|
** operation to continue but invalidate all precompiled statements.
|
|
|
|
*/
|
|
|
|
p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 0);
|
|
|
|
if( p && p->iPrefEnc==enc && p->nArg==nArg ){
|
|
|
|
if( db->activeVdbeCnt ){
|
|
|
|
sqlite3Error(db, SQLITE_BUSY,
|
|
|
|
"Unable to delete/modify user-function due to active statements");
|
2007-08-16 08:30:38 +04:00
|
|
|
assert( !db->mallocFailed );
|
2005-01-25 07:27:54 +03:00
|
|
|
return SQLITE_BUSY;
|
|
|
|
}else{
|
|
|
|
sqlite3ExpirePreparedStatements(db);
|
|
|
|
}
|
|
|
|
}
|
2004-05-26 10:18:37 +04:00
|
|
|
|
2004-06-12 13:25:12 +04:00
|
|
|
p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);
|
2007-09-03 15:04:22 +04:00
|
|
|
assert(p || db->mallocFailed);
|
|
|
|
if( !p ){
|
|
|
|
return SQLITE_NOMEM;
|
2006-01-17 16:21:40 +03:00
|
|
|
}
|
2007-09-03 15:04:22 +04:00
|
|
|
p->flags = 0;
|
|
|
|
p->xFunc = xFunc;
|
|
|
|
p->xStep = xStep;
|
|
|
|
p->xFinalize = xFinal;
|
|
|
|
p->pUserData = pUserData;
|
|
|
|
p->nArg = nArg;
|
2004-05-26 10:18:37 +04:00
|
|
|
return SQLITE_OK;
|
2002-02-24 02:45:45 +03:00
|
|
|
}
|
2006-01-17 16:21:40 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Create new user functions.
|
|
|
|
*/
|
|
|
|
int sqlite3_create_function(
|
|
|
|
sqlite3 *db,
|
|
|
|
const char *zFunctionName,
|
|
|
|
int nArg,
|
|
|
|
int enc,
|
|
|
|
void *p,
|
|
|
|
void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
|
|
|
|
void (*xStep)(sqlite3_context*,int,sqlite3_value **),
|
|
|
|
void (*xFinal)(sqlite3_context*)
|
|
|
|
){
|
|
|
|
int rc;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2006-01-17 16:21:40 +03:00
|
|
|
rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = sqlite3ApiExit(db, rc);
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
return rc;
|
2006-01-17 16:21:40 +03:00
|
|
|
}
|
|
|
|
|
2005-01-21 11:13:14 +03:00
|
|
|
#ifndef SQLITE_OMIT_UTF16
|
2004-05-26 10:18:37 +04:00
|
|
|
int sqlite3_create_function16(
|
|
|
|
sqlite3 *db,
|
|
|
|
const void *zFunctionName,
|
|
|
|
int nArg,
|
|
|
|
int eTextRep,
|
2006-01-17 16:21:40 +03:00
|
|
|
void *p,
|
2004-05-26 10:18:37 +04:00
|
|
|
void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
|
|
|
|
void (*xStep)(sqlite3_context*,int,sqlite3_value**),
|
|
|
|
void (*xFinal)(sqlite3_context*)
|
2002-02-24 02:45:45 +03:00
|
|
|
){
|
2004-05-26 10:18:37 +04:00
|
|
|
int rc;
|
2005-12-15 06:04:10 +03:00
|
|
|
char *zFunc8;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2007-08-16 08:30:38 +04:00
|
|
|
assert( !db->mallocFailed );
|
2007-08-16 14:09:01 +04:00
|
|
|
zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);
|
2006-01-17 16:21:40 +03:00
|
|
|
rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(zFunc8);
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = sqlite3ApiExit(db, rc);
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
return rc;
|
2002-02-24 02:45:45 +03:00
|
|
|
}
|
2005-01-21 11:13:14 +03:00
|
|
|
#endif
|
2002-06-20 15:36:48 +04:00
|
|
|
|
2006-09-17 01:45:14 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Declare that a function has been overloaded by a virtual table.
|
|
|
|
**
|
|
|
|
** If the function already exists as a regular global function, then
|
|
|
|
** this routine is a no-op. If the function does not exist, then create
|
|
|
|
** a new one that always throws a run-time error.
|
|
|
|
**
|
|
|
|
** When virtual tables intend to provide an overloaded function, they
|
|
|
|
** should call this routine to make sure the global function exists.
|
|
|
|
** A global function must exist in order for name resolution to work
|
|
|
|
** properly.
|
|
|
|
*/
|
|
|
|
int sqlite3_overload_function(
|
|
|
|
sqlite3 *db,
|
|
|
|
const char *zName,
|
|
|
|
int nArg
|
|
|
|
){
|
|
|
|
int nName = strlen(zName);
|
2007-08-21 20:15:55 +04:00
|
|
|
int rc;
|
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2006-09-17 01:45:14 +04:00
|
|
|
if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
|
|
|
|
sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
|
|
|
|
0, sqlite3InvalidFunction, 0, 0);
|
|
|
|
}
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = sqlite3ApiExit(db, SQLITE_OK);
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
return rc;
|
2006-09-17 01:45:14 +04:00
|
|
|
}
|
|
|
|
|
2005-08-30 03:00:03 +04:00
|
|
|
#ifndef SQLITE_OMIT_TRACE
|
2003-01-16 19:28:53 +03:00
|
|
|
/*
|
|
|
|
** Register a trace function. The pArg from the previously registered trace
|
|
|
|
** is returned.
|
|
|
|
**
|
|
|
|
** A NULL trace function means that no tracing is executes. A non-NULL
|
|
|
|
** trace is a pointer to a function that is invoked at the start of each
|
2005-08-30 03:00:03 +04:00
|
|
|
** SQL statement.
|
2003-01-16 19:28:53 +03:00
|
|
|
*/
|
2004-09-06 21:24:11 +04:00
|
|
|
void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){
|
2007-08-21 20:15:55 +04:00
|
|
|
void *pOld;
|
|
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
pOld = db->pTraceArg;
|
2003-01-16 19:28:53 +03:00
|
|
|
db->xTrace = xTrace;
|
|
|
|
db->pTraceArg = pArg;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2003-01-16 19:28:53 +03:00
|
|
|
return pOld;
|
2003-04-03 19:46:04 +04:00
|
|
|
}
|
2005-08-30 03:00:03 +04:00
|
|
|
/*
|
|
|
|
** Register a profile function. The pArg from the previously registered
|
|
|
|
** profile function is returned.
|
|
|
|
**
|
|
|
|
** A NULL profile function means that no profiling is executes. A non-NULL
|
|
|
|
** profile is a pointer to a function that is invoked at the conclusion of
|
|
|
|
** each SQL statement that is run.
|
|
|
|
*/
|
|
|
|
void *sqlite3_profile(
|
|
|
|
sqlite3 *db,
|
|
|
|
void (*xProfile)(void*,const char*,sqlite_uint64),
|
|
|
|
void *pArg
|
|
|
|
){
|
2007-08-21 20:15:55 +04:00
|
|
|
void *pOld;
|
|
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
pOld = db->pProfileArg;
|
2005-08-30 03:00:03 +04:00
|
|
|
db->xProfile = xProfile;
|
|
|
|
db->pProfileArg = pArg;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2005-08-30 03:00:03 +04:00
|
|
|
return pOld;
|
|
|
|
}
|
|
|
|
#endif /* SQLITE_OMIT_TRACE */
|
2003-04-13 22:26:49 +04:00
|
|
|
|
2004-01-15 05:44:03 +03:00
|
|
|
/*** EXPERIMENTAL ***
|
|
|
|
**
|
|
|
|
** Register a function to be invoked when a transaction comments.
|
2005-12-16 09:54:01 +03:00
|
|
|
** If the invoked function returns non-zero, then the commit becomes a
|
2004-01-15 05:44:03 +03:00
|
|
|
** rollback.
|
|
|
|
*/
|
2004-05-10 14:34:34 +04:00
|
|
|
void *sqlite3_commit_hook(
|
2004-09-06 21:24:11 +04:00
|
|
|
sqlite3 *db, /* Attach the hook to this database */
|
2004-01-15 05:44:03 +03:00
|
|
|
int (*xCallback)(void*), /* Function to invoke on each commit */
|
|
|
|
void *pArg /* Argument to the function */
|
|
|
|
){
|
2007-08-21 20:15:55 +04:00
|
|
|
void *pOld;
|
|
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
pOld = db->pCommitArg;
|
2004-01-15 05:44:03 +03:00
|
|
|
db->xCommitCallback = xCallback;
|
|
|
|
db->pCommitArg = pArg;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2004-01-15 05:44:03 +03:00
|
|
|
return pOld;
|
|
|
|
}
|
|
|
|
|
2005-12-15 18:22:08 +03:00
|
|
|
/*
|
|
|
|
** Register a callback to be invoked each time a row is updated,
|
|
|
|
** inserted or deleted using this database connection.
|
|
|
|
*/
|
2005-12-16 09:54:01 +03:00
|
|
|
void *sqlite3_update_hook(
|
2005-12-15 18:22:08 +03:00
|
|
|
sqlite3 *db, /* Attach the hook to this database */
|
|
|
|
void (*xCallback)(void*,int,char const *,char const *,sqlite_int64),
|
|
|
|
void *pArg /* Argument to the function */
|
|
|
|
){
|
2007-08-21 20:15:55 +04:00
|
|
|
void *pRet;
|
|
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
pRet = db->pUpdateArg;
|
2005-12-15 18:22:08 +03:00
|
|
|
db->xUpdateCallback = xCallback;
|
|
|
|
db->pUpdateArg = pArg;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2005-12-16 09:54:01 +03:00
|
|
|
return pRet;
|
2005-12-15 18:22:08 +03:00
|
|
|
}
|
|
|
|
|
2005-12-16 09:54:01 +03:00
|
|
|
/*
|
|
|
|
** Register a callback to be invoked each time a transaction is rolled
|
|
|
|
** back by this database connection.
|
|
|
|
*/
|
|
|
|
void *sqlite3_rollback_hook(
|
|
|
|
sqlite3 *db, /* Attach the hook to this database */
|
|
|
|
void (*xCallback)(void*), /* Callback function */
|
|
|
|
void *pArg /* Argument to the function */
|
|
|
|
){
|
2007-08-21 20:15:55 +04:00
|
|
|
void *pRet;
|
|
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
pRet = db->pRollbackArg;
|
2005-12-16 09:54:01 +03:00
|
|
|
db->xRollbackCallback = xCallback;
|
|
|
|
db->pRollbackArg = pArg;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2005-12-16 09:54:01 +03:00
|
|
|
return pRet;
|
|
|
|
}
|
2004-01-15 05:44:03 +03:00
|
|
|
|
2003-04-13 22:26:49 +04:00
|
|
|
/*
|
2003-04-15 05:19:47 +04:00
|
|
|
** This routine is called to create a connection to a database BTree
|
|
|
|
** driver. If zFilename is the name of a file, then that file is
|
|
|
|
** opened and used. If zFilename is the magic name ":memory:" then
|
|
|
|
** the database is stored in memory (and is thus forgotten as soon as
|
|
|
|
** the connection is closed.) If zFilename is NULL then the database
|
2005-07-15 17:05:21 +04:00
|
|
|
** is a "virtual" database for transient use only and is deleted as
|
|
|
|
** soon as the connection is closed.
|
2004-07-22 05:19:35 +04:00
|
|
|
**
|
2005-07-15 17:05:21 +04:00
|
|
|
** A virtual database can be either a disk file (that is automatically
|
|
|
|
** deleted when the file is closed) or it an be held entirely in memory,
|
2004-07-22 05:19:35 +04:00
|
|
|
** depending on the values of the TEMP_STORE compile-time macro and the
|
|
|
|
** db->temp_store variable, according to the following chart:
|
|
|
|
**
|
|
|
|
** TEMP_STORE db->temp_store Location of temporary database
|
|
|
|
** ---------- -------------- ------------------------------
|
|
|
|
** 0 any file
|
|
|
|
** 1 1 file
|
|
|
|
** 1 2 memory
|
|
|
|
** 1 0 file
|
|
|
|
** 2 1 file
|
|
|
|
** 2 2 memory
|
|
|
|
** 2 0 memory
|
|
|
|
** 3 any memory
|
2003-04-13 22:26:49 +04:00
|
|
|
*/
|
2004-05-08 12:23:19 +04:00
|
|
|
int sqlite3BtreeFactory(
|
2004-09-06 21:24:11 +04:00
|
|
|
const sqlite3 *db, /* Main database when opening aux otherwise 0 */
|
2003-04-13 22:26:49 +04:00
|
|
|
const char *zFilename, /* Name of the file containing the BTree database */
|
|
|
|
int omitJournal, /* if TRUE then do not journal this file */
|
|
|
|
int nCache, /* How many pages in the page cache */
|
2007-09-03 19:19:34 +04:00
|
|
|
int vfsFlags, /* Flags passed through to vfsOpen */
|
2004-05-08 12:23:19 +04:00
|
|
|
Btree **ppBtree /* Pointer to new Btree object written here */
|
|
|
|
){
|
2007-09-03 19:19:34 +04:00
|
|
|
int btFlags = 0;
|
2004-07-22 05:19:35 +04:00
|
|
|
int rc;
|
2004-05-08 12:23:19 +04:00
|
|
|
|
2007-08-21 20:15:55 +04:00
|
|
|
assert( sqlite3_mutex_held(db->mutex) );
|
2004-05-08 14:11:36 +04:00
|
|
|
assert( ppBtree != 0);
|
2004-05-08 12:23:19 +04:00
|
|
|
if( omitJournal ){
|
2007-09-03 19:19:34 +04:00
|
|
|
btFlags |= BTREE_OMIT_JOURNAL;
|
2004-05-08 12:23:19 +04:00
|
|
|
}
|
2005-02-06 05:45:41 +03:00
|
|
|
if( db->flags & SQLITE_NoReadlock ){
|
2007-09-03 19:19:34 +04:00
|
|
|
btFlags |= BTREE_NO_READLOCK;
|
2005-02-06 05:45:41 +03:00
|
|
|
}
|
2004-07-22 05:19:35 +04:00
|
|
|
if( zFilename==0 ){
|
|
|
|
#if TEMP_STORE==0
|
2004-08-14 22:34:54 +04:00
|
|
|
/* Do nothing */
|
2004-07-22 05:19:35 +04:00
|
|
|
#endif
|
2004-11-22 08:26:27 +03:00
|
|
|
#ifndef SQLITE_OMIT_MEMORYDB
|
2004-07-22 05:19:35 +04:00
|
|
|
#if TEMP_STORE==1
|
2004-08-14 22:34:54 +04:00
|
|
|
if( db->temp_store==2 ) zFilename = ":memory:";
|
2004-07-22 05:19:35 +04:00
|
|
|
#endif
|
|
|
|
#if TEMP_STORE==2
|
2004-08-14 22:34:54 +04:00
|
|
|
if( db->temp_store!=1 ) zFilename = ":memory:";
|
2004-07-22 05:19:35 +04:00
|
|
|
#endif
|
|
|
|
#if TEMP_STORE==3
|
2004-08-14 22:34:54 +04:00
|
|
|
zFilename = ":memory:";
|
2004-07-22 05:19:35 +04:00
|
|
|
#endif
|
2004-11-22 08:26:27 +03:00
|
|
|
#endif /* SQLITE_OMIT_MEMORYDB */
|
2004-07-22 05:19:35 +04:00
|
|
|
}
|
2003-04-13 22:26:49 +04:00
|
|
|
|
2007-09-03 19:19:34 +04:00
|
|
|
if( (vfsFlags & SQLITE_OPEN_MAIN_DB)!=0 && (zFilename==0 || *zFilename==0) ){
|
|
|
|
vfsFlags = (vfsFlags & ~SQLITE_OPEN_MAIN_DB) | SQLITE_OPEN_TEMP_DB;
|
|
|
|
}
|
|
|
|
rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btFlags, vfsFlags);
|
2004-07-22 05:19:35 +04:00
|
|
|
if( rc==SQLITE_OK ){
|
|
|
|
sqlite3BtreeSetCacheSize(*ppBtree, nCache);
|
|
|
|
}
|
|
|
|
return rc;
|
2004-05-08 12:23:19 +04:00
|
|
|
}
|
|
|
|
|
2004-05-21 05:47:26 +04:00
|
|
|
/*
|
|
|
|
** Return UTF-8 encoded English language explanation of the most recent
|
|
|
|
** error.
|
|
|
|
*/
|
2004-05-20 15:00:52 +04:00
|
|
|
const char *sqlite3_errmsg(sqlite3 *db){
|
2004-09-30 17:43:13 +04:00
|
|
|
const char *z;
|
2007-03-29 19:00:52 +04:00
|
|
|
if( !db ){
|
2004-06-01 03:56:42 +04:00
|
|
|
return sqlite3ErrStr(SQLITE_NOMEM);
|
2004-05-21 05:47:26 +04:00
|
|
|
}
|
2008-01-23 06:03:05 +03:00
|
|
|
if( !sqlite3SafetyCheckSickOrOk(db) || db->errCode==SQLITE_MISUSE ){
|
2004-06-26 13:50:11 +04:00
|
|
|
return sqlite3ErrStr(SQLITE_MISUSE);
|
|
|
|
}
|
2007-08-22 06:56:42 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2007-08-22 04:39:19 +04:00
|
|
|
assert( !db->mallocFailed );
|
2005-12-09 23:02:05 +03:00
|
|
|
z = (char*)sqlite3_value_text(db->pErr);
|
2008-05-22 17:56:17 +04:00
|
|
|
assert( !db->mallocFailed );
|
2004-09-30 17:43:13 +04:00
|
|
|
if( z==0 ){
|
|
|
|
z = sqlite3ErrStr(db->errCode);
|
2004-05-20 15:00:52 +04:00
|
|
|
}
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2004-09-30 17:43:13 +04:00
|
|
|
return z;
|
2004-05-20 15:00:52 +04:00
|
|
|
}
|
|
|
|
|
2004-11-15 00:56:29 +03:00
|
|
|
#ifndef SQLITE_OMIT_UTF16
|
2004-05-21 05:47:26 +04:00
|
|
|
/*
|
|
|
|
** Return UTF-16 encoded English language explanation of the most recent
|
|
|
|
** error.
|
|
|
|
*/
|
2004-05-20 15:00:52 +04:00
|
|
|
const void *sqlite3_errmsg16(sqlite3 *db){
|
2004-06-18 08:24:54 +04:00
|
|
|
/* Because all the characters in the string are in the unicode
|
|
|
|
** range 0x00-0xFF, if we pad the big-endian string with a
|
|
|
|
** zero byte, we can obtain the little-endian string with
|
|
|
|
** &big_endian[1].
|
|
|
|
*/
|
2004-10-06 19:41:16 +04:00
|
|
|
static const char outOfMemBe[] = {
|
2004-06-18 08:24:54 +04:00
|
|
|
0, 'o', 0, 'u', 0, 't', 0, ' ',
|
|
|
|
0, 'o', 0, 'f', 0, ' ',
|
|
|
|
0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0
|
|
|
|
};
|
2004-10-06 19:41:16 +04:00
|
|
|
static const char misuseBe [] = {
|
2004-06-26 13:50:11 +04:00
|
|
|
0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ',
|
|
|
|
0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ',
|
|
|
|
0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ',
|
|
|
|
0, 'o', 0, 'u', 0, 't', 0, ' ',
|
|
|
|
0, 'o', 0, 'f', 0, ' ',
|
|
|
|
0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0
|
|
|
|
};
|
2004-06-18 08:24:54 +04:00
|
|
|
|
2004-09-30 17:43:13 +04:00
|
|
|
const void *z;
|
2007-03-29 19:00:52 +04:00
|
|
|
if( !db ){
|
2004-09-30 17:43:13 +04:00
|
|
|
return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
|
|
|
|
}
|
2008-01-23 06:03:05 +03:00
|
|
|
if( !sqlite3SafetyCheckSickOrOk(db) || db->errCode==SQLITE_MISUSE ){
|
2004-09-30 17:43:13 +04:00
|
|
|
return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
|
|
|
|
}
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
assert( !db->mallocFailed );
|
2004-09-30 17:43:13 +04:00
|
|
|
z = sqlite3_value_text16(db->pErr);
|
|
|
|
if( z==0 ){
|
2007-08-21 23:33:56 +04:00
|
|
|
sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
|
2004-09-30 17:43:13 +04:00
|
|
|
SQLITE_UTF8, SQLITE_STATIC);
|
|
|
|
z = sqlite3_value_text16(db->pErr);
|
|
|
|
}
|
2008-05-22 17:56:17 +04:00
|
|
|
/* A malloc() may have failed within the call to sqlite3_value_text16()
|
|
|
|
** above. If this is the case, then the db->mallocFailed flag needs to
|
|
|
|
** be cleared before returning. Do this directly, instead of via
|
|
|
|
** sqlite3ApiExit(), to avoid setting the database handle error message.
|
|
|
|
*/
|
|
|
|
db->mallocFailed = 0;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2004-09-30 17:43:13 +04:00
|
|
|
return z;
|
2004-05-20 15:00:52 +04:00
|
|
|
}
|
2004-11-15 00:56:29 +03:00
|
|
|
#endif /* SQLITE_OMIT_UTF16 */
|
2004-05-20 15:00:52 +04:00
|
|
|
|
2004-09-30 17:43:13 +04:00
|
|
|
/*
|
2005-12-12 09:53:03 +03:00
|
|
|
** Return the most recent error code generated by an SQLite routine. If NULL is
|
|
|
|
** passed to this function, we assume a malloc() failed during sqlite3_open().
|
2004-09-30 17:43:13 +04:00
|
|
|
*/
|
2004-05-20 15:00:52 +04:00
|
|
|
int sqlite3_errcode(sqlite3 *db){
|
2008-01-31 18:31:01 +03:00
|
|
|
if( db && !sqlite3SafetyCheckSickOrOk(db) ){
|
2004-09-30 17:43:13 +04:00
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
2008-01-23 15:52:40 +03:00
|
|
|
if( !db || db->mallocFailed ){
|
|
|
|
return SQLITE_NOMEM;
|
|
|
|
}
|
2006-09-15 11:28:50 +04:00
|
|
|
return db->errCode & db->errMask;
|
2004-05-20 15:00:52 +04:00
|
|
|
}
|
|
|
|
|
2006-02-01 16:50:41 +03:00
|
|
|
/*
|
|
|
|
** Create a new collating function for database "db". The name is zName
|
|
|
|
** and the encoding is enc.
|
|
|
|
*/
|
2006-01-18 07:26:07 +03:00
|
|
|
static int createCollation(
|
|
|
|
sqlite3* db,
|
|
|
|
const char *zName,
|
|
|
|
int enc,
|
|
|
|
void* pCtx,
|
2007-05-07 13:32:45 +04:00
|
|
|
int(*xCompare)(void*,int,const void*,int,const void*),
|
|
|
|
void(*xDel)(void*)
|
2006-01-18 07:26:07 +03:00
|
|
|
){
|
|
|
|
CollSeq *pColl;
|
2006-02-16 21:16:36 +03:00
|
|
|
int enc2;
|
2006-01-18 07:26:07 +03:00
|
|
|
|
2007-08-21 20:15:55 +04:00
|
|
|
assert( sqlite3_mutex_held(db->mutex) );
|
2006-01-18 07:26:07 +03:00
|
|
|
|
|
|
|
/* If SQLITE_UTF16 is specified as the encoding type, transform this
|
|
|
|
** to one of SQLITE_UTF16LE or SQLITE_UTF16BE using the
|
|
|
|
** SQLITE_UTF16NATIVE macro. SQLITE_UTF16 is not used internally.
|
|
|
|
*/
|
2006-02-16 21:16:36 +03:00
|
|
|
enc2 = enc & ~SQLITE_UTF16_ALIGNED;
|
|
|
|
if( enc2==SQLITE_UTF16 ){
|
|
|
|
enc2 = SQLITE_UTF16NATIVE;
|
2006-01-18 07:26:07 +03:00
|
|
|
}
|
|
|
|
|
2006-02-16 21:16:36 +03:00
|
|
|
if( (enc2&~3)!=0 ){
|
|
|
|
sqlite3Error(db, SQLITE_ERROR, "unknown encoding");
|
2006-01-18 07:26:07 +03:00
|
|
|
return SQLITE_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if this call is removing or replacing an existing collation
|
|
|
|
** sequence. If so, and there are active VMs, return busy. If there
|
|
|
|
** are no active VMs, invalidate any pre-compiled statements.
|
|
|
|
*/
|
2006-02-16 21:16:36 +03:00
|
|
|
pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 0);
|
2006-01-18 07:26:07 +03:00
|
|
|
if( pColl && pColl->xCmp ){
|
|
|
|
if( db->activeVdbeCnt ){
|
|
|
|
sqlite3Error(db, SQLITE_BUSY,
|
|
|
|
"Unable to delete/modify collation sequence due to active statements");
|
|
|
|
return SQLITE_BUSY;
|
|
|
|
}
|
|
|
|
sqlite3ExpirePreparedStatements(db);
|
2007-05-07 13:32:45 +04:00
|
|
|
|
|
|
|
/* If collation sequence pColl was created directly by a call to
|
|
|
|
** sqlite3_create_collation, and not generated by synthCollSeq(),
|
|
|
|
** then any copies made by synthCollSeq() need to be invalidated.
|
|
|
|
** Also, collation destructor - CollSeq.xDel() - function may need
|
|
|
|
** to be called.
|
|
|
|
*/
|
|
|
|
if( (pColl->enc & ~SQLITE_UTF16_ALIGNED)==enc2 ){
|
|
|
|
CollSeq *aColl = sqlite3HashFind(&db->aCollSeq, zName, strlen(zName));
|
|
|
|
int j;
|
|
|
|
for(j=0; j<3; j++){
|
|
|
|
CollSeq *p = &aColl[j];
|
|
|
|
if( p->enc==pColl->enc ){
|
|
|
|
if( p->xDel ){
|
|
|
|
p->xDel(p->pUser);
|
|
|
|
}
|
|
|
|
p->xCmp = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-01-18 07:26:07 +03:00
|
|
|
}
|
|
|
|
|
2006-02-16 21:16:36 +03:00
|
|
|
pColl = sqlite3FindCollSeq(db, (u8)enc2, zName, strlen(zName), 1);
|
2006-01-18 07:26:07 +03:00
|
|
|
if( pColl ){
|
|
|
|
pColl->xCmp = xCompare;
|
|
|
|
pColl->pUser = pCtx;
|
2007-05-07 13:32:45 +04:00
|
|
|
pColl->xDel = xDel;
|
2006-02-16 21:16:36 +03:00
|
|
|
pColl->enc = enc2 | (enc & SQLITE_UTF16_ALIGNED);
|
2006-01-18 07:26:07 +03:00
|
|
|
}
|
|
|
|
sqlite3Error(db, SQLITE_OK, 0);
|
|
|
|
return SQLITE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-03-20 17:03:29 +03:00
|
|
|
/*
|
|
|
|
** This array defines hard upper bounds on limit values. The
|
|
|
|
** initializer must be kept in sync with the SQLITE_LIMIT_*
|
|
|
|
** #defines in sqlite3.h.
|
|
|
|
*/
|
2008-03-20 19:30:17 +03:00
|
|
|
static const int aHardLimit[] = {
|
2008-03-20 17:03:29 +03:00
|
|
|
SQLITE_MAX_LENGTH,
|
|
|
|
SQLITE_MAX_SQL_LENGTH,
|
|
|
|
SQLITE_MAX_COLUMN,
|
|
|
|
SQLITE_MAX_EXPR_DEPTH,
|
|
|
|
SQLITE_MAX_COMPOUND_SELECT,
|
|
|
|
SQLITE_MAX_VDBE_OP,
|
|
|
|
SQLITE_MAX_FUNCTION_ARG,
|
|
|
|
SQLITE_MAX_ATTACHED,
|
|
|
|
SQLITE_MAX_LIKE_PATTERN_LENGTH,
|
|
|
|
SQLITE_MAX_VARIABLE_NUMBER,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Make sure the hard limits are set to reasonable values
|
|
|
|
*/
|
|
|
|
#if SQLITE_MAX_LENGTH<100
|
|
|
|
# error SQLITE_MAX_LENGTH must be at least 100
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_SQL_LENGTH<100
|
|
|
|
# error SQLITE_MAX_SQL_LENGTH must be at least 100
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_SQL_LENGTH>SQLITE_MAX_LENGTH
|
|
|
|
# error SQLITE_MAX_SQL_LENGTH must not be greater than SQLITE_MAX_LENGTH
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_COMPOUND_SELECT<2
|
|
|
|
# error SQLITE_MAX_COMPOUND_SELECT must be at least 2
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_VDBE_OP<40
|
|
|
|
# error SQLITE_MAX_VDBE_OP must be at least 40
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_FUNCTION_ARG<0 || SQLITE_MAX_FUNCTION_ARG>255
|
|
|
|
# error SQLITE_MAX_FUNCTION_ARG must be between 0 and 255
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_ATTACH<0 || SQLITE_MAX_ATTACH>30
|
|
|
|
# error SQLITE_MAX_ATTACH must be between 0 and 30
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_LIKE_PATTERN_LENGTH<1
|
|
|
|
# error SQLITE_MAX_LIKE_PATTERN_LENGTH must be at least 1
|
|
|
|
#endif
|
|
|
|
#if SQLITE_MAX_VARIABLE_NUMBER<1
|
|
|
|
# error SQLITE_MAX_VARIABLE_NUMBER must be at least 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Change the value of a limit. Report the old value.
|
|
|
|
** If an invalid limit index is supplied, report -1.
|
|
|
|
** Make no changes but still report the old value if the
|
|
|
|
** new limit is negative.
|
|
|
|
**
|
|
|
|
** A new lower limit does not shrink existing constructs.
|
|
|
|
** It merely prevents new constructs that exceed the limit
|
|
|
|
** from forming.
|
|
|
|
*/
|
|
|
|
int sqlite3_limit(sqlite3 *db, int limitId, int newLimit){
|
|
|
|
int oldLimit;
|
2008-04-15 06:36:33 +04:00
|
|
|
if( limitId<0 || limitId>=SQLITE_N_LIMIT ){
|
2008-03-20 17:03:29 +03:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
oldLimit = db->aLimit[limitId];
|
|
|
|
if( newLimit>=0 ){
|
2008-03-20 21:00:49 +03:00
|
|
|
if( newLimit>aHardLimit[limitId] ){
|
2008-03-20 17:03:29 +03:00
|
|
|
newLimit = aHardLimit[limitId];
|
|
|
|
}
|
|
|
|
db->aLimit[limitId] = newLimit;
|
|
|
|
}
|
|
|
|
return oldLimit;
|
|
|
|
}
|
|
|
|
|
2004-05-21 05:47:26 +04:00
|
|
|
/*
|
|
|
|
** This routine does the work of opening a database on behalf of
|
|
|
|
** sqlite3_open() and sqlite3_open16(). The database filename "zFilename"
|
2005-04-28 16:06:05 +04:00
|
|
|
** is UTF-8 encoded.
|
2004-05-21 05:47:26 +04:00
|
|
|
*/
|
|
|
|
static int openDatabase(
|
|
|
|
const char *zFilename, /* Database filename UTF-8 encoded */
|
2007-08-21 19:13:19 +04:00
|
|
|
sqlite3 **ppDb, /* OUT: Returned database handle */
|
|
|
|
unsigned flags, /* Operational flags */
|
|
|
|
const char *zVfs /* Name of the VFS to use */
|
2004-05-21 05:47:26 +04:00
|
|
|
){
|
|
|
|
sqlite3 *db;
|
2006-01-05 14:34:32 +03:00
|
|
|
int rc;
|
2005-08-28 21:00:23 +04:00
|
|
|
CollSeq *pColl;
|
2004-05-21 05:47:26 +04:00
|
|
|
|
2008-02-19 18:20:44 +03:00
|
|
|
/* Remove harmful bits from the flags parameter */
|
|
|
|
flags &= ~( SQLITE_OPEN_DELETEONCLOSE |
|
|
|
|
SQLITE_OPEN_MAIN_DB |
|
|
|
|
SQLITE_OPEN_TEMP_DB |
|
|
|
|
SQLITE_OPEN_TRANSIENT_DB |
|
|
|
|
SQLITE_OPEN_MAIN_JOURNAL |
|
|
|
|
SQLITE_OPEN_TEMP_JOURNAL |
|
|
|
|
SQLITE_OPEN_SUBJOURNAL |
|
|
|
|
SQLITE_OPEN_MASTER_JOURNAL
|
|
|
|
);
|
|
|
|
|
2004-05-21 05:47:26 +04:00
|
|
|
/* Allocate the sqlite data structure */
|
2007-08-16 08:30:38 +04:00
|
|
|
db = sqlite3MallocZero( sizeof(sqlite3) );
|
2004-05-21 05:47:26 +04:00
|
|
|
if( db==0 ) goto opendb_out;
|
2007-08-21 19:13:19 +04:00
|
|
|
db->mutex = sqlite3_mutex_alloc(SQLITE_MUTEX_RECURSIVE);
|
|
|
|
if( db->mutex==0 ){
|
2007-08-24 07:51:33 +04:00
|
|
|
sqlite3_free(db);
|
|
|
|
db = 0;
|
2007-08-21 19:13:19 +04:00
|
|
|
goto opendb_out;
|
|
|
|
}
|
2007-08-22 06:56:42 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2006-09-15 11:28:50 +04:00
|
|
|
db->errMask = 0xff;
|
2004-05-21 05:47:26 +04:00
|
|
|
db->priorNewRowid = 0;
|
|
|
|
db->nDb = 2;
|
2007-08-24 07:51:33 +04:00
|
|
|
db->magic = SQLITE_MAGIC_BUSY;
|
2004-05-21 05:47:26 +04:00
|
|
|
db->aDb = db->aDbStatic;
|
2008-03-20 17:03:29 +03:00
|
|
|
assert( sizeof(db->aLimit)==sizeof(aHardLimit) );
|
|
|
|
memcpy(db->aLimit, aHardLimit, sizeof(db->aLimit));
|
2004-05-31 12:26:49 +04:00
|
|
|
db->autoCommit = 1;
|
2007-12-05 04:38:23 +03:00
|
|
|
db->nextAutovac = -1;
|
2008-03-20 14:04:21 +03:00
|
|
|
db->nextPagesize = 0;
|
2006-07-11 18:17:51 +04:00
|
|
|
db->flags |= SQLITE_ShortColNames
|
|
|
|
#if SQLITE_DEFAULT_FILE_FORMAT<4
|
|
|
|
| SQLITE_LegacyFileFmt
|
2007-03-28 02:24:11 +04:00
|
|
|
#endif
|
|
|
|
#ifdef SQLITE_ENABLE_LOAD_EXTENSION
|
|
|
|
| SQLITE_LoadExtension
|
2006-07-11 18:17:51 +04:00
|
|
|
#endif
|
|
|
|
;
|
2004-05-26 20:54:42 +04:00
|
|
|
sqlite3HashInit(&db->aFunc, SQLITE_HASH_STRING, 0);
|
2004-05-21 05:47:26 +04:00
|
|
|
sqlite3HashInit(&db->aCollSeq, SQLITE_HASH_STRING, 0);
|
2006-06-12 03:41:55 +04:00
|
|
|
#ifndef SQLITE_OMIT_VIRTUALTABLE
|
|
|
|
sqlite3HashInit(&db->aModule, SQLITE_HASH_STRING, 0);
|
|
|
|
#endif
|
2006-01-05 14:34:32 +03:00
|
|
|
|
2007-09-01 10:51:27 +04:00
|
|
|
db->pVfs = sqlite3_vfs_find(zVfs);
|
|
|
|
if( !db->pVfs ){
|
|
|
|
rc = SQLITE_ERROR;
|
2008-01-23 06:03:05 +03:00
|
|
|
db->magic = SQLITE_MAGIC_SICK;
|
2008-02-21 05:09:45 +03:00
|
|
|
sqlite3Error(db, rc, "no such vfs: %s", zVfs);
|
2007-09-01 10:51:27 +04:00
|
|
|
goto opendb_out;
|
|
|
|
}
|
|
|
|
|
2004-06-09 13:55:16 +04:00
|
|
|
/* Add the default collation sequence BINARY. BINARY works for both UTF-8
|
|
|
|
** and UTF-16, so add a version for each to avoid any unnecessary
|
|
|
|
** conversions. The only error that can occur here is a malloc() failure.
|
|
|
|
*/
|
2008-02-21 05:09:45 +03:00
|
|
|
createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc, 0);
|
|
|
|
createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc, 0);
|
|
|
|
createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc, 0);
|
|
|
|
createCollation(db, "RTRIM", SQLITE_UTF8, (void*)1, binCollFunc, 0);
|
2008-03-18 16:01:38 +03:00
|
|
|
if( db->mallocFailed ){
|
2008-01-23 06:03:05 +03:00
|
|
|
db->magic = SQLITE_MAGIC_SICK;
|
2004-06-09 13:55:16 +04:00
|
|
|
goto opendb_out;
|
|
|
|
}
|
2008-03-18 16:01:38 +03:00
|
|
|
db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0);
|
|
|
|
assert( db->pDfltColl!=0 );
|
2004-06-09 13:55:16 +04:00
|
|
|
|
|
|
|
/* Also add a UTF-8 case-insensitive collation sequence. */
|
2007-05-07 13:32:45 +04:00
|
|
|
createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc, 0);
|
2004-06-09 13:55:16 +04:00
|
|
|
|
2005-08-28 21:00:23 +04:00
|
|
|
/* Set flags on the built-in collating sequences */
|
|
|
|
db->pDfltColl->type = SQLITE_COLL_BINARY;
|
|
|
|
pColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "NOCASE", 6, 0);
|
|
|
|
if( pColl ){
|
|
|
|
pColl->type = SQLITE_COLL_NOCASE;
|
|
|
|
}
|
|
|
|
|
2004-05-21 05:47:26 +04:00
|
|
|
/* Open the backend database driver */
|
2007-09-03 19:19:34 +04:00
|
|
|
db->openFlags = flags;
|
|
|
|
rc = sqlite3BtreeFactory(db, zFilename, 0, SQLITE_DEFAULT_CACHE_SIZE,
|
|
|
|
flags | SQLITE_OPEN_MAIN_DB,
|
2007-05-08 05:08:49 +04:00
|
|
|
&db->aDb[0].pBt);
|
2004-05-21 05:47:26 +04:00
|
|
|
if( rc!=SQLITE_OK ){
|
|
|
|
sqlite3Error(db, rc, 0);
|
2008-01-23 06:03:05 +03:00
|
|
|
db->magic = SQLITE_MAGIC_SICK;
|
2004-05-21 05:47:26 +04:00
|
|
|
goto opendb_out;
|
|
|
|
}
|
2007-08-16 08:30:38 +04:00
|
|
|
db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
|
|
|
|
db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
|
2006-01-09 19:12:04 +03:00
|
|
|
|
2006-03-13 18:06:05 +03:00
|
|
|
|
2005-03-29 07:10:59 +04:00
|
|
|
/* The default safety_level for the main database is 'full'; for the temp
|
|
|
|
** database it is 'NONE'. This matches the pager layer defaults.
|
|
|
|
*/
|
|
|
|
db->aDb[0].zName = "main";
|
2004-06-26 10:37:06 +04:00
|
|
|
db->aDb[0].safety_level = 3;
|
2005-03-29 07:10:59 +04:00
|
|
|
#ifndef SQLITE_OMIT_TEMPDB
|
|
|
|
db->aDb[1].zName = "temp";
|
2004-06-26 10:37:06 +04:00
|
|
|
db->aDb[1].safety_level = 1;
|
2005-03-29 07:10:59 +04:00
|
|
|
#endif
|
|
|
|
|
2007-06-22 19:21:15 +04:00
|
|
|
db->magic = SQLITE_MAGIC_OPEN;
|
2007-08-16 08:30:38 +04:00
|
|
|
if( db->mallocFailed ){
|
2007-06-22 19:21:15 +04:00
|
|
|
goto opendb_out;
|
|
|
|
}
|
|
|
|
|
2004-06-07 11:52:17 +04:00
|
|
|
/* Register all built-in functions, but do not attempt to read the
|
|
|
|
** database schema yet. This is delayed until the first time the database
|
|
|
|
** is accessed.
|
|
|
|
*/
|
2007-06-22 19:21:15 +04:00
|
|
|
sqlite3Error(db, SQLITE_OK, 0);
|
|
|
|
sqlite3RegisterBuiltinFunctions(db);
|
2004-05-21 05:47:26 +04:00
|
|
|
|
2006-08-24 00:07:20 +04:00
|
|
|
/* Load automatic extensions - extensions that have been registered
|
|
|
|
** using the sqlite3_automatic_extension() API.
|
|
|
|
*/
|
2006-12-19 21:57:11 +03:00
|
|
|
(void)sqlite3AutoLoadExtensions(db);
|
2007-06-22 19:21:15 +04:00
|
|
|
if( sqlite3_errcode(db)!=SQLITE_OK ){
|
|
|
|
goto opendb_out;
|
|
|
|
}
|
2006-08-24 00:07:20 +04:00
|
|
|
|
2006-09-02 17:58:06 +04:00
|
|
|
#ifdef SQLITE_ENABLE_FTS1
|
2007-08-16 08:30:38 +04:00
|
|
|
if( !db->mallocFailed ){
|
2006-09-02 17:58:06 +04:00
|
|
|
extern int sqlite3Fts1Init(sqlite3*);
|
2007-06-22 19:21:15 +04:00
|
|
|
rc = sqlite3Fts1Init(db);
|
2006-09-02 17:58:06 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-10-20 00:27:58 +04:00
|
|
|
#ifdef SQLITE_ENABLE_FTS2
|
2007-08-16 08:30:38 +04:00
|
|
|
if( !db->mallocFailed && rc==SQLITE_OK ){
|
2006-10-20 00:27:58 +04:00
|
|
|
extern int sqlite3Fts2Init(sqlite3*);
|
2007-06-22 19:21:15 +04:00
|
|
|
rc = sqlite3Fts2Init(db);
|
2006-10-20 00:27:58 +04:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-08-20 21:37:47 +04:00
|
|
|
#ifdef SQLITE_ENABLE_FTS3
|
|
|
|
if( !db->mallocFailed && rc==SQLITE_OK ){
|
|
|
|
rc = sqlite3Fts3Init(db);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-05-06 20:04:11 +04:00
|
|
|
#ifdef SQLITE_ENABLE_ICU
|
2007-08-16 08:30:38 +04:00
|
|
|
if( !db->mallocFailed && rc==SQLITE_OK ){
|
2007-05-06 20:04:11 +04:00
|
|
|
extern int sqlite3IcuInit(sqlite3*);
|
2007-06-22 19:21:15 +04:00
|
|
|
rc = sqlite3IcuInit(db);
|
2007-05-06 20:04:11 +04:00
|
|
|
}
|
|
|
|
#endif
|
2008-05-26 22:41:54 +04:00
|
|
|
|
|
|
|
#ifdef SQLITE_ENABLE_RTREE
|
|
|
|
if( !db->mallocFailed && rc==SQLITE_OK){
|
|
|
|
extern int sqlite3RtreeInit(sqlite3*);
|
|
|
|
rc = sqlite3RtreeInit(db);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2007-06-22 19:21:15 +04:00
|
|
|
sqlite3Error(db, rc, 0);
|
2007-05-06 20:04:11 +04:00
|
|
|
|
2007-04-02 20:40:37 +04:00
|
|
|
/* -DSQLITE_DEFAULT_LOCKING_MODE=1 makes EXCLUSIVE the default locking
|
|
|
|
** mode. -DSQLITE_DEFAULT_LOCKING_MODE=0 make NORMAL the default locking
|
|
|
|
** mode. Doing nothing at all also makes NORMAL the default.
|
|
|
|
*/
|
|
|
|
#ifdef SQLITE_DEFAULT_LOCKING_MODE
|
|
|
|
db->dfltLockMode = SQLITE_DEFAULT_LOCKING_MODE;
|
|
|
|
sqlite3PagerLockingMode(sqlite3BtreePager(db->aDb[0].pBt),
|
|
|
|
SQLITE_DEFAULT_LOCKING_MODE);
|
|
|
|
#endif
|
|
|
|
|
2004-05-21 05:47:26 +04:00
|
|
|
opendb_out:
|
2008-02-21 05:09:45 +03:00
|
|
|
if( db ){
|
|
|
|
assert( db->mutex!=0 );
|
2007-08-23 00:18:21 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
}
|
2005-12-12 09:53:03 +03:00
|
|
|
if( SQLITE_NOMEM==(rc = sqlite3_errcode(db)) ){
|
|
|
|
sqlite3_close(db);
|
|
|
|
db = 0;
|
2004-06-30 15:54:06 +04:00
|
|
|
}
|
2004-05-21 05:47:26 +04:00
|
|
|
*ppDb = db;
|
2006-01-18 18:25:17 +03:00
|
|
|
return sqlite3ApiExit(0, rc);
|
2004-05-21 05:47:26 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Open a new database handle.
|
|
|
|
*/
|
2004-05-22 13:21:21 +04:00
|
|
|
int sqlite3_open(
|
2004-05-21 05:47:26 +04:00
|
|
|
const char *zFilename,
|
2004-06-08 04:02:33 +04:00
|
|
|
sqlite3 **ppDb
|
2004-05-21 05:47:26 +04:00
|
|
|
){
|
2007-08-21 19:13:19 +04:00
|
|
|
return openDatabase(zFilename, ppDb,
|
|
|
|
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
|
|
|
|
}
|
|
|
|
int sqlite3_open_v2(
|
2007-08-30 20:23:19 +04:00
|
|
|
const char *filename, /* Database filename (UTF-8) */
|
2007-08-21 19:13:19 +04:00
|
|
|
sqlite3 **ppDb, /* OUT: SQLite db handle */
|
|
|
|
int flags, /* Flags */
|
|
|
|
const char *zVfs /* Name of VFS module to use */
|
|
|
|
){
|
|
|
|
return openDatabase(filename, ppDb, flags, zVfs);
|
2004-05-21 15:39:05 +04:00
|
|
|
}
|
|
|
|
|
2004-11-15 00:56:29 +03:00
|
|
|
#ifndef SQLITE_OMIT_UTF16
|
2004-05-21 05:47:26 +04:00
|
|
|
/*
|
|
|
|
** Open a new database handle.
|
|
|
|
*/
|
|
|
|
int sqlite3_open16(
|
|
|
|
const void *zFilename,
|
2004-06-08 04:02:33 +04:00
|
|
|
sqlite3 **ppDb
|
2004-05-21 05:47:26 +04:00
|
|
|
){
|
2004-06-18 08:24:54 +04:00
|
|
|
char const *zFilename8; /* zFilename encoded in UTF-8 instead of UTF-16 */
|
|
|
|
sqlite3_value *pVal;
|
2007-08-16 14:09:01 +04:00
|
|
|
int rc = SQLITE_NOMEM;
|
2004-05-21 05:47:26 +04:00
|
|
|
|
2005-12-12 09:53:03 +03:00
|
|
|
assert( zFilename );
|
2004-05-21 05:47:26 +04:00
|
|
|
assert( ppDb );
|
2004-06-18 08:24:54 +04:00
|
|
|
*ppDb = 0;
|
2007-08-16 14:09:01 +04:00
|
|
|
pVal = sqlite3ValueNew(0);
|
2007-08-21 23:33:56 +04:00
|
|
|
sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
|
|
|
|
zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
|
2004-06-18 08:24:54 +04:00
|
|
|
if( zFilename8 ){
|
2007-08-21 19:13:19 +04:00
|
|
|
rc = openDatabase(zFilename8, ppDb,
|
|
|
|
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE, 0);
|
2008-02-21 05:09:45 +03:00
|
|
|
assert( *ppDb || rc==SQLITE_NOMEM );
|
2008-04-28 20:19:35 +04:00
|
|
|
if( rc==SQLITE_OK && !DbHasProperty(*ppDb, 0, DB_SchemaLoaded) ){
|
2008-04-03 20:28:24 +04:00
|
|
|
ENC(*ppDb) = SQLITE_UTF16NATIVE;
|
2004-06-18 08:24:54 +04:00
|
|
|
}
|
2004-05-21 05:47:26 +04:00
|
|
|
}
|
2005-12-12 09:53:03 +03:00
|
|
|
sqlite3ValueFree(pVal);
|
2004-06-07 11:52:17 +04:00
|
|
|
|
2006-01-18 18:25:17 +03:00
|
|
|
return sqlite3ApiExit(0, rc);
|
2004-05-21 05:47:26 +04:00
|
|
|
}
|
2004-11-15 00:56:29 +03:00
|
|
|
#endif /* SQLITE_OMIT_UTF16 */
|
2004-05-21 05:47:26 +04:00
|
|
|
|
2004-06-12 13:25:12 +04:00
|
|
|
/*
|
|
|
|
** Register a new collation sequence with the database handle db.
|
|
|
|
*/
|
2004-06-09 13:55:16 +04:00
|
|
|
int sqlite3_create_collation(
|
|
|
|
sqlite3* db,
|
|
|
|
const char *zName,
|
2004-06-10 06:16:01 +04:00
|
|
|
int enc,
|
2004-06-09 13:55:16 +04:00
|
|
|
void* pCtx,
|
|
|
|
int(*xCompare)(void*,int,const void*,int,const void*)
|
|
|
|
){
|
2006-01-18 07:26:07 +03:00
|
|
|
int rc;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2007-08-16 08:30:38 +04:00
|
|
|
assert( !db->mallocFailed );
|
2007-05-07 13:32:45 +04:00
|
|
|
rc = createCollation(db, zName, enc, pCtx, xCompare, 0);
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = sqlite3ApiExit(db, rc);
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
return rc;
|
2007-05-07 13:32:45 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Register a new collation sequence with the database handle db.
|
|
|
|
*/
|
2007-05-07 18:58:53 +04:00
|
|
|
int sqlite3_create_collation_v2(
|
2007-05-07 13:32:45 +04:00
|
|
|
sqlite3* db,
|
|
|
|
const char *zName,
|
|
|
|
int enc,
|
|
|
|
void* pCtx,
|
|
|
|
int(*xCompare)(void*,int,const void*,int,const void*),
|
|
|
|
void(*xDel)(void*)
|
|
|
|
){
|
|
|
|
int rc;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2007-08-16 08:30:38 +04:00
|
|
|
assert( !db->mallocFailed );
|
2007-05-07 13:32:45 +04:00
|
|
|
rc = createCollation(db, zName, enc, pCtx, xCompare, xDel);
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = sqlite3ApiExit(db, rc);
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
return rc;
|
2004-06-09 13:55:16 +04:00
|
|
|
}
|
|
|
|
|
2004-11-15 00:56:29 +03:00
|
|
|
#ifndef SQLITE_OMIT_UTF16
|
2004-06-12 13:25:12 +04:00
|
|
|
/*
|
|
|
|
** Register a new collation sequence with the database handle db.
|
|
|
|
*/
|
2004-06-09 13:55:16 +04:00
|
|
|
int sqlite3_create_collation16(
|
|
|
|
sqlite3* db,
|
|
|
|
const char *zName,
|
2004-06-10 06:16:01 +04:00
|
|
|
int enc,
|
2004-06-09 13:55:16 +04:00
|
|
|
void* pCtx,
|
|
|
|
int(*xCompare)(void*,int,const void*,int,const void*)
|
|
|
|
){
|
2006-01-18 07:26:07 +03:00
|
|
|
int rc = SQLITE_OK;
|
2008-01-23 15:52:40 +03:00
|
|
|
char *zName8;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2007-08-16 08:30:38 +04:00
|
|
|
assert( !db->mallocFailed );
|
2007-08-16 14:09:01 +04:00
|
|
|
zName8 = sqlite3Utf16to8(db, zName, -1);
|
2006-01-18 07:26:07 +03:00
|
|
|
if( zName8 ){
|
2007-05-07 13:32:45 +04:00
|
|
|
rc = createCollation(db, zName8, enc, pCtx, xCompare, 0);
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(zName8);
|
2006-01-18 07:26:07 +03:00
|
|
|
}
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = sqlite3ApiExit(db, rc);
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
return rc;
|
2004-06-09 13:55:16 +04:00
|
|
|
}
|
2004-11-15 00:56:29 +03:00
|
|
|
#endif /* SQLITE_OMIT_UTF16 */
|
2004-06-10 14:50:08 +04:00
|
|
|
|
2004-06-12 13:25:12 +04:00
|
|
|
/*
|
|
|
|
** Register a collation sequence factory callback with the database handle
|
|
|
|
** db. Replace any previously installed collation sequence factory.
|
|
|
|
*/
|
2004-06-10 14:50:08 +04:00
|
|
|
int sqlite3_collation_needed(
|
|
|
|
sqlite3 *db,
|
|
|
|
void *pCollNeededArg,
|
|
|
|
void(*xCollNeeded)(void*,sqlite3*,int eTextRep,const char*)
|
|
|
|
){
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2004-06-10 14:50:08 +04:00
|
|
|
db->xCollNeeded = xCollNeeded;
|
|
|
|
db->xCollNeeded16 = 0;
|
|
|
|
db->pCollNeededArg = pCollNeededArg;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2004-06-10 14:50:08 +04:00
|
|
|
return SQLITE_OK;
|
|
|
|
}
|
2004-06-12 13:25:12 +04:00
|
|
|
|
2004-11-15 00:56:29 +03:00
|
|
|
#ifndef SQLITE_OMIT_UTF16
|
2004-06-12 13:25:12 +04:00
|
|
|
/*
|
|
|
|
** Register a collation sequence factory callback with the database handle
|
|
|
|
** db. Replace any previously installed collation sequence factory.
|
|
|
|
*/
|
2004-06-10 14:50:08 +04:00
|
|
|
int sqlite3_collation_needed16(
|
|
|
|
sqlite3 *db,
|
|
|
|
void *pCollNeededArg,
|
|
|
|
void(*xCollNeeded16)(void*,sqlite3*,int eTextRep,const void*)
|
|
|
|
){
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2004-06-10 14:50:08 +04:00
|
|
|
db->xCollNeeded = 0;
|
|
|
|
db->xCollNeeded16 = xCollNeeded16;
|
|
|
|
db->pCollNeededArg = pCollNeededArg;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2004-06-10 14:50:08 +04:00
|
|
|
return SQLITE_OK;
|
|
|
|
}
|
2004-11-15 00:56:29 +03:00
|
|
|
#endif /* SQLITE_OMIT_UTF16 */
|
2005-03-21 07:04:02 +03:00
|
|
|
|
|
|
|
#ifndef SQLITE_OMIT_GLOBALRECOVER
|
|
|
|
/*
|
2005-12-12 09:53:03 +03:00
|
|
|
** This function is now an anachronism. It used to be used to recover from a
|
|
|
|
** malloc() failure, but SQLite now does this automatically.
|
2005-03-21 07:04:02 +03:00
|
|
|
*/
|
2007-10-12 23:35:48 +04:00
|
|
|
int sqlite3_global_recover(void){
|
2005-12-06 15:52:59 +03:00
|
|
|
return SQLITE_OK;
|
2005-03-21 07:04:02 +03:00
|
|
|
}
|
|
|
|
#endif
|
2005-05-26 20:23:34 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Test to see whether or not the database connection is in autocommit
|
|
|
|
** mode. Return TRUE if it is and FALSE if not. Autocommit mode is on
|
|
|
|
** by default. Autocommit is disabled by a BEGIN statement and reenabled
|
|
|
|
** by the next COMMIT or ROLLBACK.
|
|
|
|
**
|
|
|
|
******* THIS IS AN EXPERIMENTAL API AND IS SUBJECT TO CHANGE ******
|
|
|
|
*/
|
|
|
|
int sqlite3_get_autocommit(sqlite3 *db){
|
|
|
|
return db->autoCommit;
|
|
|
|
}
|
2005-09-17 19:20:26 +04:00
|
|
|
|
|
|
|
#ifdef SQLITE_DEBUG
|
|
|
|
/*
|
|
|
|
** The following routine is subtituted for constant SQLITE_CORRUPT in
|
|
|
|
** debugging builds. This provides a way to set a breakpoint for when
|
|
|
|
** corruption is first detected.
|
|
|
|
*/
|
|
|
|
int sqlite3Corrupt(void){
|
|
|
|
return SQLITE_CORRUPT;
|
|
|
|
}
|
|
|
|
#endif
|
2006-01-10 16:58:48 +03:00
|
|
|
|
2006-01-12 00:41:20 +03:00
|
|
|
/*
|
|
|
|
** This is a convenience routine that makes sure that all thread-specific
|
|
|
|
** data for this thread has been deallocated.
|
2007-08-16 17:01:44 +04:00
|
|
|
**
|
|
|
|
** SQLite no longer uses thread-specific data so this routine is now a
|
|
|
|
** no-op. It is retained for historical compatibility.
|
2006-01-12 00:41:20 +03:00
|
|
|
*/
|
|
|
|
void sqlite3_thread_cleanup(void){
|
|
|
|
}
|
2006-02-09 16:43:28 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Return meta information about a specific column of a database table.
|
|
|
|
** See comment in sqlite3.h (sqlite.h.in) for details.
|
|
|
|
*/
|
|
|
|
#ifdef SQLITE_ENABLE_COLUMN_METADATA
|
|
|
|
int sqlite3_table_column_metadata(
|
|
|
|
sqlite3 *db, /* Connection handle */
|
|
|
|
const char *zDbName, /* Database name or NULL */
|
|
|
|
const char *zTableName, /* Table name */
|
|
|
|
const char *zColumnName, /* Column name */
|
|
|
|
char const **pzDataType, /* OUTPUT: Declared data type */
|
|
|
|
char const **pzCollSeq, /* OUTPUT: Collation sequence name */
|
|
|
|
int *pNotNull, /* OUTPUT: True if NOT NULL constraint exists */
|
|
|
|
int *pPrimaryKey, /* OUTPUT: True if column part of PK */
|
|
|
|
int *pAutoinc /* OUTPUT: True if colums is auto-increment */
|
|
|
|
){
|
|
|
|
int rc;
|
|
|
|
char *zErrMsg = 0;
|
|
|
|
Table *pTab = 0;
|
|
|
|
Column *pCol = 0;
|
|
|
|
int iCol;
|
|
|
|
|
|
|
|
char const *zDataType = 0;
|
|
|
|
char const *zCollSeq = 0;
|
|
|
|
int notnull = 0;
|
|
|
|
int primarykey = 0;
|
|
|
|
int autoinc = 0;
|
|
|
|
|
|
|
|
/* Ensure the database schema has been loaded */
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2008-04-16 04:49:12 +04:00
|
|
|
(void)sqlite3SafetyOn(db);
|
2008-03-08 00:37:19 +03:00
|
|
|
sqlite3BtreeEnterAll(db);
|
2006-02-09 16:43:28 +03:00
|
|
|
rc = sqlite3Init(db, &zErrMsg);
|
2008-03-08 00:37:19 +03:00
|
|
|
sqlite3BtreeLeaveAll(db);
|
2006-02-09 16:43:28 +03:00
|
|
|
if( SQLITE_OK!=rc ){
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Locate the table in question */
|
|
|
|
pTab = sqlite3FindTable(db, zTableName, zDbName);
|
|
|
|
if( !pTab || pTab->pSelect ){
|
|
|
|
pTab = 0;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Find the column for which info is requested */
|
|
|
|
if( sqlite3IsRowid(zColumnName) ){
|
|
|
|
iCol = pTab->iPKey;
|
|
|
|
if( iCol>=0 ){
|
|
|
|
pCol = &pTab->aCol[iCol];
|
|
|
|
}
|
|
|
|
}else{
|
|
|
|
for(iCol=0; iCol<pTab->nCol; iCol++){
|
|
|
|
pCol = &pTab->aCol[iCol];
|
|
|
|
if( 0==sqlite3StrICmp(pCol->zName, zColumnName) ){
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( iCol==pTab->nCol ){
|
|
|
|
pTab = 0;
|
|
|
|
goto error_out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* The following block stores the meta information that will be returned
|
|
|
|
** to the caller in local variables zDataType, zCollSeq, notnull, primarykey
|
|
|
|
** and autoinc. At this point there are two possibilities:
|
|
|
|
**
|
|
|
|
** 1. The specified column name was rowid", "oid" or "_rowid_"
|
|
|
|
** and there is no explicitly declared IPK column.
|
|
|
|
**
|
|
|
|
** 2. The table is not a view and the column name identified an
|
|
|
|
** explicitly declared column. Copy meta information from *pCol.
|
|
|
|
*/
|
|
|
|
if( pCol ){
|
|
|
|
zDataType = pCol->zType;
|
|
|
|
zCollSeq = pCol->zColl;
|
|
|
|
notnull = (pCol->notNull?1:0);
|
|
|
|
primarykey = (pCol->isPrimKey?1:0);
|
|
|
|
autoinc = ((pTab->iPKey==iCol && pTab->autoInc)?1:0);
|
|
|
|
}else{
|
|
|
|
zDataType = "INTEGER";
|
|
|
|
primarykey = 1;
|
|
|
|
}
|
|
|
|
if( !zCollSeq ){
|
|
|
|
zCollSeq = "BINARY";
|
|
|
|
}
|
|
|
|
|
|
|
|
error_out:
|
2008-01-23 15:52:40 +03:00
|
|
|
(void)sqlite3SafetyOff(db);
|
2006-02-09 16:43:28 +03:00
|
|
|
|
|
|
|
/* Whether the function call succeeded or failed, set the output parameters
|
|
|
|
** to whatever their local counterparts contain. If an error did occur,
|
|
|
|
** this has the effect of zeroing all output parameters.
|
|
|
|
*/
|
|
|
|
if( pzDataType ) *pzDataType = zDataType;
|
|
|
|
if( pzCollSeq ) *pzCollSeq = zCollSeq;
|
|
|
|
if( pNotNull ) *pNotNull = notnull;
|
|
|
|
if( pPrimaryKey ) *pPrimaryKey = primarykey;
|
|
|
|
if( pAutoinc ) *pAutoinc = autoinc;
|
|
|
|
|
|
|
|
if( SQLITE_OK==rc && !pTab ){
|
|
|
|
sqlite3SetString(&zErrMsg, "no such table column: ", zTableName, ".",
|
|
|
|
zColumnName, 0);
|
|
|
|
rc = SQLITE_ERROR;
|
|
|
|
}
|
|
|
|
sqlite3Error(db, rc, (zErrMsg?"%s":0), zErrMsg);
|
2007-08-16 08:30:38 +04:00
|
|
|
sqlite3_free(zErrMsg);
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = sqlite3ApiExit(db, rc);
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2006-06-28 00:06:44 +04:00
|
|
|
return rc;
|
|
|
|
}
|
2007-08-21 20:15:55 +04:00
|
|
|
#endif
|
2006-06-28 00:06:44 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Sleep for a little while. Return the amount of time slept.
|
|
|
|
*/
|
|
|
|
int sqlite3_sleep(int ms){
|
2007-08-17 19:53:36 +04:00
|
|
|
sqlite3_vfs *pVfs;
|
2007-08-21 20:15:55 +04:00
|
|
|
int rc;
|
2007-08-21 02:48:41 +04:00
|
|
|
pVfs = sqlite3_vfs_find(0);
|
2007-08-18 14:59:19 +04:00
|
|
|
|
|
|
|
/* This function works in milliseconds, but the underlying OsSleep()
|
|
|
|
** API uses microseconds. Hence the 1000's.
|
|
|
|
*/
|
2007-08-21 20:15:55 +04:00
|
|
|
rc = (sqlite3OsSleep(pVfs, 1000*ms)/1000);
|
|
|
|
return rc;
|
2006-06-28 00:06:44 +04:00
|
|
|
}
|
2006-09-15 11:28:50 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Enable or disable the extended result codes.
|
|
|
|
*/
|
|
|
|
int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_enter(db->mutex);
|
2006-09-15 11:28:50 +04:00
|
|
|
db->errMask = onoff ? 0xffffffff : 0xff;
|
2007-08-21 20:15:55 +04:00
|
|
|
sqlite3_mutex_leave(db->mutex);
|
2006-09-15 11:28:50 +04:00
|
|
|
return SQLITE_OK;
|
|
|
|
}
|
2007-08-31 20:11:35 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Invoke the xFileControl method on a particular database.
|
|
|
|
*/
|
|
|
|
int sqlite3_file_control(sqlite3 *db, const char *zDbName, int op, void *pArg){
|
|
|
|
int rc = SQLITE_ERROR;
|
|
|
|
int iDb;
|
|
|
|
sqlite3_mutex_enter(db->mutex);
|
|
|
|
if( zDbName==0 ){
|
|
|
|
iDb = 0;
|
|
|
|
}else{
|
|
|
|
for(iDb=0; iDb<db->nDb; iDb++){
|
|
|
|
if( strcmp(db->aDb[iDb].zName, zDbName)==0 ) break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if( iDb<db->nDb ){
|
|
|
|
Btree *pBtree = db->aDb[iDb].pBt;
|
|
|
|
if( pBtree ){
|
|
|
|
Pager *pPager;
|
2008-01-22 17:50:16 +03:00
|
|
|
sqlite3_file *fd;
|
2007-08-31 20:11:35 +04:00
|
|
|
sqlite3BtreeEnter(pBtree);
|
|
|
|
pPager = sqlite3BtreePager(pBtree);
|
2008-01-22 17:50:16 +03:00
|
|
|
assert( pPager!=0 );
|
|
|
|
fd = sqlite3PagerFile(pPager);
|
|
|
|
assert( fd!=0 );
|
|
|
|
if( fd->pMethods ){
|
|
|
|
rc = sqlite3OsFileControl(fd, op, pArg);
|
2007-08-31 20:11:35 +04:00
|
|
|
}
|
|
|
|
sqlite3BtreeLeave(pBtree);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sqlite3_mutex_leave(db->mutex);
|
|
|
|
return rc;
|
|
|
|
}
|
2008-01-31 17:43:24 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Interface to the testing logic.
|
|
|
|
*/
|
|
|
|
int sqlite3_test_control(int op, ...){
|
|
|
|
int rc = 0;
|
2008-03-21 19:45:47 +03:00
|
|
|
#ifndef SQLITE_OMIT_BUILTIN_TEST
|
2008-03-19 17:15:34 +03:00
|
|
|
va_list ap;
|
2008-01-31 17:43:24 +03:00
|
|
|
va_start(ap, op);
|
|
|
|
switch( op ){
|
2008-03-19 19:08:53 +03:00
|
|
|
/*
|
|
|
|
** sqlite3_test_control(FAULT_CONFIG, fault_id, nDelay, nRepeat)
|
|
|
|
**
|
|
|
|
** Configure a fault injector. The specific fault injector is
|
|
|
|
** identified by the fault_id argument. (ex: SQLITE_FAULTINJECTOR_MALLOC)
|
|
|
|
** The fault will occur after a delay of nDelay calls. The fault
|
|
|
|
** will repeat nRepeat times.
|
|
|
|
*/
|
2008-01-31 17:43:24 +03:00
|
|
|
case SQLITE_TESTCTRL_FAULT_CONFIG: {
|
|
|
|
int id = va_arg(ap, int);
|
|
|
|
int nDelay = va_arg(ap, int);
|
|
|
|
int nRepeat = va_arg(ap, int);
|
|
|
|
sqlite3FaultConfig(id, nDelay, nRepeat);
|
|
|
|
break;
|
|
|
|
}
|
2008-03-19 19:08:53 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** sqlite3_test_control(FAULT_FAILURES, fault_id)
|
|
|
|
**
|
|
|
|
** Return the number of faults (both hard and benign faults) that have
|
|
|
|
** occurred since the injector identified by fault_id) was last configured.
|
|
|
|
*/
|
2008-01-31 17:43:24 +03:00
|
|
|
case SQLITE_TESTCTRL_FAULT_FAILURES: {
|
|
|
|
int id = va_arg(ap, int);
|
|
|
|
rc = sqlite3FaultFailures(id);
|
|
|
|
break;
|
|
|
|
}
|
2008-03-19 19:08:53 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** sqlite3_test_control(FAULT_BENIGN_FAILURES, fault_id)
|
|
|
|
**
|
|
|
|
** Return the number of benign faults that have occurred since the
|
|
|
|
** injector identified by fault_id was last configured.
|
|
|
|
*/
|
2008-01-31 17:43:24 +03:00
|
|
|
case SQLITE_TESTCTRL_FAULT_BENIGN_FAILURES: {
|
|
|
|
int id = va_arg(ap, int);
|
|
|
|
rc = sqlite3FaultBenignFailures(id);
|
|
|
|
break;
|
|
|
|
}
|
2008-03-19 19:08:53 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** sqlite3_test_control(FAULT_PENDING, fault_id)
|
|
|
|
**
|
|
|
|
** Return the number of successes that will occur before the next
|
|
|
|
** scheduled failure on fault injector fault_id.
|
|
|
|
** If no failures are scheduled, return -1.
|
|
|
|
*/
|
2008-01-31 17:43:24 +03:00
|
|
|
case SQLITE_TESTCTRL_FAULT_PENDING: {
|
|
|
|
int id = va_arg(ap, int);
|
|
|
|
rc = sqlite3FaultPending(id);
|
|
|
|
break;
|
|
|
|
}
|
2008-03-19 19:08:53 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Save the current state of the PRNG.
|
|
|
|
*/
|
2008-03-19 17:15:34 +03:00
|
|
|
case SQLITE_TESTCTRL_PRNG_SAVE: {
|
|
|
|
sqlite3PrngSaveState();
|
|
|
|
break;
|
|
|
|
}
|
2008-03-19 19:08:53 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Restore the state of the PRNG to the last state saved using
|
|
|
|
** PRNG_SAVE. If PRNG_SAVE has never before been called, then
|
|
|
|
** this verb acts like PRNG_RESET.
|
|
|
|
*/
|
2008-03-19 17:15:34 +03:00
|
|
|
case SQLITE_TESTCTRL_PRNG_RESTORE: {
|
|
|
|
sqlite3PrngRestoreState();
|
|
|
|
break;
|
|
|
|
}
|
2008-03-19 19:08:53 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Reset the PRNG back to its uninitialized state. The next call
|
|
|
|
** to sqlite3_randomness() will reseed the PRNG using a single call
|
|
|
|
** to the xRandomness method of the default VFS.
|
|
|
|
*/
|
2008-03-19 17:15:34 +03:00
|
|
|
case SQLITE_TESTCTRL_PRNG_RESET: {
|
|
|
|
sqlite3PrngResetState();
|
|
|
|
break;
|
|
|
|
}
|
2008-03-21 19:45:47 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
** sqlite3_test_control(BITVEC_TEST, size, program)
|
|
|
|
**
|
|
|
|
** Run a test against a Bitvec object of size. The program argument
|
|
|
|
** is an array of integers that defines the test. Return -1 on a
|
|
|
|
** memory allocation error, 0 on success, or non-zero for an error.
|
|
|
|
** See the sqlite3BitvecBuiltinTest() for additional information.
|
|
|
|
*/
|
|
|
|
case SQLITE_TESTCTRL_BITVEC_TEST: {
|
|
|
|
int sz = va_arg(ap, int);
|
|
|
|
int *aProg = va_arg(ap, int*);
|
|
|
|
rc = sqlite3BitvecBuiltinTest(sz, aProg);
|
|
|
|
break;
|
|
|
|
}
|
2008-01-31 17:43:24 +03:00
|
|
|
}
|
|
|
|
va_end(ap);
|
2008-03-21 19:45:47 +03:00
|
|
|
#endif /* SQLITE_OMIT_BUILTIN_TEST */
|
2008-01-31 18:31:01 +03:00
|
|
|
return rc;
|
2008-01-31 17:43:24 +03:00
|
|
|
}
|