/*

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

**

** $Id: main.c,v 1.486 2008/08/04 20:13:27 drh Exp $

*/

#include "sqliteInt.h"

#include <ctype.h>

#ifdef SQLITE_ENABLE_FTS3

# include "fts3.h"

#endif

#ifdef SQLITE_ENABLE_RTREE

# include "rtree.h"

#endif

/*

** The version of the library

*/

const char sqlite3_version[] = SQLITE_VERSION;

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

int sqlite3_libversion_number(void){ return SQLITE_VERSION_NUMBER; }

int sqlite3_threadsafe(void){ return SQLITE_THREADSAFE; }

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

*/

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

/*

** Initialize SQLite.  

**

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

** VFS, and mutex subsystesms 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.

*/

int sqlite3_initialize(void){

  static int inProgress = 0;

  int rc;

  /* If SQLite is already initialized, this call is a no-op. */

  if( sqlite3Config.isInit ) return SQLITE_OK;

  /* Make sure the mutex system is initialized. */

  rc = sqlite3MutexInit();

  if( rc==SQLITE_OK ){

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

    ** This operation is protected by the STATIC_MASTER mutex.

    */

    sqlite3_mutex *pMaster = sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_MASTER);

    sqlite3_mutex_enter(pMaster);

    if( !sqlite3Config.isMallocInit ){

      rc = sqlite3MallocInit();

    }

    if( rc==SQLITE_OK ){

      sqlite3Config.isMallocInit = 1;

      if( !sqlite3Config.pInitMutex ){

        sqlite3Config.pInitMutex = sqlite3MutexAlloc(SQLITE_MUTEX_RECURSIVE);

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

          rc = SQLITE_NOMEM;

        }

      }

    }

    sqlite3_mutex_leave(pMaster);

    if( rc!=SQLITE_OK ){

      return rc;

    }

    /* Enter the recursive pInitMutex mutex. After doing so, if the

    ** sqlite3Config.isInit flag is true, then some other thread has

    ** finished doing the initialization. If the inProgress flag is

    ** true, then this function is being called recursively from within

    ** the sqlite3_os_init() call below. In either case, exit early.

    */

    sqlite3_mutex_enter(sqlite3Config.pInitMutex);

    if( sqlite3Config.isInit || inProgress ){

      sqlite3_mutex_leave(sqlite3Config.pInitMutex);

      return SQLITE_OK;

    }

    sqlite3StatusReset();

    inProgress = 1;

    rc = sqlite3_os_init();

    inProgress = 0;

    sqlite3Config.isInit = (rc==SQLITE_OK ? 1 : 0);

    sqlite3_mutex_leave(sqlite3Config.pInitMutex);

  }

  /* Check NaN support. */

#ifndef NDEBUG

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

  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.  Not by a long shot.

*/

