/*

** 2001 September 15

**

** The author disclaims copyright to this source code. In place of

** a legal notice, here is a blessing:

**

** 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.

**

*************************************************************************

** 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.

*/

#include "sqliteInt.h"

#ifdef SQLITE_ENABLE_FTS3

# include "fts3.h"

#endif

#ifdef SQLITE_ENABLE_RTREE

# include "rtree.h"

#endif

#ifdef SQLITE_ENABLE_ICU

# include "sqliteicu.h"

#endif

#ifdef SQLITE_ENABLE_JSON1

int sqlite3Json1Init(sqlite3*);

#endif

#ifdef SQLITE_ENABLE_STMTVTAB

int sqlite3StmtVtabInit(sqlite3*);

#endif

#ifdef SQLITE_ENABLE_FTS5

int sqlite3Fts5Init(sqlite3*);

#endif

#ifndef SQLITE_AMALGAMATION

/* IMPLEMENTATION-OF: R-46656-45156 The sqlite3_version[] string constant

** contains the text of SQLITE_VERSION macro.

*/

const char sqlite3_version[] = SQLITE_VERSION;

#endif

/* IMPLEMENTATION-OF: R-53536-42575 The sqlite3_libversion() function returns

** a pointer to the to the sqlite3_version[] string constant.

*/

const char *sqlite3_libversion(void){ return sqlite3_version; }

/* IMPLEMENTATION-OF: R-63124-39300 The sqlite3_sourceid() function returns a

** pointer to a string constant whose value is the same as the

** SQLITE_SOURCE_ID C preprocessor macro.

*/

const char *sqlite3_sourceid(void){ return SQLITE_SOURCE_ID; }

/* IMPLEMENTATION-OF: R-35210-63508 The sqlite3_libversion_number() function

** returns an integer equal to SQLITE_VERSION_NUMBER.

*/

int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }

/* IMPLEMENTATION-OF: R-20790-14025 The sqlite3_threadsafe() function returns

** zero if and only if SQLite was compiled with mutexing code omitted due to

** the SQLITE_THREADSAFE compile-time option being set to 0.

*/

int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }

/*

** When compiling the test fixture or with debugging enabled (on Win32),

** this variable being set to non-zero will cause OSTRACE macros to emit

** extra diagnostic information.

*/

#ifdef SQLITE_HAVE_OS_TRACE

# ifndef SQLITE_DEBUG_OS_TRACE

# define SQLITE_DEBUG_OS_TRACE 0

# endif

int sqlite3OSTrace = SQLITE_DEBUG_OS_TRACE;

#endif

#if !defined(SQLITE_OMIT_TRACE) && defined(SQLITE_ENABLE_IOTRACE)

/*

** 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.

*/

SQLITE_API void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...) = 0;

#endif

/*

** 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;

/*

** If the following global variable points to a string which is the

** name of a directory, then that directory will be used to store

** all database files specified with a relative pathname.

**

** See also the "PRAGMA data_store_directory" SQL command.

*/

char *sqlite3_data_directory = 0;

/*

** Initialize SQLite.

**

** This routine must be called to initialize the memory allocation,

** VFS, and mutex subsystems prior to doing any serious work with

** SQLite. But as long as you do not compile with SQLITE_OMIT_AUTOINIT

** this routine will be called automatically by key routines such as

** sqlite3_open().

**

** This routine is a no-op except on its very first call for the process,

** or for the first call after a call to sqlite3_shutdown.

**

** The first thread to call this routine runs the initialization to

** completion. If subsequent threads call this routine before the first

** thread has finished the initialization process, then the subsequent

** threads must block until the first thread finishes with the initialization.

**

** The first thread might call this routine recursively. Recursive

** calls to this routine should not block, of course. Otherwise the

** initialization process would never complete.

**

** Let X be the first thread to enter this routine. Let Y be some other

** thread. Then while the initial invocation of this routine by X is

** incomplete, it is required that:

**

** * Calls to this routine from Y must block until the outer-most

** call by X completes.

**

** * Recursive calls to this routine from thread X return immediately

** without blocking.

*/

