000001  /*
000002  ** 2004 May 26
000003  **
000004  ** The author disclaims copyright to this source code.  In place of
000005  ** a legal notice, here is a blessing:
000006  **
000007  **    May you do good and not evil.
000008  **    May you find forgiveness for yourself and forgive others.
000009  **    May you share freely, never taking more than you give.
000010  **
000011  *************************************************************************
000012  **
000013  ** This file contains code use to implement APIs that are part of the
000014  ** VDBE.
000015  */
000016  #include "sqliteInt.h"
000017  #include "vdbeInt.h"
000018  #include "opcodes.h"
000019  
000020  #ifndef SQLITE_OMIT_DEPRECATED
000021  /*
000022  ** Return TRUE (non-zero) of the statement supplied as an argument needs
000023  ** to be recompiled.  A statement needs to be recompiled whenever the
000024  ** execution environment changes in a way that would alter the program
000025  ** that sqlite3_prepare() generates.  For example, if new functions or
000026  ** collating sequences are registered or if an authorizer function is
000027  ** added or changed.
000028  */
000029  int sqlite3_expired(sqlite3_stmt *pStmt){
000030    Vdbe *p = (Vdbe*)pStmt;
000031    return p==0 || p->expired;
000032  }
000033  #endif
000034  
000035  /*
000036  ** Check on a Vdbe to make sure it has not been finalized.  Log
000037  ** an error and return true if it has been finalized (or is otherwise
000038  ** invalid).  Return false if it is ok.
000039  */
000040  static int vdbeSafety(Vdbe *p){
000041    if( p->db==0 ){
000042      sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement");
000043      return 1;
000044    }else{
000045      return 0;
000046    }
000047  }
000048  static int vdbeSafetyNotNull(Vdbe *p){
000049    if( p==0 ){
000050      sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement");
000051      return 1;
000052    }else{
000053      return vdbeSafety(p);
000054    }
000055  }
000056  
000057  #ifndef SQLITE_OMIT_TRACE
000058  /*
000059  ** Invoke the profile callback.  This routine is only called if we already
000060  ** know that the profile callback is defined and needs to be invoked.
000061  */
000062  static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
000063    sqlite3_int64 iNow;
000064    sqlite3_int64 iElapse;
000065    assert( p->startTime>0 );
000066    assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 );
000067    assert( db->init.busy==0 );
000068    assert( p->zSql!=0 );
000069    sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
000070    iElapse = (iNow - p->startTime)*1000000;
000071  #ifndef SQLITE_OMIT_DEPRECATED
000072    if( db->xProfile ){
000073      db->xProfile(db->pProfileArg, p->zSql, iElapse);
000074    }
000075  #endif
000076    if( db->mTrace & SQLITE_TRACE_PROFILE ){
000077      db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
000078    }
000079    p->startTime = 0;
000080  }
000081  /*
000082  ** The checkProfileCallback(DB,P) macro checks to see if a profile callback
000083  ** is needed, and it invokes the callback if it is needed.
000084  */
000085  # define checkProfileCallback(DB,P) \
000086     if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); }
000087  #else
000088  # define checkProfileCallback(DB,P)  /*no-op*/
000089  #endif
000090  
000091  /*
000092  ** The following routine destroys a virtual machine that is created by
000093  ** the sqlite3_compile() routine. The integer returned is an SQLITE_
000094  ** success/failure code that describes the result of executing the virtual
000095  ** machine.
000096  **
000097  ** This routine sets the error code and string returned by
000098  ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
000099  */
000100  int sqlite3_finalize(sqlite3_stmt *pStmt){
000101    int rc;
000102    if( pStmt==0 ){
000103      /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
000104      ** pointer is a harmless no-op. */
000105      rc = SQLITE_OK;
000106    }else{
000107      Vdbe *v = (Vdbe*)pStmt;
000108      sqlite3 *db = v->db;
000109      if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
000110      sqlite3_mutex_enter(db->mutex);
000111      checkProfileCallback(db, v);
000112      assert( v->eVdbeState>=VDBE_READY_STATE );
000113      rc = sqlite3VdbeReset(v);
000114      sqlite3VdbeDelete(v);
000115      rc = sqlite3ApiExit(db, rc);
000116      sqlite3LeaveMutexAndCloseZombie(db);
000117    }
000118    return rc;
000119  }
000120  
000121  /*
000122  ** Terminate the current execution of an SQL statement and reset it
000123  ** back to its starting state so that it can be reused. A success code from
000124  ** the prior execution is returned.
000125  **
000126  ** This routine sets the error code and string returned by
000127  ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
000128  */
000129  int sqlite3_reset(sqlite3_stmt *pStmt){
000130    int rc;
000131    if( pStmt==0 ){
000132      rc = SQLITE_OK;
000133    }else{
000134      Vdbe *v = (Vdbe*)pStmt;
000135      sqlite3 *db = v->db;
000136      sqlite3_mutex_enter(db->mutex);
000137      checkProfileCallback(db, v);
000138      rc = sqlite3VdbeReset(v);
000139      sqlite3VdbeRewind(v);
000140      assert( (rc & (db->errMask))==rc );
000141      rc = sqlite3ApiExit(db, rc);
000142      sqlite3_mutex_leave(db->mutex);
000143    }
000144    return rc;
000145  }
000146  
000147  /*
000148  ** Set all the parameters in the compiled SQL statement to NULL.
000149  */
000150  int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
000151    int i;
000152    int rc = SQLITE_OK;
000153    Vdbe *p = (Vdbe*)pStmt;
000154  #if SQLITE_THREADSAFE
000155    sqlite3_mutex *mutex;
000156  #endif
000157  #ifdef SQLITE_ENABLE_API_ARMOR
000158    if( pStmt==0 ){
000159      return SQLITE_MISUSE_BKPT;
000160    }
000161  #endif
000162  #if SQLITE_THREADSAFE
000163    mutex = p->db->mutex;
000164  #endif
000165    sqlite3_mutex_enter(mutex);
000166    for(i=0; i<p->nVar; i++){
000167      sqlite3VdbeMemRelease(&p->aVar[i]);
000168      p->aVar[i].flags = MEM_Null;
000169    }
000170    assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
000171    if( p->expmask ){
000172      p->expired = 1;
000173    }
000174    sqlite3_mutex_leave(mutex);
000175    return rc;
000176  }
000177  
000178  
000179  /**************************** sqlite3_value_  *******************************
000180  ** The following routines extract information from a Mem or sqlite3_value
000181  ** structure.
000182  */
000183  const void *sqlite3_value_blob(sqlite3_value *pVal){
000184    Mem *p = (Mem*)pVal;
000185    if( p->flags & (MEM_Blob|MEM_Str) ){
000186      if( ExpandBlob(p)!=SQLITE_OK ){
000187        assert( p->flags==MEM_Null && p->z==0 );
000188        return 0;
000189      }
000190      p->flags |= MEM_Blob;
000191      return p->n ? p->z : 0;
000192    }else{
000193      return sqlite3_value_text(pVal);
000194    }
000195  }
000196  int sqlite3_value_bytes(sqlite3_value *pVal){
000197    return sqlite3ValueBytes(pVal, SQLITE_UTF8);
000198  }
000199  int sqlite3_value_bytes16(sqlite3_value *pVal){
000200    return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
000201  }
000202  double sqlite3_value_double(sqlite3_value *pVal){
000203    return sqlite3VdbeRealValue((Mem*)pVal);
000204  }
000205  int sqlite3_value_int(sqlite3_value *pVal){
000206    return (int)sqlite3VdbeIntValue((Mem*)pVal);
000207  }
000208  sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
000209    return sqlite3VdbeIntValue((Mem*)pVal);
000210  }
000211  unsigned int sqlite3_value_subtype(sqlite3_value *pVal){
000212    Mem *pMem = (Mem*)pVal;
000213    return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
000214  }
000215  void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){
000216    Mem *p = (Mem*)pVal;
000217    if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
000218                   (MEM_Null|MEM_Term|MEM_Subtype)
000219     && zPType!=0
000220     && p->eSubtype=='p'
000221     && strcmp(p->u.zPType, zPType)==0
000222    ){
000223      return (void*)p->z;
000224    }else{
000225      return 0;
000226    }
000227  }
000228  const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
000229    return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
000230  }
000231  #ifndef SQLITE_OMIT_UTF16
000232  const void *sqlite3_value_text16(sqlite3_value* pVal){
000233    return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
000234  }
000235  const void *sqlite3_value_text16be(sqlite3_value *pVal){
000236    return sqlite3ValueText(pVal, SQLITE_UTF16BE);
000237  }
000238  const void *sqlite3_value_text16le(sqlite3_value *pVal){
000239    return sqlite3ValueText(pVal, SQLITE_UTF16LE);
000240  }
000241  #endif /* SQLITE_OMIT_UTF16 */
000242  /* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five
000243  ** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating
000244  ** point number string BLOB NULL
000245  */
000246  int sqlite3_value_type(sqlite3_value* pVal){
000247    static const u8 aType[] = {
000248       SQLITE_BLOB,     /* 0x00 (not possible) */
000249       SQLITE_NULL,     /* 0x01 NULL */
000250       SQLITE_TEXT,     /* 0x02 TEXT */
000251       SQLITE_NULL,     /* 0x03 (not possible) */
000252       SQLITE_INTEGER,  /* 0x04 INTEGER */
000253       SQLITE_NULL,     /* 0x05 (not possible) */
000254       SQLITE_INTEGER,  /* 0x06 INTEGER + TEXT */
000255       SQLITE_NULL,     /* 0x07 (not possible) */
000256       SQLITE_FLOAT,    /* 0x08 FLOAT */
000257       SQLITE_NULL,     /* 0x09 (not possible) */
000258       SQLITE_FLOAT,    /* 0x0a FLOAT + TEXT */
000259       SQLITE_NULL,     /* 0x0b (not possible) */
000260       SQLITE_INTEGER,  /* 0x0c (not possible) */
000261       SQLITE_NULL,     /* 0x0d (not possible) */
000262       SQLITE_INTEGER,  /* 0x0e (not possible) */
000263       SQLITE_NULL,     /* 0x0f (not possible) */
000264       SQLITE_BLOB,     /* 0x10 BLOB */
000265       SQLITE_NULL,     /* 0x11 (not possible) */
000266       SQLITE_TEXT,     /* 0x12 (not possible) */
000267       SQLITE_NULL,     /* 0x13 (not possible) */
000268       SQLITE_INTEGER,  /* 0x14 INTEGER + BLOB */
000269       SQLITE_NULL,     /* 0x15 (not possible) */
000270       SQLITE_INTEGER,  /* 0x16 (not possible) */
000271       SQLITE_NULL,     /* 0x17 (not possible) */
000272       SQLITE_FLOAT,    /* 0x18 FLOAT + BLOB */
000273       SQLITE_NULL,     /* 0x19 (not possible) */
000274       SQLITE_FLOAT,    /* 0x1a (not possible) */
000275       SQLITE_NULL,     /* 0x1b (not possible) */
000276       SQLITE_INTEGER,  /* 0x1c (not possible) */
000277       SQLITE_NULL,     /* 0x1d (not possible) */
000278       SQLITE_INTEGER,  /* 0x1e (not possible) */
000279       SQLITE_NULL,     /* 0x1f (not possible) */
000280       SQLITE_FLOAT,    /* 0x20 INTREAL */
000281       SQLITE_NULL,     /* 0x21 (not possible) */
000282       SQLITE_FLOAT,    /* 0x22 INTREAL + TEXT */
000283       SQLITE_NULL,     /* 0x23 (not possible) */
000284       SQLITE_FLOAT,    /* 0x24 (not possible) */
000285       SQLITE_NULL,     /* 0x25 (not possible) */
000286       SQLITE_FLOAT,    /* 0x26 (not possible) */
000287       SQLITE_NULL,     /* 0x27 (not possible) */
000288       SQLITE_FLOAT,    /* 0x28 (not possible) */
000289       SQLITE_NULL,     /* 0x29 (not possible) */
000290       SQLITE_FLOAT,    /* 0x2a (not possible) */
000291       SQLITE_NULL,     /* 0x2b (not possible) */
000292       SQLITE_FLOAT,    /* 0x2c (not possible) */
000293       SQLITE_NULL,     /* 0x2d (not possible) */
000294       SQLITE_FLOAT,    /* 0x2e (not possible) */
000295       SQLITE_NULL,     /* 0x2f (not possible) */
000296       SQLITE_BLOB,     /* 0x30 (not possible) */
000297       SQLITE_NULL,     /* 0x31 (not possible) */
000298       SQLITE_TEXT,     /* 0x32 (not possible) */
000299       SQLITE_NULL,     /* 0x33 (not possible) */
000300       SQLITE_FLOAT,    /* 0x34 (not possible) */
000301       SQLITE_NULL,     /* 0x35 (not possible) */
000302       SQLITE_FLOAT,    /* 0x36 (not possible) */
000303       SQLITE_NULL,     /* 0x37 (not possible) */
000304       SQLITE_FLOAT,    /* 0x38 (not possible) */
000305       SQLITE_NULL,     /* 0x39 (not possible) */
000306       SQLITE_FLOAT,    /* 0x3a (not possible) */
000307       SQLITE_NULL,     /* 0x3b (not possible) */
000308       SQLITE_FLOAT,    /* 0x3c (not possible) */
000309       SQLITE_NULL,     /* 0x3d (not possible) */
000310       SQLITE_FLOAT,    /* 0x3e (not possible) */
000311       SQLITE_NULL,     /* 0x3f (not possible) */
000312    };
000313  #ifdef SQLITE_DEBUG
000314    {
000315      int eType = SQLITE_BLOB;
000316      if( pVal->flags & MEM_Null ){
000317        eType = SQLITE_NULL;
000318      }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){
000319        eType = SQLITE_FLOAT;
000320      }else if( pVal->flags & MEM_Int ){
000321        eType = SQLITE_INTEGER;
000322      }else if( pVal->flags & MEM_Str ){
000323        eType = SQLITE_TEXT;
000324      }
000325      assert( eType == aType[pVal->flags&MEM_AffMask] );
000326    }
000327  #endif
000328    return aType[pVal->flags&MEM_AffMask];
000329  }
000330  int sqlite3_value_encoding(sqlite3_value *pVal){
000331    return pVal->enc;
000332  }
000333  
000334  /* Return true if a parameter to xUpdate represents an unchanged column */
000335  int sqlite3_value_nochange(sqlite3_value *pVal){
000336    return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero);
000337  }
000338  
000339  /* Return true if a parameter value originated from an sqlite3_bind() */
000340  int sqlite3_value_frombind(sqlite3_value *pVal){
000341    return (pVal->flags&MEM_FromBind)!=0;
000342  }
000343  
000344  /* Make a copy of an sqlite3_value object
000345  */
000346  sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){
000347    sqlite3_value *pNew;
000348    if( pOrig==0 ) return 0;
000349    pNew = sqlite3_malloc( sizeof(*pNew) );
000350    if( pNew==0 ) return 0;
000351    memset(pNew, 0, sizeof(*pNew));
000352    memcpy(pNew, pOrig, MEMCELLSIZE);
000353    pNew->flags &= ~MEM_Dyn;
000354    pNew->db = 0;
000355    if( pNew->flags&(MEM_Str|MEM_Blob) ){
000356      pNew->flags &= ~(MEM_Static|MEM_Dyn);
000357      pNew->flags |= MEM_Ephem;
000358      if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
000359        sqlite3ValueFree(pNew);
000360        pNew = 0;
000361      }
000362    }else if( pNew->flags & MEM_Null ){
000363      /* Do not duplicate pointer values */
000364      pNew->flags &= ~(MEM_Term|MEM_Subtype);
000365    }
000366    return pNew;
000367  }
000368  
000369  /* Destroy an sqlite3_value object previously obtained from
000370  ** sqlite3_value_dup().
000371  */
000372  void sqlite3_value_free(sqlite3_value *pOld){
000373    sqlite3ValueFree(pOld);
000374  }
000375   
000376  
000377  /**************************** sqlite3_result_  *******************************
000378  ** The following routines are used by user-defined functions to specify
000379  ** the function result.
000380  **
000381  ** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the
000382  ** result as a string or blob.  Appropriate errors are set if the string/blob
000383  ** is too big or if an OOM occurs.
000384  **
000385  ** The invokeValueDestructor(P,X) routine invokes destructor function X()
000386  ** on value P if P is not going to be used and need to be destroyed.
000387  */
000388  static void setResultStrOrError(
000389    sqlite3_context *pCtx,  /* Function context */
000390    const char *z,          /* String pointer */
000391    int n,                  /* Bytes in string, or negative */
000392    u8 enc,                 /* Encoding of z.  0 for BLOBs */
000393    void (*xDel)(void*)     /* Destructor function */
000394  ){
000395    Mem *pOut = pCtx->pOut;
000396    int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel);
000397    if( rc ){
000398      if( rc==SQLITE_TOOBIG ){
000399        sqlite3_result_error_toobig(pCtx);
000400      }else{
000401        /* The only errors possible from sqlite3VdbeMemSetStr are
000402        ** SQLITE_TOOBIG and SQLITE_NOMEM */
000403        assert( rc==SQLITE_NOMEM );
000404        sqlite3_result_error_nomem(pCtx);
000405      }
000406      return;
000407    }
000408    sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
000409    if( sqlite3VdbeMemTooBig(pOut) ){
000410      sqlite3_result_error_toobig(pCtx);
000411    }
000412  }
000413  static int invokeValueDestructor(
000414    const void *p,             /* Value to destroy */
000415    void (*xDel)(void*),       /* The destructor */
000416    sqlite3_context *pCtx      /* Set a SQLITE_TOOBIG error if not NULL */
000417  ){
000418    assert( xDel!=SQLITE_DYNAMIC );
000419    if( xDel==0 ){
000420      /* noop */
000421    }else if( xDel==SQLITE_TRANSIENT ){
000422      /* noop */
000423    }else{
000424      xDel((void*)p);
000425    }
000426  #ifdef SQLITE_ENABLE_API_ARMOR
000427    if( pCtx!=0 ){
000428      sqlite3_result_error_toobig(pCtx);
000429    }
000430  #else
000431    assert( pCtx!=0 );
000432    sqlite3_result_error_toobig(pCtx);
000433  #endif
000434    return SQLITE_TOOBIG;
000435  }
000436  void sqlite3_result_blob(
000437    sqlite3_context *pCtx,
000438    const void *z,
000439    int n,
000440    void (*xDel)(void *)
000441  ){
000442  #ifdef SQLITE_ENABLE_API_ARMOR
000443    if( pCtx==0 || n<0 ){
000444      invokeValueDestructor(z, xDel, pCtx);
000445      return;
000446    }
000447  #endif
000448    assert( n>=0 );
000449    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000450    setResultStrOrError(pCtx, z, n, 0, xDel);
000451  }
000452  void sqlite3_result_blob64(
000453    sqlite3_context *pCtx,
000454    const void *z,
000455    sqlite3_uint64 n,
000456    void (*xDel)(void *)
000457  ){
000458    assert( xDel!=SQLITE_DYNAMIC );
000459  #ifdef SQLITE_ENABLE_API_ARMOR
000460    if( pCtx==0 ){
000461      invokeValueDestructor(z, xDel, 0);
000462      return;
000463    }
000464  #endif
000465    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000466    if( n>0x7fffffff ){
000467      (void)invokeValueDestructor(z, xDel, pCtx);
000468    }else{
000469      setResultStrOrError(pCtx, z, (int)n, 0, xDel);
000470    }
000471  }
000472  void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
000473  #ifdef SQLITE_ENABLE_API_ARMOR
000474    if( pCtx==0 ) return;
000475  #endif
000476    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000477    sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
000478  }
000479  void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
000480  #ifdef SQLITE_ENABLE_API_ARMOR
000481    if( pCtx==0 ) return;
000482  #endif
000483    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000484    pCtx->isError = SQLITE_ERROR;
000485    sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
000486  }
000487  #ifndef SQLITE_OMIT_UTF16
000488  void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
000489  #ifdef SQLITE_ENABLE_API_ARMOR
000490    if( pCtx==0 ) return;
000491  #endif
000492    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000493    pCtx->isError = SQLITE_ERROR;
000494    sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
000495  }
000496  #endif
000497  void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
000498  #ifdef SQLITE_ENABLE_API_ARMOR
000499    if( pCtx==0 ) return;
000500  #endif
000501    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000502    sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
000503  }
000504  void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
000505  #ifdef SQLITE_ENABLE_API_ARMOR
000506    if( pCtx==0 ) return;
000507  #endif
000508    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000509    sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
000510  }
000511  void sqlite3_result_null(sqlite3_context *pCtx){
000512  #ifdef SQLITE_ENABLE_API_ARMOR
000513    if( pCtx==0 ) return;
000514  #endif
000515    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000516    sqlite3VdbeMemSetNull(pCtx->pOut);
000517  }
000518  void sqlite3_result_pointer(
000519    sqlite3_context *pCtx,
000520    void *pPtr,
000521    const char *zPType,
000522    void (*xDestructor)(void*)
000523  ){
000524    Mem *pOut;
000525  #ifdef SQLITE_ENABLE_API_ARMOR
000526    if( pCtx==0 ){
000527      invokeValueDestructor(pPtr, xDestructor, 0);
000528      return;
000529    }
000530  #endif
000531    pOut = pCtx->pOut;
000532    assert( sqlite3_mutex_held(pOut->db->mutex) );
000533    sqlite3VdbeMemRelease(pOut);
000534    pOut->flags = MEM_Null;
000535    sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor);
000536  }
000537  void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
000538    Mem *pOut;
000539  #ifdef SQLITE_ENABLE_API_ARMOR
000540    if( pCtx==0 ) return;
000541  #endif
000542  #if defined(SQLITE_STRICT_SUBTYPE) && SQLITE_STRICT_SUBTYPE+0!=0
000543    if( pCtx->pFunc!=0
000544     && (pCtx->pFunc->funcFlags & SQLITE_RESULT_SUBTYPE)==0
000545    ){
000546      char zErr[200];
000547      sqlite3_snprintf(sizeof(zErr), zErr,
000548                       "misuse of sqlite3_result_subtype() by %s()", 
000549                       pCtx->pFunc->zName);
000550      sqlite3_result_error(pCtx, zErr, -1);
000551      return;
000552    }
000553  #endif /* SQLITE_STRICT_SUBTYPE */
000554    pOut = pCtx->pOut;
000555    assert( sqlite3_mutex_held(pOut->db->mutex) );
000556    pOut->eSubtype = eSubtype & 0xff;
000557    pOut->flags |= MEM_Subtype;
000558  }
000559  void sqlite3_result_text(
000560    sqlite3_context *pCtx,
000561    const char *z,
000562    int n,
000563    void (*xDel)(void *)
000564  ){
000565  #ifdef SQLITE_ENABLE_API_ARMOR
000566    if( pCtx==0 ){
000567      invokeValueDestructor(z, xDel, 0);
000568      return;
000569    }
000570  #endif
000571    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000572    setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
000573  }
000574  void sqlite3_result_text64(
000575    sqlite3_context *pCtx,
000576    const char *z,
000577    sqlite3_uint64 n,
000578    void (*xDel)(void *),
000579    unsigned char enc
000580  ){
000581  #ifdef SQLITE_ENABLE_API_ARMOR
000582    if( pCtx==0 ){
000583      invokeValueDestructor(z, xDel, 0);
000584      return;
000585    }
000586  #endif
000587    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000588    assert( xDel!=SQLITE_DYNAMIC );
000589    if( enc!=SQLITE_UTF8 ){
000590      if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
000591      n &= ~(u64)1;
000592    }
000593    if( n>0x7fffffff ){
000594      (void)invokeValueDestructor(z, xDel, pCtx);
000595    }else{
000596      setResultStrOrError(pCtx, z, (int)n, enc, xDel);
000597      sqlite3VdbeMemZeroTerminateIfAble(pCtx->pOut);
000598    }
000599  }
000600  #ifndef SQLITE_OMIT_UTF16
000601  void sqlite3_result_text16(
000602    sqlite3_context *pCtx,
000603    const void *z,
000604    int n,
000605    void (*xDel)(void *)
000606  ){
000607    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000608    setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16NATIVE, xDel);
000609  }
000610  void sqlite3_result_text16be(
000611    sqlite3_context *pCtx,
000612    const void *z,
000613    int n,
000614    void (*xDel)(void *)
000615  ){
000616    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000617    setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16BE, xDel);
000618  }
000619  void sqlite3_result_text16le(
000620    sqlite3_context *pCtx,
000621    const void *z,
000622    int n,
000623    void (*xDel)(void *)
000624  ){
000625    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000626    setResultStrOrError(pCtx, z, n & ~(u64)1, SQLITE_UTF16LE, xDel);
000627  }
000628  #endif /* SQLITE_OMIT_UTF16 */
000629  void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
000630    Mem *pOut;
000631  
000632  #ifdef SQLITE_ENABLE_API_ARMOR
000633    if( pCtx==0 ) return;
000634    if( pValue==0 ){
000635      sqlite3_result_null(pCtx);
000636      return;
000637    }
000638  #endif
000639    pOut = pCtx->pOut;
000640    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000641    sqlite3VdbeMemCopy(pOut, pValue);
000642    sqlite3VdbeChangeEncoding(pOut, pCtx->enc);
000643    if( sqlite3VdbeMemTooBig(pOut) ){
000644      sqlite3_result_error_toobig(pCtx);
000645    }
000646  }
000647  void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
000648    sqlite3_result_zeroblob64(pCtx, n>0 ? n : 0);
000649  }
000650  int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
000651    Mem *pOut;
000652  
000653  #ifdef SQLITE_ENABLE_API_ARMOR
000654    if( pCtx==0 ) return SQLITE_MISUSE_BKPT;
000655  #endif
000656    pOut = pCtx->pOut;
000657    assert( sqlite3_mutex_held(pOut->db->mutex) );
000658    if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
000659      sqlite3_result_error_toobig(pCtx);
000660      return SQLITE_TOOBIG;
000661    }
000662  #ifndef SQLITE_OMIT_INCRBLOB
000663    sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
000664    return SQLITE_OK;
000665  #else
000666    return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
000667  #endif
000668  }
000669  void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
000670  #ifdef SQLITE_ENABLE_API_ARMOR
000671    if( pCtx==0 ) return;
000672  #endif
000673    pCtx->isError = errCode ? errCode : -1;
000674  #ifdef SQLITE_DEBUG
000675    if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
000676  #endif
000677    if( pCtx->pOut->flags & MEM_Null ){
000678      setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8,
000679                          SQLITE_STATIC);
000680    }
000681  }
000682  
000683  /* Force an SQLITE_TOOBIG error. */
000684  void sqlite3_result_error_toobig(sqlite3_context *pCtx){
000685  #ifdef SQLITE_ENABLE_API_ARMOR
000686    if( pCtx==0 ) return;
000687  #endif
000688    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000689    pCtx->isError = SQLITE_TOOBIG;
000690    sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
000691                         SQLITE_UTF8, SQLITE_STATIC);
000692  }
000693  
000694  /* An SQLITE_NOMEM error. */
000695  void sqlite3_result_error_nomem(sqlite3_context *pCtx){
000696  #ifdef SQLITE_ENABLE_API_ARMOR
000697    if( pCtx==0 ) return;
000698  #endif
000699    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000700    sqlite3VdbeMemSetNull(pCtx->pOut);
000701    pCtx->isError = SQLITE_NOMEM_BKPT;
000702    sqlite3OomFault(pCtx->pOut->db);
000703  }
000704  
000705  #ifndef SQLITE_UNTESTABLE
000706  /* Force the INT64 value currently stored as the result to be
000707  ** a MEM_IntReal value.  See the SQLITE_TESTCTRL_RESULT_INTREAL
000708  ** test-control.
000709  */
000710  void sqlite3ResultIntReal(sqlite3_context *pCtx){
000711    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000712    if( pCtx->pOut->flags & MEM_Int ){
000713      pCtx->pOut->flags &= ~MEM_Int;
000714      pCtx->pOut->flags |= MEM_IntReal;
000715    }
000716  }
000717  #endif
000718  
000719  
000720  /*
000721  ** This function is called after a transaction has been committed. It
000722  ** invokes callbacks registered with sqlite3_wal_hook() as required.
000723  */
000724  static int doWalCallbacks(sqlite3 *db){
000725    int rc = SQLITE_OK;
000726  #ifndef SQLITE_OMIT_WAL
000727    int i;
000728    for(i=0; i<db->nDb; i++){
000729      Btree *pBt = db->aDb[i].pBt;
000730      if( pBt ){
000731        int nEntry;
000732        sqlite3BtreeEnter(pBt);
000733        nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
000734        sqlite3BtreeLeave(pBt);
000735        if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){
000736          rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry);
000737        }
000738      }
000739    }
000740  #endif
000741    return rc;
000742  }
000743  
000744  
000745  /*
000746  ** Execute the statement pStmt, either until a row of data is ready, the
000747  ** statement is completely executed or an error occurs.
000748  **
000749  ** This routine implements the bulk of the logic behind the sqlite_step()
000750  ** API.  The only thing omitted is the automatic recompile if a
000751  ** schema change has occurred.  That detail is handled by the
000752  ** outer sqlite3_step() wrapper procedure.
000753  */
000754  static int sqlite3Step(Vdbe *p){
000755    sqlite3 *db;
000756    int rc;
000757  
000758    assert(p);
000759    db = p->db;
000760    if( p->eVdbeState!=VDBE_RUN_STATE ){
000761      restart_step:
000762      if( p->eVdbeState==VDBE_READY_STATE ){
000763        if( p->expired ){
000764          p->rc = SQLITE_SCHEMA;
000765          rc = SQLITE_ERROR;
000766          if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
000767            /* If this statement was prepared using saved SQL and an
000768            ** error has occurred, then return the error code in p->rc to the
000769            ** caller. Set the error code in the database handle to the same
000770            ** value.
000771            */
000772            rc = sqlite3VdbeTransferError(p);
000773          }
000774          goto end_of_step;
000775        }
000776  
000777        /* If there are no other statements currently running, then
000778        ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt
000779        ** from interrupting a statement that has not yet started.
000780        */
000781        if( db->nVdbeActive==0 ){
000782          AtomicStore(&db->u1.isInterrupted, 0);
000783        }
000784  
000785        assert( db->nVdbeWrite>0 || db->autoCommit==0
000786            || (db->nDeferredCons==0 && db->nDeferredImmCons==0)
000787        );
000788  
000789  #ifndef SQLITE_OMIT_TRACE
000790        if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0
000791            && !db->init.busy && p->zSql ){
000792          sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
000793        }else{
000794          assert( p->startTime==0 );
000795        }
000796  #endif
000797  
000798        db->nVdbeActive++;
000799        if( p->readOnly==0 ) db->nVdbeWrite++;
000800        if( p->bIsReader ) db->nVdbeRead++;
000801        p->pc = 0;
000802        p->eVdbeState = VDBE_RUN_STATE;
000803      }else
000804  
000805      if( ALWAYS(p->eVdbeState==VDBE_HALT_STATE) ){
000806        /* We used to require that sqlite3_reset() be called before retrying
000807        ** sqlite3_step() after any error or after SQLITE_DONE.  But beginning
000808        ** with version 3.7.0, we changed this so that sqlite3_reset() would
000809        ** be called automatically instead of throwing the SQLITE_MISUSE error.
000810        ** This "automatic-reset" change is not technically an incompatibility,
000811        ** since any application that receives an SQLITE_MISUSE is broken by
000812        ** definition.
000813        **
000814        ** Nevertheless, some published applications that were originally written
000815        ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
000816        ** returns, and those were broken by the automatic-reset change.  As a
000817        ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
000818        ** legacy behavior of returning SQLITE_MISUSE for cases where the
000819        ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
000820        ** or SQLITE_BUSY error.
000821        */
000822  #ifdef SQLITE_OMIT_AUTORESET
000823        if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
000824          sqlite3_reset((sqlite3_stmt*)p);
000825        }else{
000826          return SQLITE_MISUSE_BKPT;
000827        }
000828  #else
000829        sqlite3_reset((sqlite3_stmt*)p);
000830  #endif
000831        assert( p->eVdbeState==VDBE_READY_STATE );
000832        goto restart_step;
000833      }
000834    }
000835  
000836  #ifdef SQLITE_DEBUG
000837    p->rcApp = SQLITE_OK;
000838  #endif
000839  #ifndef SQLITE_OMIT_EXPLAIN
000840    if( p->explain ){
000841      rc = sqlite3VdbeList(p);
000842    }else
000843  #endif /* SQLITE_OMIT_EXPLAIN */
000844    {
000845      db->nVdbeExec++;
000846      rc = sqlite3VdbeExec(p);
000847      db->nVdbeExec--;
000848    }
000849  
000850    if( rc==SQLITE_ROW ){
000851      assert( p->rc==SQLITE_OK );
000852      assert( db->mallocFailed==0 );
000853      db->errCode = SQLITE_ROW;
000854      return SQLITE_ROW;
000855    }else{
000856  #ifndef SQLITE_OMIT_TRACE
000857      /* If the statement completed successfully, invoke the profile callback */
000858      checkProfileCallback(db, p);
000859  #endif
000860      p->pResultRow = 0;
000861      if( rc==SQLITE_DONE && db->autoCommit ){
000862        assert( p->rc==SQLITE_OK );
000863        p->rc = doWalCallbacks(db);
000864        if( p->rc!=SQLITE_OK ){
000865          rc = SQLITE_ERROR;
000866        }
000867      }else if( rc!=SQLITE_DONE && (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){
000868        /* If this statement was prepared using saved SQL and an
000869        ** error has occurred, then return the error code in p->rc to the
000870        ** caller. Set the error code in the database handle to the same value.
000871        */
000872        rc = sqlite3VdbeTransferError(p);
000873      }
000874    }
000875  
000876    db->errCode = rc;
000877    if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
000878      p->rc = SQLITE_NOMEM_BKPT;
000879      if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ) rc = p->rc;
000880    }
000881  end_of_step:
000882    /* There are only a limited number of result codes allowed from the
000883    ** statements prepared using the legacy sqlite3_prepare() interface */
000884    assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0
000885         || rc==SQLITE_ROW  || rc==SQLITE_DONE   || rc==SQLITE_ERROR
000886         || (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE
000887    );
000888    return (rc&db->errMask);
000889  }
000890  
000891  /*
000892  ** This is the top-level implementation of sqlite3_step().  Call
000893  ** sqlite3Step() to do most of the work.  If a schema error occurs,
000894  ** call sqlite3Reprepare() and try again.
000895  */
000896  int sqlite3_step(sqlite3_stmt *pStmt){
000897    int rc = SQLITE_OK;      /* Result from sqlite3Step() */
000898    Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */
000899    int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
000900    sqlite3 *db;             /* The database connection */
000901  
000902    if( vdbeSafetyNotNull(v) ){
000903      return SQLITE_MISUSE_BKPT;
000904    }
000905    db = v->db;
000906    sqlite3_mutex_enter(db->mutex);
000907    while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
000908           && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){
000909      int savedPc = v->pc;
000910      rc = sqlite3Reprepare(v);
000911      if( rc!=SQLITE_OK ){
000912        /* This case occurs after failing to recompile an sql statement.
000913        ** The error message from the SQL compiler has already been loaded
000914        ** into the database handle. This block copies the error message
000915        ** from the database handle into the statement and sets the statement
000916        ** program counter to 0 to ensure that when the statement is
000917        ** finalized or reset the parser error message is available via
000918        ** sqlite3_errmsg() and sqlite3_errcode().
000919        */
000920        const char *zErr = (const char *)sqlite3_value_text(db->pErr);
000921        sqlite3DbFree(db, v->zErrMsg);
000922        if( !db->mallocFailed ){
000923          v->zErrMsg = sqlite3DbStrDup(db, zErr);
000924          v->rc = rc = sqlite3ApiExit(db, rc);
000925        } else {
000926          v->zErrMsg = 0;
000927          v->rc = rc = SQLITE_NOMEM_BKPT;
000928        }
000929        break;
000930      }
000931      sqlite3_reset(pStmt);
000932      if( savedPc>=0 ){
000933        /* Setting minWriteFileFormat to 254 is a signal to the OP_Init and
000934        ** OP_Trace opcodes to *not* perform SQLITE_TRACE_STMT because it has
000935        ** already been done once on a prior invocation that failed due to
000936        ** SQLITE_SCHEMA.   tag-20220401a  */
000937        v->minWriteFileFormat = 254;
000938      }
000939      assert( v->expired==0 );
000940    }
000941    sqlite3_mutex_leave(db->mutex);
000942    return rc;
000943  }
000944  
000945  
000946  /*
000947  ** Extract the user data from a sqlite3_context structure and return a
000948  ** pointer to it.
000949  */
000950  void *sqlite3_user_data(sqlite3_context *p){
000951  #ifdef SQLITE_ENABLE_API_ARMOR
000952    if( p==0 ) return 0;
000953  #endif
000954    assert( p && p->pFunc );
000955    return p->pFunc->pUserData;
000956  }
000957  
000958  /*
000959  ** Extract the user data from a sqlite3_context structure and return a
000960  ** pointer to it.
000961  **
000962  ** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface
000963  ** returns a copy of the pointer to the database connection (the 1st
000964  ** parameter) of the sqlite3_create_function() and
000965  ** sqlite3_create_function16() routines that originally registered the
000966  ** application defined function.
000967  */
000968  sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
000969  #ifdef SQLITE_ENABLE_API_ARMOR
000970    if( p==0 ) return 0;
000971  #else
000972    assert( p && p->pOut );
000973  #endif
000974    return p->pOut->db;
000975  }
000976  
000977  /*
000978  ** If this routine is invoked from within an xColumn method of a virtual
000979  ** table, then it returns true if and only if the the call is during an
000980  ** UPDATE operation and the value of the column will not be modified
000981  ** by the UPDATE.
000982  **
000983  ** If this routine is called from any context other than within the
000984  ** xColumn method of a virtual table, then the return value is meaningless
000985  ** and arbitrary.
000986  **
000987  ** Virtual table implements might use this routine to optimize their
000988  ** performance by substituting a NULL result, or some other light-weight
000989  ** value, as a signal to the xUpdate routine that the column is unchanged.
000990  */
000991  int sqlite3_vtab_nochange(sqlite3_context *p){
000992  #ifdef SQLITE_ENABLE_API_ARMOR
000993    if( p==0 ) return 0;
000994  #else
000995    assert( p );
000996  #endif
000997    return sqlite3_value_nochange(p->pOut);
000998  }
000999  
001000  /*
001001  ** The destructor function for a ValueList object.  This needs to be
001002  ** a separate function, unknowable to the application, to ensure that
001003  ** calls to sqlite3_vtab_in_first()/sqlite3_vtab_in_next() that are not
001004  ** preceded by activation of IN processing via sqlite3_vtab_int() do not
001005  ** try to access a fake ValueList object inserted by a hostile extension.
001006  */
001007  void sqlite3VdbeValueListFree(void *pToDelete){
001008    sqlite3_free(pToDelete);
001009  }
001010  
001011  /*
001012  ** Implementation of sqlite3_vtab_in_first() (if bNext==0) and
001013  ** sqlite3_vtab_in_next() (if bNext!=0).
001014  */
001015  static int valueFromValueList(
001016    sqlite3_value *pVal,        /* Pointer to the ValueList object */
001017    sqlite3_value **ppOut,      /* Store the next value from the list here */
001018    int bNext                   /* 1 for _next(). 0 for _first() */
001019  ){
001020    int rc;
001021    ValueList *pRhs;
001022  
001023    *ppOut = 0;
001024    if( pVal==0 ) return SQLITE_MISUSE_BKPT;
001025    if( (pVal->flags & MEM_Dyn)==0 || pVal->xDel!=sqlite3VdbeValueListFree ){
001026      return SQLITE_ERROR;
001027    }else{
001028      assert( (pVal->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) ==
001029                   (MEM_Null|MEM_Term|MEM_Subtype) );
001030      assert( pVal->eSubtype=='p' );
001031      assert( pVal->u.zPType!=0 && strcmp(pVal->u.zPType,"ValueList")==0 );
001032      pRhs = (ValueList*)pVal->z;
001033    }
001034    if( bNext ){
001035      rc = sqlite3BtreeNext(pRhs->pCsr, 0);
001036    }else{
001037      int dummy = 0;
001038      rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy);
001039      assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) );
001040      if( sqlite3BtreeEof(pRhs->pCsr) ) rc = SQLITE_DONE;
001041    }
001042    if( rc==SQLITE_OK ){
001043      u32 sz;       /* Size of current row in bytes */
001044      Mem sMem;     /* Raw content of current row */
001045      memset(&sMem, 0, sizeof(sMem));
001046      sz = sqlite3BtreePayloadSize(pRhs->pCsr);
001047      rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr,(int)sz,&sMem);
001048      if( rc==SQLITE_OK ){
001049        u8 *zBuf = (u8*)sMem.z;
001050        u32 iSerial;
001051        sqlite3_value *pOut = pRhs->pOut;
001052        int iOff = 1 + getVarint32(&zBuf[1], iSerial);
001053        sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut);
001054        pOut->enc = ENC(pOut->db);
001055        if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){
001056          rc = SQLITE_NOMEM;
001057        }else{
001058          *ppOut = pOut;
001059        }
001060      }
001061      sqlite3VdbeMemRelease(&sMem);
001062    }
001063    return rc;
001064  }
001065  
001066  /*
001067  ** Set the iterator value pVal to point to the first value in the set.
001068  ** Set (*ppOut) to point to this value before returning.
001069  */
001070  int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut){
001071    return valueFromValueList(pVal, ppOut, 0);
001072  }
001073  
001074  /*
001075  ** Set the iterator value pVal to point to the next value in the set.
001076  ** Set (*ppOut) to point to this value before returning.
001077  */
001078  int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut){
001079    return valueFromValueList(pVal, ppOut, 1);
001080  }
001081  
001082  /*
001083  ** Return the current time for a statement.  If the current time
001084  ** is requested more than once within the same run of a single prepared
001085  ** statement, the exact same time is returned for each invocation regardless
001086  ** of the amount of time that elapses between invocations.  In other words,
001087  ** the time returned is always the time of the first call.
001088  */
001089  sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){
001090    int rc;
001091  #ifndef SQLITE_ENABLE_STAT4
001092    sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime;
001093    assert( p->pVdbe!=0 );
001094  #else
001095    sqlite3_int64 iTime = 0;
001096    sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime;
001097  #endif
001098    if( *piTime==0 ){
001099      rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
001100      if( rc ) *piTime = 0;
001101    }
001102    return *piTime;
001103  }
001104  
001105  /*
001106  ** Create a new aggregate context for p and return a pointer to
001107  ** its pMem->z element.
001108  */
001109  static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){
001110    Mem *pMem = p->pMem;
001111    assert( (pMem->flags & MEM_Agg)==0 );
001112    if( nByte<=0 ){
001113      sqlite3VdbeMemSetNull(pMem);
001114      pMem->z = 0;
001115    }else{
001116      sqlite3VdbeMemClearAndResize(pMem, nByte);
001117      pMem->flags = MEM_Agg;
001118      pMem->u.pDef = p->pFunc;
001119      if( pMem->z ){
001120        memset(pMem->z, 0, nByte);
001121      }
001122    }
001123    return (void*)pMem->z;
001124  }
001125  
001126  /*
001127  ** Allocate or return the aggregate context for a user function.  A new
001128  ** context is allocated on the first call.  Subsequent calls return the
001129  ** same context that was returned on prior calls.
001130  */
001131  void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
001132    assert( p && p->pFunc && p->pFunc->xFinalize );
001133    assert( sqlite3_mutex_held(p->pOut->db->mutex) );
001134    testcase( nByte<0 );
001135    if( (p->pMem->flags & MEM_Agg)==0 ){
001136      return createAggContext(p, nByte);
001137    }else{
001138      return (void*)p->pMem->z;
001139    }
001140  }
001141  
001142  /*
001143  ** Return the auxiliary data pointer, if any, for the iArg'th argument to
001144  ** the user-function defined by pCtx.
001145  **
001146  ** The left-most argument is 0.
001147  **
001148  ** Undocumented behavior:  If iArg is negative then access a cache of
001149  ** auxiliary data pointers that is available to all functions within a
001150  ** single prepared statement.  The iArg values must match.
001151  */
001152  void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
001153    AuxData *pAuxData;
001154  
001155  #ifdef SQLITE_ENABLE_API_ARMOR
001156    if( pCtx==0 ) return 0;
001157  #endif
001158    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
001159  #if SQLITE_ENABLE_STAT4
001160    if( pCtx->pVdbe==0 ) return 0;
001161  #else
001162    assert( pCtx->pVdbe!=0 );
001163  #endif
001164    for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
001165      if(  pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
001166        return pAuxData->pAux;
001167      }
001168    }
001169    return 0;
001170  }
001171  
001172  /*
001173  ** Set the auxiliary data pointer and delete function, for the iArg'th
001174  ** argument to the user-function defined by pCtx. Any previous value is
001175  ** deleted by calling the delete function specified when it was set.
001176  **
001177  ** The left-most argument is 0.
001178  **
001179  ** Undocumented behavior:  If iArg is negative then make the data available
001180  ** to all functions within the current prepared statement using iArg as an
001181  ** access code.
001182  */
001183  void sqlite3_set_auxdata(
001184    sqlite3_context *pCtx,
001185    int iArg,
001186    void *pAux,
001187    void (*xDelete)(void*)
001188  ){
001189    AuxData *pAuxData;
001190    Vdbe *pVdbe;
001191  
001192  #ifdef SQLITE_ENABLE_API_ARMOR
001193    if( pCtx==0 ) return;
001194  #endif
001195    pVdbe= pCtx->pVdbe;
001196    assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
001197  #ifdef SQLITE_ENABLE_STAT4
001198    if( pVdbe==0 ) goto failed;
001199  #else
001200    assert( pVdbe!=0 );
001201  #endif
001202  
001203    for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){
001204      if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){
001205        break;
001206      }
001207    }
001208    if( pAuxData==0 ){
001209      pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
001210      if( !pAuxData ) goto failed;
001211      pAuxData->iAuxOp = pCtx->iOp;
001212      pAuxData->iAuxArg = iArg;
001213      pAuxData->pNextAux = pVdbe->pAuxData;
001214      pVdbe->pAuxData = pAuxData;
001215      if( pCtx->isError==0 ) pCtx->isError = -1;
001216    }else if( pAuxData->xDeleteAux ){
001217      pAuxData->xDeleteAux(pAuxData->pAux);
001218    }
001219  
001220    pAuxData->pAux = pAux;
001221    pAuxData->xDeleteAux = xDelete;
001222    return;
001223  
001224  failed:
001225    if( xDelete ){
001226      xDelete(pAux);
001227    }
001228  }
001229  
001230  #ifndef SQLITE_OMIT_DEPRECATED
001231  /*
001232  ** Return the number of times the Step function of an aggregate has been
001233  ** called.
001234  **
001235  ** This function is deprecated.  Do not use it for new code.  It is
001236  ** provide only to avoid breaking legacy code.  New aggregate function
001237  ** implementations should keep their own counts within their aggregate
001238  ** context.
001239  */
001240  int sqlite3_aggregate_count(sqlite3_context *p){
001241    assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize );
001242    return p->pMem->n;
001243  }
001244  #endif
001245  
001246  /*
001247  ** Return the number of columns in the result set for the statement pStmt.
001248  */
001249  int sqlite3_column_count(sqlite3_stmt *pStmt){
001250    Vdbe *pVm = (Vdbe *)pStmt;
001251    if( pVm==0 ) return 0;
001252    return pVm->nResColumn;
001253  }
001254  
001255  /*
001256  ** Return the number of values available from the current row of the
001257  ** currently executing statement pStmt.
001258  */
001259  int sqlite3_data_count(sqlite3_stmt *pStmt){
001260    Vdbe *pVm = (Vdbe *)pStmt;
001261    if( pVm==0 || pVm->pResultRow==0 ) return 0;
001262    return pVm->nResColumn;
001263  }
001264  
001265  /*
001266  ** Return a pointer to static memory containing an SQL NULL value.
001267  */
001268  static const Mem *columnNullValue(void){
001269    /* Even though the Mem structure contains an element
001270    ** of type i64, on certain architectures (x86) with certain compiler
001271    ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
001272    ** instead of an 8-byte one. This all works fine, except that when
001273    ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
001274    ** that a Mem structure is located on an 8-byte boundary. To prevent
001275    ** these assert()s from failing, when building with SQLITE_DEBUG defined
001276    ** using gcc, we force nullMem to be 8-byte aligned using the magical
001277    ** __attribute__((aligned(8))) macro.  */
001278    static const Mem nullMem
001279  #if defined(SQLITE_DEBUG) && defined(__GNUC__)
001280      __attribute__((aligned(8)))
001281  #endif
001282      = {
001283          /* .u          = */ {0},
001284          /* .z          = */ (char*)0,
001285          /* .n          = */ (int)0,
001286          /* .flags      = */ (u16)MEM_Null,
001287          /* .enc        = */ (u8)0,
001288          /* .eSubtype   = */ (u8)0,
001289          /* .db         = */ (sqlite3*)0,
001290          /* .szMalloc   = */ (int)0,
001291          /* .uTemp      = */ (u32)0,
001292          /* .zMalloc    = */ (char*)0,
001293          /* .xDel       = */ (void(*)(void*))0,
001294  #ifdef SQLITE_DEBUG
001295          /* .pScopyFrom = */ (Mem*)0,
001296          /* .mScopyFlags= */ 0,
001297  #endif
001298        };
001299    return &nullMem;
001300  }
001301  
001302  /*
001303  ** Check to see if column iCol of the given statement is valid.  If
001304  ** it is, return a pointer to the Mem for the value of that column.
001305  ** If iCol is not valid, return a pointer to a Mem which has a value
001306  ** of NULL.
001307  */
001308  static Mem *columnMem(sqlite3_stmt *pStmt, int i){
001309    Vdbe *pVm;
001310    Mem *pOut;
001311  
001312    pVm = (Vdbe *)pStmt;
001313    if( pVm==0 ) return (Mem*)columnNullValue();
001314    assert( pVm->db );
001315    sqlite3_mutex_enter(pVm->db->mutex);
001316    if( pVm->pResultRow!=0 && i<pVm->nResColumn && i>=0 ){
001317      pOut = &pVm->pResultRow[i];
001318    }else{
001319      sqlite3Error(pVm->db, SQLITE_RANGE);
001320      pOut = (Mem*)columnNullValue();
001321    }
001322    return pOut;
001323  }
001324  
001325  /*
001326  ** This function is called after invoking an sqlite3_value_XXX function on a
001327  ** column value (i.e. a value returned by evaluating an SQL expression in the
001328  ** select list of a SELECT statement) that may cause a malloc() failure. If
001329  ** malloc() has failed, the threads mallocFailed flag is cleared and the result
001330  ** code of statement pStmt set to SQLITE_NOMEM.
001331  **
001332  ** Specifically, this is called from within:
001333  **
001334  **     sqlite3_column_int()
001335  **     sqlite3_column_int64()
001336  **     sqlite3_column_text()
001337  **     sqlite3_column_text16()
001338  **     sqlite3_column_real()
001339  **     sqlite3_column_bytes()
001340  **     sqlite3_column_bytes16()
001341  **     sqlite3_column_blob()
001342  */
001343  static void columnMallocFailure(sqlite3_stmt *pStmt)
001344  {
001345    /* If malloc() failed during an encoding conversion within an
001346    ** sqlite3_column_XXX API, then set the return code of the statement to
001347    ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
001348    ** and _finalize() will return NOMEM.
001349    */
001350    Vdbe *p = (Vdbe *)pStmt;
001351    if( p ){
001352      assert( p->db!=0 );
001353      assert( sqlite3_mutex_held(p->db->mutex) );
001354      p->rc = sqlite3ApiExit(p->db, p->rc);
001355      sqlite3_mutex_leave(p->db->mutex);
001356    }
001357  }
001358  
001359  /**************************** sqlite3_column_  *******************************
001360  ** The following routines are used to access elements of the current row
001361  ** in the result set.
001362  */
001363  const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
001364    const void *val;
001365    val = sqlite3_value_blob( columnMem(pStmt,i) );
001366    /* Even though there is no encoding conversion, value_blob() might
001367    ** need to call malloc() to expand the result of a zeroblob()
001368    ** expression.
001369    */
001370    columnMallocFailure(pStmt);
001371    return val;
001372  }
001373  int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
001374    int val = sqlite3_value_bytes( columnMem(pStmt,i) );
001375    columnMallocFailure(pStmt);
001376    return val;
001377  }
001378  int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
001379    int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
001380    columnMallocFailure(pStmt);
001381    return val;
001382  }
001383  double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
001384    double val = sqlite3_value_double( columnMem(pStmt,i) );
001385    columnMallocFailure(pStmt);
001386    return val;
001387  }
001388  int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
001389    int val = sqlite3_value_int( columnMem(pStmt,i) );
001390    columnMallocFailure(pStmt);
001391    return val;
001392  }
001393  sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
001394    sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
001395    columnMallocFailure(pStmt);
001396    return val;
001397  }
001398  const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
001399    const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
001400    columnMallocFailure(pStmt);
001401    return val;
001402  }
001403  sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
001404    Mem *pOut = columnMem(pStmt, i);
001405    if( pOut->flags&MEM_Static ){
001406      pOut->flags &= ~MEM_Static;
001407      pOut->flags |= MEM_Ephem;
001408    }
001409    columnMallocFailure(pStmt);
001410    return (sqlite3_value *)pOut;
001411  }
001412  #ifndef SQLITE_OMIT_UTF16
001413  const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
001414    const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
001415    columnMallocFailure(pStmt);
001416    return val;
001417  }
001418  #endif /* SQLITE_OMIT_UTF16 */
001419  int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
001420    int iType = sqlite3_value_type( columnMem(pStmt,i) );
001421    columnMallocFailure(pStmt);
001422    return iType;
001423  }
001424  
001425  /*
001426  ** Column names appropriate for EXPLAIN or EXPLAIN QUERY PLAN.
001427  */
001428  static const char * const azExplainColNames8[] = {
001429     "addr", "opcode", "p1", "p2", "p3", "p4", "p5", "comment",  /* EXPLAIN */
001430     "id", "parent", "notused", "detail"                         /* EQP */
001431  };
001432  static const u16 azExplainColNames16data[] = {
001433    /*   0 */  'a', 'd', 'd', 'r',                0,
001434    /*   5 */  'o', 'p', 'c', 'o', 'd', 'e',      0,
001435    /*  12 */  'p', '1',                          0, 
001436    /*  15 */  'p', '2',                          0,
001437    /*  18 */  'p', '3',                          0,
001438    /*  21 */  'p', '4',                          0,
001439    /*  24 */  'p', '5',                          0,
001440    /*  27 */  'c', 'o', 'm', 'm', 'e', 'n', 't', 0,
001441    /*  35 */  'i', 'd',                          0,
001442    /*  38 */  'p', 'a', 'r', 'e', 'n', 't',      0,
001443    /*  45 */  'n', 'o', 't', 'u', 's', 'e', 'd', 0,
001444    /*  53 */  'd', 'e', 't', 'a', 'i', 'l',      0
001445  };
001446  static const u8 iExplainColNames16[] = {
001447    0, 5, 12, 15, 18, 21, 24, 27,
001448    35, 38, 45, 53
001449  };
001450  
001451  /*
001452  ** Convert the N-th element of pStmt->pColName[] into a string using
001453  ** xFunc() then return that string.  If N is out of range, return 0.
001454  **
001455  ** There are up to 5 names for each column.  useType determines which
001456  ** name is returned.  Here are the names:
001457  **
001458  **    0      The column name as it should be displayed for output
001459  **    1      The datatype name for the column
001460  **    2      The name of the database that the column derives from
001461  **    3      The name of the table that the column derives from
001462  **    4      The name of the table column that the result column derives from
001463  **
001464  ** If the result is not a simple column reference (if it is an expression
001465  ** or a constant) then useTypes 2, 3, and 4 return NULL.
001466  */
001467  static const void *columnName(
001468    sqlite3_stmt *pStmt,     /* The statement */
001469    int N,                   /* Which column to get the name for */
001470    int useUtf16,            /* True to return the name as UTF16 */
001471    int useType              /* What type of name */
001472  ){
001473    const void *ret;
001474    Vdbe *p;
001475    int n;
001476    sqlite3 *db;
001477  #ifdef SQLITE_ENABLE_API_ARMOR
001478    if( pStmt==0 ){
001479      (void)SQLITE_MISUSE_BKPT;
001480      return 0;
001481    }
001482  #endif
001483    if( N<0 ) return 0;
001484    ret = 0;
001485    p = (Vdbe *)pStmt;
001486    db = p->db;
001487    assert( db!=0 );
001488    sqlite3_mutex_enter(db->mutex);
001489  
001490    if( p->explain ){
001491      if( useType>0 ) goto columnName_end;
001492      n = p->explain==1 ? 8 : 4;
001493      if( N>=n ) goto columnName_end;
001494      if( useUtf16 ){
001495        int i = iExplainColNames16[N + 8*p->explain - 8];
001496        ret = (void*)&azExplainColNames16data[i];
001497      }else{
001498        ret = (void*)azExplainColNames8[N + 8*p->explain - 8];
001499      }
001500      goto columnName_end;
001501    }
001502    n = p->nResColumn;
001503    if( N<n ){
001504      u8 prior_mallocFailed = db->mallocFailed;
001505      N += useType*n;
001506  #ifndef SQLITE_OMIT_UTF16
001507      if( useUtf16 ){
001508        ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]);
001509      }else
001510  #endif
001511      {
001512        ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]);
001513      }
001514      /* A malloc may have failed inside of the _text() call. If this
001515      ** is the case, clear the mallocFailed flag and return NULL.
001516      */
001517      assert( db->mallocFailed==0 || db->mallocFailed==1 );
001518      if( db->mallocFailed > prior_mallocFailed ){
001519        sqlite3OomClear(db);
001520        ret = 0;
001521      }
001522    }
001523  columnName_end:
001524    sqlite3_mutex_leave(db->mutex);
001525    return ret;
001526  }
001527  
001528  /*
001529  ** Return the name of the Nth column of the result set returned by SQL
001530  ** statement pStmt.
001531  */
001532  const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
001533    return columnName(pStmt, N, 0, COLNAME_NAME);
001534  }
001535  #ifndef SQLITE_OMIT_UTF16
001536  const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
001537    return columnName(pStmt, N, 1, COLNAME_NAME);
001538  }
001539  #endif
001540  
001541  /*
001542  ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must
001543  ** not define OMIT_DECLTYPE.
001544  */
001545  #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
001546  # error "Must not define both SQLITE_OMIT_DECLTYPE \
001547           and SQLITE_ENABLE_COLUMN_METADATA"
001548  #endif
001549  
001550  #ifndef SQLITE_OMIT_DECLTYPE
001551  /*
001552  ** Return the column declaration type (if applicable) of the 'i'th column
001553  ** of the result set of SQL statement pStmt.
001554  */
001555  const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
001556    return columnName(pStmt, N, 0, COLNAME_DECLTYPE);
001557  }
001558  #ifndef SQLITE_OMIT_UTF16
001559  const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
001560    return columnName(pStmt, N, 1, COLNAME_DECLTYPE);
001561  }
001562  #endif /* SQLITE_OMIT_UTF16 */
001563  #endif /* SQLITE_OMIT_DECLTYPE */
001564  
001565  #ifdef SQLITE_ENABLE_COLUMN_METADATA
001566  /*
001567  ** Return the name of the database from which a result column derives.
001568  ** NULL is returned if the result column is an expression or constant or
001569  ** anything else which is not an unambiguous reference to a database column.
001570  */
001571  const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
001572    return columnName(pStmt, N, 0, COLNAME_DATABASE);
001573  }
001574  #ifndef SQLITE_OMIT_UTF16
001575  const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
001576    return columnName(pStmt, N, 1, COLNAME_DATABASE);
001577  }
001578  #endif /* SQLITE_OMIT_UTF16 */
001579  
001580  /*
001581  ** Return the name of the table from which a result column derives.
001582  ** NULL is returned if the result column is an expression or constant or
001583  ** anything else which is not an unambiguous reference to a database column.
001584  */
001585  const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
001586    return columnName(pStmt, N, 0, COLNAME_TABLE);
001587  }
001588  #ifndef SQLITE_OMIT_UTF16
001589  const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
001590    return columnName(pStmt, N, 1, COLNAME_TABLE);
001591  }
001592  #endif /* SQLITE_OMIT_UTF16 */
001593  
001594  /*
001595  ** Return the name of the table column from which a result column derives.
001596  ** NULL is returned if the result column is an expression or constant or
001597  ** anything else which is not an unambiguous reference to a database column.
001598  */
001599  const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
001600    return columnName(pStmt, N, 0, COLNAME_COLUMN);
001601  }
001602  #ifndef SQLITE_OMIT_UTF16
001603  const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
001604    return columnName(pStmt, N, 1, COLNAME_COLUMN);
001605  }
001606  #endif /* SQLITE_OMIT_UTF16 */
001607  #endif /* SQLITE_ENABLE_COLUMN_METADATA */
001608  
001609  
001610  /******************************* sqlite3_bind_  ***************************
001611  **
001612  ** Routines used to attach values to wildcards in a compiled SQL statement.
001613  */
001614  /*
001615  ** Unbind the value bound to variable i in virtual machine p. This is the
001616  ** the same as binding a NULL value to the column. If the "i" parameter is
001617  ** out of range, then SQLITE_RANGE is returned. Otherwise SQLITE_OK.
001618  **
001619  ** A successful evaluation of this routine acquires the mutex on p.
001620  ** the mutex is released if any kind of error occurs.
001621  **
001622  ** The error code stored in database p->db is overwritten with the return
001623  ** value in any case.
001624  */
001625  static int vdbeUnbind(Vdbe *p, unsigned int i){
001626    Mem *pVar;
001627    if( vdbeSafetyNotNull(p) ){
001628      return SQLITE_MISUSE_BKPT;
001629    }
001630    sqlite3_mutex_enter(p->db->mutex);
001631    if( p->eVdbeState!=VDBE_READY_STATE ){
001632      sqlite3Error(p->db, SQLITE_MISUSE_BKPT);
001633      sqlite3_mutex_leave(p->db->mutex);
001634      sqlite3_log(SQLITE_MISUSE,
001635          "bind on a busy prepared statement: [%s]", p->zSql);
001636      return SQLITE_MISUSE_BKPT;
001637    }
001638    if( i>=(unsigned int)p->nVar ){
001639      sqlite3Error(p->db, SQLITE_RANGE);
001640      sqlite3_mutex_leave(p->db->mutex);
001641      return SQLITE_RANGE;
001642    }
001643    pVar = &p->aVar[i];
001644    sqlite3VdbeMemRelease(pVar);
001645    pVar->flags = MEM_Null;
001646    p->db->errCode = SQLITE_OK;
001647  
001648    /* If the bit corresponding to this variable in Vdbe.expmask is set, then
001649    ** binding a new value to this variable invalidates the current query plan.
001650    **
001651    ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a host
001652    ** parameter in the WHERE clause might influence the choice of query plan
001653    ** for a statement, then the statement will be automatically recompiled,
001654    ** as if there had been a schema change, on the first sqlite3_step() call
001655    ** following any change to the bindings of that parameter.
001656    */
001657    assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 );
001658    if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<<i))!=0 ){
001659      p->expired = 1;
001660    }
001661    return SQLITE_OK;
001662  }
001663  
001664  /*
001665  ** Bind a text or BLOB value.
001666  */
001667  static int bindText(
001668    sqlite3_stmt *pStmt,   /* The statement to bind against */
001669    int i,                 /* Index of the parameter to bind */
001670    const void *zData,     /* Pointer to the data to be bound */
001671    i64 nData,             /* Number of bytes of data to be bound */
001672    void (*xDel)(void*),   /* Destructor for the data */
001673    u8 encoding            /* Encoding for the data */
001674  ){
001675    Vdbe *p = (Vdbe *)pStmt;
001676    Mem *pVar;
001677    int rc;
001678  
001679    rc = vdbeUnbind(p, (u32)(i-1));
001680    if( rc==SQLITE_OK ){
001681      if( zData!=0 ){
001682        pVar = &p->aVar[i-1];
001683        rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
001684        if( rc==SQLITE_OK && encoding!=0 ){
001685          rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
001686        }
001687        if( rc ){
001688          sqlite3Error(p->db, rc);
001689          rc = sqlite3ApiExit(p->db, rc);
001690        }
001691      }
001692      sqlite3_mutex_leave(p->db->mutex);
001693    }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){
001694      xDel((void*)zData);
001695    }
001696    return rc;
001697  }
001698  
001699  
001700  /*
001701  ** Bind a blob value to an SQL statement variable.
001702  */
001703  int sqlite3_bind_blob(
001704    sqlite3_stmt *pStmt,
001705    int i,
001706    const void *zData,
001707    int nData,
001708    void (*xDel)(void*)
001709  ){
001710  #ifdef SQLITE_ENABLE_API_ARMOR
001711    if( nData<0 ) return SQLITE_MISUSE_BKPT;
001712  #endif
001713    return bindText(pStmt, i, zData, nData, xDel, 0);
001714  }
001715  int sqlite3_bind_blob64(
001716    sqlite3_stmt *pStmt,
001717    int i,
001718    const void *zData,
001719    sqlite3_uint64 nData,
001720    void (*xDel)(void*)
001721  ){
001722    assert( xDel!=SQLITE_DYNAMIC );
001723    return bindText(pStmt, i, zData, nData, xDel, 0);
001724  }
001725  int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
001726    int rc;
001727    Vdbe *p = (Vdbe *)pStmt;
001728    rc = vdbeUnbind(p, (u32)(i-1));
001729    if( rc==SQLITE_OK ){
001730      sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
001731      sqlite3_mutex_leave(p->db->mutex);
001732    }
001733    return rc;
001734  }
001735  int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
001736    return sqlite3_bind_int64(p, i, (i64)iValue);
001737  }
001738  int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
001739    int rc;
001740    Vdbe *p = (Vdbe *)pStmt;
001741    rc = vdbeUnbind(p, (u32)(i-1));
001742    if( rc==SQLITE_OK ){
001743      sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
001744      sqlite3_mutex_leave(p->db->mutex);
001745    }
001746    return rc;
001747  }
001748  int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
001749    int rc;
001750    Vdbe *p = (Vdbe*)pStmt;
001751    rc = vdbeUnbind(p, (u32)(i-1));
001752    if( rc==SQLITE_OK ){
001753      sqlite3_mutex_leave(p->db->mutex);
001754    }
001755    return rc;
001756  }
001757  int sqlite3_bind_pointer(
001758    sqlite3_stmt *pStmt,
001759    int i,
001760    void *pPtr,
001761    const char *zPTtype,
001762    void (*xDestructor)(void*)
001763  ){
001764    int rc;
001765    Vdbe *p = (Vdbe*)pStmt;
001766    rc = vdbeUnbind(p, (u32)(i-1));
001767    if( rc==SQLITE_OK ){
001768      sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor);
001769      sqlite3_mutex_leave(p->db->mutex);
001770    }else if( xDestructor ){
001771      xDestructor(pPtr);
001772    }
001773    return rc;
001774  }
001775  int sqlite3_bind_text(
001776    sqlite3_stmt *pStmt,
001777    int i,
001778    const char *zData,
001779    int nData,
001780    void (*xDel)(void*)
001781  ){
001782    return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
001783  }
001784  int sqlite3_bind_text64(
001785    sqlite3_stmt *pStmt,
001786    int i,
001787    const char *zData,
001788    sqlite3_uint64 nData,
001789    void (*xDel)(void*),
001790    unsigned char enc
001791  ){
001792    assert( xDel!=SQLITE_DYNAMIC );
001793    if( enc!=SQLITE_UTF8 ){
001794      if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
001795      nData &= ~(u16)1;
001796    }
001797    return bindText(pStmt, i, zData, nData, xDel, enc);
001798  }
001799  #ifndef SQLITE_OMIT_UTF16
001800  int sqlite3_bind_text16(
001801    sqlite3_stmt *pStmt,
001802    int i,
001803    const void *zData,
001804    int n,
001805    void (*xDel)(void*)
001806  ){
001807    return bindText(pStmt, i, zData, n & ~(u64)1, xDel, SQLITE_UTF16NATIVE);
001808  }
001809  #endif /* SQLITE_OMIT_UTF16 */
001810  int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
001811    int rc;
001812    switch( sqlite3_value_type((sqlite3_value*)pValue) ){
001813      case SQLITE_INTEGER: {
001814        rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
001815        break;
001816      }
001817      case SQLITE_FLOAT: {
001818        assert( pValue->flags & (MEM_Real|MEM_IntReal) );
001819        rc = sqlite3_bind_double(pStmt, i,
001820            (pValue->flags & MEM_Real) ? pValue->u.r : (double)pValue->u.i
001821        );
001822        break;
001823      }
001824      case SQLITE_BLOB: {
001825        if( pValue->flags & MEM_Zero ){
001826          rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
001827        }else{
001828          rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
001829        }
001830        break;
001831      }
001832      case SQLITE_TEXT: {
001833        rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
001834                                pValue->enc);
001835        break;
001836      }
001837      default: {
001838        rc = sqlite3_bind_null(pStmt, i);
001839        break;
001840      }
001841    }
001842    return rc;
001843  }
001844  int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
001845    int rc;
001846    Vdbe *p = (Vdbe *)pStmt;
001847    rc = vdbeUnbind(p, (u32)(i-1));
001848    if( rc==SQLITE_OK ){
001849  #ifndef SQLITE_OMIT_INCRBLOB
001850      sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
001851  #else
001852      rc = sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
001853  #endif
001854      sqlite3_mutex_leave(p->db->mutex);
001855    }
001856    return rc;
001857  }
001858  int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
001859    int rc;
001860    Vdbe *p = (Vdbe *)pStmt;
001861  #ifdef SQLITE_ENABLE_API_ARMOR
001862    if( p==0 ) return SQLITE_MISUSE_BKPT;
001863  #endif
001864    sqlite3_mutex_enter(p->db->mutex);
001865    if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
001866      rc = SQLITE_TOOBIG;
001867    }else{
001868      assert( (n & 0x7FFFFFFF)==n );
001869      rc = sqlite3_bind_zeroblob(pStmt, i, n);
001870    }
001871    rc = sqlite3ApiExit(p->db, rc);
001872    sqlite3_mutex_leave(p->db->mutex);
001873    return rc;
001874  }
001875  
001876  /*
001877  ** Return the number of wildcards that can be potentially bound to.
001878  ** This routine is added to support DBD::SQLite. 
001879  */
001880  int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
001881    Vdbe *p = (Vdbe*)pStmt;
001882    return p ? p->nVar : 0;
001883  }
001884  
001885  /*
001886  ** Return the name of a wildcard parameter.  Return NULL if the index
001887  ** is out of range or if the wildcard is unnamed.
001888  **
001889  ** The result is always UTF-8.
001890  */
001891  const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
001892    Vdbe *p = (Vdbe*)pStmt;
001893    if( p==0 ) return 0;
001894    return sqlite3VListNumToName(p->pVList, i);
001895  }
001896  
001897  /*
001898  ** Given a wildcard parameter name, return the index of the variable
001899  ** with that name.  If there is no variable with the given name,
001900  ** return 0.
001901  */
001902  int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
001903    if( p==0 || zName==0 ) return 0;
001904    return sqlite3VListNameToNum(p->pVList, zName, nName);
001905  }
001906  int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
001907    return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
001908  }
001909  
001910  /*
001911  ** Transfer all bindings from the first statement over to the second.
001912  */
001913  int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
001914    Vdbe *pFrom = (Vdbe*)pFromStmt;
001915    Vdbe *pTo = (Vdbe*)pToStmt;
001916    int i;
001917    assert( pTo->db==pFrom->db );
001918    assert( pTo->nVar==pFrom->nVar );
001919    sqlite3_mutex_enter(pTo->db->mutex);
001920    for(i=0; i<pFrom->nVar; i++){
001921      sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
001922    }
001923    sqlite3_mutex_leave(pTo->db->mutex);
001924    return SQLITE_OK;
001925  }
001926  
001927  #ifndef SQLITE_OMIT_DEPRECATED
001928  /*
001929  ** Deprecated external interface.  Internal/core SQLite code
001930  ** should call sqlite3TransferBindings.
001931  **
001932  ** It is misuse to call this routine with statements from different
001933  ** database connections.  But as this is a deprecated interface, we
001934  ** will not bother to check for that condition.
001935  **
001936  ** If the two statements contain a different number of bindings, then
001937  ** an SQLITE_ERROR is returned.  Nothing else can go wrong, so otherwise
001938  ** SQLITE_OK is returned.
001939  */
001940  int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
001941    Vdbe *pFrom = (Vdbe*)pFromStmt;
001942    Vdbe *pTo = (Vdbe*)pToStmt;
001943    if( pFrom->nVar!=pTo->nVar ){
001944      return SQLITE_ERROR;
001945    }
001946    assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 );
001947    if( pTo->expmask ){
001948      pTo->expired = 1;
001949    }
001950    assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 );
001951    if( pFrom->expmask ){
001952      pFrom->expired = 1;
001953    }
001954    return sqlite3TransferBindings(pFromStmt, pToStmt);
001955  }
001956  #endif
001957  
001958  /*
001959  ** Return the sqlite3* database handle to which the prepared statement given
001960  ** in the argument belongs.  This is the same database handle that was
001961  ** the first argument to the sqlite3_prepare() that was used to create
001962  ** the statement in the first place.
001963  */
001964  sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
001965    return pStmt ? ((Vdbe*)pStmt)->db : 0;
001966  }
001967  
001968  /*
001969  ** Return true if the prepared statement is guaranteed to not modify the
001970  ** database.
001971  */
001972  int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
001973    return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
001974  }
001975  
001976  /*
001977  ** Return 1 if the statement is an EXPLAIN and return 2 if the
001978  ** statement is an EXPLAIN QUERY PLAN
001979  */
001980  int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){
001981    return pStmt ? ((Vdbe*)pStmt)->explain : 0;
001982  }
001983  
001984  /*
001985  ** Set the explain mode for a statement.
001986  */
001987  int sqlite3_stmt_explain(sqlite3_stmt *pStmt, int eMode){
001988    Vdbe *v = (Vdbe*)pStmt;
001989    int rc;
001990  #ifdef SQLITE_ENABLE_API_ARMOR
001991    if( pStmt==0 ) return SQLITE_MISUSE_BKPT;
001992  #endif
001993    sqlite3_mutex_enter(v->db->mutex);
001994    if( ((int)v->explain)==eMode ){
001995      rc = SQLITE_OK;
001996    }else if( eMode<0 || eMode>2 ){
001997      rc = SQLITE_ERROR;
001998    }else if( (v->prepFlags & SQLITE_PREPARE_SAVESQL)==0 ){
001999      rc = SQLITE_ERROR;
002000    }else if( v->eVdbeState!=VDBE_READY_STATE ){
002001      rc = SQLITE_BUSY;
002002    }else if( v->nMem>=10 && (eMode!=2 || v->haveEqpOps) ){
002003      /* No reprepare necessary */
002004      v->explain = eMode;
002005      rc = SQLITE_OK;
002006    }else{
002007      v->explain = eMode;
002008      rc = sqlite3Reprepare(v);
002009      v->haveEqpOps = eMode==2;
002010    }
002011    if( v->explain ){
002012      v->nResColumn = 12 - 4*v->explain;
002013    }else{
002014      v->nResColumn = v->nResAlloc;
002015    }
002016    sqlite3_mutex_leave(v->db->mutex);
002017    return rc;
002018  }
002019  
002020  /*
002021  ** Return true if the prepared statement is in need of being reset.
002022  */
002023  int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
002024    Vdbe *v = (Vdbe*)pStmt;
002025    return v!=0 && v->eVdbeState==VDBE_RUN_STATE;
002026  }
002027  
002028  /*
002029  ** Return a pointer to the next prepared statement after pStmt associated
002030  ** with database connection pDb.  If pStmt is NULL, return the first
002031  ** prepared statement for the database connection.  Return NULL if there
002032  ** are no more.
002033  */
002034  sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
002035    sqlite3_stmt *pNext;
002036  #ifdef SQLITE_ENABLE_API_ARMOR
002037    if( !sqlite3SafetyCheckOk(pDb) ){
002038      (void)SQLITE_MISUSE_BKPT;
002039      return 0;
002040    }
002041  #endif
002042    sqlite3_mutex_enter(pDb->mutex);
002043    if( pStmt==0 ){
002044      pNext = (sqlite3_stmt*)pDb->pVdbe;
002045    }else{
002046      pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pVNext;
002047    }
002048    sqlite3_mutex_leave(pDb->mutex);
002049    return pNext;
002050  }
002051  
002052  /*
002053  ** Return the value of a status counter for a prepared statement
002054  */
002055  int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
002056    Vdbe *pVdbe = (Vdbe*)pStmt;
002057    u32 v;
002058  #ifdef SQLITE_ENABLE_API_ARMOR
002059    if( !pStmt
002060     || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter)))
002061    ){
002062      (void)SQLITE_MISUSE_BKPT;
002063      return 0;
002064    }
002065  #endif
002066    if( op==SQLITE_STMTSTATUS_MEMUSED ){
002067      sqlite3 *db = pVdbe->db;
002068      sqlite3_mutex_enter(db->mutex);
002069      v = 0;
002070      db->pnBytesFreed = (int*)&v;
002071      assert( db->lookaside.pEnd==db->lookaside.pTrueEnd );
002072      db->lookaside.pEnd = db->lookaside.pStart;
002073      sqlite3VdbeDelete(pVdbe);
002074      db->pnBytesFreed = 0;
002075      db->lookaside.pEnd = db->lookaside.pTrueEnd;
002076      sqlite3_mutex_leave(db->mutex);
002077    }else{
002078      v = pVdbe->aCounter[op];
002079      if( resetFlag ) pVdbe->aCounter[op] = 0;
002080    }
002081    return (int)v;
002082  }
002083  
002084  /*
002085  ** Return the SQL associated with a prepared statement
002086  */
002087  const char *sqlite3_sql(sqlite3_stmt *pStmt){
002088    Vdbe *p = (Vdbe *)pStmt;
002089    return p ? p->zSql : 0;
002090  }
002091  
002092  /*
002093  ** Return the SQL associated with a prepared statement with
002094  ** bound parameters expanded.  Space to hold the returned string is
002095  ** obtained from sqlite3_malloc().  The caller is responsible for
002096  ** freeing the returned string by passing it to sqlite3_free().
002097  **
002098  ** The SQLITE_TRACE_SIZE_LIMIT puts an upper bound on the size of
002099  ** expanded bound parameters.
002100  */
002101  char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){
002102  #ifdef SQLITE_OMIT_TRACE
002103    return 0;
002104  #else
002105    char *z = 0;
002106    const char *zSql = sqlite3_sql(pStmt);
002107    if( zSql ){
002108      Vdbe *p = (Vdbe *)pStmt;
002109      sqlite3_mutex_enter(p->db->mutex);
002110      z = sqlite3VdbeExpandSql(p, zSql);
002111      sqlite3_mutex_leave(p->db->mutex);
002112    }
002113    return z;
002114  #endif
002115  }
002116  
002117  #ifdef SQLITE_ENABLE_NORMALIZE
002118  /*
002119  ** Return the normalized SQL associated with a prepared statement.
002120  */
002121  const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){
002122    Vdbe *p = (Vdbe *)pStmt;
002123    if( p==0 ) return 0;
002124    if( p->zNormSql==0 && ALWAYS(p->zSql!=0) ){
002125      sqlite3_mutex_enter(p->db->mutex);
002126      p->zNormSql = sqlite3Normalize(p, p->zSql);
002127      sqlite3_mutex_leave(p->db->mutex);
002128    }
002129    return p->zNormSql;
002130  }
002131  #endif /* SQLITE_ENABLE_NORMALIZE */
002132  
002133  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
002134  /*
002135  ** Allocate and populate an UnpackedRecord structure based on the serialized
002136  ** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure
002137  ** if successful, or a NULL pointer if an OOM error is encountered.
002138  */
002139  static UnpackedRecord *vdbeUnpackRecord(
002140    KeyInfo *pKeyInfo,
002141    int nKey,
002142    const void *pKey
002143  ){
002144    UnpackedRecord *pRet;           /* Return value */
002145  
002146    pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
002147    if( pRet ){
002148      memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1));
002149      sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
002150    }
002151    return pRet;
002152  }
002153  
002154  /*
002155  ** This function is called from within a pre-update callback to retrieve
002156  ** a field of the row currently being updated or deleted.
002157  */
002158  int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppValue){
002159    PreUpdate *p;
002160    Mem *pMem;
002161    int rc = SQLITE_OK;
002162  
002163  #ifdef SQLITE_ENABLE_API_ARMOR
002164    if( db==0 || ppValue==0 ){
002165      return SQLITE_MISUSE_BKPT;
002166    }
002167  #endif
002168    p = db->pPreUpdate;
002169    /* Test that this call is being made from within an SQLITE_DELETE or
002170    ** SQLITE_UPDATE pre-update callback, and that iIdx is within range. */
002171    if( !p || p->op==SQLITE_INSERT ){
002172      rc = SQLITE_MISUSE_BKPT;
002173      goto preupdate_old_out;
002174    }
002175    if( p->pPk ){
002176      iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx);
002177    }
002178    if( iIdx>=p->pCsr->nField || iIdx<0 ){
002179      rc = SQLITE_RANGE;
002180      goto preupdate_old_out;
002181    }
002182  
002183    /* If the old.* record has not yet been loaded into memory, do so now. */
002184    if( p->pUnpacked==0 ){
002185      u32 nRec;
002186      u8 *aRec;
002187  
002188      assert( p->pCsr->eCurType==CURTYPE_BTREE );
002189      nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
002190      aRec = sqlite3DbMallocRaw(db, nRec);
002191      if( !aRec ) goto preupdate_old_out;
002192      rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec);
002193      if( rc==SQLITE_OK ){
002194        p->pUnpacked = vdbeUnpackRecord(&p->keyinfo, nRec, aRec);
002195        if( !p->pUnpacked ) rc = SQLITE_NOMEM;
002196      }
002197      if( rc!=SQLITE_OK ){
002198        sqlite3DbFree(db, aRec);
002199        goto preupdate_old_out;
002200      }
002201      p->aRecord = aRec;
002202    }
002203  
002204    pMem = *ppValue = &p->pUnpacked->aMem[iIdx];
002205    if( iIdx==p->pTab->iPKey ){
002206      sqlite3VdbeMemSetInt64(pMem, p->iKey1);
002207    }else if( iIdx>=p->pUnpacked->nField ){
002208      *ppValue = (sqlite3_value *)columnNullValue();
002209    }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){
002210      if( pMem->flags & (MEM_Int|MEM_IntReal) ){
002211        testcase( pMem->flags & MEM_Int );
002212        testcase( pMem->flags & MEM_IntReal );
002213        sqlite3VdbeMemRealify(pMem);
002214      }
002215    }
002216  
002217   preupdate_old_out:
002218    sqlite3Error(db, rc);
002219    return sqlite3ApiExit(db, rc);
002220  }
002221  #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
002222  
002223  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
002224  /*
002225  ** This function is called from within a pre-update callback to retrieve
002226  ** the number of columns in the row being updated, deleted or inserted.
002227  */
002228  int sqlite3_preupdate_count(sqlite3 *db){
002229    PreUpdate *p;
002230  #ifdef SQLITE_ENABLE_API_ARMOR
002231    p = db!=0 ? db->pPreUpdate : 0;
002232  #else
002233    p = db->pPreUpdate;
002234  #endif
002235    return (p ? p->keyinfo.nKeyField : 0);
002236  }
002237  #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
002238  
002239  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
002240  /*
002241  ** This function is designed to be called from within a pre-update callback
002242  ** only. It returns zero if the change that caused the callback was made
002243  ** immediately by a user SQL statement. Or, if the change was made by a
002244  ** trigger program, it returns the number of trigger programs currently
002245  ** on the stack (1 for a top-level trigger, 2 for a trigger fired by a
002246  ** top-level trigger etc.).
002247  **
002248  ** For the purposes of the previous paragraph, a foreign key CASCADE, SET NULL
002249  ** or SET DEFAULT action is considered a trigger.
002250  */
002251  int sqlite3_preupdate_depth(sqlite3 *db){
002252    PreUpdate *p;
002253  #ifdef SQLITE_ENABLE_API_ARMOR
002254    p = db!=0 ? db->pPreUpdate : 0;
002255  #else
002256    p = db->pPreUpdate;
002257  #endif
002258    return (p ? p->v->nFrame : 0);
002259  }
002260  #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
002261  
002262  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
002263  /*
002264  ** This function is designed to be called from within a pre-update callback
002265  ** only.
002266  */
002267  int sqlite3_preupdate_blobwrite(sqlite3 *db){
002268    PreUpdate *p;
002269  #ifdef SQLITE_ENABLE_API_ARMOR
002270    p = db!=0 ? db->pPreUpdate : 0;
002271  #else
002272    p = db->pPreUpdate;
002273  #endif
002274    return (p ? p->iBlobWrite : -1);
002275  }
002276  #endif
002277  
002278  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
002279  /*
002280  ** This function is called from within a pre-update callback to retrieve
002281  ** a field of the row currently being updated or inserted.
002282  */
002283  int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppValue){
002284    PreUpdate *p;
002285    int rc = SQLITE_OK;
002286    Mem *pMem;
002287  
002288  #ifdef SQLITE_ENABLE_API_ARMOR
002289    if( db==0 || ppValue==0 ){
002290      return SQLITE_MISUSE_BKPT;
002291    }
002292  #endif
002293    p = db->pPreUpdate;
002294    if( !p || p->op==SQLITE_DELETE ){
002295      rc = SQLITE_MISUSE_BKPT;
002296      goto preupdate_new_out;
002297    }
002298    if( p->pPk && p->op!=SQLITE_UPDATE ){
002299      iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx);
002300    }
002301    if( iIdx>=p->pCsr->nField || iIdx<0 ){
002302      rc = SQLITE_RANGE;
002303      goto preupdate_new_out;
002304    }
002305  
002306    if( p->op==SQLITE_INSERT ){
002307      /* For an INSERT, memory cell p->iNewReg contains the serialized record
002308      ** that is being inserted. Deserialize it. */
002309      UnpackedRecord *pUnpack = p->pNewUnpacked;
002310      if( !pUnpack ){
002311        Mem *pData = &p->v->aMem[p->iNewReg];
002312        rc = ExpandBlob(pData);
002313        if( rc!=SQLITE_OK ) goto preupdate_new_out;
002314        pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z);
002315        if( !pUnpack ){
002316          rc = SQLITE_NOMEM;
002317          goto preupdate_new_out;
002318        }
002319        p->pNewUnpacked = pUnpack;
002320      }
002321      pMem = &pUnpack->aMem[iIdx];
002322      if( iIdx==p->pTab->iPKey ){
002323        sqlite3VdbeMemSetInt64(pMem, p->iKey2);
002324      }else if( iIdx>=pUnpack->nField ){
002325        pMem = (sqlite3_value *)columnNullValue();
002326      }
002327    }else{
002328      /* For an UPDATE, memory cell (p->iNewReg+1+iIdx) contains the required
002329      ** value. Make a copy of the cell contents and return a pointer to it.
002330      ** It is not safe to return a pointer to the memory cell itself as the
002331      ** caller may modify the value text encoding.
002332      */
002333      assert( p->op==SQLITE_UPDATE );
002334      if( !p->aNew ){
002335        p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
002336        if( !p->aNew ){
002337          rc = SQLITE_NOMEM;
002338          goto preupdate_new_out;
002339        }
002340      }
002341      assert( iIdx>=0 && iIdx<p->pCsr->nField );
002342      pMem = &p->aNew[iIdx];
002343      if( pMem->flags==0 ){
002344        if( iIdx==p->pTab->iPKey ){
002345          sqlite3VdbeMemSetInt64(pMem, p->iKey2);
002346        }else{
002347          rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]);
002348          if( rc!=SQLITE_OK ) goto preupdate_new_out;
002349        }
002350      }
002351    }
002352    *ppValue = pMem;
002353  
002354   preupdate_new_out:
002355    sqlite3Error(db, rc);
002356    return sqlite3ApiExit(db, rc);
002357  }
002358  #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
002359  
002360  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
002361  /*
002362  ** Return status data for a single loop within query pStmt.
002363  */
002364  int sqlite3_stmt_scanstatus_v2(
002365    sqlite3_stmt *pStmt,            /* Prepared statement being queried */
002366    int iScan,                      /* Index of loop to report on */
002367    int iScanStatusOp,              /* Which metric to return */
002368    int flags,
002369    void *pOut                      /* OUT: Write the answer here */
002370  ){
002371    Vdbe *p = (Vdbe*)pStmt;
002372    VdbeOp *aOp;
002373    int nOp;
002374    ScanStatus *pScan = 0;
002375    int idx;
002376  
002377  #ifdef SQLITE_ENABLE_API_ARMOR
002378    if( p==0 || pOut==0
002379        || iScanStatusOp<SQLITE_SCANSTAT_NLOOP
002380        || iScanStatusOp>SQLITE_SCANSTAT_NCYCLE ){
002381      return 1;
002382    }
002383  #endif
002384    aOp = p->aOp;
002385    nOp = p->nOp;
002386    if( p->pFrame ){
002387      VdbeFrame *pFrame;
002388      for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
002389      aOp = pFrame->aOp;
002390      nOp = pFrame->nOp;
002391    }
002392  
002393    if( iScan<0 ){
002394      int ii;
002395      if( iScanStatusOp==SQLITE_SCANSTAT_NCYCLE ){
002396        i64 res = 0;
002397        for(ii=0; ii<nOp; ii++){
002398          res += aOp[ii].nCycle;
002399        }
002400        *(i64*)pOut = res;
002401        return 0;
002402      }
002403      return 1;
002404    }
002405    if( flags & SQLITE_SCANSTAT_COMPLEX ){
002406      idx = iScan;
002407      pScan = &p->aScan[idx];
002408    }else{
002409      /* If the COMPLEX flag is clear, then this function must ignore any
002410      ** ScanStatus structures with ScanStatus.addrLoop set to 0. */
002411      for(idx=0; idx<p->nScan; idx++){
002412        pScan = &p->aScan[idx];
002413        if( pScan->zName ){
002414          iScan--;
002415          if( iScan<0 ) break;
002416        }
002417      }
002418    }
002419    if( idx>=p->nScan ) return 1;
002420  
002421    switch( iScanStatusOp ){
002422      case SQLITE_SCANSTAT_NLOOP: {
002423        if( pScan->addrLoop>0 ){
002424          *(sqlite3_int64*)pOut = aOp[pScan->addrLoop].nExec;
002425        }else{
002426          *(sqlite3_int64*)pOut = -1;
002427        }
002428        break;
002429      }
002430      case SQLITE_SCANSTAT_NVISIT: {
002431        if( pScan->addrVisit>0 ){
002432          *(sqlite3_int64*)pOut = aOp[pScan->addrVisit].nExec;
002433        }else{
002434          *(sqlite3_int64*)pOut = -1;
002435        }
002436        break;
002437      }
002438      case SQLITE_SCANSTAT_EST: {
002439        double r = 1.0;
002440        LogEst x = pScan->nEst;
002441        while( x<100 ){
002442          x += 10;
002443          r *= 0.5;
002444        }
002445        *(double*)pOut = r*sqlite3LogEstToInt(x);
002446        break;
002447      }
002448      case SQLITE_SCANSTAT_NAME: {
002449        *(const char**)pOut = pScan->zName;
002450        break;
002451      }
002452      case SQLITE_SCANSTAT_EXPLAIN: {
002453        if( pScan->addrExplain ){
002454          *(const char**)pOut = aOp[ pScan->addrExplain ].p4.z;
002455        }else{
002456          *(const char**)pOut = 0;
002457        }
002458        break;
002459      }
002460      case SQLITE_SCANSTAT_SELECTID: {
002461        if( pScan->addrExplain ){
002462          *(int*)pOut = aOp[ pScan->addrExplain ].p1;
002463        }else{
002464          *(int*)pOut = -1;
002465        }
002466        break;
002467      }
002468      case SQLITE_SCANSTAT_PARENTID: {
002469        if( pScan->addrExplain ){
002470          *(int*)pOut = aOp[ pScan->addrExplain ].p2;
002471        }else{
002472          *(int*)pOut = -1;
002473        }
002474        break;
002475      }
002476      case SQLITE_SCANSTAT_NCYCLE: {
002477        i64 res = 0;
002478        if( pScan->aAddrRange[0]==0 ){
002479          res = -1;
002480        }else{
002481          int ii;
002482          for(ii=0; ii<ArraySize(pScan->aAddrRange); ii+=2){
002483            int iIns = pScan->aAddrRange[ii];
002484            int iEnd = pScan->aAddrRange[ii+1];
002485            if( iIns==0 ) break;
002486            if( iIns>0 ){
002487              while( iIns<=iEnd ){
002488                res += aOp[iIns].nCycle;
002489                iIns++;
002490              }
002491            }else{
002492              int iOp;
002493              for(iOp=0; iOp<nOp; iOp++){
002494                Op *pOp = &aOp[iOp];
002495                if( pOp->p1!=iEnd ) continue;
002496                if( (sqlite3OpcodeProperty[pOp->opcode] & OPFLG_NCYCLE)==0 ){
002497                  continue;
002498                }
002499                res += aOp[iOp].nCycle;
002500              }
002501            }
002502          }
002503        }
002504        *(i64*)pOut = res;
002505        break;
002506      }
002507      default: {
002508        return 1;
002509      }
002510    }
002511    return 0;
002512  }
002513  
002514  /*
002515  ** Return status data for a single loop within query pStmt.
002516  */
002517  int sqlite3_stmt_scanstatus(
002518    sqlite3_stmt *pStmt,            /* Prepared statement being queried */
002519    int iScan,                      /* Index of loop to report on */
002520    int iScanStatusOp,              /* Which metric to return */
002521    void *pOut                      /* OUT: Write the answer here */
002522  ){
002523    return sqlite3_stmt_scanstatus_v2(pStmt, iScan, iScanStatusOp, 0, pOut);
002524  }
002525  
002526  /*
002527  ** Zero all counters associated with the sqlite3_stmt_scanstatus() data.
002528  */
002529  void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){
002530    Vdbe *p = (Vdbe*)pStmt;
002531    int ii;
002532    for(ii=0; p!=0 && ii<p->nOp; ii++){
002533      Op *pOp = &p->aOp[ii];
002534      pOp->nExec = 0;
002535      pOp->nCycle = 0;
002536    }
002537  }
002538  #endif /* SQLITE_ENABLE_STMT_SCANSTATUS */