/*

** 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.147 2008/10/13 10:37:50 danielk1977 Exp $

*/

#include "sqliteInt.h"

#include "vdbeInt.h"

#if 0 && defined(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

#ifndef SQLITE_OMIT_DEPRECATED

/*

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

}

#endif

/*

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

#if SQLITE_THREADSAFE

    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;

#if SQLITE_THREADSAFE

  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;

  if( db->mallocFailed ){

    return SQLITE_NOMEM;

  }

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

  }

}

#ifndef SQLITE_OMIT_DEPRECATED

/*

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

}

#endif

/*

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

  Mem *pOut = columnMem(pStmt, i);

  if( pOut->flags&MEM_Static ){

    pOut->flags &= ~MEM_Static;

    pOut->flags |= MEM_Ephem;

  }

  columnMallocFailure(pStmt);

  return (sqlite3_value *)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){