int sqlite3_initialize(void){

MUTEX_LOGIC( sqlite3_mutex *pMaster; ) /* The main static mutex */

int rc; /* Result code */

#ifdef SQLITE_EXTRA_INIT

int bRunExtraInit = 0; /* Extra initialization needed */

#endif

#ifdef SQLITE_OMIT_WSD

rc = sqlite3_wsd_init(4096, 24);

if( rc!=SQLITE_OK ){

return rc;

}

#endif

/* If the following assert() fails on some obscure processor/compiler

** combination, the work-around is to set the correct pointer

** size at compile-time using -DSQLITE_PTRSIZE=n compile-time option */

assert( SQLITE_PTRSIZE==sizeof(char*) );

/* If SQLite is already completely initialized, then this call

** to sqlite3_initialize() should be a no-op. But the initialization

** must be complete. So isInit must not be set until the very end

** of this routine.

*/

if( sqlite3GlobalConfig.isInit ) return SQLITE_OK;

/* Make sure the mutex subsystem is initialized. If unable to

** initialize the mutex subsystem, return early with the error.

** If the system is so sick that we are unable to allocate a mutex,

** there is not much SQLite is going to be able to do.

**

** The mutex subsystem must take care of serializing its own

** initialization.

*/

rc = sqlite3MutexInit();

if( rc ) return rc;

/* Initialize the malloc() system and the recursive pInitMutex mutex.

** This operation is protected by the STATIC_MASTER mutex. Note that

** MutexAlloc() is called for a static mutex prior to initializing the

** malloc subsystem - this implies that the allocation of a static

** mutex must not require support from the malloc subsystem.

*/

MUTEX_LOGIC( pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER); )

sqlite3_mutex_enter(pMaster);

sqlite3GlobalConfig.isMutexInit = 1;

if( !sqlite3GlobalConfig.isMallocInit ){

rc = sqlite3MallocInit();

}

if( rc==SQLITE_OK ){

sqlite3GlobalConfig.isMallocInit = 1;

if( !sqlite3GlobalConfig.pInitMutex ){

sqlite3GlobalConfig.pInitMutex =

sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);

if( sqlite3GlobalConfig.bCoreMutex && !sqlite3GlobalConfig.pInitMutex ){

rc = SQLITE_NOMEM_BKPT;

}

}

}

if( rc==SQLITE_OK ){

sqlite3GlobalConfig.nRefInitMutex++;

}

sqlite3_mutex_leave(pMaster);

/* If rc is not SQLITE_OK at this point, then either the malloc

** subsystem could not be initialized or the system failed to allocate

** the pInitMutex mutex. Return an error in either case. */

if( rc!=SQLITE_OK ){

return rc;

}

/* Do the rest of the initialization under the recursive mutex so

** that we will be able to handle recursive calls into

** sqlite3_initialize(). The recursive calls normally come through

** sqlite3_os_init() when it invokes sqlite3_vfs_register(), but other

** recursive calls might also be possible.

**

** IMPLEMENTATION-OF: R-00140-37445 SQLite automatically serializes calls

** to the xInit method, so the xInit method need not be threadsafe.

**

** The following mutex is what serializes access to the appdef pcache xInit

** methods. The sqlite3_pcache_methods.xInit() all is embedded in the

** call to sqlite3PcacheInitialize().

*/

sqlite3_mutex_enter(sqlite3GlobalConfig.pInitMutex);

if( sqlite3GlobalConfig.isInit==0 && sqlite3GlobalConfig.inProgress==0 ){

sqlite3GlobalConfig.inProgress = 1;

#ifdef SQLITE_ENABLE_SQLLOG

{

extern void sqlite3_init_sqllog(void);

sqlite3_init_sqllog();

}

#endif

memset(&sqlite3BuiltinFunctions, 0, sizeof(sqlite3BuiltinFunctions));

sqlite3RegisterBuiltinFunctions();

if( sqlite3GlobalConfig.isPCacheInit==0 ){

rc = sqlite3PcacheInitialize();

}

if( rc==SQLITE_OK ){

sqlite3GlobalConfig.isPCacheInit = 1;

rc = sqlite3OsInit();

}

if( rc==SQLITE_OK ){

sqlite3PCacheBufferSetup( sqlite3GlobalConfig.pPage,

sqlite3GlobalConfig.szPage, sqlite3GlobalConfig.nPage);

sqlite3GlobalConfig.isInit = 1;

#ifdef SQLITE_EXTRA_INIT

bRunExtraInit = 1;

#endif

}

sqlite3GlobalConfig.inProgress = 0;

}

sqlite3_mutex_leave(sqlite3GlobalConfig.pInitMutex);

/* Go back under the static mutex and clean up the recursive

** mutex to prevent a resource leak.

*/

sqlite3_mutex_enter(pMaster);

sqlite3GlobalConfig.nRefInitMutex--;

if( sqlite3GlobalConfig.nRefInitMutex<=0 ){

assert( sqlite3GlobalConfig.nRefInitMutex==0 );

sqlite3_mutex_free(sqlite3GlobalConfig.pInitMutex);

sqlite3GlobalConfig.pInitMutex = 0;

}

