sl@0: /*
sl@0: ** 2004 May 26
sl@0: **
sl@0: ** The author disclaims copyright to this source code.  In place of
sl@0: ** a legal notice, here is a blessing:
sl@0: **
sl@0: **    May you do good and not evil.
sl@0: **    May you find forgiveness for yourself and forgive others.
sl@0: **    May you share freely, never taking more than you give.
sl@0: **
sl@0: *************************************************************************
sl@0: **
sl@0: ** This file contains code use to implement APIs that are part of the
sl@0: ** VDBE.
sl@0: **
sl@0: ** $Id: vdbeapi.c,v 1.141 2008/09/04 12:03:43 shane Exp $
sl@0: */
sl@0: #include "sqliteInt.h"
sl@0: #include "vdbeInt.h"
sl@0: 
sl@0: #if 0 && defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)
sl@0: /*
sl@0: ** The following structure contains pointers to the end points of a
sl@0: ** doubly-linked list of all compiled SQL statements that may be holding
sl@0: ** buffers eligible for release when the sqlite3_release_memory() interface is
sl@0: ** invoked. Access to this list is protected by the SQLITE_MUTEX_STATIC_LRU2
sl@0: ** mutex.
sl@0: **
sl@0: ** Statements are added to the end of this list when sqlite3_reset() is
sl@0: ** called. They are removed either when sqlite3_step() or sqlite3_finalize()
sl@0: ** is called. When statements are added to this list, the associated 
sl@0: ** register array (p->aMem[1..p->nMem]) may contain dynamic buffers that
sl@0: ** can be freed using sqlite3VdbeReleaseMemory().
sl@0: **
sl@0: ** When statements are added or removed from this list, the mutex
sl@0: ** associated with the Vdbe being added or removed (Vdbe.db->mutex) is
sl@0: ** already held. The LRU2 mutex is then obtained, blocking if necessary,
sl@0: ** the linked-list pointers manipulated and the LRU2 mutex relinquished.
sl@0: */
sl@0: struct StatementLruList {
sl@0:   Vdbe *pFirst;
sl@0:   Vdbe *pLast;
sl@0: };
sl@0: static struct StatementLruList sqlite3LruStatements;
sl@0: 
sl@0: /*
sl@0: ** Check that the list looks to be internally consistent. This is used
sl@0: ** as part of an assert() statement as follows:
sl@0: **
sl@0: **   assert( stmtLruCheck() );
sl@0: */
sl@0: #ifndef NDEBUG
sl@0: static int stmtLruCheck(){
sl@0:   Vdbe *p;
sl@0:   for(p=sqlite3LruStatements.pFirst; p; p=p->pLruNext){
sl@0:     assert(p->pLruNext || p==sqlite3LruStatements.pLast);
sl@0:     assert(!p->pLruNext || p->pLruNext->pLruPrev==p);
sl@0:     assert(p->pLruPrev || p==sqlite3LruStatements.pFirst);
sl@0:     assert(!p->pLruPrev || p->pLruPrev->pLruNext==p);
sl@0:   }
sl@0:   return 1;
sl@0: }
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Add vdbe p to the end of the statement lru list. It is assumed that
sl@0: ** p is not already part of the list when this is called. The lru list
sl@0: ** is protected by the SQLITE_MUTEX_STATIC_LRU mutex.
sl@0: */
sl@0: static void stmtLruAdd(Vdbe *p){
sl@0:   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
sl@0: 
sl@0:   if( p->pLruPrev || p->pLruNext || sqlite3LruStatements.pFirst==p ){
sl@0:     sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
sl@0:     return;
sl@0:   }
sl@0: 
sl@0:   assert( stmtLruCheck() );
sl@0: 
sl@0:   if( !sqlite3LruStatements.pFirst ){
sl@0:     assert( !sqlite3LruStatements.pLast );
sl@0:     sqlite3LruStatements.pFirst = p;
sl@0:     sqlite3LruStatements.pLast = p;
sl@0:   }else{
sl@0:     assert( !sqlite3LruStatements.pLast->pLruNext );
sl@0:     p->pLruPrev = sqlite3LruStatements.pLast;
sl@0:     sqlite3LruStatements.pLast->pLruNext = p;
sl@0:     sqlite3LruStatements.pLast = p;
sl@0:   }
sl@0: 
sl@0:   assert( stmtLruCheck() );
sl@0: 
sl@0:   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is already held, remove
sl@0: ** statement p from the least-recently-used statement list. If the 
sl@0: ** statement is not currently part of the list, this call is a no-op.
sl@0: */
sl@0: static void stmtLruRemoveNomutex(Vdbe *p){
sl@0:   if( p->pLruPrev || p->pLruNext || p==sqlite3LruStatements.pFirst ){
sl@0:     assert( stmtLruCheck() );
sl@0:     if( p->pLruNext ){
sl@0:       p->pLruNext->pLruPrev = p->pLruPrev;
sl@0:     }else{
sl@0:       sqlite3LruStatements.pLast = p->pLruPrev;
sl@0:     }
sl@0:     if( p->pLruPrev ){
sl@0:       p->pLruPrev->pLruNext = p->pLruNext;
sl@0:     }else{
sl@0:       sqlite3LruStatements.pFirst = p->pLruNext;
sl@0:     }
sl@0:     p->pLruNext = 0;
sl@0:     p->pLruPrev = 0;
sl@0:     assert( stmtLruCheck() );
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is not held, remove
sl@0: ** statement p from the least-recently-used statement list. If the 
sl@0: ** statement is not currently part of the list, this call is a no-op.
sl@0: */
sl@0: static void stmtLruRemove(Vdbe *p){
sl@0:   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
sl@0:   stmtLruRemoveNomutex(p);
sl@0:   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Try to release n bytes of memory by freeing buffers associated 
sl@0: ** with the memory registers of currently unused vdbes.
sl@0: */
sl@0: int sqlite3VdbeReleaseMemory(int n){
sl@0:   Vdbe *p;
sl@0:   Vdbe *pNext;
sl@0:   int nFree = 0;
sl@0: 
sl@0:   sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
sl@0:   for(p=sqlite3LruStatements.pFirst; p && nFree<n; p=pNext){
sl@0:     pNext = p->pLruNext;
sl@0: 
sl@0:     /* For each statement handle in the lru list, attempt to obtain the
sl@0:     ** associated database mutex. If it cannot be obtained, continue
sl@0:     ** to the next statement handle. It is not possible to block on
sl@0:     ** the database mutex - that could cause deadlock.
sl@0:     */
sl@0:     if( SQLITE_OK==sqlite3_mutex_try(p->db->mutex) ){
sl@0:       nFree += sqlite3VdbeReleaseBuffers(p);
sl@0:       stmtLruRemoveNomutex(p);
sl@0:       sqlite3_mutex_leave(p->db->mutex);
sl@0:     }
sl@0:   }
sl@0:   sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
sl@0: 
sl@0:   return nFree;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Call sqlite3Reprepare() on the statement. Remove it from the
sl@0: ** lru list before doing so, as Reprepare() will free all the
sl@0: ** memory register buffers anyway.
sl@0: */
sl@0: int vdbeReprepare(Vdbe *p){
sl@0:   stmtLruRemove(p);
sl@0:   return sqlite3Reprepare(p);
sl@0: }
sl@0: 
sl@0: #else       /* !SQLITE_ENABLE_MEMORY_MANAGEMENT */
sl@0:   #define stmtLruRemove(x)
sl@0:   #define stmtLruAdd(x)
sl@0:   #define vdbeReprepare(x) sqlite3Reprepare(x)
sl@0: #endif
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Return TRUE (non-zero) of the statement supplied as an argument needs
sl@0: ** to be recompiled.  A statement needs to be recompiled whenever the
sl@0: ** execution environment changes in a way that would alter the program
sl@0: ** that sqlite3_prepare() generates.  For example, if new functions or
sl@0: ** collating sequences are registered or if an authorizer function is
sl@0: ** added or changed.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_expired(sqlite3_stmt *pStmt){
sl@0:   Vdbe *p = (Vdbe*)pStmt;
sl@0:   return p==0 || p->expired;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The following routine destroys a virtual machine that is created by
sl@0: ** the sqlite3_compile() routine. The integer returned is an SQLITE_
sl@0: ** success/failure code that describes the result of executing the virtual
sl@0: ** machine.
sl@0: **
sl@0: ** This routine sets the error code and string returned by
sl@0: ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_finalize(sqlite3_stmt *pStmt){
sl@0:   int rc;
sl@0:   if( pStmt==0 ){
sl@0:     rc = SQLITE_OK;
sl@0:   }else{
sl@0:     Vdbe *v = (Vdbe*)pStmt;
sl@0: #ifndef SQLITE_MUTEX_NOOP
sl@0:     sqlite3_mutex *mutex = v->db->mutex;
sl@0: #endif
sl@0:     sqlite3_mutex_enter(mutex);
sl@0:     stmtLruRemove(v);
sl@0:     rc = sqlite3VdbeFinalize(v);
sl@0:     sqlite3_mutex_leave(mutex);
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Terminate the current execution of an SQL statement and reset it
sl@0: ** back to its starting state so that it can be reused. A success code from
sl@0: ** the prior execution is returned.
sl@0: **
sl@0: ** This routine sets the error code and string returned by
sl@0: ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_reset(sqlite3_stmt *pStmt){
sl@0:   int rc;
sl@0:   if( pStmt==0 ){
sl@0:     rc = SQLITE_OK;
sl@0:   }else{
sl@0:     Vdbe *v = (Vdbe*)pStmt;
sl@0:     sqlite3_mutex_enter(v->db->mutex);
sl@0:     rc = sqlite3VdbeReset(v);
sl@0:     stmtLruAdd(v);
sl@0:     sqlite3VdbeMakeReady(v, -1, 0, 0, 0);
sl@0:     assert( (rc & (v->db->errMask))==rc );
sl@0:     sqlite3_mutex_leave(v->db->mutex);
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Set all the parameters in the compiled SQL statement to NULL.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
sl@0:   int i;
sl@0:   int rc = SQLITE_OK;
sl@0:   Vdbe *p = (Vdbe*)pStmt;
sl@0: #ifndef SQLITE_MUTEX_NOOP
sl@0:   sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
sl@0: #endif
sl@0:   sqlite3_mutex_enter(mutex);
sl@0:   for(i=0; i<p->nVar; i++){
sl@0:     sqlite3VdbeMemRelease(&p->aVar[i]);
sl@0:     p->aVar[i].flags = MEM_Null;
sl@0:   }
sl@0:   sqlite3_mutex_leave(mutex);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: 
sl@0: /**************************** sqlite3_value_  *******************************
sl@0: ** The following routines extract information from a Mem or sqlite3_value
sl@0: ** structure.
sl@0: */
sl@0: SQLITE_EXPORT const void *sqlite3_value_blob(sqlite3_value *pVal){
sl@0:   Mem *p = (Mem*)pVal;
sl@0:   if( p->flags & (MEM_Blob|MEM_Str) ){
sl@0:     sqlite3VdbeMemExpandBlob(p);
sl@0:     p->flags &= ~MEM_Str;
sl@0:     p->flags |= MEM_Blob;
sl@0:     return p->z;
sl@0:   }else{
sl@0:     return sqlite3_value_text(pVal);
sl@0:   }
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_value_bytes(sqlite3_value *pVal){
sl@0:   return sqlite3ValueBytes(pVal, SQLITE_UTF8);
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_value_bytes16(sqlite3_value *pVal){
sl@0:   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
sl@0: }
sl@0: SQLITE_EXPORT double sqlite3_value_double(sqlite3_value *pVal){
sl@0:   return sqlite3VdbeRealValue((Mem*)pVal);
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_value_int(sqlite3_value *pVal){
sl@0:   return sqlite3VdbeIntValue((Mem*)pVal);
sl@0: }
sl@0: SQLITE_EXPORT sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
sl@0:   return sqlite3VdbeIntValue((Mem*)pVal);
sl@0: }
sl@0: SQLITE_EXPORT const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
sl@0:   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: SQLITE_EXPORT const void *sqlite3_value_text16(sqlite3_value* pVal){
sl@0:   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
sl@0: }
sl@0: SQLITE_EXPORT const void *sqlite3_value_text16be(sqlite3_value *pVal){
sl@0:   return sqlite3ValueText(pVal, SQLITE_UTF16BE);
sl@0: }
sl@0: SQLITE_EXPORT const void *sqlite3_value_text16le(sqlite3_value *pVal){
sl@0:   return sqlite3ValueText(pVal, SQLITE_UTF16LE);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: SQLITE_EXPORT int sqlite3_value_type(sqlite3_value* pVal){
sl@0:   return pVal->type;
sl@0: }
sl@0: 
sl@0: /**************************** sqlite3_result_  *******************************
sl@0: ** The following routines are used by user-defined functions to specify
sl@0: ** the function result.
sl@0: */
sl@0: SQLITE_EXPORT void sqlite3_result_blob(
sl@0:   sqlite3_context *pCtx, 
sl@0:   const void *z, 
sl@0:   int n, 
sl@0:   void (*xDel)(void *)
sl@0: ){
sl@0:   assert( n>=0 );
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   pCtx->isError = SQLITE_ERROR;
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: SQLITE_EXPORT void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   pCtx->isError = SQLITE_ERROR;
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
sl@0: }
sl@0: #endif
sl@0: SQLITE_EXPORT void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_null(sqlite3_context *pCtx){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetNull(&pCtx->s);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_text(
sl@0:   sqlite3_context *pCtx, 
sl@0:   const char *z, 
sl@0:   int n,
sl@0:   void (*xDel)(void *)
sl@0: ){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: SQLITE_EXPORT void sqlite3_result_text16(
sl@0:   sqlite3_context *pCtx, 
sl@0:   const void *z, 
sl@0:   int n, 
sl@0:   void (*xDel)(void *)
sl@0: ){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_text16be(
sl@0:   sqlite3_context *pCtx, 
sl@0:   const void *z, 
sl@0:   int n, 
sl@0:   void (*xDel)(void *)
sl@0: ){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_text16le(
sl@0:   sqlite3_context *pCtx, 
sl@0:   const void *z, 
sl@0:   int n, 
sl@0:   void (*xDel)(void *)
sl@0: ){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: SQLITE_EXPORT void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemCopy(&pCtx->s, pValue);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
sl@0: }
sl@0: SQLITE_EXPORT void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
sl@0:   pCtx->isError = errCode;
sl@0: }
sl@0: 
sl@0: /* Force an SQLITE_TOOBIG error. */
sl@0: SQLITE_EXPORT void sqlite3_result_error_toobig(sqlite3_context *pCtx){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   pCtx->isError = SQLITE_TOOBIG;
sl@0:   sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1, 
sl@0:                        SQLITE_UTF8, SQLITE_STATIC);
sl@0: }
sl@0: 
sl@0: /* An SQLITE_NOMEM error. */
sl@0: SQLITE_EXPORT void sqlite3_result_error_nomem(sqlite3_context *pCtx){
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   sqlite3VdbeMemSetNull(&pCtx->s);
sl@0:   pCtx->isError = SQLITE_NOMEM;
sl@0:   pCtx->s.db->mallocFailed = 1;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Execute the statement pStmt, either until a row of data is ready, the
sl@0: ** statement is completely executed or an error occurs.
sl@0: **
sl@0: ** This routine implements the bulk of the logic behind the sqlite_step()
sl@0: ** API.  The only thing omitted is the automatic recompile if a 
sl@0: ** schema change has occurred.  That detail is handled by the
sl@0: ** outer sqlite3_step() wrapper procedure.
sl@0: */
sl@0: static int sqlite3Step(Vdbe *p){
sl@0:   sqlite3 *db;
sl@0:   int rc;
sl@0: 
sl@0:   assert(p);
sl@0:   if( p->magic!=VDBE_MAGIC_RUN ){
sl@0:     return SQLITE_MISUSE;
sl@0:   }
sl@0: 
sl@0:   /* Assert that malloc() has not failed */
sl@0:   db = p->db;
sl@0:   if( db->mallocFailed ){
sl@0:     return SQLITE_NOMEM;
sl@0:   }
sl@0: 
sl@0:   if( p->pc<=0 && p->expired ){
sl@0:     if( p->rc==SQLITE_OK ){
sl@0:       p->rc = SQLITE_SCHEMA;
sl@0:     }
sl@0:     rc = SQLITE_ERROR;
sl@0:     goto end_of_step;
sl@0:   }
sl@0:   if( sqlite3SafetyOn(db) ){
sl@0:     p->rc = SQLITE_MISUSE;
sl@0:     return SQLITE_MISUSE;
sl@0:   }
sl@0:   if( p->pc<0 ){
sl@0:     /* If there are no other statements currently running, then
sl@0:     ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt
sl@0:     ** from interrupting a statement that has not yet started.
sl@0:     */
sl@0:     if( db->activeVdbeCnt==0 ){
sl@0:       db->u1.isInterrupted = 0;
sl@0:     }
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRACE
sl@0:     if( db->xProfile && !db->init.busy ){
sl@0:       double rNow;
sl@0:       sqlite3OsCurrentTime(db->pVfs, &rNow);
sl@0:       p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;
sl@0:     }
sl@0: #endif
sl@0: 
sl@0:     db->activeVdbeCnt++;
sl@0:     p->pc = 0;
sl@0:     stmtLruRemove(p);
sl@0:   }
sl@0: #ifndef SQLITE_OMIT_EXPLAIN
sl@0:   if( p->explain ){
sl@0:     rc = sqlite3VdbeList(p);
sl@0:   }else
sl@0: #endif /* SQLITE_OMIT_EXPLAIN */
sl@0:   {
sl@0:     rc = sqlite3VdbeExec(p);
sl@0:   }
sl@0: 
sl@0:   if( sqlite3SafetyOff(db) ){
sl@0:     rc = SQLITE_MISUSE;
sl@0:   }
sl@0: 
sl@0: #ifndef SQLITE_OMIT_TRACE
sl@0:   /* Invoke the profile callback if there is one
sl@0:   */
sl@0:   if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->nOp>0
sl@0:            && p->aOp[0].opcode==OP_Trace && p->aOp[0].p4.z!=0 ){
sl@0:     double rNow;
sl@0:     u64 elapseTime;
sl@0: 
sl@0:     sqlite3OsCurrentTime(db->pVfs, &rNow);
sl@0:     elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;
sl@0:     db->xProfile(db->pProfileArg, p->aOp[0].p4.z, elapseTime);
sl@0:   }
sl@0: #endif
sl@0: 
sl@0:   db->errCode = rc;
sl@0:   /*sqlite3Error(p->db, rc, 0);*/
sl@0:   p->rc = sqlite3ApiExit(p->db, p->rc);
sl@0: end_of_step:
sl@0:   assert( (rc&0xff)==rc );
sl@0:   if( p->zSql && (rc&0xff)<SQLITE_ROW ){
sl@0:     /* This behavior occurs if sqlite3_prepare_v2() was used to build
sl@0:     ** the prepared statement.  Return error codes directly */
sl@0:     p->db->errCode = p->rc;
sl@0:     /* sqlite3Error(p->db, p->rc, 0); */
sl@0:     return p->rc;
sl@0:   }else{
sl@0:     /* This is for legacy sqlite3_prepare() builds and when the code
sl@0:     ** is SQLITE_ROW or SQLITE_DONE */
sl@0:     return rc;
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This is the top-level implementation of sqlite3_step().  Call
sl@0: ** sqlite3Step() to do most of the work.  If a schema error occurs,
sl@0: ** call sqlite3Reprepare() and try again.
sl@0: */
sl@0: #ifdef SQLITE_OMIT_PARSER
sl@0: int sqlite3_step(sqlite3_stmt *pStmt){
sl@0:   int rc = SQLITE_MISUSE;
sl@0:   if( pStmt ){
sl@0:     Vdbe *v;
sl@0:     v = (Vdbe*)pStmt;
sl@0:     sqlite3_mutex_enter(v->db->mutex);
sl@0:     rc = sqlite3Step(v);
sl@0:     sqlite3_mutex_leave(v->db->mutex);
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: #else
sl@0: SQLITE_EXPORT int sqlite3_step(sqlite3_stmt *pStmt){
sl@0:   int rc = SQLITE_MISUSE;
sl@0:   if( pStmt ){
sl@0:     int cnt = 0;
sl@0:     Vdbe *v = (Vdbe*)pStmt;
sl@0:     sqlite3 *db = v->db;
sl@0:     sqlite3_mutex_enter(db->mutex);
sl@0:     while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
sl@0:            && cnt++ < 5
sl@0:            && vdbeReprepare(v) ){
sl@0:       sqlite3_reset(pStmt);
sl@0:       v->expired = 0;
sl@0:     }
sl@0:     if( rc==SQLITE_SCHEMA && v->zSql && db->pErr ){
sl@0:       /* This case occurs after failing to recompile an sql statement. 
sl@0:       ** The error message from the SQL compiler has already been loaded 
sl@0:       ** into the database handle. This block copies the error message 
sl@0:       ** from the database handle into the statement and sets the statement
sl@0:       ** program counter to 0 to ensure that when the statement is 
sl@0:       ** finalized or reset the parser error message is available via
sl@0:       ** sqlite3_errmsg() and sqlite3_errcode().
sl@0:       */
sl@0:       const char *zErr = (const char *)sqlite3_value_text(db->pErr); 
sl@0:       sqlite3DbFree(db, v->zErrMsg);
sl@0:       if( !db->mallocFailed ){
sl@0:         v->zErrMsg = sqlite3DbStrDup(db, zErr);
sl@0:       } else {
sl@0:         v->zErrMsg = 0;
sl@0:         v->rc = SQLITE_NOMEM;
sl@0:       }
sl@0:     }
sl@0:     rc = sqlite3ApiExit(db, rc);
sl@0:     sqlite3_mutex_leave(db->mutex);
sl@0:   }
sl@0:   return rc;
sl@0: }
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Extract the user data from a sqlite3_context structure and return a
sl@0: ** pointer to it.
sl@0: */
sl@0: SQLITE_EXPORT void *sqlite3_user_data(sqlite3_context *p){
sl@0:   assert( p && p->pFunc );
sl@0:   return p->pFunc->pUserData;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Extract the user data from a sqlite3_context structure and return a
sl@0: ** pointer to it.
sl@0: */
sl@0: SQLITE_EXPORT sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
sl@0:   assert( p && p->pFunc );
sl@0:   return p->s.db;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** The following is the implementation of an SQL function that always
sl@0: ** fails with an error message stating that the function is used in the
sl@0: ** wrong context.  The sqlite3_overload_function() API might construct
sl@0: ** SQL function that use this routine so that the functions will exist
sl@0: ** for name resolution but are actually overloaded by the xFindFunction
sl@0: ** method of virtual tables.
sl@0: */
sl@0: void sqlite3InvalidFunction(
sl@0:   sqlite3_context *context,  /* The function calling context */
sl@0:   int argc,                  /* Number of arguments to the function */
sl@0:   sqlite3_value **argv       /* Value of each argument */
sl@0: ){
sl@0:   const char *zName = context->pFunc->zName;
sl@0:   char *zErr;
sl@0:   zErr = sqlite3MPrintf(0,
sl@0:       "unable to use function %s in the requested context", zName);
sl@0:   sqlite3_result_error(context, zErr, -1);
sl@0:   sqlite3_free(zErr);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Allocate or return the aggregate context for a user function.  A new
sl@0: ** context is allocated on the first call.  Subsequent calls return the
sl@0: ** same context that was returned on prior calls.
sl@0: */
sl@0: SQLITE_EXPORT void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
sl@0:   Mem *pMem;
sl@0:   assert( p && p->pFunc && p->pFunc->xStep );
sl@0:   assert( sqlite3_mutex_held(p->s.db->mutex) );
sl@0:   pMem = p->pMem;
sl@0:   if( (pMem->flags & MEM_Agg)==0 ){
sl@0:     if( nByte==0 ){
sl@0:       sqlite3VdbeMemReleaseExternal(pMem);
sl@0:       pMem->flags = MEM_Null;
sl@0:       pMem->z = 0;
sl@0:     }else{
sl@0:       sqlite3VdbeMemGrow(pMem, nByte, 0);
sl@0:       pMem->flags = MEM_Agg;
sl@0:       pMem->u.pDef = p->pFunc;
sl@0:       if( pMem->z ){
sl@0:         memset(pMem->z, 0, nByte);
sl@0:       }
sl@0:     }
sl@0:   }
sl@0:   return (void*)pMem->z;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the auxilary data pointer, if any, for the iArg'th argument to
sl@0: ** the user-function defined by pCtx.
sl@0: */
sl@0: SQLITE_EXPORT void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
sl@0:   VdbeFunc *pVdbeFunc;
sl@0: 
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   pVdbeFunc = pCtx->pVdbeFunc;
sl@0:   if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   return pVdbeFunc->apAux[iArg].pAux;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Set the auxilary data pointer and delete function, for the iArg'th
sl@0: ** argument to the user-function defined by pCtx. Any previous value is
sl@0: ** deleted by calling the delete function specified when it was set.
sl@0: */
sl@0: SQLITE_EXPORT void sqlite3_set_auxdata(
sl@0:   sqlite3_context *pCtx, 
sl@0:   int iArg, 
sl@0:   void *pAux, 
sl@0:   void (*xDelete)(void*)
sl@0: ){
sl@0:   struct AuxData *pAuxData;
sl@0:   VdbeFunc *pVdbeFunc;
sl@0:   if( iArg<0 ) goto failed;
sl@0: 
sl@0:   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
sl@0:   pVdbeFunc = pCtx->pVdbeFunc;
sl@0:   if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
sl@0:     int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
sl@0:     int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
sl@0:     pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
sl@0:     if( !pVdbeFunc ){
sl@0:       goto failed;
sl@0:     }
sl@0:     pCtx->pVdbeFunc = pVdbeFunc;
sl@0:     memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
sl@0:     pVdbeFunc->nAux = iArg+1;
sl@0:     pVdbeFunc->pFunc = pCtx->pFunc;
sl@0:   }
sl@0: 
sl@0:   pAuxData = &pVdbeFunc->apAux[iArg];
sl@0:   if( pAuxData->pAux && pAuxData->xDelete ){
sl@0:     pAuxData->xDelete(pAuxData->pAux);
sl@0:   }
sl@0:   pAuxData->pAux = pAux;
sl@0:   pAuxData->xDelete = xDelete;
sl@0:   return;
sl@0: 
sl@0: failed:
sl@0:   if( xDelete ){
sl@0:     xDelete(pAux);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the number of times the Step function of a aggregate has been 
sl@0: ** called.
sl@0: **
sl@0: ** This function is deprecated.  Do not use it for new code.  It is
sl@0: ** provide only to avoid breaking legacy code.  New aggregate function
sl@0: ** implementations should keep their own counts within their aggregate
sl@0: ** context.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_aggregate_count(sqlite3_context *p){
sl@0:   assert( p && p->pFunc && p->pFunc->xStep );
sl@0:   return p->pMem->n;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the number of columns in the result set for the statement pStmt.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_column_count(sqlite3_stmt *pStmt){
sl@0:   Vdbe *pVm = (Vdbe *)pStmt;
sl@0:   return pVm ? pVm->nResColumn : 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the number of values available from the current row of the
sl@0: ** currently executing statement pStmt.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_data_count(sqlite3_stmt *pStmt){
sl@0:   Vdbe *pVm = (Vdbe *)pStmt;
sl@0:   if( pVm==0 || pVm->pResultSet==0 ) return 0;
sl@0:   return pVm->nResColumn;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Check to see if column iCol of the given statement is valid.  If
sl@0: ** it is, return a pointer to the Mem for the value of that column.
sl@0: ** If iCol is not valid, return a pointer to a Mem which has a value
sl@0: ** of NULL.
sl@0: */
sl@0: static Mem *columnMem(sqlite3_stmt *pStmt, int i){
sl@0:   Vdbe *pVm;
sl@0:   int vals;
sl@0:   Mem *pOut;
sl@0: 
sl@0:   pVm = (Vdbe *)pStmt;
sl@0:   if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
sl@0:     sqlite3_mutex_enter(pVm->db->mutex);
sl@0:     vals = sqlite3_data_count(pStmt);
sl@0:     pOut = &pVm->pResultSet[i];
sl@0:   }else{
sl@0:     static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };
sl@0:     if( pVm->db ){
sl@0:       sqlite3_mutex_enter(pVm->db->mutex);
sl@0:       sqlite3Error(pVm->db, SQLITE_RANGE, 0);
sl@0:     }
sl@0:     pOut = (Mem*)&nullMem;
sl@0:   }
sl@0:   return pOut;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** This function is called after invoking an sqlite3_value_XXX function on a 
sl@0: ** column value (i.e. a value returned by evaluating an SQL expression in the
sl@0: ** select list of a SELECT statement) that may cause a malloc() failure. If 
sl@0: ** malloc() has failed, the threads mallocFailed flag is cleared and the result
sl@0: ** code of statement pStmt set to SQLITE_NOMEM.
sl@0: **
sl@0: ** Specifically, this is called from within:
sl@0: **
sl@0: **     sqlite3_column_int()
sl@0: **     sqlite3_column_int64()
sl@0: **     sqlite3_column_text()
sl@0: **     sqlite3_column_text16()
sl@0: **     sqlite3_column_real()
sl@0: **     sqlite3_column_bytes()
sl@0: **     sqlite3_column_bytes16()
sl@0: **
sl@0: ** But not for sqlite3_column_blob(), which never calls malloc().
sl@0: */
sl@0: static void columnMallocFailure(sqlite3_stmt *pStmt)
sl@0: {
sl@0:   /* If malloc() failed during an encoding conversion within an
sl@0:   ** sqlite3_column_XXX API, then set the return code of the statement to
sl@0:   ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
sl@0:   ** and _finalize() will return NOMEM.
sl@0:   */
sl@0:   Vdbe *p = (Vdbe *)pStmt;
sl@0:   if( p ){
sl@0:     p->rc = sqlite3ApiExit(p->db, p->rc);
sl@0:     sqlite3_mutex_leave(p->db->mutex);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /**************************** sqlite3_column_  *******************************
sl@0: ** The following routines are used to access elements of the current row
sl@0: ** in the result set.
sl@0: */
sl@0: SQLITE_EXPORT const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
sl@0:   const void *val;
sl@0:   val = sqlite3_value_blob( columnMem(pStmt,i) );
sl@0:   /* Even though there is no encoding conversion, value_blob() might
sl@0:   ** need to call malloc() to expand the result of a zeroblob() 
sl@0:   ** expression. 
sl@0:   */
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
sl@0:   int val = sqlite3_value_bytes( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
sl@0:   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: SQLITE_EXPORT double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
sl@0:   double val = sqlite3_value_double( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
sl@0:   int val = sqlite3_value_int( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: SQLITE_EXPORT sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
sl@0:   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: SQLITE_EXPORT const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
sl@0:   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: SQLITE_EXPORT sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
sl@0:   sqlite3_value *pOut = columnMem(pStmt, i);
sl@0:   columnMallocFailure(pStmt);
sl@0:   return pOut;
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: SQLITE_EXPORT const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
sl@0:   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return val;
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: SQLITE_EXPORT int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
sl@0:   int iType = sqlite3_value_type( columnMem(pStmt,i) );
sl@0:   columnMallocFailure(pStmt);
sl@0:   return iType;
sl@0: }
sl@0: 
sl@0: /* The following function is experimental and subject to change or
sl@0: ** removal */
sl@0: /*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
sl@0: **  return sqlite3_value_numeric_type( columnMem(pStmt,i) );
sl@0: **}
sl@0: */
sl@0: 
sl@0: /*
sl@0: ** Convert the N-th element of pStmt->pColName[] into a string using
sl@0: ** xFunc() then return that string.  If N is out of range, return 0.
sl@0: **
sl@0: ** There are up to 5 names for each column.  useType determines which
sl@0: ** name is returned.  Here are the names:
sl@0: **
sl@0: **    0      The column name as it should be displayed for output
sl@0: **    1      The datatype name for the column
sl@0: **    2      The name of the database that the column derives from
sl@0: **    3      The name of the table that the column derives from
sl@0: **    4      The name of the table column that the result column derives from
sl@0: **
sl@0: ** If the result is not a simple column reference (if it is an expression
sl@0: ** or a constant) then useTypes 2, 3, and 4 return NULL.
sl@0: */
sl@0: static const void *columnName(
sl@0:   sqlite3_stmt *pStmt,
sl@0:   int N,
sl@0:   const void *(*xFunc)(Mem*),
sl@0:   int useType
sl@0: ){
sl@0:   const void *ret = 0;
sl@0:   Vdbe *p = (Vdbe *)pStmt;
sl@0:   int n;
sl@0:   
sl@0: 
sl@0:   if( p!=0 ){
sl@0:     n = sqlite3_column_count(pStmt);
sl@0:     if( N<n && N>=0 ){
sl@0:       N += useType*n;
sl@0:       sqlite3_mutex_enter(p->db->mutex);
sl@0:       ret = xFunc(&p->aColName[N]);
sl@0: 
sl@0:       /* A malloc may have failed inside of the xFunc() call. If this
sl@0:       ** is the case, clear the mallocFailed flag and return NULL.
sl@0:       */
sl@0:       if( p->db && p->db->mallocFailed ){
sl@0:         p->db->mallocFailed = 0;
sl@0:         ret = 0;
sl@0:       }
sl@0:       sqlite3_mutex_leave(p->db->mutex);
sl@0:     }
sl@0:   }
sl@0:   return ret;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the name of the Nth column of the result set returned by SQL
sl@0: ** statement pStmt.
sl@0: */
sl@0: SQLITE_EXPORT const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: SQLITE_EXPORT const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
sl@0: }
sl@0: #endif
sl@0: 
sl@0: /*
sl@0: ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must
sl@0: ** not define OMIT_DECLTYPE.
sl@0: */
sl@0: #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
sl@0: # error "Must not define both SQLITE_OMIT_DECLTYPE \
sl@0:          and SQLITE_ENABLE_COLUMN_METADATA"
sl@0: #endif
sl@0: 
sl@0: #ifndef SQLITE_OMIT_DECLTYPE
sl@0: /*
sl@0: ** Return the column declaration type (if applicable) of the 'i'th column
sl@0: ** of the result set of SQL statement pStmt.
sl@0: */
sl@0: SQLITE_EXPORT const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: SQLITE_EXPORT const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: #endif /* SQLITE_OMIT_DECLTYPE */
sl@0: 
sl@0: #ifdef SQLITE_ENABLE_COLUMN_METADATA
sl@0: /*
sl@0: ** Return the name of the database from which a result column derives.
sl@0: ** NULL is returned if the result column is an expression or constant or
sl@0: ** anything else which is not an unabiguous reference to a database column.
sl@0: */
sl@0: const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: 
sl@0: /*
sl@0: ** Return the name of the table from which a result column derives.
sl@0: ** NULL is returned if the result column is an expression or constant or
sl@0: ** anything else which is not an unabiguous reference to a database column.
sl@0: */
sl@0: const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: 
sl@0: /*
sl@0: ** Return the name of the table column from which a result column derives.
sl@0: ** NULL is returned if the result column is an expression or constant or
sl@0: ** anything else which is not an unabiguous reference to a database column.
sl@0: */
sl@0: const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
sl@0:   return columnName(
sl@0:       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: #endif /* SQLITE_ENABLE_COLUMN_METADATA */
sl@0: 
sl@0: 
sl@0: /******************************* sqlite3_bind_  ***************************
sl@0: ** 
sl@0: ** Routines used to attach values to wildcards in a compiled SQL statement.
sl@0: */
sl@0: /*
sl@0: ** Unbind the value bound to variable i in virtual machine p. This is the 
sl@0: ** the same as binding a NULL value to the column. If the "i" parameter is
sl@0: ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
sl@0: **
sl@0: ** The error code stored in database p->db is overwritten with the return
sl@0: ** value in any case.
sl@0: */
sl@0: static int vdbeUnbind(Vdbe *p, int i){
sl@0:   Mem *pVar;
sl@0:   if( p==0 || p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
sl@0:     if( p ) sqlite3Error(p->db, SQLITE_MISUSE, 0);
sl@0:     return SQLITE_MISUSE;
sl@0:   }
sl@0:   if( i<1 || i>p->nVar ){
sl@0:     sqlite3Error(p->db, SQLITE_RANGE, 0);
sl@0:     return SQLITE_RANGE;
sl@0:   }
sl@0:   i--;
sl@0:   pVar = &p->aVar[i];
sl@0:   sqlite3VdbeMemRelease(pVar);
sl@0:   pVar->flags = MEM_Null;
sl@0:   sqlite3Error(p->db, SQLITE_OK, 0);
sl@0:   return SQLITE_OK;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Bind a text or BLOB value.
sl@0: */
sl@0: static int bindText(
sl@0:   sqlite3_stmt *pStmt,   /* The statement to bind against */
sl@0:   int i,                 /* Index of the parameter to bind */
sl@0:   const void *zData,     /* Pointer to the data to be bound */
sl@0:   int nData,             /* Number of bytes of data to be bound */
sl@0:   void (*xDel)(void*),   /* Destructor for the data */
sl@0:   int encoding           /* Encoding for the data */
sl@0: ){
sl@0:   Vdbe *p = (Vdbe *)pStmt;
sl@0:   Mem *pVar;
sl@0:   int rc;
sl@0: 
sl@0:   if( p==0 ){
sl@0:     return SQLITE_MISUSE;
sl@0:   }
sl@0:   sqlite3_mutex_enter(p->db->mutex);
sl@0:   rc = vdbeUnbind(p, i);
sl@0:   if( rc==SQLITE_OK && zData!=0 ){
sl@0:     pVar = &p->aVar[i-1];
sl@0:     rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
sl@0:     if( rc==SQLITE_OK && encoding!=0 ){
sl@0:       rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
sl@0:     }
sl@0:     sqlite3Error(p->db, rc, 0);
sl@0:     rc = sqlite3ApiExit(p->db, rc);
sl@0:   }
sl@0:   sqlite3_mutex_leave(p->db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: 
sl@0: /*
sl@0: ** Bind a blob value to an SQL statement variable.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_bind_blob(
sl@0:   sqlite3_stmt *pStmt, 
sl@0:   int i, 
sl@0:   const void *zData, 
sl@0:   int nData, 
sl@0:   void (*xDel)(void*)
sl@0: ){
sl@0:   return bindText(pStmt, i, zData, nData, xDel, 0);
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
sl@0:   int rc;
sl@0:   Vdbe *p = (Vdbe *)pStmt;
sl@0:   sqlite3_mutex_enter(p->db->mutex);
sl@0:   rc = vdbeUnbind(p, i);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
sl@0:   }
sl@0:   sqlite3_mutex_leave(p->db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
sl@0:   return sqlite3_bind_int64(p, i, (i64)iValue);
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
sl@0:   int rc;
sl@0:   Vdbe *p = (Vdbe *)pStmt;
sl@0:   sqlite3_mutex_enter(p->db->mutex);
sl@0:   rc = vdbeUnbind(p, i);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
sl@0:   }
sl@0:   sqlite3_mutex_leave(p->db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
sl@0:   int rc;
sl@0:   Vdbe *p = (Vdbe*)pStmt;
sl@0:   sqlite3_mutex_enter(p->db->mutex);
sl@0:   rc = vdbeUnbind(p, i);
sl@0:   sqlite3_mutex_leave(p->db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_bind_text( 
sl@0:   sqlite3_stmt *pStmt, 
sl@0:   int i, 
sl@0:   const char *zData, 
sl@0:   int nData, 
sl@0:   void (*xDel)(void*)
sl@0: ){
sl@0:   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
sl@0: }
sl@0: #ifndef SQLITE_OMIT_UTF16
sl@0: SQLITE_EXPORT int sqlite3_bind_text16(
sl@0:   sqlite3_stmt *pStmt, 
sl@0:   int i, 
sl@0:   const void *zData, 
sl@0:   int nData, 
sl@0:   void (*xDel)(void*)
sl@0: ){
sl@0:   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
sl@0: }
sl@0: #endif /* SQLITE_OMIT_UTF16 */
sl@0: SQLITE_EXPORT int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
sl@0:   int rc;
sl@0:   Vdbe *p = (Vdbe *)pStmt;
sl@0:   sqlite3_mutex_enter(p->db->mutex);
sl@0:   rc = vdbeUnbind(p, i);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);
sl@0:     if( rc==SQLITE_OK ){
sl@0:       rc = sqlite3VdbeChangeEncoding(&p->aVar[i-1], ENC(p->db));
sl@0:     }
sl@0:   }
sl@0:   rc = sqlite3ApiExit(p->db, rc);
sl@0:   sqlite3_mutex_leave(p->db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: SQLITE_EXPORT int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
sl@0:   int rc;
sl@0:   Vdbe *p = (Vdbe *)pStmt;
sl@0:   sqlite3_mutex_enter(p->db->mutex);
sl@0:   rc = vdbeUnbind(p, i);
sl@0:   if( rc==SQLITE_OK ){
sl@0:     sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
sl@0:   }
sl@0:   sqlite3_mutex_leave(p->db->mutex);
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the number of wildcards that can be potentially bound to.
sl@0: ** This routine is added to support DBD::SQLite.  
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
sl@0:   Vdbe *p = (Vdbe*)pStmt;
sl@0:   return p ? p->nVar : 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Create a mapping from variable numbers to variable names
sl@0: ** in the Vdbe.azVar[] array, if such a mapping does not already
sl@0: ** exist.
sl@0: */
sl@0: static void createVarMap(Vdbe *p){
sl@0:   if( !p->okVar ){
sl@0:     sqlite3_mutex_enter(p->db->mutex);
sl@0:     if( !p->okVar ){
sl@0:       int j;
sl@0:       Op *pOp;
sl@0:       for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
sl@0:         if( pOp->opcode==OP_Variable ){
sl@0:           assert( pOp->p1>0 && pOp->p1<=p->nVar );
sl@0:           p->azVar[pOp->p1-1] = pOp->p4.z;
sl@0:         }
sl@0:       }
sl@0:       p->okVar = 1;
sl@0:     }
sl@0:     sqlite3_mutex_leave(p->db->mutex);
sl@0:   }
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the name of a wildcard parameter.  Return NULL if the index
sl@0: ** is out of range or if the wildcard is unnamed.
sl@0: **
sl@0: ** The result is always UTF-8.
sl@0: */
sl@0: SQLITE_EXPORT const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
sl@0:   Vdbe *p = (Vdbe*)pStmt;
sl@0:   if( p==0 || i<1 || i>p->nVar ){
sl@0:     return 0;
sl@0:   }
sl@0:   createVarMap(p);
sl@0:   return p->azVar[i-1];
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Given a wildcard parameter name, return the index of the variable
sl@0: ** with that name.  If there is no variable with the given name,
sl@0: ** return 0.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
sl@0:   Vdbe *p = (Vdbe*)pStmt;
sl@0:   int i;
sl@0:   if( p==0 ){
sl@0:     return 0;
sl@0:   }
sl@0:   createVarMap(p); 
sl@0:   if( zName ){
sl@0:     for(i=0; i<p->nVar; i++){
sl@0:       const char *z = p->azVar[i];
sl@0:       if( z && strcmp(z,zName)==0 ){
sl@0:         return i+1;
sl@0:       }
sl@0:     }
sl@0:   }
sl@0:   return 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Transfer all bindings from the first statement over to the second.
sl@0: ** If the two statements contain a different number of bindings, then
sl@0: ** an SQLITE_ERROR is returned.
sl@0: */
sl@0: int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
sl@0:   Vdbe *pFrom = (Vdbe*)pFromStmt;
sl@0:   Vdbe *pTo = (Vdbe*)pToStmt;
sl@0:   int i, rc = SQLITE_OK;
sl@0:   if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)
sl@0:     || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)
sl@0:     || pTo->db!=pFrom->db ){
sl@0:     return SQLITE_MISUSE;
sl@0:   }
sl@0:   if( pFrom->nVar!=pTo->nVar ){
sl@0:     return SQLITE_ERROR;
sl@0:   }
sl@0:   sqlite3_mutex_enter(pTo->db->mutex);
sl@0:   for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){
sl@0:     sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
sl@0:   }
sl@0:   sqlite3_mutex_leave(pTo->db->mutex);
sl@0:   assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
sl@0:   return rc;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Deprecated external interface.  Internal/core SQLite code
sl@0: ** should call sqlite3TransferBindings.
sl@0: */
sl@0: SQLITE_EXPORT int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
sl@0:   return sqlite3TransferBindings(pFromStmt, pToStmt);
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return the sqlite3* database handle to which the prepared statement given
sl@0: ** in the argument belongs.  This is the same database handle that was
sl@0: ** the first argument to the sqlite3_prepare() that was used to create
sl@0: ** the statement in the first place.
sl@0: */
sl@0: SQLITE_EXPORT sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
sl@0:   return pStmt ? ((Vdbe*)pStmt)->db : 0;
sl@0: }
sl@0: 
sl@0: /*
sl@0: ** Return a pointer to the next prepared statement after pStmt associated
sl@0: ** with database connection pDb.  If pStmt is NULL, return the first
sl@0: ** prepared statement for the database connection.  Return NULL if there
sl@0: ** are no more.
sl@0: */
sl@0: SQLITE_EXPORT sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
sl@0:   sqlite3_stmt *pNext;
sl@0:   sqlite3_mutex_enter(pDb->mutex);
sl@0:   if( pStmt==0 ){
sl@0:     pNext = (sqlite3_stmt*)pDb->pVdbe;
sl@0:   }else{
sl@0:     pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
sl@0:   }
sl@0:   sqlite3_mutex_leave(pDb->mutex);
sl@0:   return pNext;
sl@0: }