int sqlite3_shutdown(void){

  sqlite3_mutex_free(sqlite3Config.pInitMutex);

  sqlite3Config.pInitMutex = 0;

  sqlite3Config.isMallocInit = 0;

  if( sqlite3Config.isInit ){

    sqlite3_os_end();

  }

  if( sqlite3Config.m.xShutdown ){

    sqlite3MallocEnd();

  }

  if( sqlite3Config.mutex.xMutexEnd ){

    sqlite3MutexEnd();

  }

  sqlite3Config.isInit = 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( sqlite3Config.isInit ) return SQLITE_MISUSE;

  va_start(ap, op);

  switch( op ){

    case SQLITE_CONFIG_SINGLETHREAD: {

      /* Disable all mutexing */

      sqlite3Config.bCoreMutex = 0;

      sqlite3Config.bFullMutex = 0;

      break;

    }

    case SQLITE_CONFIG_MULTITHREAD: {

      /* Disable mutexing of database connections */

      /* Enable mutexing of core data structures */

      sqlite3Config.bCoreMutex = 1;

      sqlite3Config.bFullMutex = 0;

      break;

    }

    case SQLITE_CONFIG_SERIALIZED: {

      /* Enable all mutexing */

      sqlite3Config.bCoreMutex = 1;

      sqlite3Config.bFullMutex = 1;

      break;

    }

    case SQLITE_CONFIG_MALLOC: {

      /* Specify an alternative malloc implementation */

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

      break;

    }

    case SQLITE_CONFIG_GETMALLOC: {

      /* Retrieve the current malloc() implementation */

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

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

      break;

    }

    case SQLITE_CONFIG_MUTEX: {

      /* Specify an alternative mutex implementation */

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

      break;

    }

    case SQLITE_CONFIG_GETMUTEX: {

      /* Retrieve the current mutex implementation */

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

      break;

    }

    case SQLITE_CONFIG_MEMSTATUS: {

      /* Enable or disable the malloc status collection */

      sqlite3Config.bMemstat = va_arg(ap, int);

      break;

    }

    case SQLITE_CONFIG_SCRATCH: {

      /* Designate a buffer for scratch memory space */

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

      sqlite3Config.szScratch = va_arg(ap, int);

      sqlite3Config.nScratch = va_arg(ap, int);

      break;

    }

    case SQLITE_CONFIG_PAGECACHE: {

      /* Designate a buffer for scratch memory space */

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

      sqlite3Config.szPage = va_arg(ap, int);

      sqlite3Config.nPage = va_arg(ap, int);

      break;

    }

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

    case SQLITE_CONFIG_HEAP: {

      /* Designate a buffer for heap memory space */

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

      sqlite3Config.nHeap = va_arg(ap, int);

      sqlite3Config.mnReq = va_arg(ap, int);

      if( sqlite3Config.pHeap==0 ){

        /* If the heap pointer is NULL, then restore the malloc implementation

        ** back to NULL pointers too.  This will cause the malloc to go

        ** back to its default implementation when sqlite3_initialize() is

        ** run.

        */

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

      }else{

        /* The heap pointer is not NULL, then install one of the

        ** mem5.c/mem3.c methods. If neither ENABLE_MEMSYS3 nor

        ** ENABLE_MEMSYS5 is defined, return an error.

        ** the default case and return an error.

        */

#ifdef SQLITE_ENABLE_MEMSYS3

        sqlite3Config.m = *sqlite3MemGetMemsys3();

#endif

#ifdef SQLITE_ENABLE_MEMSYS5

        sqlite3Config.m = *sqlite3MemGetMemsys5();

#endif

      }

      break;

    }

#endif

#if defined(SQLITE_ENABLE_MEMSYS6)

    case SQLITE_CONFIG_CHUNKALLOC: {

      sqlite3Config.nSmall = va_arg(ap, int);

      sqlite3Config.m = *sqlite3MemGetMemsys6();

      break;

    }

#endif

    case SQLITE_CONFIG_LOOKASIDE: {

      sqlite3Config.szLookaside = va_arg(ap, int);

      sqlite3Config.nLookaside = 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){

  void *pStart;

  if( db->lookaside.nOut ){

    return SQLITE_BUSY;

  }

  if( sz<0 ) sz = 0;

  if( cnt<0 ) cnt = 0;

  sz = (sz+7)&~7;

  if( pBuf==0 ){

    sqlite3BeginBenignMalloc();

    pStart = sqlite3Malloc( sz*cnt );

    sqlite3EndBenignMalloc();

  }else{

    pStart = pBuf;

  }

  if( db->lookaside.bMalloced ){

    sqlite3_free(db->lookaside.pStart);

  }

  db->lookaside.pStart = pStart;

  db->lookaside.pFree = 0;

  db->lookaside.sz = sz;

  db->lookaside.bMalloced = pBuf==0;

  if( pStart ){

    int i;

    LookasideSlot *p;

    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.bEnabled = 1;

  }else{

    db->lookaside.pEnd = 0;

    db->lookaside.bEnabled = 0;

  }

  return SQLITE_OK;

}

/*

** 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_LOOKASIDE: {

      void *pBuf = va_arg(ap, void*);

      int sz = va_arg(ap, int);

      int cnt = va_arg(ap, int);

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

      break;

    }

    default: {

      rc = SQLITE_ERROR;

      break;

    }

  }

  va_end(ap);

  return rc;

}

/*

** Routine needed to support the testcase() macro.

*/

#ifdef SQLITE_COVERAGE_TEST

void sqlite3Coverage(int x){

  static int dummy = 0;

  dummy += x;

}

#endif

/*

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

  rc = memcmp(pKey1, pKey2, n);

  if( rc==0 ){

    if( padFlag

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

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

    ){

      /* Leave rc unchanged at 0 */

    }else{

      rc = nKey1 - nKey2;

    }

  }

  return rc;

}

/*

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

*/

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

  if( 0==r ){

    r = nKey1-nKey2;

  }

  return r;

}

/*

** Return the ROWID of the most recent insert

*/