sqlite3_mutex_leave(pMaster);

/* The following is just a sanity check to make sure SQLite has

** been compiled correctly. It is important to run this code, but

** we don't want to run it too often and soak up CPU cycles for no

** reason. So we run it once during initialization.

*/

#ifndef NDEBUG

#ifndef SQLITE_OMIT_FLOATING_POINT

/* This section of code's only "output" is via assert() statements. */

if ( rc==SQLITE_OK ){

u64 x = (((u64)1)<<63)-1;

double y;

assert(sizeof(x)==8);

assert(sizeof(x)==sizeof(y));

memcpy(&y, &x, 8);

assert( sqlite3IsNaN(y) );

}

#endif

#endif

/* Do extra initialization steps requested by the SQLITE_EXTRA_INIT

** compile-time option.

*/

#ifdef SQLITE_EXTRA_INIT

if( bRunExtraInit ){

int SQLITE_EXTRA_INIT(const char*);

rc = SQLITE_EXTRA_INIT(0);

}

#endif

return rc;

}

/*

** Undo the effects of sqlite3_initialize(). Must not be called while

** there are outstanding database connections or memory allocations or

** while any part of SQLite is otherwise in use in any thread. This

** routine is not threadsafe. But it is safe to invoke this routine

** on when SQLite is already shut down. If SQLite is already shut down

** when this routine is invoked, then this routine is a harmless no-op.

*/

int sqlite3_shutdown(void){

#ifdef SQLITE_OMIT_WSD

int rc = sqlite3_wsd_init(4096, 24);

if( rc!=SQLITE_OK ){

return rc;

}

#endif

if( sqlite3GlobalConfig.isInit ){

#ifdef SQLITE_EXTRA_SHUTDOWN

void SQLITE_EXTRA_SHUTDOWN(void);

SQLITE_EXTRA_SHUTDOWN();

#endif

sqlite3_os_end();

sqlite3_reset_auto_extension();

sqlite3GlobalConfig.isInit = 0;

}

if( sqlite3GlobalConfig.isPCacheInit ){

sqlite3PcacheShutdown();

sqlite3GlobalConfig.isPCacheInit = 0;

}

if( sqlite3GlobalConfig.isMallocInit ){

sqlite3MallocEnd();

sqlite3GlobalConfig.isMallocInit = 0;

#ifndef SQLITE_OMIT_SHUTDOWN_DIRECTORIES

/* The heap subsystem has now been shutdown and these values are supposed

** to be NULL or point to memory that was obtained from sqlite3_malloc(),

** which would rely on that heap subsystem; therefore, make sure these

** values cannot refer to heap memory that was just invalidated when the

** heap subsystem was shutdown. This is only done if the current call to

** this function resulted in the heap subsystem actually being shutdown.

*/

sqlite3_data_directory = 0;

sqlite3_temp_directory = 0;

#endif

}

if( sqlite3GlobalConfig.isMutexInit ){

sqlite3MutexEnd();

sqlite3GlobalConfig.isMutexInit = 0;

}

return SQLITE_OK;

}

/*

** This API allows applications to modify the global configuration of

** the SQLite library at run-time.

**

** This routine should only be called when there are no outstanding

** database connections or memory allocations. This routine is not

** threadsafe. Failure to heed these warnings can lead to unpredictable

** behavior.

*/

