src/third_party/sqlite/src/src/vdbeapi.c

   1 /*
   2 ** 2004 May 26
   3 **
   4 ** The author disclaims copyright to this source code.  In place of
   5 ** a legal notice, here is a blessing:
   6 **
   7 **    May you do good and not evil.
   8 **    May you find forgiveness for yourself and forgive others.
   9 **    May you share freely, never taking more than you give.
  10 **
  11 *************************************************************************
  12 **
  13 ** This file contains code use to implement APIs that are part of the
  14 ** VDBE.
  15 */
  16 #include "sqliteInt.h"
  17 #include "vdbeInt.h"
  18
  19 #ifndef SQLITE_OMIT_DEPRECATED
  20 /*
  21 ** Return TRUE (non-zero) of the statement supplied as an argument needs
  22 ** to be recompiled.  A statement needs to be recompiled whenever the
  23 ** execution environment changes in a way that would alter the program
  24 ** that sqlite3_prepare() generates.  For example, if new functions or
  25 ** collating sequences are registered or if an authorizer function is
  26 ** added or changed.
  27 */
  28 int sqlite3_expired(sqlite3_stmt *pStmt){
  29   Vdbe *p = (Vdbe*)pStmt;
  30   return p==0 || p->expired;
  31 }
  32 #endif
  33
  34 /*
  35 ** Check on a Vdbe to make sure it has not been finalized.  Log
  36 ** an error and return true if it has been finalized (or is otherwise
  37 ** invalid).  Return false if it is ok.
  38 */
  39 static int vdbeSafety(Vdbe *p){
  40   if( p->db==0 ){
  41     sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement");
  42     return 1;
  43   }else{
  44     return 0;
  45   }
  46 }
  47 static int vdbeSafetyNotNull(Vdbe *p){
  48   if( p==0 ){
  49     sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement");
  50     return 1;
  51   }else{
  52     return vdbeSafety(p);
  53   }
  54 }
  55
  56 /*
  57 ** The following routine destroys a virtual machine that is created by
  58 ** the sqlite3_compile() routine. The integer returned is an SQLITE_
  59 ** success/failure code that describes the result of executing the virtual
  60 ** machine.
  61 **
  62 ** This routine sets the error code and string returned by
  63 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
  64 */
  65 int sqlite3_finalize(sqlite3_stmt *pStmt){
  66   int rc;
  67   if( pStmt==0 ){
  68     /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
  69     ** pointer is a harmless no-op. */
  70     rc = SQLITE_OK;
  71   }else{
  72     Vdbe *v = (Vdbe*)pStmt;
  73     sqlite3 *db = v->db;
  74 #if SQLITE_THREADSAFE
  75     sqlite3_mutex *mutex;
  76 #endif
  77     if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
  78 #if SQLITE_THREADSAFE
  79     mutex = v->db->mutex;
  80 #endif
  81     sqlite3_mutex_enter(mutex);
  82     rc = sqlite3VdbeFinalize(v);
  83     rc = sqlite3ApiExit(db, rc);
  84     sqlite3_mutex_leave(mutex);
  85   }
  86   return rc;
  87 }
  88
  89 /*
  90 ** Terminate the current execution of an SQL statement and reset it
  91 ** back to its starting state so that it can be reused. A success code from
  92 ** the prior execution is returned.
  93 **
  94 ** This routine sets the error code and string returned by
  95 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
  96 */
  97 int sqlite3_reset(sqlite3_stmt *pStmt){
  98   int rc;
  99   if( pStmt==0 ){
 100     rc = SQLITE_OK;
 101   }else{
 102     Vdbe *v = (Vdbe*)pStmt;
 103     sqlite3_mutex_enter(v->db->mutex);
 104     rc = sqlite3VdbeReset(v);
 105     sqlite3VdbeMakeReady(v, -1, 0, 0, 0, 0, 0);
 106     assert( (rc & (v->db->errMask))==rc );
 107     rc = sqlite3ApiExit(v->db, rc);
 108     sqlite3_mutex_leave(v->db->mutex);
 109   }
 110   return rc;
 111 }
 112
 113 /*
 114 ** Set all the parameters in the compiled SQL statement to NULL.
 115 */
 116 int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
 117   int i;
 118   int rc = SQLITE_OK;
 119   Vdbe *p = (Vdbe*)pStmt;
 120 #if SQLITE_THREADSAFE
 121   sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
 122 #endif
 123   sqlite3_mutex_enter(mutex);
 124   for(i=0; i<p->nVar; i++){
 125     sqlite3VdbeMemRelease(&p->aVar[i]);
 126     p->aVar[i].flags = MEM_Null;
 127   }
 128   if( p->isPrepareV2 && p->expmask ){
 129     p->expired = 1;
 130   }
 131   sqlite3_mutex_leave(mutex);
 132   return rc;
 133 }
 134
 135
 136 /**************************** sqlite3_value_  *******************************
 137 ** The following routines extract information from a Mem or sqlite3_value
 138 ** structure.
 139 */
 140 const void *sqlite3_value_blob(sqlite3_value *pVal){
 141   Mem *p = (Mem*)pVal;
 142   if( p->flags & (MEM_Blob|MEM_Str) ){
 143     sqlite3VdbeMemExpandBlob(p);
 144     p->flags &= ~MEM_Str;
 145     p->flags |= MEM_Blob;
 146     return p->n ? p->z : 0;
 147   }else{
 148     return sqlite3_value_text(pVal);
 149   }
 150 }
 151 int sqlite3_value_bytes(sqlite3_value *pVal){
 152   return sqlite3ValueBytes(pVal, SQLITE_UTF8);
 153 }
 154 int sqlite3_value_bytes16(sqlite3_value *pVal){
 155   return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
 156 }
 157 double sqlite3_value_double(sqlite3_value *pVal){
 158   return sqlite3VdbeRealValue((Mem*)pVal);
 159 }
 160 int sqlite3_value_int(sqlite3_value *pVal){
 161   return (int)sqlite3VdbeIntValue((Mem*)pVal);
 162 }
 163 sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
 164   return sqlite3VdbeIntValue((Mem*)pVal);
 165 }
 166 const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
 167   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
 168 }
 169 #ifndef SQLITE_OMIT_UTF16
 170 const void *sqlite3_value_text16(sqlite3_value* pVal){
 171   return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
 172 }
 173 const void *sqlite3_value_text16be(sqlite3_value *pVal){
 174   return sqlite3ValueText(pVal, SQLITE_UTF16BE);
 175 }
 176 const void *sqlite3_value_text16le(sqlite3_value *pVal){
 177   return sqlite3ValueText(pVal, SQLITE_UTF16LE);
 178 }
 179 #endif /* SQLITE_OMIT_UTF16 */
 180 int sqlite3_value_type(sqlite3_value* pVal){
 181   return pVal->type;
 182 }
 183
 184 /**************************** sqlite3_result_  *******************************
 185 ** The following routines are used by user-defined functions to specify
 186 ** the function result.
 187 **
 188 ** The setStrOrError() funtion calls sqlite3VdbeMemSetStr() to store the
 189 ** result as a string or blob but if the string or blob is too large, it
 190 ** then sets the error code to SQLITE_TOOBIG
 191 */
 192 static void setResultStrOrError(
 193   sqlite3_context *pCtx,  /* Function context */
 194   const char *z,          /* String pointer */
 195   int n,                  /* Bytes in string, or negative */
 196   u8 enc,                 /* Encoding of z.  0 for BLOBs */
 197   void (*xDel)(void*)     /* Destructor function */
 198 ){
 199   if( sqlite3VdbeMemSetStr(&pCtx->s, z, n, enc, xDel)==SQLITE_TOOBIG ){
 200     sqlite3_result_error_toobig(pCtx);
 201   }
 202 }
 203 void sqlite3_result_blob(
 204   sqlite3_context *pCtx,
 205   const void *z,
 206   int n,
 207   void (*xDel)(void *)
 208 ){
 209   assert( n>=0 );
 210   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 211   setResultStrOrError(pCtx, z, n, 0, xDel);
 212 }
 213 void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
 214   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 215   sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
 216 }
 217 void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
 218   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 219   pCtx->isError = SQLITE_ERROR;
 220   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
 221 }
 222 #ifndef SQLITE_OMIT_UTF16
 223 void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
 224   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 225   pCtx->isError = SQLITE_ERROR;
 226   sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
 227 }
 228 #endif
 229 void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
 230   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 231   sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
 232 }
 233 void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
 234   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 235   sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
 236 }
 237 void sqlite3_result_null(sqlite3_context *pCtx){
 238   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 239   sqlite3VdbeMemSetNull(&pCtx->s);
 240 }
 241 void sqlite3_result_text(
 242   sqlite3_context *pCtx,
 243   const char *z,
 244   int n,
 245   void (*xDel)(void *)
 246 ){
 247   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 248   setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
 249 }
 250 #ifndef SQLITE_OMIT_UTF16
 251 void sqlite3_result_text16(
 252   sqlite3_context *pCtx,
 253   const void *z,
 254   int n,
 255   void (*xDel)(void *)
 256 ){
 257   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 258   setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
 259 }
 260 void sqlite3_result_text16be(
 261   sqlite3_context *pCtx,
 262   const void *z,
 263   int n,
 264   void (*xDel)(void *)
 265 ){
 266   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 267   setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
 268 }
 269 void sqlite3_result_text16le(
 270   sqlite3_context *pCtx,
 271   const void *z,
 272   int n,
 273   void (*xDel)(void *)
 274 ){
 275   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 276   setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
 277 }
 278 #endif /* SQLITE_OMIT_UTF16 */
 279 void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
 280   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 281   sqlite3VdbeMemCopy(&pCtx->s, pValue);
 282 }
 283 void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
 284   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 285   sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
 286 }
 287 void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
 288   pCtx->isError = errCode;
 289   if( pCtx->s.flags & MEM_Null ){
 290     sqlite3VdbeMemSetStr(&pCtx->s, sqlite3ErrStr(errCode), -1,
 291                          SQLITE_UTF8, SQLITE_STATIC);
 292   }
 293 }
 294
 295 /* Force an SQLITE_TOOBIG error. */
 296 void sqlite3_result_error_toobig(sqlite3_context *pCtx){
 297   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 298   pCtx->isError = SQLITE_TOOBIG;
 299   sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1,
 300                        SQLITE_UTF8, SQLITE_STATIC);
 301 }
 302
 303 /* An SQLITE_NOMEM error. */
 304 void sqlite3_result_error_nomem(sqlite3_context *pCtx){
 305   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 306   sqlite3VdbeMemSetNull(&pCtx->s);
 307   pCtx->isError = SQLITE_NOMEM;
 308   pCtx->s.db->mallocFailed = 1;
 309 }
 310
 311 /*
 312 ** This function is called after a transaction has been committed. It
 313 ** invokes callbacks registered with sqlite3_wal_hook() as required.
 314 */
 315 static int doWalCallbacks(sqlite3 *db){
 316   int rc = SQLITE_OK;
 317 #ifndef SQLITE_OMIT_WAL
 318   int i;
 319   for(i=0; i<db->nDb; i++){
 320     Btree *pBt = db->aDb[i].pBt;
 321     if( pBt ){
 322       int nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
 323       if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){
 324         rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry);
 325       }
 326     }
 327   }
 328 #endif
 329   return rc;
 330 }
 331
 332 /*
 333 ** Execute the statement pStmt, either until a row of data is ready, the
 334 ** statement is completely executed or an error occurs.
 335 **
 336 ** This routine implements the bulk of the logic behind the sqlite_step()
 337 ** API.  The only thing omitted is the automatic recompile if a
 338 ** schema change has occurred.  That detail is handled by the
 339 ** outer sqlite3_step() wrapper procedure.
 340 */
 341 static int sqlite3Step(Vdbe *p){
 342   sqlite3 *db;
 343   int rc;
 344
 345   assert(p);
 346   if( p->magic!=VDBE_MAGIC_RUN ){
 347     /* We used to require that sqlite3_reset() be called before retrying
 348     ** sqlite3_step() after any error or after SQLITE_DONE.  But beginning
 349     ** with version 3.7.0, we changed this so that sqlite3_reset() would
 350     ** be called automatically instead of throwing the SQLITE_MISUSE error.
 351     ** This "automatic-reset" change is not technically an incompatibility,
 352     ** since any application that receives an SQLITE_MISUSE is broken by
 353     ** definition.
 354     **
 355     ** Nevertheless, some published applications that were originally written
 356     ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
 357     ** returns, and the so were broken by the automatic-reset change.  As a
 358     ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
 359     ** legacy behavior of returning SQLITE_MISUSE for cases where the
 360     ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
 361     ** or SQLITE_BUSY error.
 362     */
 363 #ifdef SQLITE_OMIT_AUTORESET
 364     if( p->rc==SQLITE_BUSY || p->rc==SQLITE_LOCKED ){
 365       sqlite3_reset((sqlite3_stmt*)p);
 366     }else{
 367       return SQLITE_MISUSE_BKPT;
 368     }
 369 #else
 370     sqlite3_reset((sqlite3_stmt*)p);
 371 #endif
 372   }
 373
 374   /* Check that malloc() has not failed. If it has, return early. */
 375   db = p->db;
 376   if( db->mallocFailed ){
 377     p->rc = SQLITE_NOMEM;
 378     return SQLITE_NOMEM;
 379   }
 380
 381   if( p->pc<=0 && p->expired ){
 382     p->rc = SQLITE_SCHEMA;
 383     rc = SQLITE_ERROR;
 384     goto end_of_step;
 385   }
 386   if( p->pc<0 ){
 387     /* If there are no other statements currently running, then
 388     ** reset the interrupt flag.  This prevents a call to sqlite3_interrupt
 389     ** from interrupting a statement that has not yet started.
 390     */
 391     if( db->activeVdbeCnt==0 ){
 392       db->u1.isInterrupted = 0;
 393     }
 394
 395     assert( db->writeVdbeCnt>0 || db->autoCommit==0 || db->nDeferredCons==0 );
 396
 397 #ifndef SQLITE_OMIT_TRACE
 398     if( db->xProfile && !db->init.busy ){
 399       sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
 400     }
 401 #endif
 402
 403     db->activeVdbeCnt++;
 404     if( p->readOnly==0 ) db->writeVdbeCnt++;
 405     p->pc = 0;
 406   }
 407 #ifndef SQLITE_OMIT_EXPLAIN
 408   if( p->explain ){
 409     rc = sqlite3VdbeList(p);
 410   }else
 411 #endif /* SQLITE_OMIT_EXPLAIN */
 412   {
 413     db->vdbeExecCnt++;
 414     rc = sqlite3VdbeExec(p);
 415     db->vdbeExecCnt--;
 416   }
 417
 418 #ifndef SQLITE_OMIT_TRACE
 419   /* Invoke the profile callback if there is one
 420   */
 421   if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){
 422     sqlite3_int64 iNow;
 423     sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
 424     db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000);
 425   }
 426 #endif
 427
 428   if( rc==SQLITE_DONE ){
 429     assert( p->rc==SQLITE_OK );
 430     p->rc = doWalCallbacks(db);
 431     if( p->rc!=SQLITE_OK ){
 432       rc = SQLITE_ERROR;
 433     }
 434   }
 435
 436   db->errCode = rc;
 437   if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
 438     p->rc = SQLITE_NOMEM;
 439   }
 440 end_of_step:
 441   /* At this point local variable rc holds the value that should be
 442   ** returned if this statement was compiled using the legacy
 443   ** sqlite3_prepare() interface. According to the docs, this can only
 444   ** be one of the values in the first assert() below. Variable p->rc
 445   ** contains the value that would be returned if sqlite3_finalize()
 446   ** were called on statement p.
 447   */
 448   assert( rc==SQLITE_ROW  || rc==SQLITE_DONE   || rc==SQLITE_ERROR
 449        || rc==SQLITE_BUSY || rc==SQLITE_MISUSE
 450   );
 451   assert( p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE );
 452   if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
 453     /* If this statement was prepared using sqlite3_prepare_v2(), and an
 454     ** error has occured, then return the error code in p->rc to the
 455     ** caller. Set the error code in the database handle to the same value.
 456     */
 457     rc = db->errCode = p->rc;
 458   }
 459   return (rc&db->errMask);
 460 }
 461
 462 /*
 463 ** This is the top-level implementation of sqlite3_step().  Call
 464 ** sqlite3Step() to do most of the work.  If a schema error occurs,
 465 ** call sqlite3Reprepare() and try again.
 466 */
 467 int sqlite3_step(sqlite3_stmt *pStmt){
 468   int rc = SQLITE_OK;      /* Result from sqlite3Step() */
 469   int rc2 = SQLITE_OK;     /* Result from sqlite3Reprepare() */
 470   Vdbe *v = (Vdbe*)pStmt;  /* the prepared statement */
 471   int cnt = 0;             /* Counter to prevent infinite loop of reprepares */
 472   sqlite3 *db;             /* The database connection */
 473
 474   if( vdbeSafetyNotNull(v) ){
 475     return SQLITE_MISUSE_BKPT;
 476   }
 477   db = v->db;
 478   sqlite3_mutex_enter(db->mutex);
 479   while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
 480          && cnt++ < 5
 481          && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
 482     sqlite3_reset(pStmt);
 483     v->expired = 0;
 484   }
 485   if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
 486     /* This case occurs after failing to recompile an sql statement.
 487     ** The error message from the SQL compiler has already been loaded
 488     ** into the database handle. This block copies the error message
 489     ** from the database handle into the statement and sets the statement
 490     ** program counter to 0 to ensure that when the statement is
 491     ** finalized or reset the parser error message is available via
 492     ** sqlite3_errmsg() and sqlite3_errcode().
 493     */
 494     const char *zErr = (const char *)sqlite3_value_text(db->pErr);
 495     sqlite3DbFree(db, v->zErrMsg);
 496     if( !db->mallocFailed ){
 497       v->zErrMsg = sqlite3DbStrDup(db, zErr);
 498       v->rc = rc2;
 499     } else {
 500       v->zErrMsg = 0;
 501       v->rc = rc = SQLITE_NOMEM;
 502     }
 503   }
 504   rc = sqlite3ApiExit(db, rc);
 505   sqlite3_mutex_leave(db->mutex);
 506   return rc;
 507 }
 508
 509 /*
 510 ** Extract the user data from a sqlite3_context structure and return a
 511 ** pointer to it.
 512 */
 513 void *sqlite3_user_data(sqlite3_context *p){
 514   assert( p && p->pFunc );
 515   return p->pFunc->pUserData;
 516 }
 517
 518 /*
 519 ** Extract the user data from a sqlite3_context structure and return a
 520 ** pointer to it.
 521 **
 522 ** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface
 523 ** returns a copy of the pointer to the database connection (the 1st
 524 ** parameter) of the sqlite3_create_function() and
 525 ** sqlite3_create_function16() routines that originally registered the
 526 ** application defined function.
 527 */
 528 sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
 529   assert( p && p->pFunc );
 530   return p->s.db;
 531 }
 532
 533 /*
 534 ** The following is the implementation of an SQL function that always
 535 ** fails with an error message stating that the function is used in the
 536 ** wrong context.  The sqlite3_overload_function() API might construct
 537 ** SQL function that use this routine so that the functions will exist
 538 ** for name resolution but are actually overloaded by the xFindFunction
 539 ** method of virtual tables.
 540 */
 541 void sqlite3InvalidFunction(
 542   sqlite3_context *context,  /* The function calling context */
 543   int NotUsed,               /* Number of arguments to the function */
 544   sqlite3_value **NotUsed2   /* Value of each argument */
 545 ){
 546   const char *zName = context->pFunc->zName;
 547   char *zErr;
 548   UNUSED_PARAMETER2(NotUsed, NotUsed2);
 549   zErr = sqlite3_mprintf(
 550       "unable to use function %s in the requested context", zName);
 551   sqlite3_result_error(context, zErr, -1);
 552   sqlite3_free(zErr);
 553 }
 554
 555 /*
 556 ** Allocate or return the aggregate context for a user function.  A new
 557 ** context is allocated on the first call.  Subsequent calls return the
 558 ** same context that was returned on prior calls.
 559 */
 560 void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
 561   Mem *pMem;
 562   assert( p && p->pFunc && p->pFunc->xStep );
 563   assert( sqlite3_mutex_held(p->s.db->mutex) );
 564   pMem = p->pMem;
 565   testcase( nByte<0 );
 566   if( (pMem->flags & MEM_Agg)==0 ){
 567     if( nByte<=0 ){
 568       sqlite3VdbeMemReleaseExternal(pMem);
 569       pMem->flags = MEM_Null;
 570       pMem->z = 0;
 571     }else{
 572       sqlite3VdbeMemGrow(pMem, nByte, 0);
 573       pMem->flags = MEM_Agg;
 574       pMem->u.pDef = p->pFunc;
 575       if( pMem->z ){
 576         memset(pMem->z, 0, nByte);
 577       }
 578     }
 579   }
 580   return (void*)pMem->z;
 581 }
 582
 583 /*
 584 ** Return the auxilary data pointer, if any, for the iArg'th argument to
 585 ** the user-function defined by pCtx.
 586 */
 587 void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
 588   VdbeFunc *pVdbeFunc;
 589
 590   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 591   pVdbeFunc = pCtx->pVdbeFunc;
 592   if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
 593     return 0;
 594   }
 595   return pVdbeFunc->apAux[iArg].pAux;
 596 }
 597
 598 /*
 599 ** Set the auxilary data pointer and delete function, for the iArg'th
 600 ** argument to the user-function defined by pCtx. Any previous value is
 601 ** deleted by calling the delete function specified when it was set.
 602 */
 603 void sqlite3_set_auxdata(
 604   sqlite3_context *pCtx,
 605   int iArg,
 606   void *pAux,
 607   void (*xDelete)(void*)
 608 ){
 609   struct AuxData *pAuxData;
 610   VdbeFunc *pVdbeFunc;
 611   if( iArg<0 ) goto failed;
 612
 613   assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
 614   pVdbeFunc = pCtx->pVdbeFunc;
 615   if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
 616     int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
 617     int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
 618     pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
 619     if( !pVdbeFunc ){
 620       goto failed;
 621     }
 622     pCtx->pVdbeFunc = pVdbeFunc;
 623     memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
 624     pVdbeFunc->nAux = iArg+1;
 625     pVdbeFunc->pFunc = pCtx->pFunc;
 626   }
 627
 628   pAuxData = &pVdbeFunc->apAux[iArg];
 629   if( pAuxData->pAux && pAuxData->xDelete ){
 630     pAuxData->xDelete(pAuxData->pAux);
 631   }
 632   pAuxData->pAux = pAux;
 633   pAuxData->xDelete = xDelete;
 634   return;
 635
 636 failed:
 637   if( xDelete ){
 638     xDelete(pAux);
 639   }
 640 }
 641
 642 #ifndef SQLITE_OMIT_DEPRECATED
 643 /*
 644 ** Return the number of times the Step function of a aggregate has been
 645 ** called.
 646 **
 647 ** This function is deprecated.  Do not use it for new code.  It is
 648 ** provide only to avoid breaking legacy code.  New aggregate function
 649 ** implementations should keep their own counts within their aggregate
 650 ** context.
 651 */
 652 int sqlite3_aggregate_count(sqlite3_context *p){
 653   assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
 654   return p->pMem->n;
 655 }
 656 #endif
 657
 658 /*
 659 ** Return the number of columns in the result set for the statement pStmt.
 660 */
 661 int sqlite3_column_count(sqlite3_stmt *pStmt){
 662   Vdbe *pVm = (Vdbe *)pStmt;
 663   return pVm ? pVm->nResColumn : 0;
 664 }
 665
 666 /*
 667 ** Return the number of values available from the current row of the
 668 ** currently executing statement pStmt.
 669 */
 670 int sqlite3_data_count(sqlite3_stmt *pStmt){
 671   Vdbe *pVm = (Vdbe *)pStmt;
 672   if( pVm==0 || pVm->pResultSet==0 ) return 0;
 673   return pVm->nResColumn;
 674 }
 675
 676
 677 /*
 678 ** Check to see if column iCol of the given statement is valid.  If
 679 ** it is, return a pointer to the Mem for the value of that column.
 680 ** If iCol is not valid, return a pointer to a Mem which has a value
 681 ** of NULL.
 682 */
 683 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
 684   Vdbe *pVm;
 685   Mem *pOut;
 686
 687   pVm = (Vdbe *)pStmt;
 688   if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
 689     sqlite3_mutex_enter(pVm->db->mutex);
 690     pOut = &pVm->pResultSet[i];
 691   }else{
 692     /* If the value passed as the second argument is out of range, return
 693     ** a pointer to the following static Mem object which contains the
 694     ** value SQL NULL. Even though the Mem structure contains an element
 695     ** of type i64, on certain architecture (x86) with certain compiler
 696     ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
 697     ** instead of an 8-byte one. This all works fine, except that when
 698     ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
 699     ** that a Mem structure is located on an 8-byte boundary. To prevent
 700     ** this assert() from failing, when building with SQLITE_DEBUG defined
 701     ** using gcc, force nullMem to be 8-byte aligned using the magical
 702     ** __attribute__((aligned(8))) macro.  */
 703     static const Mem nullMem
 704 #if defined(SQLITE_DEBUG) && defined(__GNUC__)
 705       __attribute__((aligned(8)))
 706 #endif
 707       = {0, "", (double)0, {0}, 0, MEM_Null, SQLITE_NULL, 0,
 708 #ifdef SQLITE_DEBUG
 709          0, 0,  /* pScopyFrom, pFiller */
 710 #endif
 711          0, 0 };
 712
 713     if( pVm && ALWAYS(pVm->db) ){
 714       sqlite3_mutex_enter(pVm->db->mutex);
 715       sqlite3Error(pVm->db, SQLITE_RANGE, 0);
 716     }
 717     pOut = (Mem*)&nullMem;
 718   }
 719   return pOut;
 720 }
 721
 722 /*
 723 ** This function is called after invoking an sqlite3_value_XXX function on a
 724 ** column value (i.e. a value returned by evaluating an SQL expression in the
 725 ** select list of a SELECT statement) that may cause a malloc() failure. If
 726 ** malloc() has failed, the threads mallocFailed flag is cleared and the result
 727 ** code of statement pStmt set to SQLITE_NOMEM.
 728 **
 729 ** Specifically, this is called from within:
 730 **
 731 **     sqlite3_column_int()
 732 **     sqlite3_column_int64()
 733 **     sqlite3_column_text()
 734 **     sqlite3_column_text16()
 735 **     sqlite3_column_real()
 736 **     sqlite3_column_bytes()
 737 **     sqlite3_column_bytes16()
 738 **     sqiite3_column_blob()
 739 */
 740 static void columnMallocFailure(sqlite3_stmt *pStmt)
 741 {
 742   /* If malloc() failed during an encoding conversion within an
 743   ** sqlite3_column_XXX API, then set the return code of the statement to
 744   ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
 745   ** and _finalize() will return NOMEM.
 746   */
 747   Vdbe *p = (Vdbe *)pStmt;
 748   if( p ){
 749     p->rc = sqlite3ApiExit(p->db, p->rc);
 750     sqlite3_mutex_leave(p->db->mutex);
 751   }
 752 }
 753
 754 /**************************** sqlite3_column_  *******************************
 755 ** The following routines are used to access elements of the current row
 756 ** in the result set.
 757 */
 758 const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
 759   const void *val;
 760   val = sqlite3_value_blob( columnMem(pStmt,i) );
 761   /* Even though there is no encoding conversion, value_blob() might
 762   ** need to call malloc() to expand the result of a zeroblob()
 763   ** expression.
 764   */
 765   columnMallocFailure(pStmt);
 766   return val;
 767 }
 768 int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
 769   int val = sqlite3_value_bytes( columnMem(pStmt,i) );
 770   columnMallocFailure(pStmt);
 771   return val;
 772 }
 773 int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
 774   int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
 775   columnMallocFailure(pStmt);
 776   return val;
 777 }
 778 double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
 779   double val = sqlite3_value_double( columnMem(pStmt,i) );
 780   columnMallocFailure(pStmt);
 781   return val;
 782 }
 783 int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
 784   int val = sqlite3_value_int( columnMem(pStmt,i) );
 785   columnMallocFailure(pStmt);
 786   return val;
 787 }
 788 sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
 789   sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
 790   columnMallocFailure(pStmt);
 791   return val;
 792 }
 793 const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
 794   const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
 795   columnMallocFailure(pStmt);
 796   return val;
 797 }
 798 sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
 799   Mem *pOut = columnMem(pStmt, i);
 800   if( pOut->flags&MEM_Static ){
 801     pOut->flags &= ~MEM_Static;
 802     pOut->flags |= MEM_Ephem;
 803   }
 804   columnMallocFailure(pStmt);
 805   return (sqlite3_value *)pOut;
 806 }
 807 #ifndef SQLITE_OMIT_UTF16
 808 const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
 809   const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
 810   columnMallocFailure(pStmt);
 811   return val;
 812 }
 813 #endif /* SQLITE_OMIT_UTF16 */
 814 int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
 815   int iType = sqlite3_value_type( columnMem(pStmt,i) );
 816   columnMallocFailure(pStmt);
 817   return iType;
 818 }
 819
 820 /* The following function is experimental and subject to change or
 821 ** removal */
 822 /*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
 823 **  return sqlite3_value_numeric_type( columnMem(pStmt,i) );
 824 **}
 825 */
 826
 827 /*
 828 ** Convert the N-th element of pStmt->pColName[] into a string using
 829 ** xFunc() then return that string.  If N is out of range, return 0.
 830 **
 831 ** There are up to 5 names for each column.  useType determines which
 832 ** name is returned.  Here are the names:
 833 **
 834 **    0      The column name as it should be displayed for output
 835 **    1      The datatype name for the column
 836 **    2      The name of the database that the column derives from
 837 **    3      The name of the table that the column derives from
 838 **    4      The name of the table column that the result column derives from
 839 **
 840 ** If the result is not a simple column reference (if it is an expression
 841 ** or a constant) then useTypes 2, 3, and 4 return NULL.
 842 */
 843 static const void *columnName(
 844   sqlite3_stmt *pStmt,
 845   int N,
 846   const void *(*xFunc)(Mem*),
 847   int useType
 848 ){
 849   const void *ret = 0;
 850   Vdbe *p = (Vdbe *)pStmt;
 851   int n;
 852   sqlite3 *db = p->db;
 853
 854   assert( db!=0 );
 855   n = sqlite3_column_count(pStmt);
 856   if( N<n && N>=0 ){
 857     N += useType*n;
 858     sqlite3_mutex_enter(db->mutex);
 859     assert( db->mallocFailed==0 );
 860     ret = xFunc(&p->aColName[N]);
 861      /* A malloc may have failed inside of the xFunc() call. If this
 862     ** is the case, clear the mallocFailed flag and return NULL.
 863     */
 864     if( db->mallocFailed ){
 865       db->mallocFailed = 0;
 866       ret = 0;
 867     }
 868     sqlite3_mutex_leave(db->mutex);
 869   }
 870   return ret;
 871 }
 872
 873 /*
 874 ** Return the name of the Nth column of the result set returned by SQL
 875 ** statement pStmt.
 876 */
 877 const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
 878   return columnName(
 879       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
 880 }
 881 #ifndef SQLITE_OMIT_UTF16
 882 const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
 883   return columnName(
 884       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
 885 }
 886 #endif
 887
 888 /*
 889 ** Constraint:  If you have ENABLE_COLUMN_METADATA then you must
 890 ** not define OMIT_DECLTYPE.
 891 */
 892 #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
 893 # error "Must not define both SQLITE_OMIT_DECLTYPE \
 894          and SQLITE_ENABLE_COLUMN_METADATA"
 895 #endif
 896
 897 #ifndef SQLITE_OMIT_DECLTYPE
 898 /*
 899 ** Return the column declaration type (if applicable) of the 'i'th column
 900 ** of the result set of SQL statement pStmt.
 901 */
 902 const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
 903   return columnName(
 904       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
 905 }
 906 #ifndef SQLITE_OMIT_UTF16
 907 const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
 908   return columnName(
 909       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
 910 }
 911 #endif /* SQLITE_OMIT_UTF16 */
 912 #endif /* SQLITE_OMIT_DECLTYPE */
 913
 914 #ifdef SQLITE_ENABLE_COLUMN_METADATA
 915 /*
 916 ** Return the name of the database from which a result column derives.
 917 ** NULL is returned if the result column is an expression or constant or
 918 ** anything else which is not an unabiguous reference to a database column.
 919 */
 920 const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
 921   return columnName(
 922       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
 923 }
 924 #ifndef SQLITE_OMIT_UTF16
 925 const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
 926   return columnName(
 927       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
 928 }
 929 #endif /* SQLITE_OMIT_UTF16 */
 930
 931 /*
 932 ** Return the name of the table from which a result column derives.
 933 ** NULL is returned if the result column is an expression or constant or
 934 ** anything else which is not an unabiguous reference to a database column.
 935 */
 936 const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
 937   return columnName(
 938       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
 939 }
 940 #ifndef SQLITE_OMIT_UTF16
 941 const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
 942   return columnName(
 943       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
 944 }
 945 #endif /* SQLITE_OMIT_UTF16 */
 946
 947 /*
 948 ** Return the name of the table column from which a result column derives.
 949 ** NULL is returned if the result column is an expression or constant or
 950 ** anything else which is not an unabiguous reference to a database column.
 951 */
 952 const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
 953   return columnName(
 954       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
 955 }
 956 #ifndef SQLITE_OMIT_UTF16
 957 const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
 958   return columnName(
 959       pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
 960 }
 961 #endif /* SQLITE_OMIT_UTF16 */
 962 #endif /* SQLITE_ENABLE_COLUMN_METADATA */
 963
 964
 965 /******************************* sqlite3_bind_  ***************************
 966 **
 967 ** Routines used to attach values to wildcards in a compiled SQL statement.
 968 */
 969 /*
 970 ** Unbind the value bound to variable i in virtual machine p. This is the
 971 ** the same as binding a NULL value to the column. If the "i" parameter is
 972 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
 973 **
 974 ** A successful evaluation of this routine acquires the mutex on p.
 975 ** the mutex is released if any kind of error occurs.
 976 **
 977 ** The error code stored in database p->db is overwritten with the return
 978 ** value in any case.
 979 */
 980 static int vdbeUnbind(Vdbe *p, int i){
 981   Mem *pVar;
 982   if( vdbeSafetyNotNull(p) ){
 983     return SQLITE_MISUSE_BKPT;
 984   }
 985   sqlite3_mutex_enter(p->db->mutex);
 986   if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
 987     sqlite3Error(p->db, SQLITE_MISUSE, 0);
 988     sqlite3_mutex_leave(p->db->mutex);
 989     sqlite3_log(SQLITE_MISUSE,
 990         "bind on a busy prepared statement: [%s]", p->zSql);
 991     return SQLITE_MISUSE_BKPT;
 992   }
 993   if( i<1 || i>p->nVar ){
 994     sqlite3Error(p->db, SQLITE_RANGE, 0);
 995     sqlite3_mutex_leave(p->db->mutex);
 996     return SQLITE_RANGE;
 997   }
 998   i--;
 999   pVar = &p->aVar[i];