sqlite_int64 sqlite3_last_insert_rowid(sqlite3 *db){

  return db->lastRowid;

}

/*

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

*/

int sqlite3_changes(sqlite3 *db){

  return db->nChange;

}

/*

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

*/

int sqlite3_total_changes(sqlite3 *db){

  return db->nTotalChange;

}

/*

** Close an existing SQLite database

*/

int sqlite3_close(sqlite3 *db){

  HashElem *i;

  int j;

  if( !db ){

    return SQLITE_OK;

  }

  if( !sqlite3SafetyCheckSickOrOk(db) ){

    return SQLITE_MISUSE;

  }

  sqlite3_mutex_enter(db->mutex);

#ifdef SQLITE_SSE

  {

    extern void sqlite3SseCleanup(sqlite3*);

    sqlite3SseCleanup(db);

  }

#endif 

  sqlite3ResetInternalSchema(db, 0);

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

  /* If there are any outstanding VMs, return SQLITE_BUSY. */

  if( db->pVdbe ){

    sqlite3Error(db, SQLITE_BUSY, 

        "Unable to close due to unfinalised statements");

    sqlite3_mutex_leave(db->mutex);

    return SQLITE_BUSY;

  }

  assert( sqlite3SafetyCheckSickOrOk(db) );

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

    struct Db *pDb = &db->aDb[j];

    if( pDb->pBt ){

      sqlite3BtreeClose(pDb->pBt);

      pDb->pBt = 0;

      if( j!=1 ){

        pDb->pSchema = 0;

      }

    }

  }

  sqlite3ResetInternalSchema(db, 0);

  assert( db->nDb<=2 );

  assert( db->aDb==db->aDbStatic );

  for(i=sqliteHashFirst(&db->aFunc); i; i=sqliteHashNext(i)){

    FuncDef *pFunc, *pNext;

    for(pFunc = (FuncDef*)sqliteHashData(i); pFunc; pFunc=pNext){

      pNext = pFunc->pNext;

      sqlite3DbFree(db, pFunc);

    }

  }

  for(i=sqliteHashFirst(&db->aCollSeq); i; i=sqliteHashNext(i)){

    CollSeq *pColl = (CollSeq *)sqliteHashData(i);

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

      }

    }

    sqlite3DbFree(db, pColl);

  }

  sqlite3HashClear(&db->aCollSeq);

#ifndef SQLITE_OMIT_VIRTUALTABLE

  for(i=sqliteHashFirst(&db->aModule); i; i=sqliteHashNext(i)){

    Module *pMod = (Module *)sqliteHashData(i);

    if( pMod->xDestroy ){

      pMod->xDestroy(pMod->pAux);

    }

    sqlite3DbFree(db, pMod);

  }

  sqlite3HashClear(&db->aModule);

#endif

  sqlite3HashClear(&db->aFunc);

  sqlite3Error(db, SQLITE_OK, 0); /* Deallocates any cached error strings. */

  if( db->pErr ){

    sqlite3ValueFree(db->pErr);

  }

  sqlite3CloseExtensions(db);

  db->magic = SQLITE_MAGIC_ERROR;

  /* 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?

  */

  sqlite3DbFree(db, db->aDb[1].pSchema);

  sqlite3_mutex_leave(db->mutex);

  db->magic = SQLITE_MAGIC_CLOSED;

  sqlite3_mutex_free(db->mutex);

  if( db->lookaside.bMalloced ){

    sqlite3_free(db->lookaside.pStart);

  }

  sqlite3_free(db);

  return SQLITE_OK;

}

/*

** Rollback all database files.

*/

void sqlite3RollbackAll(sqlite3 *db){

  int i;

  int inTrans = 0;

  assert( sqlite3_mutex_held(db->mutex) );

  sqlite3BeginBenignMalloc();

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

    if( db->aDb[i].pBt ){

      if( sqlite3BtreeIsInTrans(db->aDb[i].pBt) ){

        inTrans = 1;

      }

      sqlite3BtreeRollback(db->aDb[i].pBt);

      db->aDb[i].inTrans = 0;

    }

  }

  sqlite3VtabRollback(db);

  sqlite3EndBenignMalloc();

  if( db->flags&SQLITE_InternChanges ){

    sqlite3ExpirePreparedStatements(db);

    sqlite3ResetInternalSchema(db, 0);

  }

  /* If one has been configured, invoke the rollback-hook callback */

  if( db->xRollbackCallback && (inTrans || !db->autoCommit) ){

    db->xRollbackCallback(db->pRollbackArg);

  }

}