int sqlite3_config(int op, ...){

va_list ap;

int rc = SQLITE_OK;

/* sqlite3_config() shall return SQLITE_MISUSE if it is invoked while

** the SQLite library is in use. */

if( sqlite3GlobalConfig.isInit ) return SQLITE_MISUSE_BKPT;

va_start(ap, op);

switch( op ){

/* Mutex configuration options are only available in a threadsafe

** compile.

*/

#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-54466-46756 */

case SQLITE_CONFIG_SINGLETHREAD: {

/* EVIDENCE-OF: R-02748-19096 This option sets the threading mode to

** Single-thread. */

sqlite3GlobalConfig.bCoreMutex = 0; /* Disable mutex on core */

sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */

break;

}

#endif

#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-20520-54086 */

case SQLITE_CONFIG_MULTITHREAD: {

/* EVIDENCE-OF: R-14374-42468 This option sets the threading mode to

** Multi-thread. */

sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */

sqlite3GlobalConfig.bFullMutex = 0; /* Disable mutex on connections */

break;

}

#endif

#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-59593-21810 */

case SQLITE_CONFIG_SERIALIZED: {

/* EVIDENCE-OF: R-41220-51800 This option sets the threading mode to

** Serialized. */

sqlite3GlobalConfig.bCoreMutex = 1; /* Enable mutex on core */

sqlite3GlobalConfig.bFullMutex = 1; /* Enable mutex on connections */

break;

}

#endif

#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-63666-48755 */

case SQLITE_CONFIG_MUTEX: {

/* Specify an alternative mutex implementation */

sqlite3GlobalConfig.mutex = *va_arg(ap, sqlite3_mutex_methods*);

break;

}

#endif

#if defined(SQLITE_THREADSAFE) && SQLITE_THREADSAFE>0 /* IMP: R-14450-37597 */

case SQLITE_CONFIG_GETMUTEX: {

/* Retrieve the current mutex implementation */

*va_arg(ap, sqlite3_mutex_methods*) = sqlite3GlobalConfig.mutex;

break;

}

#endif

case SQLITE_CONFIG_MALLOC: {

/* EVIDENCE-OF: R-55594-21030 The SQLITE_CONFIG_MALLOC option takes a

** single argument which is a pointer to an instance of the

** sqlite3_mem_methods structure. The argument specifies alternative

** low-level memory allocation routines to be used in place of the memory

** allocation routines built into SQLite. */

sqlite3GlobalConfig.m = *va_arg(ap, sqlite3_mem_methods*);

break;

}

case SQLITE_CONFIG_GETMALLOC: {

/* EVIDENCE-OF: R-51213-46414 The SQLITE_CONFIG_GETMALLOC option takes a

** single argument which is a pointer to an instance of the

** sqlite3_mem_methods structure. The sqlite3_mem_methods structure is

** filled with the currently defined memory allocation routines. */

if( sqlite3GlobalConfig.m.xMalloc==0 ) sqlite3MemSetDefault();

*va_arg(ap, sqlite3_mem_methods*) = sqlite3GlobalConfig.m;

break;

}

case SQLITE_CONFIG_MEMSTATUS: {

/* EVIDENCE-OF: R-61275-35157 The SQLITE_CONFIG_MEMSTATUS option takes

** single argument of type int, interpreted as a boolean, which enables

** or disables the collection of memory allocation statistics. */

sqlite3GlobalConfig.bMemstat = va_arg(ap, int);

break;

}

case SQLITE_CONFIG_SCRATCH: {

/* EVIDENCE-OF: R-08404-60887 There are three arguments to

** SQLITE_CONFIG_SCRATCH: A pointer an 8-byte aligned memory buffer from

** which the scratch allocations will be drawn, the size of each scratch

** allocation (sz), and the maximum number of scratch allocations (N). */

sqlite3GlobalConfig.pScratch = va_arg(ap, void*);

sqlite3GlobalConfig.szScratch = va_arg(ap, int);

sqlite3GlobalConfig.nScratch = va_arg(ap, int);

break;

}

case SQLITE_CONFIG_PAGECACHE: {

/* EVIDENCE-OF: R-18761-36601 There are three arguments to

** SQLITE_CONFIG_PAGECACHE: A pointer to 8-byte aligned memory (pMem),

** the size of each page cache line (sz), and the number of cache lines

** (N). */

sqlite3GlobalConfig.pPage = va_arg(ap, void*);

sqlite3GlobalConfig.szPage = va_arg(ap, int);

sqlite3GlobalConfig.nPage = va_arg(ap, int);

break;

}

case SQLITE_CONFIG_PCACHE_HDRSZ: {

/* EVIDENCE-OF: R-39100-27317 The SQLITE_CONFIG_PCACHE_HDRSZ option takes

** a single parameter which is a pointer to an integer and writes into

** that integer the number of extra bytes per page required for each page

** in SQLITE_CONFIG_PAGECACHE. */

*va_arg(ap, int*) =

sqlite3HeaderSizeBtree() +

sqlite3HeaderSizePcache() +

sqlite3HeaderSizePcache1();

break;

}

case SQLITE_CONFIG_PCACHE: {

/* no-op */

break;

}

case SQLITE_CONFIG_GETPCACHE: {

/* now an error */

rc = SQLITE_ERROR;

break;

}

case SQLITE_CONFIG_PCACHE2: {

/* EVIDENCE-OF: R-63325-48378 The SQLITE_CONFIG_PCACHE2 option takes a

** single argument which is a pointer to an sqlite3_pcache_methods2

** object. This object specifies the interface to a custom page cache

** implementation. */

sqlite3GlobalConfig.pcache2 = *va_arg(ap, sqlite3_pcache_methods2*);

break;

}

case SQLITE_CONFIG_GETPCACHE2: {

/* EVIDENCE-OF: R-22035-46182 The SQLITE_CONFIG_GETPCACHE2 option takes a

** single argument which is a pointer to an sqlite3_pcache_methods2

** object. SQLite copies of the current page cache implementation into

** that object. */

if( sqlite3GlobalConfig.pcache2.xInit==0 ){

sqlite3PCacheSetDefault();

}

*va_arg(ap, sqlite3_pcache_methods2*) = sqlite3GlobalConfig.pcache2;

break;

}

/* EVIDENCE-OF: R-06626-12911 The SQLITE_CONFIG_HEAP option is only

** available if SQLite is compiled with either SQLITE_ENABLE_MEMSYS3 or

** SQLITE_ENABLE_MEMSYS5 and returns SQLITE_ERROR if invoked otherwise. */

#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)

case SQLITE_CONFIG_HEAP: {

/* EVIDENCE-OF: R-19854-42126 There are three arguments to

** SQLITE_CONFIG_HEAP: An 8-byte aligned pointer to the memory, the

** number of bytes in the memory buffer, and the minimum allocation size.

*/

sqlite3GlobalConfig.pHeap = va_arg(ap, void*);

sqlite3GlobalConfig.nHeap = va_arg(ap, int);

sqlite3GlobalConfig.mnReq = va_arg(ap, int);

if( sqlite3GlobalConfig.mnReq<1 ){

sqlite3GlobalConfig.mnReq = 1;

}else if( sqlite3GlobalConfig.mnReq>(1<<12) ){

/* cap min request size at 2^12 */

sqlite3GlobalConfig.mnReq = (1<<12);

}

if( sqlite3GlobalConfig.pHeap==0 ){

/* EVIDENCE-OF: R-49920-60189 If the first pointer (the memory pointer)

** is NULL, then SQLite reverts to using its default memory allocator

** (the system malloc() implementation), undoing any prior invocation of

** SQLITE_CONFIG_MALLOC.

**

** Setting sqlite3GlobalConfig.m to all zeros will cause malloc to

** revert to its default implementation when sqlite3_initialize() is run

*/

memset(&sqlite3GlobalConfig.m, 0, sizeof(sqlite3GlobalConfig.m));

}else{

/* EVIDENCE-OF: R-61006-08918 If the memory pointer is not NULL then the

** alternative memory allocator is engaged to handle all of SQLites

** memory allocation needs. */

#ifdef SQLITE_ENABLE_MEMSYS3

sqlite3GlobalConfig.m = *sqlite3MemGetMemsys3();

#endif

#ifdef SQLITE_ENABLE_MEMSYS5

sqlite3GlobalConfig.m = *sqlite3MemGetMemsys5();

#endif

}

break;

}

#endif

case SQLITE_CONFIG_LOOKASIDE: {

sqlite3GlobalConfig.szLookaside = va_arg(ap, int);

sqlite3GlobalConfig.nLookaside = va_arg(ap, int);

break;

}

/* Record a pointer to the logger function and its first argument.

** The default is NULL. Logging is disabled if the function pointer is

** NULL.

*/

case SQLITE_CONFIG_LOG: {

/* MSVC is picky about pulling func ptrs from va lists.

** http://support.microsoft.com/kb/47961

** sqlite3GlobalConfig.xLog = va_arg(ap, void(*)(void*,int,const char*));

*/

typedef void(*LOGFUNC_t)(void*,int,const char*);

sqlite3GlobalConfig.xLog = va_arg(ap, LOGFUNC_t);

sqlite3GlobalConfig.pLogArg = va_arg(ap, void*);

break;

}

/* EVIDENCE-OF: R-55548-33817 The compile-time setting for URI filenames

** can be changed at start-time using the

** sqlite3_config(SQLITE_CONFIG_URI,1) or

** sqlite3_config(SQLITE_CONFIG_URI,0) configuration calls.

*/

case SQLITE_CONFIG_URI: {

/* EVIDENCE-OF: R-25451-61125 The SQLITE_CONFIG_URI option takes a single

** argument of type int. If non-zero, then URI handling is globally

** enabled. If the parameter is zero, then URI handling is globally

** disabled. */

sqlite3GlobalConfig.bOpenUri = va_arg(ap, int);

break;

}

case SQLITE_CONFIG_COVERING_INDEX_SCAN: {

/* EVIDENCE-OF: R-36592-02772 The SQLITE_CONFIG_COVERING_INDEX_SCAN

** option takes a single integer argument which is interpreted as a

** boolean in order to enable or disable the use of covering indices for

** full table scans in the query optimizer. */

sqlite3GlobalConfig.bUseCis = va_arg(ap, int);

break;

}

#ifdef SQLITE_ENABLE_SQLLOG

case SQLITE_CONFIG_SQLLOG: {

typedef void(*SQLLOGFUNC_t)(void*, sqlite3*, const char*, int);

sqlite3GlobalConfig.xSqllog = va_arg(ap, SQLLOGFUNC_t);

sqlite3GlobalConfig.pSqllogArg = va_arg(ap, void *);

break;

}

#endif

case SQLITE_CONFIG_MMAP_SIZE: {

/* EVIDENCE-OF: R-58063-38258 SQLITE_CONFIG_MMAP_SIZE takes two 64-bit

** integer (sqlite3_int64) values that are the default mmap size limit

** (the default setting for PRAGMA mmap_size) and the maximum allowed

** mmap size limit. */

sqlite3_int64 szMmap = va_arg(ap, sqlite3_int64);

sqlite3_int64 mxMmap = va_arg(ap, sqlite3_int64);

/* EVIDENCE-OF: R-53367-43190 If either argument to this option is

** negative, then that argument is changed to its compile-time default.

**

** EVIDENCE-OF: R-34993-45031 The maximum allowed mmap size will be

** silently truncated if necessary so that it does not exceed the

** compile-time maximum mmap size set by the SQLITE_MAX_MMAP_SIZE

** compile-time option.

*/

if( mxMmap<0 || mxMmap>SQLITE_MAX_MMAP_SIZE ){

mxMmap = SQLITE_MAX_MMAP_SIZE;

}

if( szMmap<0 ) szMmap = SQLITE_DEFAULT_MMAP_SIZE;

if( szMmap>mxMmap) szMmap = mxMmap;

sqlite3GlobalConfig.mxMmap = mxMmap;

sqlite3GlobalConfig.szMmap = szMmap;

break;

}

#if SQLITE_OS_WIN && defined(SQLITE_WIN32_MALLOC) /* IMP: R-04780-55815 */

case SQLITE_CONFIG_WIN32_HEAPSIZE: {

/* EVIDENCE-OF: R-34926-03360 SQLITE_CONFIG_WIN32_HEAPSIZE takes a 32-bit

** unsigned integer value that specifies the maximum size of the created

** heap. */

sqlite3GlobalConfig.nHeap = va_arg(ap, int);

break;

}

#endif

case SQLITE_CONFIG_PMASZ: {

sqlite3GlobalConfig.szPma = va_arg(ap, unsigned int);

break;

}

case SQLITE_CONFIG_STMTJRNL_SPILL: {

sqlite3GlobalConfig.nStmtSpill = va_arg(ap, int);

break;

}

default: {

rc = SQLITE_ERROR;

break;

}

}

va_end(ap);

return rc;

}