1000   sqlite3VdbeMemRelease(pVar);
1001   pVar->flags = MEM_Null;
1002   sqlite3Error(p->db, SQLITE_OK, 0);
1003
1004   /* If the bit corresponding to this variable in Vdbe.expmask is set, then
1005   ** binding a new value to this variable invalidates the current query plan.
1006   **
1007   ** IMPLEMENTATION-OF: R-48440-37595 If the specific value bound to host
1008   ** parameter in the WHERE clause might influence the choice of query plan
1009   ** for a statement, then the statement will be automatically recompiled,
1010   ** as if there had been a schema change, on the first sqlite3_step() call
1011   ** following any change to the bindings of that parameter.
1012   */
1013   if( p->isPrepareV2 &&
1014      ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
1015   ){
1016     p->expired = 1;
1017   }
1018   return SQLITE_OK;
1019 }
1020
1021 /*
1022 ** Bind a text or BLOB value.
1023 */
1024 static int bindText(
1025   sqlite3_stmt *pStmt,   /* The statement to bind against */
1026   int i,                 /* Index of the parameter to bind */
1027   const void *zData,     /* Pointer to the data to be bound */
1028   int nData,             /* Number of bytes of data to be bound */
1029   void (*xDel)(void*),   /* Destructor for the data */
1030   u8 encoding            /* Encoding for the data */
1031 ){
1032   Vdbe *p = (Vdbe *)pStmt;
1033   Mem *pVar;
1034   int rc;
1035
1036   rc = vdbeUnbind(p, i);
1037   if( rc==SQLITE_OK ){
1038     if( zData!=0 ){
1039       pVar = &p->aVar[i-1];
1040       rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
1041       if( rc==SQLITE_OK && encoding!=0 ){
1042         rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
1043       }
1044       sqlite3Error(p->db, rc, 0);
1045       rc = sqlite3ApiExit(p->db, rc);
1046     }
1047     sqlite3_mutex_leave(p->db->mutex);
1048   }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){
1049     xDel((void*)zData);
1050   }
1051   return rc;
1052 }
1053
1054
1055 /*
1056 ** Bind a blob value to an SQL statement variable.
1057 */
1058 int sqlite3_bind_blob(
1059   sqlite3_stmt *pStmt,
1060   int i,
1061   const void *zData,
1062   int nData,
1063   void (*xDel)(void*)
1064 ){
1065   return bindText(pStmt, i, zData, nData, xDel, 0);
1066 }
1067 int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
1068   int rc;
1069   Vdbe *p = (Vdbe *)pStmt;
1070   rc = vdbeUnbind(p, i);
1071   if( rc==SQLITE_OK ){
1072     sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
1073     sqlite3_mutex_leave(p->db->mutex);
1074   }
1075   return rc;
1076 }
1077 int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
1078   return sqlite3_bind_int64(p, i, (i64)iValue);
1079 }
1080 int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
1081   int rc;
1082   Vdbe *p = (Vdbe *)pStmt;
1083   rc = vdbeUnbind(p, i);
1084   if( rc==SQLITE_OK ){
1085     sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
1086     sqlite3_mutex_leave(p->db->mutex);
1087   }
1088   return rc;
1089 }
1090 int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
1091   int rc;
1092   Vdbe *p = (Vdbe*)pStmt;
1093   rc = vdbeUnbind(p, i);
1094   if( rc==SQLITE_OK ){
1095     sqlite3_mutex_leave(p->db->mutex);
1096   }
1097   return rc;
1098 }
1099 int sqlite3_bind_text(
1100   sqlite3_stmt *pStmt,
1101   int i,
1102   const char *zData,
1103   int nData,
1104   void (*xDel)(void*)
1105 ){
1106   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
1107 }
1108 #ifndef SQLITE_OMIT_UTF16
1109 int sqlite3_bind_text16(
1110   sqlite3_stmt *pStmt,
1111   int i,
1112   const void *zData,
1113   int nData,
1114   void (*xDel)(void*)
1115 ){
1116   return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
1117 }
1118 #endif /* SQLITE_OMIT_UTF16 */
1119 int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
1120   int rc;
1121   switch( pValue->type ){
1122     case SQLITE_INTEGER: {
1123       rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
1124       break;
1125     }
1126     case SQLITE_FLOAT: {
1127       rc = sqlite3_bind_double(pStmt, i, pValue->r);
1128       break;
1129     }
1130     case SQLITE_BLOB: {
1131       if( pValue->flags & MEM_Zero ){
1132         rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
1133       }else{
1134         rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
1135       }
1136       break;
1137     }
1138     case SQLITE_TEXT: {
1139       rc = bindText(pStmt,i,  pValue->z, pValue->n, SQLITE_TRANSIENT,
1140                               pValue->enc);
1141       break;
1142     }
1143     default: {
1144       rc = sqlite3_bind_null(pStmt, i);
1145       break;
1146     }
1147   }
1148   return rc;
1149 }
1150 int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
1151   int rc;
1152   Vdbe *p = (Vdbe *)pStmt;
1153   rc = vdbeUnbind(p, i);
1154   if( rc==SQLITE_OK ){
1155     sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
1156     sqlite3_mutex_leave(p->db->mutex);
1157   }
1158   return rc;
1159 }
1160
1161 /*
1162 ** Return the number of wildcards that can be potentially bound to.
1163 ** This routine is added to support DBD::SQLite.
1164 */
1165 int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
1166   Vdbe *p = (Vdbe*)pStmt;
1167   return p ? p->nVar : 0;
1168 }
1169
1170 /*
1171 ** Create a mapping from variable numbers to variable names
1172 ** in the Vdbe.azVar[] array, if such a mapping does not already
1173 ** exist.
1174 */
1175 static void createVarMap(Vdbe *p){
1176   if( !p->okVar ){
1177     int j;
1178     Op *pOp;
1179     sqlite3_mutex_enter(p->db->mutex);
1180     /* The race condition here is harmless.  If two threads call this
1181     ** routine on the same Vdbe at the same time, they both might end
1182     ** up initializing the Vdbe.azVar[] array.  That is a little extra
1183     ** work but it results in the same answer.
1184     */
1185     for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
1186       if( pOp->opcode==OP_Variable ){
1187         assert( pOp->p1>0 && pOp->p1<=p->nVar );
1188         p->azVar[pOp->p1-1] = pOp->p4.z;
1189       }
1190     }
1191     p->okVar = 1;
1192     sqlite3_mutex_leave(p->db->mutex);
1193   }
1194 }
1195
1196 /*
1197 ** Return the name of a wildcard parameter.  Return NULL if the index
1198 ** is out of range or if the wildcard is unnamed.
1199 **
1200 ** The result is always UTF-8.
1201 */
1202 const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
1203   Vdbe *p = (Vdbe*)pStmt;
1204   if( p==0 || i<1 || i>p->nVar ){
1205     return 0;
1206   }
1207   createVarMap(p);
1208   return p->azVar[i-1];
1209 }
1210
1211 /*
1212 ** Given a wildcard parameter name, return the index of the variable
1213 ** with that name.  If there is no variable with the given name,
1214 ** return 0.
1215 */
1216 int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
1217   int i;
1218   if( p==0 ){
1219     return 0;
1220   }
1221   createVarMap(p);
1222   if( zName ){
1223     for(i=0; i<p->nVar; i++){
1224       const char *z = p->azVar[i];
1225       if( z && strncmp(z,zName,nName)==0 && z[nName]==0 ){
1226         return i+1;
1227       }
1228     }
1229   }
1230   return 0;
1231 }
1232 int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
1233   return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
1234 }
1235
1236 /*
1237 ** Transfer all bindings from the first statement over to the second.
1238 */
1239 int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
1240   Vdbe *pFrom = (Vdbe*)pFromStmt;
1241   Vdbe *pTo = (Vdbe*)pToStmt;
1242   int i;
1243   assert( pTo->db==pFrom->db );
1244   assert( pTo->nVar==pFrom->nVar );
1245   sqlite3_mutex_enter(pTo->db->mutex);
1246   for(i=0; i<pFrom->nVar; i++){
1247     sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
1248   }
1249   sqlite3_mutex_leave(pTo->db->mutex);
1250   return SQLITE_OK;
1251 }
1252
1253 #ifndef SQLITE_OMIT_DEPRECATED
1254 /*
1255 ** Deprecated external interface.  Internal/core SQLite code
1256 ** should call sqlite3TransferBindings.
1257 **
1258 ** Is is misuse to call this routine with statements from different
1259 ** database connections.  But as this is a deprecated interface, we
1260 ** will not bother to check for that condition.
1261 **
1262 ** If the two statements contain a different number of bindings, then
1263 ** an SQLITE_ERROR is returned.  Nothing else can go wrong, so otherwise
1264 ** SQLITE_OK is returned.
1265 */
1266 int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
1267   Vdbe *pFrom = (Vdbe*)pFromStmt;
1268   Vdbe *pTo = (Vdbe*)pToStmt;
1269   if( pFrom->nVar!=pTo->nVar ){
1270     return SQLITE_ERROR;
1271   }
1272   if( pTo->isPrepareV2 && pTo->expmask ){
1273     pTo->expired = 1;
1274   }
1275   if( pFrom->isPrepareV2 && pFrom->expmask ){
1276     pFrom->expired = 1;
1277   }
1278   return sqlite3TransferBindings(pFromStmt, pToStmt);
1279 }
1280 #endif
1281
1282 /*
1283 ** Return the sqlite3* database handle to which the prepared statement given
1284 ** in the argument belongs.  This is the same database handle that was
1285 ** the first argument to the sqlite3_prepare() that was used to create
1286 ** the statement in the first place.
1287 */
1288 sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
1289   return pStmt ? ((Vdbe*)pStmt)->db : 0;
1290 }
1291
1292 /*
1293 ** Return true if the prepared statement is guaranteed to not modify the
1294 ** database.
1295 */
1296 int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
1297   return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
1298 }
1299
1300 /*
1301 ** Return a pointer to the next prepared statement after pStmt associated
1302 ** with database connection pDb.  If pStmt is NULL, return the first
1303 ** prepared statement for the database connection.  Return NULL if there
1304 ** are no more.
1305 */
1306 sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
1307   sqlite3_stmt *pNext;
1308   sqlite3_mutex_enter(pDb->mutex);
1309   if( pStmt==0 ){
1310     pNext = (sqlite3_stmt*)pDb->pVdbe;
1311   }else{
1312     pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
1313   }
1314   sqlite3_mutex_leave(pDb->mutex);
1315   return pNext;
1316 }
1317
1318 /*
1319 ** Return the value of a status counter for a prepared statement
1320 */
1321 int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
1322   Vdbe *pVdbe = (Vdbe*)pStmt;
1323   int v = pVdbe->aCounter[op-1];
1324   if( resetFlag ) pVdbe->aCounter[op-1] = 0;
1325   return v;
1326 }