/*

** Return a static string that describes the kind of error specified in the

** argument.

*/

const char *sqlite3ErrStr(int rc){

  const char *z;

  switch( rc & 0xff ){

    case SQLITE_ROW:

    case SQLITE_DONE:

    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;

    case SQLITE_FULL:       z = "database or disk is full";              break;

    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;

    case SQLITE_TOOBIG:     z = "String or BLOB exceeded size limit";    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;

    case SQLITE_NOLFS:      z = "large file support is disabled";        break;

    case SQLITE_AUTH:       z = "authorization denied";                  break;

    case SQLITE_FORMAT:     z = "auxiliary database format error";       break;

    case SQLITE_RANGE:      z = "bind or column index out of range";     break;

    case SQLITE_NOTADB:     z = "file is encrypted or is not a database";break;

    default:                z = "unknown error";                         break;

  }

  return z;

}

/*

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

*/

static int sqliteDefaultBusyCallback(

 void *ptr,               /* Database connection */

 int count                /* Number of times table has been busy */

){

#if SQLITE_OS_WIN || (defined(HAVE_USLEEP) && HAVE_USLEEP)

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

# define NDELAY (sizeof(delays)/sizeof(delays[0]))

  sqlite3 *db = (sqlite3 *)ptr;

  int timeout = db->busyTimeout;

  int delay, prior;

  assert( count>=0 );

  if( count < NDELAY ){

    delay = delays[count];

    prior = totals[count];

  }else{

    delay = delays[NDELAY-1];

    prior = totals[NDELAY-1] + delay*(count-(NDELAY-1));

  }

  if( prior + delay > timeout ){

    delay = timeout - prior;

    if( delay<=0 ) return 0;

  }

  sqlite3OsSleep(db->pVfs, delay*1000);

  return 1;

#else

  sqlite3 *db = (sqlite3 *)ptr;

  int timeout = ((sqlite3 *)ptr)->busyTimeout;

  if( (count+1)*1000 > timeout ){

    return 0;

  }

  sqlite3OsSleep(db->pVfs, 1000000);

  return 1;

#endif

}

/*

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

}

/*

** This routine sets the busy callback for an Sqlite database to the

** given callback function with the given argument.

*/

int sqlite3_busy_handler(

  sqlite3 *db,

  int (*xBusy)(void*,int),

  void *pArg

){

  sqlite3_mutex_enter(db->mutex);

  db->busyHandler.xFunc = xBusy;

  db->busyHandler.pArg = pArg;

  db->busyHandler.nBusy = 0;

  sqlite3_mutex_leave(db->mutex);

  return SQLITE_OK;

}

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

*/

void sqlite3_progress_handler(

  sqlite3 *db, 

  int nOps,

  int (*xProgress)(void*), 

  void *pArg

){

  sqlite3_mutex_enter(db->mutex);

  if( nOps>0 ){

    db->xProgress = xProgress;

    db->nProgressOps = nOps;

    db->pProgressArg = pArg;

  }else{

    db->xProgress = 0;

    db->nProgressOps = 0;

    db->pProgressArg = 0;

  }

  sqlite3_mutex_leave(db->mutex);

}

#endif

/*

** This routine installs a default busy handler that waits for the

** specified number of milliseconds before returning 0.

*/

int sqlite3_busy_timeout(sqlite3 *db, int ms){

  if( ms>0 ){

    db->busyTimeout = ms;

    sqlite3_busy_handler(db, sqliteDefaultBusyCallback, (void*)db);

  }else{

    sqlite3_busy_handler(db, 0, 0);

  }

  return SQLITE_OK;

}

/*

** Cause any pending operation to stop at its earliest opportunity.

*/

void sqlite3_interrupt(sqlite3 *db){

  db->u1.isInterrupted = 1;

}

/*

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

*/