/*

** Set up the lookaside buffers for a database connection.

** Return SQLITE_OK on success.

** If lookaside is already active, return SQLITE_BUSY.

**

** The sz parameter is the number of bytes in each lookaside slot.

** The cnt parameter is the number of slots. If pStart is NULL the

** space for the lookaside memory is obtained from sqlite3_malloc().

** If pStart is not NULL then it is sz*cnt bytes of memory to use for

** the lookaside memory.

*/

static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){

#ifndef SQLITE_OMIT_LOOKASIDE

void *pStart;

if( db->lookaside.nOut ){

return SQLITE_BUSY;

}

/* Free any existing lookaside buffer for this handle before

** allocating a new one so we don't have to have space for

** both at the same time.

*/

if( db->lookaside.bMalloced ){

sqlite3_free(db->lookaside.pStart);

}

/* The size of a lookaside slot after ROUNDDOWN8 needs to be larger

** than a pointer to be useful.

*/

sz = ROUNDDOWN8(sz); /* IMP: R-33038-09382 */

if( sz<=(int)sizeof(LookasideSlot*) ) sz = 0;

if( cnt<0 ) cnt = 0;

if( sz==0 || cnt==0 ){

sz = 0;

pStart = 0;

}else if( pBuf==0 ){

sqlite3BeginBenignMalloc();

pStart = sqlite3Malloc( sz*cnt ); /* IMP: R-61949-35727 */

sqlite3EndBenignMalloc();

if( pStart ) cnt = sqlite3MallocSize(pStart)/sz;

}else{

pStart = pBuf;

}

db->lookaside.pStart = pStart;

db->lookaside.pFree = 0;

db->lookaside.sz = (u16)sz;

if( pStart ){

int i;

LookasideSlot *p;

assert( sz > (int)sizeof(LookasideSlot*) );

p = (LookasideSlot*)pStart;

for(i=cnt-1; i>=0; i--){

p->pNext = db->lookaside.pFree;

db->lookaside.pFree = p;

p = (LookasideSlot*)&((u8*)p)[sz];

}

db->lookaside.pEnd = p;

db->lookaside.bDisable = 0;

db->lookaside.bMalloced = pBuf==0 ?1:0;

}else{

db->lookaside.pStart = db;

db->lookaside.pEnd = db;

db->lookaside.bDisable = 1;

db->lookaside.bMalloced = 0;

}

#endif /* SQLITE_OMIT_LOOKASIDE */

return SQLITE_OK;

}

