/*

 ** 2004 May 26

 **

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

 **

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

 **

 ** This file contains code use to implement APIs that are part of the

 ** VDBE.

 **

 ** $Id: vdbeapi.c,v 1.138 2008/08/02 03:50:39 drh Exp $

 */

 #include "sqliteInt.h"

 #include "vdbeInt.h"

 #ifdef SQLITE_ENABLE_MEMORY_MANAGEMENT

 /*

 ** The following structure contains pointers to the end points of a

 ** doubly-linked list of all compiled SQL statements that may be holding

 ** buffers eligible for release when the sqlite3_release_memory() interface is

 ** invoked. Access to this list is protected by the SQLITE_MUTEX_STATIC_LRU2

 ** mutex.

 **

 ** Statements are added to the end of this list when sqlite3_reset() is

 ** called. They are removed either when sqlite3_step() or sqlite3_finalize()

 ** is called. When statements are added to this list, the associated 

 ** register array (p->aMem[1..p->nMem]) may contain dynamic buffers that

 ** can be freed using sqlite3VdbeReleaseMemory().

 **

 ** When statements are added or removed from this list, the mutex

 ** associated with the Vdbe being added or removed (Vdbe.db->mutex) is

 ** already held. The LRU2 mutex is then obtained, blocking if necessary,

 ** the linked-list pointers manipulated and the LRU2 mutex relinquished.

 */

 struct StatementLruList {

   Vdbe *pFirst;

   Vdbe *pLast;

 };

 static struct StatementLruList sqlite3LruStatements;

 /*

 ** Check that the list looks to be internally consistent. This is used

 ** as part of an assert() statement as follows:

 **

 **   assert( stmtLruCheck() );

 */

 #ifndef NDEBUG

 static int stmtLruCheck(){

   Vdbe *p;

   for(p=sqlite3LruStatements.pFirst; p; p=p->pLruNext){

     assert(p->pLruNext || p==sqlite3LruStatements.pLast);

     assert(!p->pLruNext || p->pLruNext->pLruPrev==p);

     assert(p->pLruPrev || p==sqlite3LruStatements.pFirst);

     assert(!p->pLruPrev || p->pLruPrev->pLruNext==p);

   }

   return 1;

 }

 #endif

 /*

 ** Add vdbe p to the end of the statement lru list. It is assumed that

 ** p is not already part of the list when this is called. The lru list

 ** is protected by the SQLITE_MUTEX_STATIC_LRU mutex.

 */

 static void stmtLruAdd(Vdbe *p){

   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   if( p->pLruPrev || p->pLruNext || sqlite3LruStatements.pFirst==p ){

     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

     return;

   }

   assert( stmtLruCheck() );

   if( !sqlite3LruStatements.pFirst ){

     assert( !sqlite3LruStatements.pLast );

     sqlite3LruStatements.pFirst = p;

     sqlite3LruStatements.pLast = p;

   }else{

     assert( !sqlite3LruStatements.pLast->pLruNext );

     p->pLruPrev = sqlite3LruStatements.pLast;

     sqlite3LruStatements.pLast->pLruNext = p;

     sqlite3LruStatements.pLast = p;

   }

   assert( stmtLruCheck() );

   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

 }

 /*

 ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is already held, remove

 ** statement p from the least-recently-used statement list. If the 

 ** statement is not currently part of the list, this call is a no-op.

 */

 static void stmtLruRemoveNomutex(Vdbe *p){

   if( p->pLruPrev || p->pLruNext || p==sqlite3LruStatements.pFirst ){

     assert( stmtLruCheck() );

     if( p->pLruNext ){

       p->pLruNext->pLruPrev = p->pLruPrev;

     }else{

       sqlite3LruStatements.pLast = p->pLruPrev;

     }

     if( p->pLruPrev ){

       p->pLruPrev->pLruNext = p->pLruNext;

     }else{

       sqlite3LruStatements.pFirst = p->pLruNext;

     }

     p->pLruNext = 0;

     p->pLruPrev = 0;

     assert( stmtLruCheck() );

   }

 }

 /*

 ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is not held, remove

 ** statement p from the least-recently-used statement list. If the 

 ** statement is not currently part of the list, this call is a no-op.

 */

 static void stmtLruRemove(Vdbe *p){

   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   stmtLruRemoveNomutex(p);

   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

 }

 /*

 ** Try to release n bytes of memory by freeing buffers associated 

 ** with the memory registers of currently unused vdbes.

 */

 int sqlite3VdbeReleaseMemory(int n){

   Vdbe *p;

   Vdbe *pNext;

   int nFree = 0;

   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   for(p=sqlite3LruStatements.pFirst; p && nFree<n; p=pNext){

     pNext = p->pLruNext;

     /* For each statement handle in the lru list, attempt to obtain the

     ** associated database mutex. If it cannot be obtained, continue

     ** to the next statement handle. It is not possible to block on

     ** the database mutex - that could cause deadlock.

     */

     if( SQLITE_OK==sqlite3_mutex_try(p->db->mutex) ){

       nFree += sqlite3VdbeReleaseBuffers(p);

       stmtLruRemoveNomutex(p);

       sqlite3_mutex_leave(p->db->mutex);

     }

   }

   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));

   return nFree;

 }

 /*

 ** Call sqlite3Reprepare() on the statement. Remove it from the

 ** lru list before doing so, as Reprepare() will free all the

 ** memory register buffers anyway.

 */

 int vdbeReprepare(Vdbe *p){

   stmtLruRemove(p);

   return sqlite3Reprepare(p);

 }

 #else       /* !SQLITE_ENABLE_MEMORY_MANAGEMENT */

   #define stmtLruRemove(x)

   #define stmtLruAdd(x)

   #define vdbeReprepare(x) sqlite3Reprepare(x)

 #endif

 /*

 ** Return TRUE (non-zero) of the statement supplied as an argument needs

 ** to be recompiled.  A statement needs to be recompiled whenever the

 ** execution environment changes in a way that would alter the program

 ** that sqlite3_prepare() generates.  For example, if new functions or

 ** collating sequences are registered or if an authorizer function is

 ** added or changed.

 */

 int sqlite3_expired(sqlite3_stmt *pStmt){

   Vdbe *p = (Vdbe*)pStmt;

   return p==0 || p->expired;

 }

 /*

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

 */

 int sqlite3_finalize(sqlite3_stmt *pStmt){

   int rc;

   if( pStmt==0 ){

     rc = SQLITE_OK;

   }else{

     Vdbe *v = (Vdbe*)pStmt;

 #ifndef SQLITE_MUTEX_NOOP

     sqlite3_mutex *mutex = v->db->mutex;

 #endif

     sqlite3_mutex_enter(mutex);

     stmtLruRemove(v);

     rc = sqlite3VdbeFinalize(v);

     sqlite3_mutex_leave(mutex);

   }

   return rc;

 }

 /*

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

 */

 int sqlite3_reset(sqlite3_stmt *pStmt){

   int rc;

   if( pStmt==0 ){

     rc = SQLITE_OK;

   }else{

     Vdbe *v = (Vdbe*)pStmt;

     sqlite3_mutex_enter(v->db->mutex);

     rc = sqlite3VdbeReset(v);

     stmtLruAdd(v);

     sqlite3VdbeMakeReady(v, -1, 0, 0, 0);

     assert( (rc & (v->db->errMask))==rc );

     sqlite3_mutex_leave(v->db->mutex);

   }

   return rc;

 }

 /*

 ** Set all the parameters in the compiled SQL statement to NULL.

 */

 int sqlite3_clear_bindings(sqlite3_stmt *pStmt){

   int i;

   int rc = SQLITE_OK;

   Vdbe *p = (Vdbe*)pStmt;

 #ifndef SQLITE_MUTEX_NOOP

   sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;

 #endif

   sqlite3_mutex_enter(mutex);

   for(i=0; i<p->nVar; i++){

     sqlite3VdbeMemRelease(&p->aVar[i]);

     p->aVar[i].flags = MEM_Null;

   }

   sqlite3_mutex_leave(mutex);

   return rc;

 }

 /**************************** sqlite3_value_  *******************************

 ** The following routines extract information from a Mem or sqlite3_value

 ** structure.

 */

 const void *sqlite3_value_blob(sqlite3_value *pVal){

   Mem *p = (Mem*)pVal;

   if( p->flags & (MEM_Blob|MEM_Str) ){

     sqlite3VdbeMemExpandBlob(p);

     p->flags &= ~MEM_Str;

     p->flags |= MEM_Blob;

     return p->z;

   }else{

     return sqlite3_value_text(pVal);

   }

 }

 int sqlite3_value_bytes(sqlite3_value *pVal){

   return sqlite3ValueBytes(pVal, SQLITE_UTF8);

 }

 int sqlite3_value_bytes16(sqlite3_value *pVal){

   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);

 }

 double sqlite3_value_double(sqlite3_value *pVal){

   return sqlite3VdbeRealValue((Mem*)pVal);

 }

 int sqlite3_value_int(sqlite3_value *pVal){

   return sqlite3VdbeIntValue((Mem*)pVal);

 }

 sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){

   return sqlite3VdbeIntValue((Mem*)pVal);

 }

 const unsigned char *sqlite3_value_text(sqlite3_value *pVal){

   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);

 }

 #ifndef SQLITE_OMIT_UTF16

 const void *sqlite3_value_text16(sqlite3_value* pVal){

   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);

 }

 const void *sqlite3_value_text16be(sqlite3_value *pVal){

   return sqlite3ValueText(pVal, SQLITE_UTF16BE);

 }

 const void *sqlite3_value_text16le(sqlite3_value *pVal){

   return sqlite3ValueText(pVal, SQLITE_UTF16LE);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 int sqlite3_value_type(sqlite3_value* pVal){

   return pVal->type;

 }

 /**************************** sqlite3_result_  *******************************

 ** The following routines are used by user-defined functions to specify

 ** the function result.

 */

 void sqlite3_result_blob(

   sqlite3_context *pCtx, 

   const void *z, 

   int n, 

   void (*xDel)(void *)

 ){

   assert( n>=0 );

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);

 }

 void sqlite3_result_double(sqlite3_context *pCtx, double rVal){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetDouble(&pCtx->s, rVal);

 }

 void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   pCtx->isError = SQLITE_ERROR;

   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);

 }

 #ifndef SQLITE_OMIT_UTF16

 void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   pCtx->isError = SQLITE_ERROR;

   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);

 }

 #endif

 void sqlite3_result_int(sqlite3_context *pCtx, int iVal){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);

 }

 void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetInt64(&pCtx->s, iVal);

 }

 void sqlite3_result_null(sqlite3_context *pCtx){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetNull(&pCtx->s);

 }

 void sqlite3_result_text(

   sqlite3_context *pCtx, 

   const char *z, 

   int n,

   void (*xDel)(void *)

 ){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);

 }

 #ifndef SQLITE_OMIT_UTF16

 void sqlite3_result_text16(

   sqlite3_context *pCtx, 

   const void *z, 

   int n, 

   void (*xDel)(void *)

 ){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);

 }

 void sqlite3_result_text16be(

   sqlite3_context *pCtx, 

   const void *z, 

   int n, 

   void (*xDel)(void *)

 ){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);

 }

 void sqlite3_result_text16le(

   sqlite3_context *pCtx, 

   const void *z, 

   int n, 

   void (*xDel)(void *)

 ){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemCopy(&pCtx->s, pValue);

 }

 void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);

 }

 void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){

   pCtx->isError = errCode;

 }

 /* Force an SQLITE_TOOBIG error. */

 void sqlite3_result_error_toobig(sqlite3_context *pCtx){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   pCtx->isError = SQLITE_TOOBIG;

   sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1, 

                        SQLITE_UTF8, SQLITE_STATIC);

 }

 /* An SQLITE_NOMEM error. */

 void sqlite3_result_error_nomem(sqlite3_context *pCtx){

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   sqlite3VdbeMemSetNull(&pCtx->s);

   pCtx->isError = SQLITE_NOMEM;

   pCtx->s.db->mallocFailed = 1;

 }

 /*

 ** Execute the statement pStmt, either until a row of data is ready, the

 ** statement is completely executed or an error occurs.

 **

 ** This routine implements the bulk of the logic behind the sqlite_step()

 ** API.  The only thing omitted is the automatic recompile if a 

 ** schema change has occurred.  That detail is handled by the

 ** outer sqlite3_step() wrapper procedure.

 */

 static int sqlite3Step(Vdbe *p){

   sqlite3 *db;

   int rc;

   assert(p);

   if( p->magic!=VDBE_MAGIC_RUN ){

     return SQLITE_MISUSE;

   }

   /* Assert that malloc() has not failed */

   db = p->db;

   assert( !db->mallocFailed );

   if( p->pc<=0 && p->expired ){

     if( p->rc==SQLITE_OK ){

       p->rc = SQLITE_SCHEMA;

     }

     rc = SQLITE_ERROR;

     goto end_of_step;

   }

   if( sqlite3SafetyOn(db) ){

     p->rc = SQLITE_MISUSE;

     return SQLITE_MISUSE;

   }

   if( p->pc<0 ){

     /* If there are no other statements currently running, then

     ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt

     ** from interrupting a statement that has not yet started.

     */

     if( db->activeVdbeCnt==0 ){

       db->u1.isInterrupted = 0;

     }

 #ifndef SQLITE_OMIT_TRACE

     if( db->xProfile && !db->init.busy ){

       double rNow;

       sqlite3OsCurrentTime(db->pVfs, &rNow);

       p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;

     }

 #endif

     db->activeVdbeCnt++;

     p->pc = 0;

     stmtLruRemove(p);

   }

 #ifndef SQLITE_OMIT_EXPLAIN

   if( p->explain ){

     rc = sqlite3VdbeList(p);

   }else

 #endif /* SQLITE_OMIT_EXPLAIN */

   {

     rc = sqlite3VdbeExec(p);

   }

   if( sqlite3SafetyOff(db) ){

     rc = SQLITE_MISUSE;

   }

 #ifndef SQLITE_OMIT_TRACE

   /* Invoke the profile callback if there is one

   */

   if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->nOp>0

            && p->aOp[0].opcode==OP_Trace && p->aOp[0].p4.z!=0 ){

     double rNow;

     u64 elapseTime;

     sqlite3OsCurrentTime(db->pVfs, &rNow);

     elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;

     db->xProfile(db->pProfileArg, p->aOp[0].p4.z, elapseTime);

   }

 #endif

   db->errCode = rc;

   /*sqlite3Error(p->db, rc, 0);*/

   p->rc = sqlite3ApiExit(p->db, p->rc);

 end_of_step:

   assert( (rc&0xff)==rc );

   if( p->zSql && (rc&0xff)<SQLITE_ROW ){

     /* This behavior occurs if sqlite3_prepare_v2() was used to build

     ** the prepared statement.  Return error codes directly */

     p->db->errCode = p->rc;

     /* sqlite3Error(p->db, p->rc, 0); */

     return p->rc;

   }else{

     /* This is for legacy sqlite3_prepare() builds and when the code

     ** is SQLITE_ROW or SQLITE_DONE */

     return rc;

   }

 }

 /*

 ** This is the top-level implementation of sqlite3_step().  Call

 ** sqlite3Step() to do most of the work.  If a schema error occurs,

 ** call sqlite3Reprepare() and try again.

 */

 #ifdef SQLITE_OMIT_PARSER

 int sqlite3_step(sqlite3_stmt *pStmt){

   int rc = SQLITE_MISUSE;

   if( pStmt ){

     Vdbe *v;

     v = (Vdbe*)pStmt;

     sqlite3_mutex_enter(v->db->mutex);

     rc = sqlite3Step(v);

     sqlite3_mutex_leave(v->db->mutex);

   }

   return rc;

 }

 #else

 int sqlite3_step(sqlite3_stmt *pStmt){

   int rc = SQLITE_MISUSE;

   if( pStmt ){

     int cnt = 0;

     Vdbe *v = (Vdbe*)pStmt;

     sqlite3 *db = v->db;

     sqlite3_mutex_enter(db->mutex);

     while( (rc = sqlite3Step(v))==SQLITE_SCHEMA

            && cnt++ < 5

            && vdbeReprepare(v) ){

       sqlite3_reset(pStmt);

       v->expired = 0;

     }

     if( rc==SQLITE_SCHEMA && v->zSql && db->pErr ){

       /* This case occurs after failing to recompile an sql statement. 

       ** The error message from the SQL compiler has already been loaded 

       ** into the database handle. This block copies the error message 

       ** from the database handle into the statement and sets the statement

       ** program counter to 0 to ensure that when the statement is 

       ** finalized or reset the parser error message is available via

       ** sqlite3_errmsg() and sqlite3_errcode().

       */

       const char *zErr = (const char *)sqlite3_value_text(db->pErr); 

       sqlite3DbFree(db, v->zErrMsg);

       if( !db->mallocFailed ){

         v->zErrMsg = sqlite3DbStrDup(db, zErr);

       } else {

         v->zErrMsg = 0;

         v->rc = SQLITE_NOMEM;

       }

     }

     rc = sqlite3ApiExit(db, rc);

     sqlite3_mutex_leave(db->mutex);

   }

   return rc;

 }

 #endif

 /*

 ** Extract the user data from a sqlite3_context structure and return a

 ** pointer to it.

 */

 void *sqlite3_user_data(sqlite3_context *p){

   assert( p && p->pFunc );

   return p->pFunc->pUserData;

 }

 /*

 ** Extract the user data from a sqlite3_context structure and return a

 ** pointer to it.

 */

 sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){

   assert( p && p->pFunc );

   return p->s.db;

 }

 /*

 ** The following is the implementation of an SQL function that always

 ** fails with an error message stating that the function is used in the

 ** wrong context.  The sqlite3_overload_function() API might construct

 ** SQL function that use this routine so that the functions will exist

 ** for name resolution but are actually overloaded by the xFindFunction

 ** method of virtual tables.

 */

 void sqlite3InvalidFunction(

   sqlite3_context *context,  /* The function calling context */

   int argc,                  /* Number of arguments to the function */

   sqlite3_value **argv       /* Value of each argument */

 ){

   const char *zName = context->pFunc->zName;

   char *zErr;

   zErr = sqlite3MPrintf(0,

       "unable to use function %s in the requested context", zName);

   sqlite3_result_error(context, zErr, -1);

   sqlite3_free(zErr);

 }

 /*

 ** Allocate or return the aggregate context for a user function.  A new

 ** context is allocated on the first call.  Subsequent calls return the

 ** same context that was returned on prior calls.

 */

 void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){

   Mem *pMem;

   assert( p && p->pFunc && p->pFunc->xStep );

   assert( sqlite3_mutex_held(p->s.db->mutex) );

   pMem = p->pMem;

   if( (pMem->flags & MEM_Agg)==0 ){

     if( nByte==0 ){

       sqlite3VdbeMemReleaseExternal(pMem);

       pMem->flags = MEM_Null;

       pMem->z = 0;

     }else{

       sqlite3VdbeMemGrow(pMem, nByte, 0);

       pMem->flags = MEM_Agg;

       pMem->u.pDef = p->pFunc;

       if( pMem->z ){

         memset(pMem->z, 0, nByte);

       }

     }

   }

   return (void*)pMem->z;

 }

 /*

 ** Return the auxilary data pointer, if any, for the iArg'th argument to

 ** the user-function defined by pCtx.

 */

 void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){

   VdbeFunc *pVdbeFunc;

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   pVdbeFunc = pCtx->pVdbeFunc;

   if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){

     return 0;

   }

   return pVdbeFunc->apAux[iArg].pAux;

 }

 /*

 ** Set the auxilary data pointer and delete function, for the iArg'th

 ** argument to the user-function defined by pCtx. Any previous value is

 ** deleted by calling the delete function specified when it was set.

 */

 void sqlite3_set_auxdata(

   sqlite3_context *pCtx, 

   int iArg, 

   void *pAux, 

   void (*xDelete)(void*)

 ){

   struct AuxData *pAuxData;

   VdbeFunc *pVdbeFunc;

   if( iArg<0 ) goto failed;

   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );

   pVdbeFunc = pCtx->pVdbeFunc;

   if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){

     int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);

     int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;

     pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);

     if( !pVdbeFunc ){

       goto failed;

     }

     pCtx->pVdbeFunc = pVdbeFunc;

     memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));

     pVdbeFunc->nAux = iArg+1;

     pVdbeFunc->pFunc = pCtx->pFunc;

   }

   pAuxData = &pVdbeFunc->apAux[iArg];

   if( pAuxData->pAux && pAuxData->xDelete ){

     pAuxData->xDelete(pAuxData->pAux);

   }

   pAuxData->pAux = pAux;

   pAuxData->xDelete = xDelete;

   return;

 failed:

   if( xDelete ){

     xDelete(pAux);

   }

 }

 /*

 ** Return the number of times the Step function of a aggregate has been 

 ** called.

 **

 ** This function is deprecated.  Do not use it for new code.  It is

 ** provide only to avoid breaking legacy code.  New aggregate function

 ** implementations should keep their own counts within their aggregate

 ** context.

 */

 int sqlite3_aggregate_count(sqlite3_context *p){

   assert( p && p->pFunc && p->pFunc->xStep );

   return p->pMem->n;

 }

 /*

 ** Return the number of columns in the result set for the statement pStmt.

 */

 int sqlite3_column_count(sqlite3_stmt *pStmt){

   Vdbe *pVm = (Vdbe *)pStmt;

   return pVm ? pVm->nResColumn : 0;

 }

 /*

 ** Return the number of values available from the current row of the

 ** currently executing statement pStmt.

 */

 int sqlite3_data_count(sqlite3_stmt *pStmt){

   Vdbe *pVm = (Vdbe *)pStmt;

   if( pVm==0 || pVm->pResultSet==0 ) return 0;

   return pVm->nResColumn;

 }

 /*

 ** Check to see if column iCol of the given statement is valid.  If

 ** it is, return a pointer to the Mem for the value of that column.

 ** If iCol is not valid, return a pointer to a Mem which has a value

 ** of NULL.

 */

 static Mem *columnMem(sqlite3_stmt *pStmt, int i){

   Vdbe *pVm;

   int vals;

   Mem *pOut;

   pVm = (Vdbe *)pStmt;

   if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){

     sqlite3_mutex_enter(pVm->db->mutex);

     vals = sqlite3_data_count(pStmt);

     pOut = &pVm->pResultSet[i];

   }else{

     static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };

     if( pVm->db ){

       sqlite3_mutex_enter(pVm->db->mutex);

       sqlite3Error(pVm->db, SQLITE_RANGE, 0);

     }

     pOut = (Mem*)&nullMem;

   }

   return pOut;

 }

 /*

 ** This function is called after invoking an sqlite3_value_XXX function on a 

 ** column value (i.e. a value returned by evaluating an SQL expression in the

 ** select list of a SELECT statement) that may cause a malloc() failure. If 

 ** malloc() has failed, the threads mallocFailed flag is cleared and the result

 ** code of statement pStmt set to SQLITE_NOMEM.

 **

 ** Specifically, this is called from within:

 **

 **     sqlite3_column_int()

 **     sqlite3_column_int64()

 **     sqlite3_column_text()

 **     sqlite3_column_text16()

 **     sqlite3_column_real()

 **     sqlite3_column_bytes()

 **     sqlite3_column_bytes16()

 **

 ** But not for sqlite3_column_blob(), which never calls malloc().

 */

 static void columnMallocFailure(sqlite3_stmt *pStmt)

 {

   /* If malloc() failed during an encoding conversion within an

   ** sqlite3_column_XXX API, then set the return code of the statement to

   ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR

   ** and _finalize() will return NOMEM.

   */

   Vdbe *p = (Vdbe *)pStmt;

   if( p ){

     p->rc = sqlite3ApiExit(p->db, p->rc);

     sqlite3_mutex_leave(p->db->mutex);

   }

 }

 /**************************** sqlite3_column_  *******************************

 ** The following routines are used to access elements of the current row

 ** in the result set.

 */

 const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){

   const void *val;

   val = sqlite3_value_blob( columnMem(pStmt,i) );

   /* Even though there is no encoding conversion, value_blob() might

   ** need to call malloc() to expand the result of a zeroblob() 

   ** expression. 

   */

   columnMallocFailure(pStmt);

   return val;

 }

 int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){

   int val = sqlite3_value_bytes( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return val;

 }

 int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){

   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return val;

 }

 double sqlite3_column_double(sqlite3_stmt *pStmt, int i){

   double val = sqlite3_value_double( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return val;

 }

 int sqlite3_column_int(sqlite3_stmt *pStmt, int i){

   int val = sqlite3_value_int( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return val;

 }

 sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){

   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return val;

 }

 const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){

   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return val;

 }

 sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){

   sqlite3_value *pOut = columnMem(pStmt, i);

   columnMallocFailure(pStmt);

   return pOut;

 }

 #ifndef SQLITE_OMIT_UTF16

 const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){

   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return val;

 }

 #endif /* SQLITE_OMIT_UTF16 */

 int sqlite3_column_type(sqlite3_stmt *pStmt, int i){

   int iType = sqlite3_value_type( columnMem(pStmt,i) );

   columnMallocFailure(pStmt);

   return iType;

 }

 /* The following function is experimental and subject to change or

 ** removal */

 /*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){

 **  return sqlite3_value_numeric_type( columnMem(pStmt,i) );

 **}

 */

 /*

 ** Convert the N-th element of pStmt->pColName[] into a string using

 ** xFunc() then return that string.  If N is out of range, return 0.

 **

 ** There are up to 5 names for each column.  useType determines which

 ** name is returned.  Here are the names:

 **

 **    0      The column name as it should be displayed for output

 **    1      The datatype name for the column

 **    2      The name of the database that the column derives from

 **    3      The name of the table that the column derives from

 **    4      The name of the table column that the result column derives from

 **

 ** If the result is not a simple column reference (if it is an expression

 ** or a constant) then useTypes 2, 3, and 4 return NULL.

 */

 static const void *columnName(

   sqlite3_stmt *pStmt,

   int N,

   const void *(*xFunc)(Mem*),

   int useType

 ){

   const void *ret = 0;

   Vdbe *p = (Vdbe *)pStmt;

   int n;

   if( p!=0 ){

     n = sqlite3_column_count(pStmt);

     if( N<n && N>=0 ){

       N += useType*n;

       sqlite3_mutex_enter(p->db->mutex);

       ret = xFunc(&p->aColName[N]);

       /* A malloc may have failed inside of the xFunc() call. If this

       ** is the case, clear the mallocFailed flag and return NULL.

       */

       if( p->db && p->db->mallocFailed ){

         p->db->mallocFailed = 0;

         ret = 0;

       }

       sqlite3_mutex_leave(p->db->mutex);

     }

   }

   return ret;

 }

 /*

 ** Return the name of the Nth column of the result set returned by SQL

 ** statement pStmt.

 */

 const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);

 }

 #ifndef SQLITE_OMIT_UTF16

 const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);

 }

 #endif

 /*

 ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must

 ** not define OMIT_DECLTYPE.

 */

 #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)

 # error "Must not define both SQLITE_OMIT_DECLTYPE \

          and SQLITE_ENABLE_COLUMN_METADATA"

 #endif

 #ifndef SQLITE_OMIT_DECLTYPE

 /*

 ** Return the column declaration type (if applicable) of the 'i'th column

 ** of the result set of SQL statement pStmt.

 */

 const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);

 }

 #ifndef SQLITE_OMIT_UTF16

 const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 #endif /* SQLITE_OMIT_DECLTYPE */

 #ifdef SQLITE_ENABLE_COLUMN_METADATA

 /*

 ** Return the name of the database from which a result column derives.

 ** NULL is returned if the result column is an expression or constant or

 ** anything else which is not an unabiguous reference to a database column.

 */

 const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);

 }

 #ifndef SQLITE_OMIT_UTF16

 const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 /*

 ** Return the name of the table from which a result column derives.

 ** NULL is returned if the result column is an expression or constant or

 ** anything else which is not an unabiguous reference to a database column.

 */

 const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);

 }

 #ifndef SQLITE_OMIT_UTF16

 const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 /*

 ** Return the name of the table column from which a result column derives.

 ** NULL is returned if the result column is an expression or constant or

 ** anything else which is not an unabiguous reference to a database column.

 */

 const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);

 }

 #ifndef SQLITE_OMIT_UTF16

 const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){

   return columnName(

       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 #endif /* SQLITE_ENABLE_COLUMN_METADATA */

 /******************************* sqlite3_bind_  ***************************

 ** 

 ** Routines used to attach values to wildcards in a compiled SQL statement.

 */

 /*

 ** Unbind the value bound to variable i in virtual machine p. This is the 

 ** the same as binding a NULL value to the column. If the "i" parameter is

 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.

 **

 ** The error code stored in database p->db is overwritten with the return

 ** value in any case.

 */

 static int vdbeUnbind(Vdbe *p, int i){

   Mem *pVar;

   if( p==0 || p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){

     if( p ) sqlite3Error(p->db, SQLITE_MISUSE, 0);

     return SQLITE_MISUSE;

   }

   if( i<1 || i>p->nVar ){

     sqlite3Error(p->db, SQLITE_RANGE, 0);

     return SQLITE_RANGE;

   }

   i--;

   pVar = &p->aVar[i];

   sqlite3VdbeMemRelease(pVar);

   pVar->flags = MEM_Null;

   sqlite3Error(p->db, SQLITE_OK, 0);

   return SQLITE_OK;

 }

 /*

 ** Bind a text or BLOB value.

 */

 static int bindText(

   sqlite3_stmt *pStmt,   /* The statement to bind against */

   int i,                 /* Index of the parameter to bind */

   const void *zData,     /* Pointer to the data to be bound */

   int nData,             /* Number of bytes of data to be bound */

   void (*xDel)(void*),   /* Destructor for the data */

   int encoding           /* Encoding for the data */

 ){

   Vdbe *p = (Vdbe *)pStmt;

   Mem *pVar;

   int rc;

   if( p==0 ){

     return SQLITE_MISUSE;

   }

   sqlite3_mutex_enter(p->db->mutex);

   rc = vdbeUnbind(p, i);

   if( rc==SQLITE_OK && zData!=0 ){

     pVar = &p->aVar[i-1];

     rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);

     if( rc==SQLITE_OK && encoding!=0 ){

       rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));

     }

     sqlite3Error(p->db, rc, 0);

     rc = sqlite3ApiExit(p->db, rc);

   }

   sqlite3_mutex_leave(p->db->mutex);

   return rc;

 }

 /*

 ** Bind a blob value to an SQL statement variable.

 */

 int sqlite3_bind_blob(

   sqlite3_stmt *pStmt, 

   int i, 

   const void *zData, 

   int nData, 

   void (*xDel)(void*)

 ){

   return bindText(pStmt, i, zData, nData, xDel, 0);

 }

 int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){

   int rc;

   Vdbe *p = (Vdbe *)pStmt;

   sqlite3_mutex_enter(p->db->mutex);

   rc = vdbeUnbind(p, i);

   if( rc==SQLITE_OK ){

     sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);

   }

   sqlite3_mutex_leave(p->db->mutex);

   return rc;

 }

 int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){

   return sqlite3_bind_int64(p, i, (i64)iValue);

 }

 int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){

   int rc;

   Vdbe *p = (Vdbe *)pStmt;

   sqlite3_mutex_enter(p->db->mutex);

   rc = vdbeUnbind(p, i);

   if( rc==SQLITE_OK ){

     sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);

   }

   sqlite3_mutex_leave(p->db->mutex);

   return rc;

 }

 int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){

   int rc;

   Vdbe *p = (Vdbe*)pStmt;

   sqlite3_mutex_enter(p->db->mutex);

   rc = vdbeUnbind(p, i);

   sqlite3_mutex_leave(p->db->mutex);

   return rc;

 }

 int sqlite3_bind_text( 

   sqlite3_stmt *pStmt, 

   int i, 

   const char *zData, 

   int nData, 

   void (*xDel)(void*)

 ){

   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);

 }

 #ifndef SQLITE_OMIT_UTF16

 int sqlite3_bind_text16(

   sqlite3_stmt *pStmt, 

   int i, 

   const void *zData, 

   int nData, 

   void (*xDel)(void*)

 ){

   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);

 }

 #endif /* SQLITE_OMIT_UTF16 */

 int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){

   int rc;

   Vdbe *p = (Vdbe *)pStmt;

   sqlite3_mutex_enter(p->db->mutex);

   rc = vdbeUnbind(p, i);

   if( rc==SQLITE_OK ){

     rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);

     if( rc==SQLITE_OK ){

       rc = sqlite3VdbeChangeEncoding(&p->aVar[i-1], ENC(p->db));

     }

   }

   rc = sqlite3ApiExit(p->db, rc);

   sqlite3_mutex_leave(p->db->mutex);

   return rc;

 }

 int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){

   int rc;

   Vdbe *p = (Vdbe *)pStmt;

   sqlite3_mutex_enter(p->db->mutex);

   rc = vdbeUnbind(p, i);

   if( rc==SQLITE_OK ){

     sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);

   }

   sqlite3_mutex_leave(p->db->mutex);

   return rc;

 }

 /*

 ** Return the number of wildcards that can be potentially bound to.

 ** This routine is added to support DBD::SQLite.  

 */

 int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){

   Vdbe *p = (Vdbe*)pStmt;

   return p ? p->nVar : 0;

 }

 /*

 ** Create a mapping from variable numbers to variable names

 ** in the Vdbe.azVar[] array, if such a mapping does not already

 ** exist.

 */

 static void createVarMap(Vdbe *p){

   if( !p->okVar ){

     sqlite3_mutex_enter(p->db->mutex);

     if( !p->okVar ){

       int j;

       Op *pOp;

       for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){

         if( pOp->opcode==OP_Variable ){

           assert( pOp->p1>0 && pOp->p1<=p->nVar );

           p->azVar[pOp->p1-1] = pOp->p4.z;

         }

       }

       p->okVar = 1;

     }

     sqlite3_mutex_leave(p->db->mutex);

   }

 }

 /*

 ** Return the name of a wildcard parameter.  Return NULL if the index

 ** is out of range or if the wildcard is unnamed.

 **

 ** The result is always UTF-8.

 */

 const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){

   Vdbe *p = (Vdbe*)pStmt;

   if( p==0 || i<1 || i>p->nVar ){

     return 0;

   }

   createVarMap(p);

   return p->azVar[i-1];

 }

 /*

 ** Given a wildcard parameter name, return the index of the variable

 ** with that name.  If there is no variable with the given name,

 ** return 0.

 */

 int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){

   Vdbe *p = (Vdbe*)pStmt;

   int i;

   if( p==0 ){

     return 0;

   }

   createVarMap(p); 

   if( zName ){

     for(i=0; i<p->nVar; i++){

       const char *z = p->azVar[i];

       if( z && strcmp(z,zName)==0 ){

         return i+1;

       }

     }

   }

   return 0;

 }

 /*

 ** Transfer all bindings from the first statement over to the second.

 ** If the two statements contain a different number of bindings, then

 ** an SQLITE_ERROR is returned.

 */

 int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){

   Vdbe *pFrom = (Vdbe*)pFromStmt;

   Vdbe *pTo = (Vdbe*)pToStmt;

   int i, rc = SQLITE_OK;

   if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)

     || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)

     || pTo->db!=pFrom->db ){

     return SQLITE_MISUSE;

   }

   if( pFrom->nVar!=pTo->nVar ){

     return SQLITE_ERROR;

   }

   sqlite3_mutex_enter(pTo->db->mutex);

   for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){

     sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);

   }

   sqlite3_mutex_leave(pTo->db->mutex);

   assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );

   return rc;

 }

 /*

 ** Return the sqlite3* database handle to which the prepared statement given

 ** in the argument belongs.  This is the same database handle that was

 ** the first argument to the sqlite3_prepare() that was used to create

 ** the statement in the first place.

 */

 sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){

   return pStmt ? ((Vdbe*)pStmt)->db : 0;

 }

 /*

 ** Return a pointer to the next prepared statement after pStmt associated

 ** with database connection pDb.  If pStmt is NULL, return the first

 ** prepared statement for the database connection.  Return NULL if there

 ** are no more.

 */

 sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){

   sqlite3_stmt *pNext;

   sqlite3_mutex_enter(pDb->mutex);

   if( pStmt==0 ){

     pNext = (sqlite3_stmt*)pDb->pVdbe;

   }else{

     pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;

   }

   sqlite3_mutex_leave(pDb->mutex);

   return pNext;

 }