int sqlite3CreateFunc(

  sqlite3 *db,

  const char *zFunctionName,

  int nArg,

  int enc,

  void *pUserData,

  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),

  void (*xStep)(sqlite3_context*,int,sqlite3_value **),

  void (*xFinal)(sqlite3_context*)

){

  FuncDef *p;

  int nName;

  assert( sqlite3_mutex_held(db->mutex) );

  if( zFunctionName==0 ||

      (xFunc && (xFinal || xStep)) || 

      (!xFunc && (xFinal && !xStep)) ||

      (!xFunc && (!xFinal && xStep)) ||

      (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) ||

      (255<(nName = sqlite3Strlen(db, zFunctionName))) ){

    sqlite3Error(db, SQLITE_ERROR, "bad parameters");

    return SQLITE_ERROR;

  }

#ifndef SQLITE_OMIT_UTF16

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

    rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8,

         pUserData, xFunc, xStep, xFinal);

    if( rc==SQLITE_OK ){

      rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE,

          pUserData, xFunc, xStep, xFinal);

    }

    if( rc!=SQLITE_OK ){

      return rc;

    }

    enc = SQLITE_UTF16BE;

  }

#else

  enc = SQLITE_UTF8;

#endif

  /* 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");

      assert( !db->mallocFailed );

      return SQLITE_BUSY;

    }else{

      sqlite3ExpirePreparedStatements(db);

    }

  }

  p = sqlite3FindFunction(db, zFunctionName, nName, nArg, enc, 1);

  assert(p || db->mallocFailed);

  if( !p ){

    return SQLITE_NOMEM;

  }

  p->flags = 0;

  p->xFunc = xFunc;

  p->xStep = xStep;

  p->xFinalize = xFinal;

  p->pUserData = pUserData;

  p->nArg = nArg;

  return SQLITE_OK;

}

/*

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

  sqlite3_mutex_enter(db->mutex);

  rc = sqlite3CreateFunc(db, zFunctionName, nArg, enc, p, xFunc, xStep, xFinal);

  rc = sqlite3ApiExit(db, rc);

  sqlite3_mutex_leave(db->mutex);

  return rc;

}

#ifndef SQLITE_OMIT_UTF16

int sqlite3_create_function16(

  sqlite3 *db,

  const void *zFunctionName,

  int nArg,

  int eTextRep,

  void *p,

  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),

  void (*xStep)(sqlite3_context*,int,sqlite3_value**),

  void (*xFinal)(sqlite3_context*)

){

  int rc;

  char *zFunc8;

  sqlite3_mutex_enter(db->mutex);

  assert( !db->mallocFailed );

  zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1);

  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal);

  sqlite3DbFree(db, zFunc8);

  rc = sqlite3ApiExit(db, rc);

  sqlite3_mutex_leave(db->mutex);

  return rc;

}

#endif

/*

** 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 = sqlite3Strlen(db, zName);

  int rc;

  sqlite3_mutex_enter(db->mutex);

  if( sqlite3FindFunction(db, zName, nName, nArg, SQLITE_UTF8, 0)==0 ){

    sqlite3CreateFunc(db, zName, nArg, SQLITE_UTF8,

                      0, sqlite3InvalidFunction, 0, 0);

  }

  rc = sqlite3ApiExit(db, SQLITE_OK);

  sqlite3_mutex_leave(db->mutex);

  return rc;

}

#ifndef SQLITE_OMIT_TRACE

/*

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

** SQL statement.

*/

void *sqlite3_trace(sqlite3 *db, void (*xTrace)(void*,const char*), void *pArg){

  void *pOld;

  sqlite3_mutex_enter(db->mutex);

  pOld = db->pTraceArg;

  db->xTrace = xTrace;

  db->pTraceArg = pArg;

  sqlite3_mutex_leave(db->mutex);

  return pOld;

}

/*

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

  sqlite3_mutex_enter(db->mutex);

  pOld = db->pProfileArg;

  db->xProfile = xProfile;

  db->pProfileArg = pArg;

  sqlite3_mutex_leave(db->mutex);

  return pOld;

}

#endif /* SQLITE_OMIT_TRACE */

/*** EXPERIMENTAL ***

**

** Register a function to be invoked when a transaction comments.

** If the invoked function returns non-zero, then the commit becomes a

** rollback.

*/

void *sqlite3_commit_hook(

  sqlite3 *db,              /* Attach the hook to this database */

  int (*xCallback)(void*),  /* Function to invoke on each commit */

  void *pArg                /* Argument to the function */

){

  void *pOld;

  sqlite3_mutex_enter(db->mutex);

  pOld = db->pCommitArg;

  db->xCommitCallback = xCallback;

  db->pCommitArg = pArg;

  sqlite3_mutex_leave(db->mutex);

  return pOld;

}

/*

** Register a callback to be invoked each time a row is updated,

** inserted or deleted using this database connection.