/*

** Return the mutex associated with a database connection.

*/

sqlite3_mutex *sqlite3_db_mutex(sqlite3 *db){

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) ){

(void)SQLITE_MISUSE_BKPT;

return 0;

}

#endif

return db->mutex;

}

/*

** Free up as much memory as we can from the given database

** connection.

*/

int sqlite3_db_release_memory(sqlite3 *db){

int i;

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;

#endif

sqlite3_mutex_enter(db->mutex);

sqlite3BtreeEnterAll(db);

for(i=0; i<db->nDb; i++){

Btree *pBt = db->aDb[i].pBt;

if( pBt ){

Pager *pPager = sqlite3BtreePager(pBt);

sqlite3PagerShrink(pPager);

}

}

sqlite3BtreeLeaveAll(db);

sqlite3_mutex_leave(db->mutex);

return SQLITE_OK;

}

/*

** Flush any dirty pages in the pager-cache for any attached database

** to disk.

*/

int sqlite3_db_cacheflush(sqlite3 *db){

int i;

int rc = SQLITE_OK;

int bSeenBusy = 0;

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) ) return SQLITE_MISUSE_BKPT;

#endif

sqlite3_mutex_enter(db->mutex);

sqlite3BtreeEnterAll(db);

for(i=0; rc==SQLITE_OK && i<db->nDb; i++){

Btree *pBt = db->aDb[i].pBt;

if( pBt && sqlite3BtreeIsInTrans(pBt) ){

Pager *pPager = sqlite3BtreePager(pBt);

rc = sqlite3PagerFlush(pPager);

if( rc==SQLITE_BUSY ){

bSeenBusy = 1;

rc = SQLITE_OK;

}

}

}

