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.
|
|
|
|
**
|
2006-12-19 21:57:11 +03:00
|
|
|
** $Id: main.c,v 1.360 2006/12/19 18:57:11 drh Exp $
|
2000-05-29 18:26:00 +04:00
|
|
|
*/
|
|
|
|
#include "sqliteInt.h"
|
2001-09-19 17:22:39 +04:00
|
|
|
#include "os.h"
|
2002-05-15 18:17:44 +04:00
|
|
|
#include <ctype.h>
|
2000-05-29 18:26:00 +04:00
|
|
|
|
2004-05-22 21:41:58 +04:00
|
|
|
/*
|
2004-05-31 22:51:57 +04:00
|
|
|
** The following constant value is used by the SQLITE_BIGENDIAN and
|
|
|
|
** SQLITE_LITTLEENDIAN macros.
|
2004-05-22 21:41:58 +04:00
|
|
|
*/
|
|
|
|
const int sqlite3one = 1;
|
|
|
|
|
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; }
|
2000-08-22 17:40:18 +04:00
|
|
|
|
2004-05-21 02:16:29 +04:00
|
|
|
/*
|
|
|
|
** This is the default collating function named "BINARY" which is always
|
|
|
|
** available.
|
|
|
|
*/
|
2005-01-13 05:14:23 +03:00
|
|
|
static int binCollFunc(
|
2004-05-21 02:16:29 +04:00
|
|
|
void *NotUsed,
|
|
|
|
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 ){
|
|
|
|
rc = nKey1 - nKey2;
|
|
|
|
}
|
|
|
|
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
|
|
|
}
|
2004-09-30 17:43:13 +04:00
|
|
|
if( sqlite3SafetyCheck(db) ){
|
2004-06-26 13:50:11 +04:00
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
|
|
|
|
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
|
|
|
|
|
2004-06-19 07:33:57 +04:00
|
|
|
/* If there are any outstanding VMs, return SQLITE_BUSY. */
|
2006-07-31 00:50:44 +04:00
|
|
|
sqlite3ResetInternalSchema(db, 0);
|
2004-06-19 07:33:57 +04:00
|
|
|
if( db->pVdbe ){
|
|
|
|
sqlite3Error(db, SQLITE_BUSY,
|
|
|
|
"Unable to close due to unfinalised statements");
|
|
|
|
return SQLITE_BUSY;
|
|
|
|
}
|
|
|
|
assert( !sqlite3SafetyCheck(db) );
|
2004-06-15 20:51:01 +04:00
|
|
|
|
|
|
|
/* FIX ME: db->magic may be set to SQLITE_MAGIC_CLOSED if the database
|
|
|
|
** cannot be opened for some reason. So this routine needs to run in
|
|
|
|
** that case. But maybe there should be an extra magic value for the
|
|
|
|
** "failed to open" state.
|
|
|
|
*/
|
2004-06-19 07:33:57 +04:00
|
|
|
if( db->magic!=SQLITE_MAGIC_CLOSED && sqlite3SafetyOn(db) ){
|
2003-02-17 01:21:32 +03:00
|
|
|
/* printf("DID NOT CLOSE\n"); fflush(stdout); */
|
2004-06-19 07:33:57 +04:00
|
|
|
return SQLITE_ERROR;
|
2003-02-17 01:21:32 +03:00
|
|
|
}
|
2004-06-15 20:51:01 +04:00
|
|
|
|
2006-06-23 15:34:54 +04:00
|
|
|
sqlite3VtabRollback(db);
|
|
|
|
|
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;
|
|
|
|
sqliteFree(pFunc);
|
|
|
|
}
|
|
|
|
}
|
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);
|
2004-06-12 13:25:12 +04:00
|
|
|
sqliteFree(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);
|
|
|
|
sqliteFree(pMod);
|
|
|
|
}
|
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?
|
|
|
|
*/
|
2006-01-05 14:34:32 +03:00
|
|
|
sqliteFree(db->aDb[1].pSchema);
|
2000-05-29 18:26:00 +04:00
|
|
|
sqliteFree(db);
|
2006-01-12 00:41:20 +03:00
|
|
|
sqlite3ReleaseThreadData();
|
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;
|
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);
|
2005-12-16 09:54:01 +03:00
|
|
|
if( db->flags&SQLITE_InternChanges ){
|
|
|
|
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_PROTOCOL: z = "database locking protocol failure"; break;
|
|
|
|
case SQLITE_EMPTY: z = "table contains no data"; break;
|
|
|
|
case SQLITE_SCHEMA: z = "database schema has changed"; break;
|
|
|
|
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;
|
2002-11-09 03:33:15 +03:00
|
|
|
case SQLITE_NOLFS: z = "kernel lacks large file support"; 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]))
|
2005-05-25 00:19:57 +04:00
|
|
|
int timeout = ((sqlite3 *)ptr)->busyTimeout;
|
|
|
|
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;
|
|
|
|
}
|
2006-01-06 17:32:19 +03:00
|
|
|
sqlite3OsSleep(delay);
|
2000-07-28 18:32:48 +04:00
|
|
|
return 1;
|
|
|
|
#else
|
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;
|
|
|
|
}
|
2006-01-06 17:32:19 +03:00
|
|
|
sqlite3OsSleep(1000);
|
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
|
|
|
|
){
|
2004-09-30 17:43:13 +04:00
|
|
|
if( sqlite3SafetyCheck(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
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;
|
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
|
|
|
|
){
|
2004-09-30 17:43:13 +04:00
|
|
|
if( !sqlite3SafetyCheck(db) ){
|
|
|
|
if( nOps>0 ){
|
|
|
|
db->xProgress = xProgress;
|
|
|
|
db->nProgressOps = nOps;
|
|
|
|
db->pProgressArg = pArg;
|
|
|
|
}else{
|
|
|
|
db->xProgress = 0;
|
|
|
|
db->nProgressOps = 0;
|
|
|
|
db->pProgressArg = 0;
|
|
|
|
}
|
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){
|
2006-07-06 14:59:57 +04:00
|
|
|
if( sqlite3SafetyCheck(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
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){
|
2006-07-26 05:39:30 +04:00
|
|
|
if( db && (db->magic==SQLITE_MAGIC_OPEN || db->magic==SQLITE_MAGIC_BUSY) ){
|
|
|
|
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-06-27 01:35:44 +04:00
|
|
|
** Memory allocation routines that use SQLites internal memory
|
|
|
|
** memory allocator. Depending on how SQLite is compiled, the
|
|
|
|
** internal memory allocator might be just an alias for the
|
|
|
|
** system default malloc/realloc/free. Or the built-in allocator
|
|
|
|
** might do extra stuff like put sentinals around buffers to
|
|
|
|
** check for overruns or look for memory leaks.
|
2002-02-02 18:01:15 +03:00
|
|
|
**
|
2006-06-27 01:35:44 +04:00
|
|
|
** Use sqlite3_free() to free memory returned by sqlite3_mprintf().
|
2002-02-02 18:01:15 +03:00
|
|
|
*/
|
2006-06-27 01:35:44 +04:00
|
|
|
void sqlite3_free(void *p){ if( p ) sqlite3OsFree(p); }
|
|
|
|
void *sqlite3_malloc(int nByte){ return nByte>0 ? sqlite3OsMalloc(nByte) : 0; }
|
|
|
|
void *sqlite3_realloc(void *pOld, int nByte){
|
|
|
|
if( pOld ){
|
|
|
|
if( nByte>0 ){
|
|
|
|
return sqlite3OsRealloc(pOld, nByte);
|
|
|
|
}else{
|
|
|
|
sqlite3OsFree(pOld);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}else{
|
|
|
|
return sqlite3_malloc(nByte);
|
|
|
|
}
|
|
|
|
}
|
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
|
|
|
|
2004-09-30 17:43:13 +04:00
|
|
|
if( sqlite3SafetyCheck(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
|
|
|
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);
|
2004-06-12 13:25:12 +04:00
|
|
|
if( rc!=SQLITE_OK ) return rc;
|
2006-01-17 16:21:40 +03:00
|
|
|
rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,
|
2004-06-19 12:18:07 +04:00
|
|
|
pUserData, xFunc, xStep, xFinal);
|
2004-06-12 13:25:12 +04:00
|
|
|
if( rc!=SQLITE_OK ) return rc;
|
|
|
|
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");
|
2006-01-18 19:51:35 +03:00
|
|
|
assert( !sqlite3MallocFailed() );
|
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);
|
2006-01-17 16:21:40 +03:00
|
|
|
if( p ){
|
|
|
|
p->flags = 0;
|
|
|
|
p->xFunc = xFunc;
|
|
|
|
p->xStep = xStep;
|
|
|
|
p->xFinalize = xFinal;
|
|
|
|
p->pUserData = pUserData;
|
2006-06-24 15:51:33 +04:00
|
|
|
p->nArg = nArg;
|
2006-01-17 16:21:40 +03:00
|
|
|
}
|
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;
|
2006-01-18 19:51:35 +03:00
|
|
|
assert( !sqlite3MallocFailed() );
|
2006-01-17 16:21:40 +03:00
|
|
|
rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);
|
|
|
|
|
2006-01-18 18:25:17 +03:00
|
|
|
return sqlite3ApiExit(db, 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;
|
2006-01-18 19:51:35 +03:00
|
|
|
assert( !sqlite3MallocFailed() );
|
2004-06-18 08:24:54 +04:00
|
|
|
|
2005-12-15 06:04:10 +03:00
|
|
|
zFunc8 = sqlite3utf16to8(zFunctionName, -1);
|
2006-01-17 16:21:40 +03:00
|
|
|
rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);
|
2005-12-15 06:04:10 +03:00
|
|
|
sqliteFree(zFunc8);
|
2006-01-17 16:21:40 +03:00
|
|
|
|
2006-01-18 18:25:17 +03:00
|
|
|
return sqlite3ApiExit(db, 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);
|
|
|
|
if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){
|
|
|
|
sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,
|
|
|
|
0, sqlite3InvalidFunction, 0, 0);
|
|
|
|
}
|
|
|
|
return sqlite3ApiExit(db, SQLITE_OK);
|
|
|
|
}
|
|
|
|
|
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){
|
2003-01-16 19:28:53 +03:00
|
|
|
void *pOld = db->pTraceArg;
|
|
|
|
db->xTrace = xTrace;
|
|
|
|
db->pTraceArg = pArg;
|
|
|
|
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
|
|
|
|
){
|
|
|
|
void *pOld = db->pProfileArg;
|
|
|
|
db->xProfile = xProfile;
|
|
|
|
db->pProfileArg = pArg;
|
|
|
|
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 */
|
|
|
|
){
|
|
|
|
void *pOld = db->pCommitArg;
|
|
|
|
db->xCommitCallback = xCallback;
|
|
|
|
db->pCommitArg = pArg;
|
|
|
|
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 */
|
|
|
|
){
|
2005-12-16 09:54:01 +03:00
|
|
|
void *pRet = db->pUpdateArg;
|
2005-12-15 18:22:08 +03:00
|
|
|
db->xUpdateCallback = xCallback;
|
|
|
|
db->pUpdateArg = pArg;
|
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 */
|
|
|
|
){
|
|
|
|
void *pRet = db->pRollbackArg;
|
|
|
|
db->xRollbackCallback = xCallback;
|
|
|
|
db->pRollbackArg = pArg;
|
|
|
|
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 */
|
2004-05-08 12:23:19 +04:00
|
|
|
Btree **ppBtree /* Pointer to new Btree object written here */
|
|
|
|
){
|
|
|
|
int btree_flags = 0;
|
2004-07-22 05:19:35 +04:00
|
|
|
int rc;
|
2004-05-08 12:23:19 +04:00
|
|
|
|
2004-05-08 14:11:36 +04:00
|
|
|
assert( ppBtree != 0);
|
2004-05-08 12:23:19 +04:00
|
|
|
if( omitJournal ){
|
|
|
|
btree_flags |= BTREE_OMIT_JOURNAL;
|
|
|
|
}
|
2005-02-06 05:45:41 +03:00
|
|
|
if( db->flags & SQLITE_NoReadlock ){
|
|
|
|
btree_flags |= BTREE_NO_READLOCK;
|
|
|
|
}
|
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
|
|
|
|
2006-01-05 14:34:32 +03:00
|
|
|
rc = sqlite3BtreeOpen(zFilename, (sqlite3 *)db, ppBtree, btree_flags);
|
2004-07-22 05:19:35 +04:00
|
|
|
if( rc==SQLITE_OK ){
|
|
|
|
sqlite3BtreeSetBusyHandler(*ppBtree, (void*)&db->busyHandler);
|
|
|
|
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;
|
2006-01-18 19:51:35 +03:00
|
|
|
if( !db || sqlite3MallocFailed() ){
|
2004-06-01 03:56:42 +04:00
|
|
|
return sqlite3ErrStr(SQLITE_NOMEM);
|
2004-05-21 05:47:26 +04:00
|
|
|
}
|
2004-09-30 17:43:13 +04:00
|
|
|
if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){
|
2004-06-26 13:50:11 +04:00
|
|
|
return sqlite3ErrStr(SQLITE_MISUSE);
|
|
|
|
}
|
2005-12-09 23:02:05 +03:00
|
|
|
z = (char*)sqlite3_value_text(db->pErr);
|
2004-09-30 17:43:13 +04:00
|
|
|
if( z==0 ){
|
|
|
|
z = sqlite3ErrStr(db->errCode);
|
2004-05-20 15:00:52 +04:00
|
|
|
}
|
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;
|
2006-01-18 19:51:35 +03:00
|
|
|
if( sqlite3MallocFailed() ){
|
2004-09-30 17:43:13 +04:00
|
|
|
return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
|
|
|
|
}
|
|
|
|
if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){
|
|
|
|
return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]);
|
|
|
|
}
|
|
|
|
z = sqlite3_value_text16(db->pErr);
|
|
|
|
if( z==0 ){
|
|
|
|
sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode),
|
|
|
|
SQLITE_UTF8, SQLITE_STATIC);
|
|
|
|
z = sqlite3_value_text16(db->pErr);
|
|
|
|
}
|
2006-01-18 18:25:17 +03:00
|
|
|
sqlite3ApiExit(0, 0);
|
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){
|
2006-01-18 19:51:35 +03:00
|
|
|
if( !db || sqlite3MallocFailed() ){
|
2004-09-30 17:43:13 +04:00
|
|
|
return SQLITE_NOMEM;
|
|
|
|
}
|
|
|
|
if( sqlite3SafetyCheck(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
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,
|
|
|
|
int(*xCompare)(void*,int,const void*,int,const void*)
|
|
|
|
){
|
|
|
|
CollSeq *pColl;
|
2006-02-16 21:16:36 +03:00
|
|
|
int enc2;
|
2006-01-18 07:26:07 +03:00
|
|
|
|
|
|
|
if( sqlite3SafetyCheck(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
}
|
|
|
|
|
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;
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
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 */
|
2004-06-07 11:52:17 +04:00
|
|
|
sqlite3 **ppDb /* OUT: Returned database handle */
|
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
|
|
|
|
2006-01-18 19:51:35 +03:00
|
|
|
assert( !sqlite3MallocFailed() );
|
2005-12-12 09:53:03 +03:00
|
|
|
|
2004-05-21 05:47:26 +04:00
|
|
|
/* Allocate the sqlite data structure */
|
2004-09-06 21:24:11 +04:00
|
|
|
db = sqliteMalloc( sizeof(sqlite3) );
|
2004-05-21 05:47:26 +04:00
|
|
|
if( db==0 ) goto opendb_out;
|
2006-09-15 11:28:50 +04:00
|
|
|
db->errMask = 0xff;
|
2004-05-21 05:47:26 +04:00
|
|
|
db->priorNewRowid = 0;
|
|
|
|
db->magic = SQLITE_MAGIC_BUSY;
|
|
|
|
db->nDb = 2;
|
|
|
|
db->aDb = db->aDbStatic;
|
2004-05-31 12:26:49 +04:00
|
|
|
db->autoCommit = 1;
|
2006-07-11 18:17:51 +04:00
|
|
|
db->flags |= SQLITE_ShortColNames
|
|
|
|
#if SQLITE_DEFAULT_FILE_FORMAT<4
|
|
|
|
| SQLITE_LegacyFileFmt
|
|
|
|
#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
|
|
|
|
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.
|
|
|
|
*/
|
2006-02-01 16:50:41 +03:00
|
|
|
if( createCollation(db, "BINARY", SQLITE_UTF8, 0, binCollFunc) ||
|
|
|
|
createCollation(db, "BINARY", SQLITE_UTF16BE, 0, binCollFunc) ||
|
|
|
|
createCollation(db, "BINARY", SQLITE_UTF16LE, 0, binCollFunc) ||
|
2006-01-09 19:12:04 +03:00
|
|
|
(db->pDfltColl = sqlite3FindCollSeq(db, SQLITE_UTF8, "BINARY", 6, 0))==0
|
2005-12-12 09:53:03 +03:00
|
|
|
){
|
2006-01-18 19:51:35 +03:00
|
|
|
assert( sqlite3MallocFailed() );
|
2004-06-09 13:55:16 +04:00
|
|
|
db->magic = SQLITE_MAGIC_CLOSED;
|
|
|
|
goto opendb_out;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Also add a UTF-8 case-insensitive collation sequence. */
|
2006-01-18 07:26:07 +03:00
|
|
|
createCollation(db, "NOCASE", SQLITE_UTF8, 0, nocaseCollatingFunc);
|
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 */
|
|
|
|
rc = sqlite3BtreeFactory(db, zFilename, 0, MAX_PAGES, &db->aDb[0].pBt);
|
|
|
|
if( rc!=SQLITE_OK ){
|
|
|
|
sqlite3Error(db, rc, 0);
|
|
|
|
db->magic = SQLITE_MAGIC_CLOSED;
|
|
|
|
goto opendb_out;
|
|
|
|
}
|
2006-01-05 14:34:32 +03:00
|
|
|
db->aDb[0].pSchema = sqlite3SchemaGet(db->aDb[0].pBt);
|
|
|
|
db->aDb[1].pSchema = sqlite3SchemaGet(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
|
|
|
|
|
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.
|
|
|
|
*/
|
2006-01-18 19:51:35 +03:00
|
|
|
if( !sqlite3MallocFailed() ){
|
2006-01-17 16:21:40 +03:00
|
|
|
sqlite3Error(db, SQLITE_OK, 0);
|
2006-09-17 01:45:14 +04:00
|
|
|
sqlite3RegisterBuiltinFunctions(db);
|
2006-01-17 16:21:40 +03:00
|
|
|
}
|
2005-01-12 15:44:03 +03:00
|
|
|
db->magic = SQLITE_MAGIC_OPEN;
|
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);
|
2006-08-24 00:07:20 +04:00
|
|
|
|
2006-09-02 17:58:06 +04:00
|
|
|
#ifdef SQLITE_ENABLE_FTS1
|
|
|
|
{
|
|
|
|
extern int sqlite3Fts1Init(sqlite3*);
|
|
|
|
sqlite3Fts1Init(db);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2006-10-20 00:27:58 +04:00
|
|
|
#ifdef SQLITE_ENABLE_FTS2
|
|
|
|
{
|
|
|
|
extern int sqlite3Fts2Init(sqlite3*);
|
|
|
|
sqlite3Fts2Init(db);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2004-05-21 05:47:26 +04:00
|
|
|
opendb_out:
|
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
|
|
|
){
|
2004-06-07 11:52:17 +04:00
|
|
|
return openDatabase(zFilename, ppDb);
|
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 */
|
2006-01-18 18:25:17 +03:00
|
|
|
int rc = SQLITE_OK;
|
2004-06-18 08:24:54 +04:00
|
|
|
sqlite3_value *pVal;
|
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;
|
|
|
|
pVal = sqlite3ValueNew();
|
|
|
|
sqlite3ValueSetStr(pVal, -1, zFilename, SQLITE_UTF16NATIVE, SQLITE_STATIC);
|
|
|
|
zFilename8 = sqlite3ValueText(pVal, SQLITE_UTF8);
|
|
|
|
if( zFilename8 ){
|
|
|
|
rc = openDatabase(zFilename8, ppDb);
|
|
|
|
if( rc==SQLITE_OK && *ppDb ){
|
2005-12-06 16:19:07 +03:00
|
|
|
rc = sqlite3_exec(*ppDb, "PRAGMA encoding = 'UTF-16'", 0, 0, 0);
|
2006-01-18 08:51:57 +03:00
|
|
|
if( rc!=SQLITE_OK ){
|
|
|
|
sqlite3_close(*ppDb);
|
|
|
|
*ppDb = 0;
|
|
|
|
}
|
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-05-21 14:08:53 +04:00
|
|
|
/*
|
|
|
|
** The following routine destroys a virtual machine that is created by
|
|
|
|
** the sqlite3_compile() routine. The integer returned is an SQLITE_
|
|
|
|
** success/failure code that describes the result of executing the virtual
|
|
|
|
** machine.
|
|
|
|
**
|
|
|
|
** This routine sets the error code and string returned by
|
|
|
|
** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
|
|
|
|
*/
|
2004-05-26 06:04:57 +04:00
|
|
|
int sqlite3_finalize(sqlite3_stmt *pStmt){
|
2004-08-28 18:49:46 +04:00
|
|
|
int rc;
|
|
|
|
if( pStmt==0 ){
|
|
|
|
rc = SQLITE_OK;
|
|
|
|
}else{
|
|
|
|
rc = sqlite3VdbeFinalize((Vdbe*)pStmt);
|
|
|
|
}
|
|
|
|
return rc;
|
2004-05-21 14:08:53 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Terminate the current execution of an SQL statement and reset it
|
|
|
|
** back to its starting state so that it can be reused. A success code from
|
|
|
|
** the prior execution is returned.
|
|
|
|
**
|
|
|
|
** This routine sets the error code and string returned by
|
|
|
|
** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
|
|
|
|
*/
|
2004-05-26 06:04:57 +04:00
|
|
|
int sqlite3_reset(sqlite3_stmt *pStmt){
|
2004-08-28 18:49:46 +04:00
|
|
|
int rc;
|
|
|
|
if( pStmt==0 ){
|
|
|
|
rc = SQLITE_OK;
|
|
|
|
}else{
|
|
|
|
rc = sqlite3VdbeReset((Vdbe*)pStmt);
|
2005-09-08 01:22:45 +04:00
|
|
|
sqlite3VdbeMakeReady((Vdbe*)pStmt, -1, 0, 0, 0);
|
2006-09-15 11:28:50 +04:00
|
|
|
assert( (rc & (sqlite3_db_handle(pStmt)->errMask))==rc );
|
2004-08-28 18:49:46 +04:00
|
|
|
}
|
2004-05-21 14:08:53 +04:00
|
|
|
return rc;
|
|
|
|
}
|
2004-06-09 13:55:16 +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;
|
2006-01-18 19:51:35 +03:00
|
|
|
assert( !sqlite3MallocFailed() );
|
2006-01-18 07:26:07 +03:00
|
|
|
rc = createCollation(db, zName, enc, pCtx, xCompare);
|
2006-01-18 18:25:17 +03:00
|
|
|
return sqlite3ApiExit(db, 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;
|
|
|
|
char *zName8;
|
2006-01-18 19:51:35 +03:00
|
|
|
assert( !sqlite3MallocFailed() );
|
2005-12-15 06:04:10 +03:00
|
|
|
zName8 = sqlite3utf16to8(zName, -1);
|
2006-01-18 07:26:07 +03:00
|
|
|
if( zName8 ){
|
|
|
|
rc = createCollation(db, zName8, enc, pCtx, xCompare);
|
|
|
|
sqliteFree(zName8);
|
|
|
|
}
|
2006-01-18 18:25:17 +03:00
|
|
|
return sqlite3ApiExit(db, 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*)
|
|
|
|
){
|
2004-09-30 17:43:13 +04:00
|
|
|
if( sqlite3SafetyCheck(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
2004-06-10 14:50:08 +04:00
|
|
|
db->xCollNeeded = xCollNeeded;
|
|
|
|
db->xCollNeeded16 = 0;
|
|
|
|
db->pCollNeededArg = pCollNeededArg;
|
|
|
|
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*)
|
|
|
|
){
|
2004-09-30 17:43:13 +04:00
|
|
|
if( sqlite3SafetyCheck(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
2004-06-10 14:50:08 +04:00
|
|
|
db->xCollNeeded = 0;
|
|
|
|
db->xCollNeeded16 = xCollNeeded16;
|
|
|
|
db->pCollNeededArg = pCollNeededArg;
|
|
|
|
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
|
|
|
*/
|
|
|
|
int sqlite3_global_recover(){
|
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
|
|
|
|
|
|
|
|
|
|
|
#ifndef SQLITE_OMIT_SHARED_CACHE
|
|
|
|
/*
|
|
|
|
** Enable or disable the shared pager and schema features for the
|
|
|
|
** current thread.
|
|
|
|
**
|
|
|
|
** This routine should only be called when there are no open
|
|
|
|
** database connections.
|
|
|
|
*/
|
|
|
|
int sqlite3_enable_shared_cache(int enable){
|
|
|
|
ThreadData *pTd = sqlite3ThreadData();
|
2006-01-24 16:09:33 +03:00
|
|
|
if( pTd ){
|
|
|
|
/* It is only legal to call sqlite3_enable_shared_cache() when there
|
|
|
|
** are no currently open b-trees that were opened by the calling thread.
|
|
|
|
** This condition is only easy to detect if the shared-cache were
|
|
|
|
** previously enabled (and is being disabled).
|
|
|
|
*/
|
|
|
|
if( pTd->pBtree && !enable ){
|
|
|
|
assert( pTd->useSharedData );
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
2006-01-10 16:58:48 +03:00
|
|
|
|
2006-01-24 16:09:33 +03:00
|
|
|
pTd->useSharedData = enable;
|
|
|
|
sqlite3ReleaseThreadData();
|
|
|
|
}
|
|
|
|
return sqlite3ApiExit(0, SQLITE_OK);
|
2006-01-10 16:58:48 +03:00
|
|
|
}
|
|
|
|
#endif
|
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.
|
|
|
|
*/
|
|
|
|
void sqlite3_thread_cleanup(void){
|
2006-01-19 20:42:50 +03:00
|
|
|
ThreadData *pTd = sqlite3OsThreadSpecificData(0);
|
2006-01-18 18:25:17 +03:00
|
|
|
if( pTd ){
|
|
|
|
memset(pTd, 0, sizeof(*pTd));
|
2006-01-19 20:42:50 +03:00
|
|
|
sqlite3OsThreadSpecificData(-1);
|
2006-01-18 18:25:17 +03:00
|
|
|
}
|
2006-01-12 00:41:20 +03:00
|
|
|
}
|
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 */
|
|
|
|
if( sqlite3SafetyOn(db) ){
|
|
|
|
return SQLITE_MISUSE;
|
|
|
|
}
|
|
|
|
rc = sqlite3Init(db, &zErrMsg);
|
|
|
|
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:
|
|
|
|
if( sqlite3SafetyOff(db) ){
|
|
|
|
rc = SQLITE_MISUSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
sqliteFree(zErrMsg);
|
|
|
|
return sqlite3ApiExit(db, rc);
|
|
|
|
}
|
|
|
|
#endif
|
2006-06-28 00:06:44 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Set all the parameters in the compiled SQL statement to NULL.
|
|
|
|
*/
|
|
|
|
int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
|
|
|
|
int i;
|
|
|
|
int rc = SQLITE_OK;
|
|
|
|
for(i=1; rc==SQLITE_OK && i<=sqlite3_bind_parameter_count(pStmt); i++){
|
|
|
|
rc = sqlite3_bind_null(pStmt, i);
|
|
|
|
}
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
** Sleep for a little while. Return the amount of time slept.
|
|
|
|
*/
|
|
|
|
int sqlite3_sleep(int ms){
|
|
|
|
return sqlite3OsSleep(ms);
|
|
|
|
}
|
2006-09-15 11:28:50 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
** Enable or disable the extended result codes.
|
|
|
|
*/
|
|
|
|
int sqlite3_extended_result_codes(sqlite3 *db, int onoff){
|
|
|
|
db->errMask = onoff ? 0xffffffff : 0xff;
|
|
|
|
return SQLITE_OK;
|
|
|
|
}
|