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
000019 #ifndef SQLITE_OMIT_DEPRECATED
000020 /*
000021 ** Return TRUE (non-zero) of the statement supplied as an argument needs
000022 ** to be recompiled. A statement needs to be recompiled whenever the
000023 ** execution environment changes in a way that would alter the program
000024 ** that sqlite3_prepare() generates. For example, if new functions or
000025 ** collating sequences are registered or if an authorizer function is
000026 ** added or changed.
000027 */
000028 int sqlite3_expired(sqlite3_stmt *pStmt){
000029 Vdbe *p = (Vdbe*)pStmt;
000030 return p==0 || p->expired;
000031 }
000032 #endif
000033
000034 /*
000035 ** Check on a Vdbe to make sure it has not been finalized. Log
000036 ** an error and return true if it has been finalized (or is otherwise
000037 ** invalid). Return false if it is ok.
000038 */
000039 static int vdbeSafety(Vdbe *p){
000040 if( p->db==0 ){
000041 sqlite3_log(SQLITE_MISUSE, "API called with finalized prepared statement");
000042 return 1;
000043 }else{
000044 return 0;
000045 }
000046 }
000047 static int vdbeSafetyNotNull(Vdbe *p){
000048 if( p==0 ){
000049 sqlite3_log(SQLITE_MISUSE, "API called with NULL prepared statement");
000050 return 1;
000051 }else{
000052 return vdbeSafety(p);
000053 }
000054 }
000055
000056 #ifndef SQLITE_OMIT_TRACE
000057 /*
000058 ** Invoke the profile callback. This routine is only called if we already
000059 ** know that the profile callback is defined and needs to be invoked.
000060 */
000061 static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){
000062 sqlite3_int64 iNow;
000063 sqlite3_int64 iElapse;
000064 assert( p->startTime>0 );
000065 assert( db->xProfile!=0 || (db->mTrace & SQLITE_TRACE_PROFILE)!=0 );
000066 assert( db->init.busy==0 );
000067 assert( p->zSql!=0 );
000068 sqlite3OsCurrentTimeInt64(db->pVfs, &iNow);
000069 iElapse = (iNow - p->startTime)*1000000;
000070 if( db->xProfile ){
000071 db->xProfile(db->pProfileArg, p->zSql, iElapse);
000072 }
000073 if( db->mTrace & SQLITE_TRACE_PROFILE ){
000074 db->xTrace(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse);
000075 }
000076 p->startTime = 0;
000077 }
000078 /*
000079 ** The checkProfileCallback(DB,P) macro checks to see if a profile callback
000080 ** is needed, and it invokes the callback if it is needed.
000081 */
000082 # define checkProfileCallback(DB,P) \
000083 if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); }
000084 #else
000085 # define checkProfileCallback(DB,P) /*no-op*/
000086 #endif
000087
000088 /*
000089 ** The following routine destroys a virtual machine that is created by
000090 ** the sqlite3_compile() routine. The integer returned is an SQLITE_
000091 ** success/failure code that describes the result of executing the virtual
000092 ** machine.
000093 **
000094 ** This routine sets the error code and string returned by
000095 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
000096 */
000097 int sqlite3_finalize(sqlite3_stmt *pStmt){
000098 int rc;
000099 if( pStmt==0 ){
000100 /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL
000101 ** pointer is a harmless no-op. */
000102 rc = SQLITE_OK;
000103 }else{
000104 Vdbe *v = (Vdbe*)pStmt;
000105 sqlite3 *db = v->db;
000106 if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
000107 sqlite3_mutex_enter(db->mutex);
000108 checkProfileCallback(db, v);
000109 rc = sqlite3VdbeFinalize(v);
000110 rc = sqlite3ApiExit(db, rc);
000111 sqlite3LeaveMutexAndCloseZombie(db);
000112 }
000113 return rc;
000114 }
000115
000116 /*
000117 ** Terminate the current execution of an SQL statement and reset it
000118 ** back to its starting state so that it can be reused. A success code from
000119 ** the prior execution is returned.
000120 **
000121 ** This routine sets the error code and string returned by
000122 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
000123 */
000124 int sqlite3_reset(sqlite3_stmt *pStmt){
000125 int rc;
000126 if( pStmt==0 ){
000127 rc = SQLITE_OK;
000128 }else{
000129 Vdbe *v = (Vdbe*)pStmt;
000130 sqlite3 *db = v->db;
000131 sqlite3_mutex_enter(db->mutex);
000132 checkProfileCallback(db, v);
000133 rc = sqlite3VdbeReset(v);
000134 sqlite3VdbeRewind(v);
000135 assert( (rc & (db->errMask))==rc );
000136 rc = sqlite3ApiExit(db, rc);
000137 sqlite3_mutex_leave(db->mutex);
000138 }
000139 return rc;
000140 }
000141
000142 /*
000143 ** Set all the parameters in the compiled SQL statement to NULL.
000144 */
000145 int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
000146 int i;
000147 int rc = SQLITE_OK;
000148 Vdbe *p = (Vdbe*)pStmt;
000149 #if SQLITE_THREADSAFE
000150 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
000151 #endif
000152 sqlite3_mutex_enter(mutex);
000153 for(i=0; i<p->nVar; i++){
000154 sqlite3VdbeMemRelease(&p->aVar[i]);
000155 p->aVar[i].flags = MEM_Null;
000156 }
000157 if( p->isPrepareV2 && p->expmask ){
000158 p->expired = 1;
000159 }
000160 sqlite3_mutex_leave(mutex);
000161 return rc;
000162 }
000163
000164
000165 /**************************** sqlite3_value_ *******************************
000166 ** The following routines extract information from a Mem or sqlite3_value
000167 ** structure.
000168 */
000169 const void *sqlite3_value_blob(sqlite3_value *pVal){
000170 Mem *p = (Mem*)pVal;
000171 if( p->flags & (MEM_Blob|MEM_Str) ){
000172 if( ExpandBlob(p)!=SQLITE_OK ){
000173 assert( p->flags==MEM_Null && p->z==0 );
000174 return 0;
000175 }
000176 p->flags |= MEM_Blob;
000177 return p->n ? p->z : 0;
000178 }else{
000179 return sqlite3_value_text(pVal);
000180 }
000181 }
000182 int sqlite3_value_bytes(sqlite3_value *pVal){
000183 return sqlite3ValueBytes(pVal, SQLITE_UTF8);
000184 }
000185 int sqlite3_value_bytes16(sqlite3_value *pVal){
000186 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
000187 }
000188 double sqlite3_value_double(sqlite3_value *pVal){
000189 return sqlite3VdbeRealValue((Mem*)pVal);
000190 }
000191 int sqlite3_value_int(sqlite3_value *pVal){
000192 return (int)sqlite3VdbeIntValue((Mem*)pVal);
000193 }
000194 sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
000195 return sqlite3VdbeIntValue((Mem*)pVal);
000196 }
000197 unsigned int sqlite3_value_subtype(sqlite3_value *pVal){
000198 Mem *pMem = (Mem*)pVal;
000199 return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
000200 }
000201 const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
000202 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
000203 }
000204 #ifndef SQLITE_OMIT_UTF16
000205 const void *sqlite3_value_text16(sqlite3_value* pVal){
000206 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
000207 }
000208 const void *sqlite3_value_text16be(sqlite3_value *pVal){
000209 return sqlite3ValueText(pVal, SQLITE_UTF16BE);
000210 }
000211 const void *sqlite3_value_text16le(sqlite3_value *pVal){
000212 return sqlite3ValueText(pVal, SQLITE_UTF16LE);
000213 }
000214 #endif /* SQLITE_OMIT_UTF16 */
000215 /* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five
000216 ** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating
000217 ** point number string BLOB NULL
000218 */
000219 int sqlite3_value_type(sqlite3_value* pVal){
000220 static const u8 aType[] = {
000221 SQLITE_BLOB, /* 0x00 */
000222 SQLITE_NULL, /* 0x01 */
000223 SQLITE_TEXT, /* 0x02 */
000224 SQLITE_NULL, /* 0x03 */
000225 SQLITE_INTEGER, /* 0x04 */
000226 SQLITE_NULL, /* 0x05 */
000227 SQLITE_INTEGER, /* 0x06 */
000228 SQLITE_NULL, /* 0x07 */
000229 SQLITE_FLOAT, /* 0x08 */
000230 SQLITE_NULL, /* 0x09 */
000231 SQLITE_FLOAT, /* 0x0a */
000232 SQLITE_NULL, /* 0x0b */
000233 SQLITE_INTEGER, /* 0x0c */
000234 SQLITE_NULL, /* 0x0d */
000235 SQLITE_INTEGER, /* 0x0e */
000236 SQLITE_NULL, /* 0x0f */
000237 SQLITE_BLOB, /* 0x10 */
000238 SQLITE_NULL, /* 0x11 */
000239 SQLITE_TEXT, /* 0x12 */
000240 SQLITE_NULL, /* 0x13 */
000241 SQLITE_INTEGER, /* 0x14 */
000242 SQLITE_NULL, /* 0x15 */
000243 SQLITE_INTEGER, /* 0x16 */
000244 SQLITE_NULL, /* 0x17 */
000245 SQLITE_FLOAT, /* 0x18 */
000246 SQLITE_NULL, /* 0x19 */
000247 SQLITE_FLOAT, /* 0x1a */
000248 SQLITE_NULL, /* 0x1b */
000249 SQLITE_INTEGER, /* 0x1c */
000250 SQLITE_NULL, /* 0x1d */
000251 SQLITE_INTEGER, /* 0x1e */
000252 SQLITE_NULL, /* 0x1f */
000253 };
000254 return aType[pVal->flags&MEM_AffMask];
000255 }
000256
000257 /* Make a copy of an sqlite3_value object
000258 */
000259 sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){
000260 sqlite3_value *pNew;
000261 if( pOrig==0 ) return 0;
000262 pNew = sqlite3_malloc( sizeof(*pNew) );
000263 if( pNew==0 ) return 0;
000264 memset(pNew, 0, sizeof(*pNew));
000265 memcpy(pNew, pOrig, MEMCELLSIZE);
000266 pNew->flags &= ~MEM_Dyn;
000267 pNew->db = 0;
000268 if( pNew->flags&(MEM_Str|MEM_Blob) ){
000269 pNew->flags &= ~(MEM_Static|MEM_Dyn);
000270 pNew->flags |= MEM_Ephem;
000271 if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){
000272 sqlite3ValueFree(pNew);
000273 pNew = 0;
000274 }
000275 }
000276 return pNew;
000277 }
000278
000279 /* Destroy an sqlite3_value object previously obtained from
000280 ** sqlite3_value_dup().
000281 */
000282 void sqlite3_value_free(sqlite3_value *pOld){
000283 sqlite3ValueFree(pOld);
000284 }
000285
000286
000287 /**************************** sqlite3_result_ *******************************
000288 ** The following routines are used by user-defined functions to specify
000289 ** the function result.
000290 **
000291 ** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the
000292 ** result as a string or blob but if the string or blob is too large, it
000293 ** then sets the error code to SQLITE_TOOBIG
000294 **
000295 ** The invokeValueDestructor(P,X) routine invokes destructor function X()
000296 ** on value P is not going to be used and need to be destroyed.
000297 */
000298 static void setResultStrOrError(
000299 sqlite3_context *pCtx, /* Function context */
000300 const char *z, /* String pointer */
000301 int n, /* Bytes in string, or negative */
000302 u8 enc, /* Encoding of z. 0 for BLOBs */
000303 void (*xDel)(void*) /* Destructor function */
000304 ){
000305 if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){
000306 sqlite3_result_error_toobig(pCtx);
000307 }
000308 }
000309 static int invokeValueDestructor(
000310 const void *p, /* Value to destroy */
000311 void (*xDel)(void*), /* The destructor */
000312 sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */
000313 ){
000314 assert( xDel!=SQLITE_DYNAMIC );
000315 if( xDel==0 ){
000316 /* noop */
000317 }else if( xDel==SQLITE_TRANSIENT ){
000318 /* noop */
000319 }else{
000320 xDel((void*)p);
000321 }
000322 if( pCtx ) sqlite3_result_error_toobig(pCtx);
000323 return SQLITE_TOOBIG;
000324 }
000325 void sqlite3_result_blob(
000326 sqlite3_context *pCtx,
000327 const void *z,
000328 int n,
000329 void (*xDel)(void *)
000330 ){
000331 assert( n>=0 );
000332 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000333 setResultStrOrError(pCtx, z, n, 0, xDel);
000334 }
000335 void sqlite3_result_blob64(
000336 sqlite3_context *pCtx,
000337 const void *z,
000338 sqlite3_uint64 n,
000339 void (*xDel)(void *)
000340 ){
000341 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000342 assert( xDel!=SQLITE_DYNAMIC );
000343 if( n>0x7fffffff ){
000344 (void)invokeValueDestructor(z, xDel, pCtx);
000345 }else{
000346 setResultStrOrError(pCtx, z, (int)n, 0, xDel);
000347 }
000348 }
000349 void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
000350 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000351 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal);
000352 }
000353 void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
000354 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000355 pCtx->isError = SQLITE_ERROR;
000356 pCtx->fErrorOrAux = 1;
000357 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
000358 }
000359 #ifndef SQLITE_OMIT_UTF16
000360 void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
000361 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000362 pCtx->isError = SQLITE_ERROR;
000363 pCtx->fErrorOrAux = 1;
000364 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
000365 }
000366 #endif
000367 void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
000368 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000369 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal);
000370 }
000371 void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
000372 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000373 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal);
000374 }
000375 void sqlite3_result_null(sqlite3_context *pCtx){
000376 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000377 sqlite3VdbeMemSetNull(pCtx->pOut);
000378 }
000379 void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
000380 Mem *pOut = pCtx->pOut;
000381 assert( sqlite3_mutex_held(pOut->db->mutex) );
000382 pOut->eSubtype = eSubtype & 0xff;
000383 pOut->flags |= MEM_Subtype;
000384 }
000385 void sqlite3_result_text(
000386 sqlite3_context *pCtx,
000387 const char *z,
000388 int n,
000389 void (*xDel)(void *)
000390 ){
000391 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000392 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
000393 }
000394 void sqlite3_result_text64(
000395 sqlite3_context *pCtx,
000396 const char *z,
000397 sqlite3_uint64 n,
000398 void (*xDel)(void *),
000399 unsigned char enc
000400 ){
000401 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000402 assert( xDel!=SQLITE_DYNAMIC );
000403 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
000404 if( n>0x7fffffff ){
000405 (void)invokeValueDestructor(z, xDel, pCtx);
000406 }else{
000407 setResultStrOrError(pCtx, z, (int)n, enc, xDel);
000408 }
000409 }
000410 #ifndef SQLITE_OMIT_UTF16
000411 void sqlite3_result_text16(
000412 sqlite3_context *pCtx,
000413 const void *z,
000414 int n,
000415 void (*xDel)(void *)
000416 ){
000417 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000418 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
000419 }
000420 void sqlite3_result_text16be(
000421 sqlite3_context *pCtx,
000422 const void *z,
000423 int n,
000424 void (*xDel)(void *)
000425 ){
000426 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000427 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
000428 }
000429 void sqlite3_result_text16le(
000430 sqlite3_context *pCtx,
000431 const void *z,
000432 int n,
000433 void (*xDel)(void *)
000434 ){
000435 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000436 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
000437 }
000438 #endif /* SQLITE_OMIT_UTF16 */
000439 void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
000440 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000441 sqlite3VdbeMemCopy(pCtx->pOut, pValue);
000442 }
000443 void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
000444 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000445 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n);
000446 }
000447 int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
000448 Mem *pOut = pCtx->pOut;
000449 assert( sqlite3_mutex_held(pOut->db->mutex) );
000450 if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
000451 return SQLITE_TOOBIG;
000452 }
000453 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
000454 return SQLITE_OK;
000455 }
000456 void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
000457 pCtx->isError = errCode;
000458 pCtx->fErrorOrAux = 1;
000459 #ifdef SQLITE_DEBUG
000460 if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
000461 #endif
000462 if( pCtx->pOut->flags & MEM_Null ){
000463 sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,
000464 SQLITE_UTF8, SQLITE_STATIC);
000465 }
000466 }
000467
000468 /* Force an SQLITE_TOOBIG error. */
000469 void sqlite3_result_error_toobig(sqlite3_context *pCtx){
000470 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000471 pCtx->isError = SQLITE_TOOBIG;
000472 pCtx->fErrorOrAux = 1;
000473 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1,
000474 SQLITE_UTF8, SQLITE_STATIC);
000475 }
000476
000477 /* An SQLITE_NOMEM error. */
000478 void sqlite3_result_error_nomem(sqlite3_context *pCtx){
000479 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000480 sqlite3VdbeMemSetNull(pCtx->pOut);
000481 pCtx->isError = SQLITE_NOMEM_BKPT;
000482 pCtx->fErrorOrAux = 1;
000483 sqlite3OomFault(pCtx->pOut->db);
000484 }
000485
000486 /*
000487 ** This function is called after a transaction has been committed. It
000488 ** invokes callbacks registered with sqlite3_wal_hook() as required.
000489 */
000490 static int doWalCallbacks(sqlite3 *db){
000491 int rc = SQLITE_OK;
000492 #ifndef SQLITE_OMIT_WAL
000493 int i;
000494 for(i=0; i<db->nDb; i++){
000495 Btree *pBt = db->aDb[i].pBt;
000496 if( pBt ){
000497 int nEntry;
000498 sqlite3BtreeEnter(pBt);
000499 nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt));
000500 sqlite3BtreeLeave(pBt);
000501 if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){
000502 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry);
000503 }
000504 }
000505 }
000506 #endif
000507 return rc;
000508 }
000509
000510
000511 /*
000512 ** Execute the statement pStmt, either until a row of data is ready, the
000513 ** statement is completely executed or an error occurs.
000514 **
000515 ** This routine implements the bulk of the logic behind the sqlite_step()
000516 ** API. The only thing omitted is the automatic recompile if a
000517 ** schema change has occurred. That detail is handled by the
000518 ** outer sqlite3_step() wrapper procedure.
000519 */
000520 static int sqlite3Step(Vdbe *p){
000521 sqlite3 *db;
000522 int rc;
000523
000524 assert(p);
000525 if( p->magic!=VDBE_MAGIC_RUN ){
000526 /* We used to require that sqlite3_reset() be called before retrying
000527 ** sqlite3_step() after any error or after SQLITE_DONE. But beginning
000528 ** with version 3.7.0, we changed this so that sqlite3_reset() would
000529 ** be called automatically instead of throwing the SQLITE_MISUSE error.
000530 ** This "automatic-reset" change is not technically an incompatibility,
000531 ** since any application that receives an SQLITE_MISUSE is broken by
000532 ** definition.
000533 **
000534 ** Nevertheless, some published applications that were originally written
000535 ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE
000536 ** returns, and those were broken by the automatic-reset change. As a
000537 ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the
000538 ** legacy behavior of returning SQLITE_MISUSE for cases where the
000539 ** previous sqlite3_step() returned something other than a SQLITE_LOCKED
000540 ** or SQLITE_BUSY error.
000541 */
000542 #ifdef SQLITE_OMIT_AUTORESET
000543 if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){
000544 sqlite3_reset((sqlite3_stmt*)p);
000545 }else{
000546 return SQLITE_MISUSE_BKPT;
000547 }
000548 #else
000549 sqlite3_reset((sqlite3_stmt*)p);
000550 #endif
000551 }
000552
000553 /* Check that malloc() has not failed. If it has, return early. */
000554 db = p->db;
000555 if( db->mallocFailed ){
000556 p->rc = SQLITE_NOMEM;
000557 return SQLITE_NOMEM_BKPT;
000558 }
000559
000560 if( p->pc<=0 && p->expired ){
000561 p->rc = SQLITE_SCHEMA;
000562 rc = SQLITE_ERROR;
000563 goto end_of_step;
000564 }
000565 if( p->pc<0 ){
000566 /* If there are no other statements currently running, then
000567 ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
000568 ** from interrupting a statement that has not yet started.
000569 */
000570 if( db->nVdbeActive==0 ){
000571 db->u1.isInterrupted = 0;
000572 }
000573
000574 assert( db->nVdbeWrite>0 || db->autoCommit==0
000575 || (db->nDeferredCons==0 && db->nDeferredImmCons==0)
000576 );
000577
000578 #ifndef SQLITE_OMIT_TRACE
000579 if( (db->xProfile || (db->mTrace & SQLITE_TRACE_PROFILE)!=0)
000580 && !db->init.busy && p->zSql ){
000581 sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime);
000582 }else{
000583 assert( p->startTime==0 );
000584 }
000585 #endif
000586
000587 db->nVdbeActive++;
000588 if( p->readOnly==0 ) db->nVdbeWrite++;
000589 if( p->bIsReader ) db->nVdbeRead++;
000590 p->pc = 0;
000591 }
000592 #ifdef SQLITE_DEBUG
000593 p->rcApp = SQLITE_OK;
000594 #endif
000595 #ifndef SQLITE_OMIT_EXPLAIN
000596 if( p->explain ){
000597 rc = sqlite3VdbeList(p);
000598 }else
000599 #endif /* SQLITE_OMIT_EXPLAIN */
000600 {
000601 db->nVdbeExec++;
000602 rc = sqlite3VdbeExec(p);
000603 db->nVdbeExec--;
000604 }
000605
000606 #ifndef SQLITE_OMIT_TRACE
000607 /* If the statement completed successfully, invoke the profile callback */
000608 if( rc!=SQLITE_ROW ) checkProfileCallback(db, p);
000609 #endif
000610
000611 if( rc==SQLITE_DONE ){
000612 assert( p->rc==SQLITE_OK );
000613 p->rc = doWalCallbacks(db);
000614 if( p->rc!=SQLITE_OK ){
000615 rc = SQLITE_ERROR;
000616 }
000617 }
000618
000619 db->errCode = rc;
000620 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
000621 p->rc = SQLITE_NOMEM_BKPT;
000622 }
000623 end_of_step:
000624 /* At this point local variable rc holds the value that should be
000625 ** returned if this statement was compiled using the legacy
000626 ** sqlite3_prepare() interface. According to the docs, this can only
000627 ** be one of the values in the first assert() below. Variable p->rc
000628 ** contains the value that would be returned if sqlite3_finalize()
000629 ** were called on statement p.
000630 */
000631 assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR
000632 || (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE
000633 );
000634 assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp );
000635 if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
000636 /* If this statement was prepared using sqlite3_prepare_v2(), and an
000637 ** error has occurred, then return the error code in p->rc to the
000638 ** caller. Set the error code in the database handle to the same value.
000639 */
000640 rc = sqlite3VdbeTransferError(p);
000641 }
000642 return (rc&db->errMask);
000643 }
000644
000645 /*
000646 ** This is the top-level implementation of sqlite3_step(). Call
000647 ** sqlite3Step() to do most of the work. If a schema error occurs,
000648 ** call sqlite3Reprepare() and try again.
000649 */
000650 int sqlite3_step(sqlite3_stmt *pStmt){
000651 int rc = SQLITE_OK; /* Result from sqlite3Step() */
000652 int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */
000653 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */
000654 int cnt = 0; /* Counter to prevent infinite loop of reprepares */
000655 sqlite3 *db; /* The database connection */
000656
000657 if( vdbeSafetyNotNull(v) ){
000658 return SQLITE_MISUSE_BKPT;
000659 }
000660 db = v->db;
000661 sqlite3_mutex_enter(db->mutex);
000662 v->doingRerun = 0;
000663 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
000664 && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){
000665 int savedPc = v->pc;
000666 rc2 = rc = sqlite3Reprepare(v);
000667 if( rc!=SQLITE_OK) break;
000668 sqlite3_reset(pStmt);
000669 if( savedPc>=0 ) v->doingRerun = 1;
000670 assert( v->expired==0 );
000671 }
000672 if( rc2!=SQLITE_OK ){
000673 /* This case occurs after failing to recompile an sql statement.
000674 ** The error message from the SQL compiler has already been loaded
000675 ** into the database handle. This block copies the error message
000676 ** from the database handle into the statement and sets the statement
000677 ** program counter to 0 to ensure that when the statement is
000678 ** finalized or reset the parser error message is available via
000679 ** sqlite3_errmsg() and sqlite3_errcode().
000680 */
000681 const char *zErr = (const char *)sqlite3_value_text(db->pErr);
000682 sqlite3DbFree(db, v->zErrMsg);
000683 if( !db->mallocFailed ){
000684 v->zErrMsg = sqlite3DbStrDup(db, zErr);
000685 v->rc = rc2;
000686 } else {
000687 v->zErrMsg = 0;
000688 v->rc = rc = SQLITE_NOMEM_BKPT;
000689 }
000690 }
000691 rc = sqlite3ApiExit(db, rc);
000692 sqlite3_mutex_leave(db->mutex);
000693 return rc;
000694 }
000695
000696
000697 /*
000698 ** Extract the user data from a sqlite3_context structure and return a
000699 ** pointer to it.
000700 */
000701 void *sqlite3_user_data(sqlite3_context *p){
000702 assert( p && p->pFunc );
000703 return p->pFunc->pUserData;
000704 }
000705
000706 /*
000707 ** Extract the user data from a sqlite3_context structure and return a
000708 ** pointer to it.
000709 **
000710 ** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface
000711 ** returns a copy of the pointer to the database connection (the 1st
000712 ** parameter) of the sqlite3_create_function() and
000713 ** sqlite3_create_function16() routines that originally registered the
000714 ** application defined function.
000715 */
000716 sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
000717 assert( p && p->pOut );
000718 return p->pOut->db;
000719 }
000720
000721 /*
000722 ** Return the current time for a statement. If the current time
000723 ** is requested more than once within the same run of a single prepared
000724 ** statement, the exact same time is returned for each invocation regardless
000725 ** of the amount of time that elapses between invocations. In other words,
000726 ** the time returned is always the time of the first call.
000727 */
000728 sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){
000729 int rc;
000730 #ifndef SQLITE_ENABLE_STAT3_OR_STAT4
000731 sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime;
000732 assert( p->pVdbe!=0 );
000733 #else
000734 sqlite3_int64 iTime = 0;
000735 sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime;
000736 #endif
000737 if( *piTime==0 ){
000738 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime);
000739 if( rc ) *piTime = 0;
000740 }
000741 return *piTime;
000742 }
000743
000744 /*
000745 ** The following is the implementation of an SQL function that always
000746 ** fails with an error message stating that the function is used in the
000747 ** wrong context. The sqlite3_overload_function() API might construct
000748 ** SQL function that use this routine so that the functions will exist
000749 ** for name resolution but are actually overloaded by the xFindFunction
000750 ** method of virtual tables.
000751 */
000752 void sqlite3InvalidFunction(
000753 sqlite3_context *context, /* The function calling context */
000754 int NotUsed, /* Number of arguments to the function */
000755 sqlite3_value **NotUsed2 /* Value of each argument */
000756 ){
000757 const char *zName = context->pFunc->zName;
000758 char *zErr;
000759 UNUSED_PARAMETER2(NotUsed, NotUsed2);
000760 zErr = sqlite3_mprintf(
000761 "unable to use function %s in the requested context", zName);
000762 sqlite3_result_error(context, zErr, -1);
000763 sqlite3_free(zErr);
000764 }
000765
000766 /*
000767 ** Create a new aggregate context for p and return a pointer to
000768 ** its pMem->z element.
000769 */
000770 static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){
000771 Mem *pMem = p->pMem;
000772 assert( (pMem->flags & MEM_Agg)==0 );
000773 if( nByte<=0 ){
000774 sqlite3VdbeMemSetNull(pMem);
000775 pMem->z = 0;
000776 }else{
000777 sqlite3VdbeMemClearAndResize(pMem, nByte);
000778 pMem->flags = MEM_Agg;
000779 pMem->u.pDef = p->pFunc;
000780 if( pMem->z ){
000781 memset(pMem->z, 0, nByte);
000782 }
000783 }
000784 return (void*)pMem->z;
000785 }
000786
000787 /*
000788 ** Allocate or return the aggregate context for a user function. A new
000789 ** context is allocated on the first call. Subsequent calls return the
000790 ** same context that was returned on prior calls.
000791 */
000792 void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
000793 assert( p && p->pFunc && p->pFunc->xFinalize );
000794 assert( sqlite3_mutex_held(p->pOut->db->mutex) );
000795 testcase( nByte<0 );
000796 if( (p->pMem->flags & MEM_Agg)==0 ){
000797 return createAggContext(p, nByte);
000798 }else{
000799 return (void*)p->pMem->z;
000800 }
000801 }
000802
000803 /*
000804 ** Return the auxiliary data pointer, if any, for the iArg'th argument to
000805 ** the user-function defined by pCtx.
000806 */
000807 void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
000808 AuxData *pAuxData;
000809
000810 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000811 #if SQLITE_ENABLE_STAT3_OR_STAT4
000812 if( pCtx->pVdbe==0 ) return 0;
000813 #else
000814 assert( pCtx->pVdbe!=0 );
000815 #endif
000816 for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
000817 if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
000818 }
000819
000820 return (pAuxData ? pAuxData->pAux : 0);
000821 }
000822
000823 /*
000824 ** Set the auxiliary data pointer and delete function, for the iArg'th
000825 ** argument to the user-function defined by pCtx. Any previous value is
000826 ** deleted by calling the delete function specified when it was set.
000827 */
000828 void sqlite3_set_auxdata(
000829 sqlite3_context *pCtx,
000830 int iArg,
000831 void *pAux,
000832 void (*xDelete)(void*)
000833 ){
000834 AuxData *pAuxData;
000835 Vdbe *pVdbe = pCtx->pVdbe;
000836
000837 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
000838 if( iArg<0 ) goto failed;
000839 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
000840 if( pVdbe==0 ) goto failed;
000841 #else
000842 assert( pVdbe!=0 );
000843 #endif
000844
000845 for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){
000846 if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break;
000847 }
000848 if( pAuxData==0 ){
000849 pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData));
000850 if( !pAuxData ) goto failed;
000851 pAuxData->iOp = pCtx->iOp;
000852 pAuxData->iArg = iArg;
000853 pAuxData->pNext = pVdbe->pAuxData;
000854 pVdbe->pAuxData = pAuxData;
000855 if( pCtx->fErrorOrAux==0 ){
000856 pCtx->isError = 0;
000857 pCtx->fErrorOrAux = 1;
000858 }
000859 }else if( pAuxData->xDelete ){
000860 pAuxData->xDelete(pAuxData->pAux);
000861 }
000862
000863 pAuxData->pAux = pAux;
000864 pAuxData->xDelete = xDelete;
000865 return;
000866
000867 failed:
000868 if( xDelete ){
000869 xDelete(pAux);
000870 }
000871 }
000872
000873 #ifndef SQLITE_OMIT_DEPRECATED
000874 /*
000875 ** Return the number of times the Step function of an aggregate has been
000876 ** called.
000877 **
000878 ** This function is deprecated. Do not use it for new code. It is
000879 ** provide only to avoid breaking legacy code. New aggregate function
000880 ** implementations should keep their own counts within their aggregate
000881 ** context.
000882 */
000883 int sqlite3_aggregate_count(sqlite3_context *p){
000884 assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize );
000885 return p->pMem->n;
000886 }
000887 #endif
000888
000889 /*
000890 ** Return the number of columns in the result set for the statement pStmt.
000891 */
000892 int sqlite3_column_count(sqlite3_stmt *pStmt){
000893 Vdbe *pVm = (Vdbe *)pStmt;
000894 return pVm ? pVm->nResColumn : 0;
000895 }
000896
000897 /*
000898 ** Return the number of values available from the current row of the
000899 ** currently executing statement pStmt.
000900 */
000901 int sqlite3_data_count(sqlite3_stmt *pStmt){
000902 Vdbe *pVm = (Vdbe *)pStmt;
000903 if( pVm==0 || pVm->pResultSet==0 ) return 0;
000904 return pVm->nResColumn;
000905 }
000906
000907 /*
000908 ** Return a pointer to static memory containing an SQL NULL value.
000909 */
000910 static const Mem *columnNullValue(void){
000911 /* Even though the Mem structure contains an element
000912 ** of type i64, on certain architectures (x86) with certain compiler
000913 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
000914 ** instead of an 8-byte one. This all works fine, except that when
000915 ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
000916 ** that a Mem structure is located on an 8-byte boundary. To prevent
000917 ** these assert()s from failing, when building with SQLITE_DEBUG defined
000918 ** using gcc, we force nullMem to be 8-byte aligned using the magical
000919 ** __attribute__((aligned(8))) macro. */
000920 static const Mem nullMem
000921 #if defined(SQLITE_DEBUG) && defined(__GNUC__)
000922 __attribute__((aligned(8)))
000923 #endif
000924 = {
000925 /* .u = */ {0},
000926 /* .flags = */ (u16)MEM_Null,
000927 /* .enc = */ (u8)0,
000928 /* .eSubtype = */ (u8)0,
000929 /* .n = */ (int)0,
000930 /* .z = */ (char*)0,
000931 /* .zMalloc = */ (char*)0,
000932 /* .szMalloc = */ (int)0,
000933 /* .uTemp = */ (u32)0,
000934 /* .db = */ (sqlite3*)0,
000935 /* .xDel = */ (void(*)(void*))0,
000936 #ifdef SQLITE_DEBUG
000937 /* .pScopyFrom = */ (Mem*)0,
000938 /* .pFiller = */ (void*)0,
000939 #endif
000940 };
000941 return &nullMem;
000942 }
000943
000944 /*
000945 ** Check to see if column iCol of the given statement is valid. If
000946 ** it is, return a pointer to the Mem for the value of that column.
000947 ** If iCol is not valid, return a pointer to a Mem which has a value
000948 ** of NULL.
000949 */
000950 static Mem *columnMem(sqlite3_stmt *pStmt, int i){
000951 Vdbe *pVm;
000952 Mem *pOut;
000953
000954 pVm = (Vdbe *)pStmt;
000955 if( pVm==0 ) return (Mem*)columnNullValue();
000956 assert( pVm->db );
000957 sqlite3_mutex_enter(pVm->db->mutex);
000958 if( pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
000959 pOut = &pVm->pResultSet[i];
000960 }else{
000961 sqlite3Error(pVm->db, SQLITE_RANGE);
000962 pOut = (Mem*)columnNullValue();
000963 }
000964 return pOut;
000965 }
000966
000967 /*
000968 ** This function is called after invoking an sqlite3_value_XXX function on a
000969 ** column value (i.e. a value returned by evaluating an SQL expression in the
000970 ** select list of a SELECT statement) that may cause a malloc() failure. If
000971 ** malloc() has failed, the threads mallocFailed flag is cleared and the result
000972 ** code of statement pStmt set to SQLITE_NOMEM.
000973 **
000974 ** Specifically, this is called from within:
000975 **
000976 ** sqlite3_column_int()
000977 ** sqlite3_column_int64()
000978 ** sqlite3_column_text()
000979 ** sqlite3_column_text16()
000980 ** sqlite3_column_real()
000981 ** sqlite3_column_bytes()
000982 ** sqlite3_column_bytes16()
000983 ** sqiite3_column_blob()
000984 */
000985 static void columnMallocFailure(sqlite3_stmt *pStmt)
000986 {
000987 /* If malloc() failed during an encoding conversion within an
000988 ** sqlite3_column_XXX API, then set the return code of the statement to
000989 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
000990 ** and _finalize() will return NOMEM.
000991 */
000992 Vdbe *p = (Vdbe *)pStmt;
000993 if( p ){
000994 assert( p->db!=0 );
000995 assert( sqlite3_mutex_held(p->db->mutex) );
000996 p->rc = sqlite3ApiExit(p->db, p->rc);
000997 sqlite3_mutex_leave(p->db->mutex);
000998 }
000999 }
001000
001001 /**************************** sqlite3_column_ *******************************
001002 ** The following routines are used to access elements of the current row
001003 ** in the result set.
001004 */
001005 const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
001006 const void *val;
001007 val = sqlite3_value_blob( columnMem(pStmt,i) );
001008 /* Even though there is no encoding conversion, value_blob() might
001009 ** need to call malloc() to expand the result of a zeroblob()
001010 ** expression.
001011 */
001012 columnMallocFailure(pStmt);
001013 return val;
001014 }
001015 int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
001016 int val = sqlite3_value_bytes( columnMem(pStmt,i) );
001017 columnMallocFailure(pStmt);
001018 return val;
001019 }
001020 int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
001021 int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
001022 columnMallocFailure(pStmt);
001023 return val;
001024 }
001025 double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
001026 double val = sqlite3_value_double( columnMem(pStmt,i) );
001027 columnMallocFailure(pStmt);
001028 return val;
001029 }
001030 int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
001031 int val = sqlite3_value_int( columnMem(pStmt,i) );
001032 columnMallocFailure(pStmt);
001033 return val;
001034 }
001035 sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
001036 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
001037 columnMallocFailure(pStmt);
001038 return val;
001039 }
001040 const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
001041 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
001042 columnMallocFailure(pStmt);
001043 return val;
001044 }
001045 sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
001046 Mem *pOut = columnMem(pStmt, i);
001047 if( pOut->flags&MEM_Static ){
001048 pOut->flags &= ~MEM_Static;
001049 pOut->flags |= MEM_Ephem;
001050 }
001051 columnMallocFailure(pStmt);
001052 return (sqlite3_value *)pOut;
001053 }
001054 #ifndef SQLITE_OMIT_UTF16
001055 const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
001056 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
001057 columnMallocFailure(pStmt);
001058 return val;
001059 }
001060 #endif /* SQLITE_OMIT_UTF16 */
001061 int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
001062 int iType = sqlite3_value_type( columnMem(pStmt,i) );
001063 columnMallocFailure(pStmt);
001064 return iType;
001065 }
001066
001067 /*
001068 ** Convert the N-th element of pStmt->pColName[] into a string using
001069 ** xFunc() then return that string. If N is out of range, return 0.
001070 **
001071 ** There are up to 5 names for each column. useType determines which
001072 ** name is returned. Here are the names:
001073 **
001074 ** 0 The column name as it should be displayed for output
001075 ** 1 The datatype name for the column
001076 ** 2 The name of the database that the column derives from
001077 ** 3 The name of the table that the column derives from
001078 ** 4 The name of the table column that the result column derives from
001079 **
001080 ** If the result is not a simple column reference (if it is an expression
001081 ** or a constant) then useTypes 2, 3, and 4 return NULL.
001082 */
001083 static const void *columnName(
001084 sqlite3_stmt *pStmt,
001085 int N,
001086 const void *(*xFunc)(Mem*),
001087 int useType
001088 ){
001089 const void *ret;
001090 Vdbe *p;
001091 int n;
001092 sqlite3 *db;
001093 #ifdef SQLITE_ENABLE_API_ARMOR
001094 if( pStmt==0 ){
001095 (void)SQLITE_MISUSE_BKPT;
001096 return 0;
001097 }
001098 #endif
001099 ret = 0;
001100 p = (Vdbe *)pStmt;
001101 db = p->db;
001102 assert( db!=0 );
001103 n = sqlite3_column_count(pStmt);
001104 if( N<n && N>=0 ){
001105 N += useType*n;
001106 sqlite3_mutex_enter(db->mutex);
001107 assert( db->mallocFailed==0 );
001108 ret = xFunc(&p->aColName[N]);
001109 /* A malloc may have failed inside of the xFunc() call. If this
001110 ** is the case, clear the mallocFailed flag and return NULL.
001111 */
001112 if( db->mallocFailed ){
001113 sqlite3OomClear(db);
001114 ret = 0;
001115 }
001116 sqlite3_mutex_leave(db->mutex);
001117 }
001118 return ret;
001119 }
001120
001121 /*
001122 ** Return the name of the Nth column of the result set returned by SQL
001123 ** statement pStmt.
001124 */
001125 const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
001126 return columnName(
001127 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
001128 }
001129 #ifndef SQLITE_OMIT_UTF16
001130 const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
001131 return columnName(
001132 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
001133 }
001134 #endif
001135
001136 /*
001137 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must
001138 ** not define OMIT_DECLTYPE.
001139 */
001140 #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
001141 # error "Must not define both SQLITE_OMIT_DECLTYPE \
001142 and SQLITE_ENABLE_COLUMN_METADATA"
001143 #endif
001144
001145 #ifndef SQLITE_OMIT_DECLTYPE
001146 /*
001147 ** Return the column declaration type (if applicable) of the 'i'th column
001148 ** of the result set of SQL statement pStmt.
001149 */
001150 const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
001151 return columnName(
001152 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
001153 }
001154 #ifndef SQLITE_OMIT_UTF16
001155 const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
001156 return columnName(
001157 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
001158 }
001159 #endif /* SQLITE_OMIT_UTF16 */
001160 #endif /* SQLITE_OMIT_DECLTYPE */
001161
001162 #ifdef SQLITE_ENABLE_COLUMN_METADATA
001163 /*
001164 ** Return the name of the database from which a result column derives.
001165 ** NULL is returned if the result column is an expression or constant or
001166 ** anything else which is not an unambiguous reference to a database column.
001167 */
001168 const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
001169 return columnName(
001170 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
001171 }
001172 #ifndef SQLITE_OMIT_UTF16
001173 const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
001174 return columnName(
001175 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
001176 }
001177 #endif /* SQLITE_OMIT_UTF16 */
001178
001179 /*
001180 ** Return the name of the table from which a result column derives.
001181 ** NULL is returned if the result column is an expression or constant or
001182 ** anything else which is not an unambiguous reference to a database column.
001183 */
001184 const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
001185 return columnName(
001186 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
001187 }
001188 #ifndef SQLITE_OMIT_UTF16
001189 const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
001190 return columnName(
001191 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
001192 }
001193 #endif /* SQLITE_OMIT_UTF16 */
001194
001195 /*
001196 ** Return the name of the table column from which a result column derives.
001197 ** NULL is returned if the result column is an expression or constant or
001198 ** anything else which is not an unambiguous reference to a database column.
001199 */
001200 const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
001201 return columnName(
001202 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
001203 }
001204 #ifndef SQLITE_OMIT_UTF16
001205 const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
001206 return columnName(
001207 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
001208 }
001209 #endif /* SQLITE_OMIT_UTF16 */
001210 #endif /* SQLITE_ENABLE_COLUMN_METADATA */
001211
001212
001213 /******************************* sqlite3_bind_ ***************************
001214 **
001215 ** Routines used to attach values to wildcards in a compiled SQL statement.
001216 */
001217 /*
001218 ** Unbind the value bound to variable i in virtual machine p. This is the
001219 ** the same as binding a NULL value to the column. If the "i" parameter is
001220 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
001221 **
001222 ** A successful evaluation of this routine acquires the mutex on p.
001223 ** the mutex is released if any kind of error occurs.
001224 **
001225 ** The error code stored in database p->db is overwritten with the return
001226 ** value in any case.
001227 */
001228 static int vdbeUnbind(Vdbe *p, int i){
001229 Mem *pVar;
001230 if( vdbeSafetyNotNull(p) ){
001231 return SQLITE_MISUSE_BKPT;
001232 }
001233 sqlite3_mutex_enter(p->db->mutex);
001234 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
001235 sqlite3Error(p->db, SQLITE_MISUSE);
001236 sqlite3_mutex_leave(p->db->mutex);
001237 sqlite3_log(SQLITE_MISUSE,
001238 "bind on a busy prepared statement: [%s]", p->zSql);
001239 return SQLITE_MISUSE_BKPT;
001240 }
001241 if( i<1 || i>p->nVar ){
001242 sqlite3Error(p->db, SQLITE_RANGE);
001243 sqlite3_mutex_leave(p->db->mutex);
001244 return SQLITE_RANGE;
001245 }
001246 i--;
001247 pVar = &p->aVar[i];
001248 sqlite3VdbeMemRelease(pVar);
001249 pVar->flags = MEM_Null;
001250 sqlite3Error(p->db, SQLITE_OK);
001251
001252 /* If the bit corresponding to this variable in Vdbe.expmask is set, then
001253 ** binding a new value to this variable invalidates the current query plan.
001254 **
001255 ** IMPLEMENTATION-OF: R-48440-37595 If the specific value bound to host
001256 ** parameter in the WHERE clause might influence the choice of query plan
001257 ** for a statement, then the statement will be automatically recompiled,
001258 ** as if there had been a schema change, on the first sqlite3_step() call
001259 ** following any change to the bindings of that parameter.
001260 */
001261 if( p->isPrepareV2 &&
001262 ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
001263 ){
001264 p->expired = 1;
001265 }
001266 return SQLITE_OK;
001267 }
001268
001269 /*
001270 ** Bind a text or BLOB value.
001271 */
001272 static int bindText(
001273 sqlite3_stmt *pStmt, /* The statement to bind against */
001274 int i, /* Index of the parameter to bind */
001275 const void *zData, /* Pointer to the data to be bound */
001276 int nData, /* Number of bytes of data to be bound */
001277 void (*xDel)(void*), /* Destructor for the data */
001278 u8 encoding /* Encoding for the data */
001279 ){
001280 Vdbe *p = (Vdbe *)pStmt;
001281 Mem *pVar;
001282 int rc;
001283
001284 rc = vdbeUnbind(p, i);
001285 if( rc==SQLITE_OK ){
001286 if( zData!=0 ){
001287 pVar = &p->aVar[i-1];
001288 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
001289 if( rc==SQLITE_OK && encoding!=0 ){
001290 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
001291 }
001292 sqlite3Error(p->db, rc);
001293 rc = sqlite3ApiExit(p->db, rc);
001294 }
001295 sqlite3_mutex_leave(p->db->mutex);
001296 }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){
001297 xDel((void*)zData);
001298 }
001299 return rc;
001300 }
001301
001302
001303 /*
001304 ** Bind a blob value to an SQL statement variable.
001305 */
001306 int sqlite3_bind_blob(
001307 sqlite3_stmt *pStmt,
001308 int i,
001309 const void *zData,
001310 int nData,
001311 void (*xDel)(void*)
001312 ){
001313 #ifdef SQLITE_ENABLE_API_ARMOR
001314 if( nData<0 ) return SQLITE_MISUSE_BKPT;
001315 #endif
001316 return bindText(pStmt, i, zData, nData, xDel, 0);
001317 }
001318 int sqlite3_bind_blob64(
001319 sqlite3_stmt *pStmt,
001320 int i,
001321 const void *zData,
001322 sqlite3_uint64 nData,
001323 void (*xDel)(void*)
001324 ){
001325 assert( xDel!=SQLITE_DYNAMIC );
001326 if( nData>0x7fffffff ){
001327 return invokeValueDestructor(zData, xDel, 0);
001328 }else{
001329 return bindText(pStmt, i, zData, (int)nData, xDel, 0);
001330 }
001331 }
001332 int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
001333 int rc;
001334 Vdbe *p = (Vdbe *)pStmt;
001335 rc = vdbeUnbind(p, i);
001336 if( rc==SQLITE_OK ){
001337 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
001338 sqlite3_mutex_leave(p->db->mutex);
001339 }
001340 return rc;
001341 }
001342 int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
001343 return sqlite3_bind_int64(p, i, (i64)iValue);
001344 }
001345 int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
001346 int rc;
001347 Vdbe *p = (Vdbe *)pStmt;
001348 rc = vdbeUnbind(p, i);
001349 if( rc==SQLITE_OK ){
001350 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
001351 sqlite3_mutex_leave(p->db->mutex);
001352 }
001353 return rc;
001354 }
001355 int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
001356 int rc;
001357 Vdbe *p = (Vdbe*)pStmt;
001358 rc = vdbeUnbind(p, i);
001359 if( rc==SQLITE_OK ){
001360 sqlite3_mutex_leave(p->db->mutex);
001361 }
001362 return rc;
001363 }
001364 int sqlite3_bind_text(
001365 sqlite3_stmt *pStmt,
001366 int i,
001367 const char *zData,
001368 int nData,
001369 void (*xDel)(void*)
001370 ){
001371 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
001372 }
001373 int sqlite3_bind_text64(
001374 sqlite3_stmt *pStmt,
001375 int i,
001376 const char *zData,
001377 sqlite3_uint64 nData,
001378 void (*xDel)(void*),
001379 unsigned char enc
001380 ){
001381 assert( xDel!=SQLITE_DYNAMIC );
001382 if( nData>0x7fffffff ){
001383 return invokeValueDestructor(zData, xDel, 0);
001384 }else{
001385 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
001386 return bindText(pStmt, i, zData, (int)nData, xDel, enc);
001387 }
001388 }
001389 #ifndef SQLITE_OMIT_UTF16
001390 int sqlite3_bind_text16(
001391 sqlite3_stmt *pStmt,
001392 int i,
001393 const void *zData,
001394 int nData,
001395 void (*xDel)(void*)
001396 ){
001397 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
001398 }
001399 #endif /* SQLITE_OMIT_UTF16 */
001400 int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
001401 int rc;
001402 switch( sqlite3_value_type((sqlite3_value*)pValue) ){
001403 case SQLITE_INTEGER: {
001404 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
001405 break;
001406 }
001407 case SQLITE_FLOAT: {
001408 rc = sqlite3_bind_double(pStmt, i, pValue->u.r);
001409 break;
001410 }
001411 case SQLITE_BLOB: {
001412 if( pValue->flags & MEM_Zero ){
001413 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
001414 }else{
001415 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
001416 }
001417 break;
001418 }
001419 case SQLITE_TEXT: {
001420 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
001421 pValue->enc);
001422 break;
001423 }
001424 default: {
001425 rc = sqlite3_bind_null(pStmt, i);
001426 break;
001427 }
001428 }
001429 return rc;
001430 }
001431 int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
001432 int rc;
001433 Vdbe *p = (Vdbe *)pStmt;
001434 rc = vdbeUnbind(p, i);
001435 if( rc==SQLITE_OK ){
001436 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
001437 sqlite3_mutex_leave(p->db->mutex);
001438 }
001439 return rc;
001440 }
001441 int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){
001442 int rc;
001443 Vdbe *p = (Vdbe *)pStmt;
001444 sqlite3_mutex_enter(p->db->mutex);
001445 if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){
001446 rc = SQLITE_TOOBIG;
001447 }else{
001448 assert( (n & 0x7FFFFFFF)==n );
001449 rc = sqlite3_bind_zeroblob(pStmt, i, n);
001450 }
001451 rc = sqlite3ApiExit(p->db, rc);
001452 sqlite3_mutex_leave(p->db->mutex);
001453 return rc;
001454 }
001455
001456 /*
001457 ** Return the number of wildcards that can be potentially bound to.
001458 ** This routine is added to support DBD::SQLite.
001459 */
001460 int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
001461 Vdbe *p = (Vdbe*)pStmt;
001462 return p ? p->nVar : 0;
001463 }
001464
001465 /*
001466 ** Return the name of a wildcard parameter. Return NULL if the index
001467 ** is out of range or if the wildcard is unnamed.
001468 **
001469 ** The result is always UTF-8.
001470 */
001471 const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
001472 Vdbe *p = (Vdbe*)pStmt;
001473 if( p==0 ) return 0;
001474 return sqlite3VListNumToName(p->pVList, i);
001475 }
001476
001477 /*
001478 ** Given a wildcard parameter name, return the index of the variable
001479 ** with that name. If there is no variable with the given name,
001480 ** return 0.
001481 */
001482 int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
001483 if( p==0 || zName==0 ) return 0;
001484 return sqlite3VListNameToNum(p->pVList, zName, nName);
001485 }
001486 int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
001487 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
001488 }
001489
001490 /*
001491 ** Transfer all bindings from the first statement over to the second.
001492 */
001493 int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
001494 Vdbe *pFrom = (Vdbe*)pFromStmt;
001495 Vdbe *pTo = (Vdbe*)pToStmt;
001496 int i;
001497 assert( pTo->db==pFrom->db );
001498 assert( pTo->nVar==pFrom->nVar );
001499 sqlite3_mutex_enter(pTo->db->mutex);
001500 for(i=0; i<pFrom->nVar; i++){
001501 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
001502 }
001503 sqlite3_mutex_leave(pTo->db->mutex);
001504 return SQLITE_OK;
001505 }
001506
001507 #ifndef SQLITE_OMIT_DEPRECATED
001508 /*
001509 ** Deprecated external interface. Internal/core SQLite code
001510 ** should call sqlite3TransferBindings.
001511 **
001512 ** It is misuse to call this routine with statements from different
001513 ** database connections. But as this is a deprecated interface, we
001514 ** will not bother to check for that condition.
001515 **
001516 ** If the two statements contain a different number of bindings, then
001517 ** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise
001518 ** SQLITE_OK is returned.
001519 */
001520 int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
001521 Vdbe *pFrom = (Vdbe*)pFromStmt;
001522 Vdbe *pTo = (Vdbe*)pToStmt;
001523 if( pFrom->nVar!=pTo->nVar ){
001524 return SQLITE_ERROR;
001525 }
001526 if( pTo->isPrepareV2 && pTo->expmask ){
001527 pTo->expired = 1;
001528 }
001529 if( pFrom->isPrepareV2 && pFrom->expmask ){
001530 pFrom->expired = 1;
001531 }
001532 return sqlite3TransferBindings(pFromStmt, pToStmt);
001533 }
001534 #endif
001535
001536 /*
001537 ** Return the sqlite3* database handle to which the prepared statement given
001538 ** in the argument belongs. This is the same database handle that was
001539 ** the first argument to the sqlite3_prepare() that was used to create
001540 ** the statement in the first place.
001541 */
001542 sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
001543 return pStmt ? ((Vdbe*)pStmt)->db : 0;
001544 }
001545
001546 /*
001547 ** Return true if the prepared statement is guaranteed to not modify the
001548 ** database.
001549 */
001550 int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){
001551 return pStmt ? ((Vdbe*)pStmt)->readOnly : 1;
001552 }
001553
001554 /*
001555 ** Return true if the prepared statement is in need of being reset.
001556 */
001557 int sqlite3_stmt_busy(sqlite3_stmt *pStmt){
001558 Vdbe *v = (Vdbe*)pStmt;
001559 return v!=0 && v->magic==VDBE_MAGIC_RUN && v->pc>=0;
001560 }
001561
001562 /*
001563 ** Return a pointer to the next prepared statement after pStmt associated
001564 ** with database connection pDb. If pStmt is NULL, return the first
001565 ** prepared statement for the database connection. Return NULL if there
001566 ** are no more.
001567 */
001568 sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
001569 sqlite3_stmt *pNext;
001570 #ifdef SQLITE_ENABLE_API_ARMOR
001571 if( !sqlite3SafetyCheckOk(pDb) ){
001572 (void)SQLITE_MISUSE_BKPT;
001573 return 0;
001574 }
001575 #endif
001576 sqlite3_mutex_enter(pDb->mutex);
001577 if( pStmt==0 ){
001578 pNext = (sqlite3_stmt*)pDb->pVdbe;
001579 }else{
001580 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
001581 }
001582 sqlite3_mutex_leave(pDb->mutex);
001583 return pNext;
001584 }
001585
001586 /*
001587 ** Return the value of a status counter for a prepared statement
001588 */
001589 int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
001590 Vdbe *pVdbe = (Vdbe*)pStmt;
001591 u32 v;
001592 #ifdef SQLITE_ENABLE_API_ARMOR
001593 if( !pStmt ){
001594 (void)SQLITE_MISUSE_BKPT;
001595 return 0;
001596 }
001597 #endif
001598 v = pVdbe->aCounter[op];
001599 if( resetFlag ) pVdbe->aCounter[op] = 0;
001600 return (int)v;
001601 }
001602
001603 /*
001604 ** Return the SQL associated with a prepared statement
001605 */
001606 const char *sqlite3_sql(sqlite3_stmt *pStmt){
001607 Vdbe *p = (Vdbe *)pStmt;
001608 return p ? p->zSql : 0;
001609 }
001610
001611 /*
001612 ** Return the SQL associated with a prepared statement with
001613 ** bound parameters expanded. Space to hold the returned string is
001614 ** obtained from sqlite3_malloc(). The caller is responsible for
001615 ** freeing the returned string by passing it to sqlite3_free().
001616 **
001617 ** The SQLITE_TRACE_SIZE_LIMIT puts an upper bound on the size of
001618 ** expanded bound parameters.
001619 */
001620 char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){
001621 #ifdef SQLITE_OMIT_TRACE
001622 return 0;
001623 #else
001624 char *z = 0;
001625 const char *zSql = sqlite3_sql(pStmt);
001626 if( zSql ){
001627 Vdbe *p = (Vdbe *)pStmt;
001628 sqlite3_mutex_enter(p->db->mutex);
001629 z = sqlite3VdbeExpandSql(p, zSql);
001630 sqlite3_mutex_leave(p->db->mutex);
001631 }
001632 return z;
001633 #endif
001634 }
001635
001636 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
001637 /*
001638 ** Allocate and populate an UnpackedRecord structure based on the serialized
001639 ** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure
001640 ** if successful, or a NULL pointer if an OOM error is encountered.
001641 */
001642 static UnpackedRecord *vdbeUnpackRecord(
001643 KeyInfo *pKeyInfo,
001644 int nKey,
001645 const void *pKey
001646 ){
001647 UnpackedRecord *pRet; /* Return value */
001648
001649 pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo);
001650 if( pRet ){
001651 memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nField+1));
001652 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet);
001653 }
001654 return pRet;
001655 }
001656
001657 /*
001658 ** This function is called from within a pre-update callback to retrieve
001659 ** a field of the row currently being updated or deleted.
001660 */
001661 int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppValue){
001662 PreUpdate *p = db->pPreUpdate;
001663 int rc = SQLITE_OK;
001664
001665 /* Test that this call is being made from within an SQLITE_DELETE or
001666 ** SQLITE_UPDATE pre-update callback, and that iIdx is within range. */
001667 if( !p || p->op==SQLITE_INSERT ){
001668 rc = SQLITE_MISUSE_BKPT;
001669 goto preupdate_old_out;
001670 }
001671 if( iIdx>=p->pCsr->nField || iIdx<0 ){
001672 rc = SQLITE_RANGE;
001673 goto preupdate_old_out;
001674 }
001675
001676 /* If the old.* record has not yet been loaded into memory, do so now. */
001677 if( p->pUnpacked==0 ){
001678 u32 nRec;
001679 u8 *aRec;
001680
001681 nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor);
001682 aRec = sqlite3DbMallocRaw(db, nRec);
001683 if( !aRec ) goto preupdate_old_out;
001684 rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec);
001685 if( rc==SQLITE_OK ){
001686 p->pUnpacked = vdbeUnpackRecord(&p->keyinfo, nRec, aRec);
001687 if( !p->pUnpacked ) rc = SQLITE_NOMEM;
001688 }
001689 if( rc!=SQLITE_OK ){
001690 sqlite3DbFree(db, aRec);
001691 goto preupdate_old_out;
001692 }
001693 p->aRecord = aRec;
001694 }
001695
001696 if( iIdx>=p->pUnpacked->nField ){
001697 *ppValue = (sqlite3_value *)columnNullValue();
001698 }else{
001699 Mem *pMem = *ppValue = &p->pUnpacked->aMem[iIdx];
001700 *ppValue = &p->pUnpacked->aMem[iIdx];
001701 if( iIdx==p->pTab->iPKey ){
001702 sqlite3VdbeMemSetInt64(pMem, p->iKey1);
001703 }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){
001704 if( pMem->flags & MEM_Int ){
001705 sqlite3VdbeMemRealify(pMem);
001706 }
001707 }
001708 }
001709
001710 preupdate_old_out:
001711 sqlite3Error(db, rc);
001712 return sqlite3ApiExit(db, rc);
001713 }
001714 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
001715
001716 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
001717 /*
001718 ** This function is called from within a pre-update callback to retrieve
001719 ** the number of columns in the row being updated, deleted or inserted.
001720 */
001721 int sqlite3_preupdate_count(sqlite3 *db){
001722 PreUpdate *p = db->pPreUpdate;
001723 return (p ? p->keyinfo.nField : 0);
001724 }
001725 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
001726
001727 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
001728 /*
001729 ** This function is designed to be called from within a pre-update callback
001730 ** only. It returns zero if the change that caused the callback was made
001731 ** immediately by a user SQL statement. Or, if the change was made by a
001732 ** trigger program, it returns the number of trigger programs currently
001733 ** on the stack (1 for a top-level trigger, 2 for a trigger fired by a
001734 ** top-level trigger etc.).
001735 **
001736 ** For the purposes of the previous paragraph, a foreign key CASCADE, SET NULL
001737 ** or SET DEFAULT action is considered a trigger.
001738 */
001739 int sqlite3_preupdate_depth(sqlite3 *db){
001740 PreUpdate *p = db->pPreUpdate;
001741 return (p ? p->v->nFrame : 0);
001742 }
001743 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
001744
001745 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
001746 /*
001747 ** This function is called from within a pre-update callback to retrieve
001748 ** a field of the row currently being updated or inserted.
001749 */
001750 int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppValue){
001751 PreUpdate *p = db->pPreUpdate;
001752 int rc = SQLITE_OK;
001753 Mem *pMem;
001754
001755 if( !p || p->op==SQLITE_DELETE ){
001756 rc = SQLITE_MISUSE_BKPT;
001757 goto preupdate_new_out;
001758 }
001759 if( iIdx>=p->pCsr->nField || iIdx<0 ){
001760 rc = SQLITE_RANGE;
001761 goto preupdate_new_out;
001762 }
001763
001764 if( p->op==SQLITE_INSERT ){
001765 /* For an INSERT, memory cell p->iNewReg contains the serialized record
001766 ** that is being inserted. Deserialize it. */
001767 UnpackedRecord *pUnpack = p->pNewUnpacked;
001768 if( !pUnpack ){
001769 Mem *pData = &p->v->aMem[p->iNewReg];
001770 rc = ExpandBlob(pData);
001771 if( rc!=SQLITE_OK ) goto preupdate_new_out;
001772 pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z);
001773 if( !pUnpack ){
001774 rc = SQLITE_NOMEM;
001775 goto preupdate_new_out;
001776 }
001777 p->pNewUnpacked = pUnpack;
001778 }
001779 if( iIdx>=pUnpack->nField ){
001780 pMem = (sqlite3_value *)columnNullValue();
001781 }else{
001782 pMem = &pUnpack->aMem[iIdx];
001783 if( iIdx==p->pTab->iPKey ){
001784 sqlite3VdbeMemSetInt64(pMem, p->iKey2);
001785 }
001786 }
001787 }else{
001788 /* For an UPDATE, memory cell (p->iNewReg+1+iIdx) contains the required
001789 ** value. Make a copy of the cell contents and return a pointer to it.
001790 ** It is not safe to return a pointer to the memory cell itself as the
001791 ** caller may modify the value text encoding.
001792 */
001793 assert( p->op==SQLITE_UPDATE );
001794 if( !p->aNew ){
001795 p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField);
001796 if( !p->aNew ){
001797 rc = SQLITE_NOMEM;
001798 goto preupdate_new_out;
001799 }
001800 }
001801 assert( iIdx>=0 && iIdx<p->pCsr->nField );
001802 pMem = &p->aNew[iIdx];
001803 if( pMem->flags==0 ){
001804 if( iIdx==p->pTab->iPKey ){
001805 sqlite3VdbeMemSetInt64(pMem, p->iKey2);
001806 }else{
001807 rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]);
001808 if( rc!=SQLITE_OK ) goto preupdate_new_out;
001809 }
001810 }
001811 }
001812 *ppValue = pMem;
001813
001814 preupdate_new_out:
001815 sqlite3Error(db, rc);
001816 return sqlite3ApiExit(db, rc);
001817 }
001818 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */
001819
001820 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
001821 /*
001822 ** Return status data for a single loop within query pStmt.
001823 */
001824 int sqlite3_stmt_scanstatus(
001825 sqlite3_stmt *pStmt, /* Prepared statement being queried */
001826 int idx, /* Index of loop to report on */
001827 int iScanStatusOp, /* Which metric to return */
001828 void *pOut /* OUT: Write the answer here */
001829 ){
001830 Vdbe *p = (Vdbe*)pStmt;
001831 ScanStatus *pScan;
001832 if( idx<0 || idx>=p->nScan ) return 1;
001833 pScan = &p->aScan[idx];
001834 switch( iScanStatusOp ){
001835 case SQLITE_SCANSTAT_NLOOP: {
001836 *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop];
001837 break;
001838 }
001839 case SQLITE_SCANSTAT_NVISIT: {
001840 *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit];
001841 break;
001842 }
001843 case SQLITE_SCANSTAT_EST: {
001844 double r = 1.0;
001845 LogEst x = pScan->nEst;
001846 while( x<100 ){
001847 x += 10;
001848 r *= 0.5;
001849 }
001850 *(double*)pOut = r*sqlite3LogEstToInt(x);
001851 break;
001852 }
001853 case SQLITE_SCANSTAT_NAME: {
001854 *(const char**)pOut = pScan->zName;
001855 break;
001856 }
001857 case SQLITE_SCANSTAT_EXPLAIN: {
001858 if( pScan->addrExplain ){
001859 *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z;
001860 }else{
001861 *(const char**)pOut = 0;
001862 }
001863 break;
001864 }
001865 case SQLITE_SCANSTAT_SELECTID: {
001866 if( pScan->addrExplain ){
001867 *(int*)pOut = p->aOp[ pScan->addrExplain ].p1;
001868 }else{
001869 *(int*)pOut = -1;
001870 }
001871 break;
001872 }
001873 default: {
001874 return 1;
001875 }
001876 }
001877 return 0;
001878 }
001879
001880 /*
001881 ** Zero all counters associated with the sqlite3_stmt_scanstatus() data.
001882 */
001883 void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){
001884 Vdbe *p = (Vdbe*)pStmt;
001885 memset(p->anExec, 0, p->nOp * sizeof(i64));
001886 }
001887 #endif /* SQLITE_ENABLE_STMT_SCANSTATUS */