sqlite3BtreeLeaveAll(db);

sqlite3_mutex_leave(db->mutex);

return ((rc==SQLITE_OK && bSeenBusy) ? SQLITE_BUSY : rc);

}

/*

** Configuration settings for an individual database connection

*/

int sqlite3_db_config(sqlite3 *db, int op, ...){

va_list ap;

int rc;

va_start(ap, op);

switch( op ){

case SQLITE_DBCONFIG_MAINDBNAME: {

/* IMP: R-06824-28531 */

/* IMP: R-36257-52125 */

db->aDb[0].zDbSName = va_arg(ap,char*);

rc = SQLITE_OK;

break;

}

case SQLITE_DBCONFIG_LOOKASIDE: {

void *pBuf = va_arg(ap, void*); /* IMP: R-26835-10964 */

int sz = va_arg(ap, int); /* IMP: R-47871-25994 */

int cnt = va_arg(ap, int); /* IMP: R-04460-53386 */

rc = setupLookaside(db, pBuf, sz, cnt);

break;

}

default: {

static const struct {

int op; /* The opcode */

u32 mask; /* Mask of the bit in sqlite3.flags to set/clear */

} aFlagOp[] = {

{ SQLITE_DBCONFIG_ENABLE_FKEY, SQLITE_ForeignKeys },

{ SQLITE_DBCONFIG_ENABLE_TRIGGER, SQLITE_EnableTrigger },

{ SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER, SQLITE_Fts3Tokenizer },

{ SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION, SQLITE_LoadExtension },

{ SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE, SQLITE_NoCkptOnClose },

{ SQLITE_DBCONFIG_ENABLE_QPSG, SQLITE_EnableQPSG },

};

unsigned int i;

rc = SQLITE_ERROR; /* IMP: R-42790-23372 */

for(i=0; i<ArraySize(aFlagOp); i++){

if( aFlagOp[i].op==op ){

int onoff = va_arg(ap, int);

int *pRes = va_arg(ap, int*);

int oldFlags = db->flags;

if( onoff>0 ){

db->flags |= aFlagOp[i].mask;

}else if( onoff==0 ){

db->flags &= ~aFlagOp[i].mask;

}

if( oldFlags!=db->flags ){

sqlite3ExpirePreparedStatements(db);

}

if( pRes ){

*pRes = (db->flags & aFlagOp[i].mask)!=0;

}

rc = SQLITE_OK;

break;

}

}

break;

}

}

va_end(ap);

return rc;

}

/*

** Return true if the buffer z[0..n-1] contains all spaces.

*/

static int allSpaces(const char *z, int n){

while( n>0 && z[n-1]==' ' ){ n--; }

return n==0;

}

/*

** This is the default collating function named "BINARY" which is always

** available.

**

** If the padFlag argument is not NULL then space padding at the end

** of strings is ignored. This implements the RTRIM collation.

*/

static int binCollFunc(

void *padFlag,

int nKey1, const void *pKey1,

int nKey2, const void *pKey2

){

int rc, n;

n = nKey1<nKey2 ? nKey1 : nKey2;

/* EVIDENCE-OF: R-65033-28449 The built-in BINARY collation compares

** strings byte by byte using the memcmp() function from the standard C

** library. */

assert( pKey1 && pKey2 );

rc = memcmp(pKey1, pKey2, n);

if( rc==0 ){

if( padFlag

&& allSpaces(((char*)pKey1)+n, nKey1-n)

&& allSpaces(((char*)pKey2)+n, nKey2-n)

){

/* EVIDENCE-OF: R-31624-24737 RTRIM is like BINARY except that extra

** spaces at the end of either string do not change the result. In other

** words, strings will compare equal to one another as long as they

** differ only in the number of spaces at the end.

*/

}else{

rc = nKey1 - nKey2;

}

}

return rc;

}

/*

** Another built-in collating sequence: NOCASE.

**

** This collating sequence is intended to be used for "case independent

** 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.

*/

static int nocaseCollatingFunc(

void *NotUsed,

int nKey1, const void *pKey1,

int nKey2, const void *pKey2

){

int r = sqlite3StrNICmp(

(const char *)pKey1, (const char *)pKey2, (nKey1<nKey2)?nKey1:nKey2);

UNUSED_PARAMETER(NotUsed);

if( 0==r ){

r = nKey1-nKey2;

}

return r;

}

/*

** Return the ROWID of the most recent insert

*/

sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) ){

(void)SQLITE_MISUSE_BKPT;

return 0;

}

#endif

return db->lastRowid;

}

/*

** Set the value returned by the sqlite3_last_insert_rowid() API function.

*/

void sqlite3_set_last_insert_rowid(sqlite3 *db, sqlite3_int64 iRowid){

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) ){

(void)SQLITE_MISUSE_BKPT;

return;

}

#endif

sqlite3_mutex_enter(db->mutex);

db->lastRowid = iRowid;

sqlite3_mutex_leave(db->mutex);

}

/*

** Return the number of changes in the most recent call to sqlite3_exec().

*/

int sqlite3_changes(sqlite3 *db){

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) ){

(void)SQLITE_MISUSE_BKPT;

return 0;

}

#endif

return db->nChange;

}

/*

** Return the number of changes since the database handle was opened.

*/

int sqlite3_total_changes(sqlite3 *db){

#ifdef SQLITE_ENABLE_API_ARMOR

if( !sqlite3SafetyCheckOk(db) ){

(void)SQLITE_MISUSE_BKPT;

return 0;

}

#endif

return db->nTotalChange;

}

/*

** Close all open savepoints. This function only manipulates fields of the

** database handle object, it does not close any savepoints that may be open

** at the b-tree/pager level.

*/

void sqlite3CloseSavepoints(sqlite3 *db){

while( db->pSavepoint ){

Savepoint *pTmp = db->pSavepoint;

db->pSavepoint = pTmp->pNext;

sqlite3DbFree(db, pTmp);

}

db->nSavepoint = 0;

db->nStatement = 0;

db->isTransactionSavepoint = 0;

}

/*

** Invoke the destructor function associated with FuncDef p, if any. Except,

** if this is not the last copy of the function, do not invoke it. Multiple

** copies of a single function are created when create_function() is called

** with SQLITE_ANY as the encoding.

*/

static void functionDestroy(sqlite3 *db, FuncDef *p){

FuncDestructor *pDestructor = p->u.pDestructor;

if( pDestructor ){

pDestructor->nRef--;

if( pDestructor->nRef==0 ){

pDestructor->xDestroy(pDestructor->pUserData);

sqlite3DbFree(db, pDestructor);