1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SQLite364/vdbeapi.c Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,1307 @@
1.4 +/*
1.5 +** 2004 May 26
1.6 +**
1.7 +** The author disclaims copyright to this source code. In place of
1.8 +** a legal notice, here is a blessing:
1.9 +**
1.10 +** May you do good and not evil.
1.11 +** May you find forgiveness for yourself and forgive others.
1.12 +** May you share freely, never taking more than you give.
1.13 +**
1.14 +*************************************************************************
1.15 +**
1.16 +** This file contains code use to implement APIs that are part of the
1.17 +** VDBE.
1.18 +**
1.19 +** $Id: vdbeapi.c,v 1.147 2008/10/13 10:37:50 danielk1977 Exp $
1.20 +*/
1.21 +#include "sqliteInt.h"
1.22 +#include "vdbeInt.h"
1.23 +
1.24 +#if 0 && defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)
1.25 +/*
1.26 +** The following structure contains pointers to the end points of a
1.27 +** doubly-linked list of all compiled SQL statements that may be holding
1.28 +** buffers eligible for release when the sqlite3_release_memory() interface is
1.29 +** invoked. Access to this list is protected by the SQLITE_MUTEX_STATIC_LRU2
1.30 +** mutex.
1.31 +**
1.32 +** Statements are added to the end of this list when sqlite3_reset() is
1.33 +** called. They are removed either when sqlite3_step() or sqlite3_finalize()
1.34 +** is called. When statements are added to this list, the associated
1.35 +** register array (p->aMem[1..p->nMem]) may contain dynamic buffers that
1.36 +** can be freed using sqlite3VdbeReleaseMemory().
1.37 +**
1.38 +** When statements are added or removed from this list, the mutex
1.39 +** associated with the Vdbe being added or removed (Vdbe.db->mutex) is
1.40 +** already held. The LRU2 mutex is then obtained, blocking if necessary,
1.41 +** the linked-list pointers manipulated and the LRU2 mutex relinquished.
1.42 +*/
1.43 +struct StatementLruList {
1.44 + Vdbe *pFirst;
1.45 + Vdbe *pLast;
1.46 +};
1.47 +static struct StatementLruList sqlite3LruStatements;
1.48 +
1.49 +/*
1.50 +** Check that the list looks to be internally consistent. This is used
1.51 +** as part of an assert() statement as follows:
1.52 +**
1.53 +** assert( stmtLruCheck() );
1.54 +*/
1.55 +#ifndef NDEBUG
1.56 +static int stmtLruCheck(){
1.57 + Vdbe *p;
1.58 + for(p=sqlite3LruStatements.pFirst; p; p=p->pLruNext){
1.59 + assert(p->pLruNext || p==sqlite3LruStatements.pLast);
1.60 + assert(!p->pLruNext || p->pLruNext->pLruPrev==p);
1.61 + assert(p->pLruPrev || p==sqlite3LruStatements.pFirst);
1.62 + assert(!p->pLruPrev || p->pLruPrev->pLruNext==p);
1.63 + }
1.64 + return 1;
1.65 +}
1.66 +#endif
1.67 +
1.68 +/*
1.69 +** Add vdbe p to the end of the statement lru list. It is assumed that
1.70 +** p is not already part of the list when this is called. The lru list
1.71 +** is protected by the SQLITE_MUTEX_STATIC_LRU mutex.
1.72 +*/
1.73 +static void stmtLruAdd(Vdbe *p){
1.74 + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
1.75 +
1.76 + if( p->pLruPrev || p->pLruNext || sqlite3LruStatements.pFirst==p ){
1.77 + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
1.78 + return;
1.79 + }
1.80 +
1.81 + assert( stmtLruCheck() );
1.82 +
1.83 + if( !sqlite3LruStatements.pFirst ){
1.84 + assert( !sqlite3LruStatements.pLast );
1.85 + sqlite3LruStatements.pFirst = p;
1.86 + sqlite3LruStatements.pLast = p;
1.87 + }else{
1.88 + assert( !sqlite3LruStatements.pLast->pLruNext );
1.89 + p->pLruPrev = sqlite3LruStatements.pLast;
1.90 + sqlite3LruStatements.pLast->pLruNext = p;
1.91 + sqlite3LruStatements.pLast = p;
1.92 + }
1.93 +
1.94 + assert( stmtLruCheck() );
1.95 +
1.96 + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
1.97 +}
1.98 +
1.99 +/*
1.100 +** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is already held, remove
1.101 +** statement p from the least-recently-used statement list. If the
1.102 +** statement is not currently part of the list, this call is a no-op.
1.103 +*/
1.104 +static void stmtLruRemoveNomutex(Vdbe *p){
1.105 + if( p->pLruPrev || p->pLruNext || p==sqlite3LruStatements.pFirst ){
1.106 + assert( stmtLruCheck() );
1.107 + if( p->pLruNext ){
1.108 + p->pLruNext->pLruPrev = p->pLruPrev;
1.109 + }else{
1.110 + sqlite3LruStatements.pLast = p->pLruPrev;
1.111 + }
1.112 + if( p->pLruPrev ){
1.113 + p->pLruPrev->pLruNext = p->pLruNext;
1.114 + }else{
1.115 + sqlite3LruStatements.pFirst = p->pLruNext;
1.116 + }
1.117 + p->pLruNext = 0;
1.118 + p->pLruPrev = 0;
1.119 + assert( stmtLruCheck() );
1.120 + }
1.121 +}
1.122 +
1.123 +/*
1.124 +** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is not held, remove
1.125 +** statement p from the least-recently-used statement list. If the
1.126 +** statement is not currently part of the list, this call is a no-op.
1.127 +*/
1.128 +static void stmtLruRemove(Vdbe *p){
1.129 + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
1.130 + stmtLruRemoveNomutex(p);
1.131 + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
1.132 +}
1.133 +
1.134 +/*
1.135 +** Try to release n bytes of memory by freeing buffers associated
1.136 +** with the memory registers of currently unused vdbes.
1.137 +*/
1.138 +int sqlite3VdbeReleaseMemory(int n){
1.139 + Vdbe *p;
1.140 + Vdbe *pNext;
1.141 + int nFree = 0;
1.142 +
1.143 + sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
1.144 + for(p=sqlite3LruStatements.pFirst; p && nFree<n; p=pNext){
1.145 + pNext = p->pLruNext;
1.146 +
1.147 + /* For each statement handle in the lru list, attempt to obtain the
1.148 + ** associated database mutex. If it cannot be obtained, continue
1.149 + ** to the next statement handle. It is not possible to block on
1.150 + ** the database mutex - that could cause deadlock.
1.151 + */
1.152 + if( SQLITE_OK==sqlite3_mutex_try(p->db->mutex) ){
1.153 + nFree += sqlite3VdbeReleaseBuffers(p);
1.154 + stmtLruRemoveNomutex(p);
1.155 + sqlite3_mutex_leave(p->db->mutex);
1.156 + }
1.157 + }
1.158 + sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
1.159 +
1.160 + return nFree;
1.161 +}
1.162 +
1.163 +/*
1.164 +** Call sqlite3Reprepare() on the statement. Remove it from the
1.165 +** lru list before doing so, as Reprepare() will free all the
1.166 +** memory register buffers anyway.
1.167 +*/
1.168 +int vdbeReprepare(Vdbe *p){
1.169 + stmtLruRemove(p);
1.170 + return sqlite3Reprepare(p);
1.171 +}
1.172 +
1.173 +#else /* !SQLITE_ENABLE_MEMORY_MANAGEMENT */
1.174 + #define stmtLruRemove(x)
1.175 + #define stmtLruAdd(x)
1.176 + #define vdbeReprepare(x) sqlite3Reprepare(x)
1.177 +#endif
1.178 +
1.179 +
1.180 +#ifndef SQLITE_OMIT_DEPRECATED
1.181 +/*
1.182 +** Return TRUE (non-zero) of the statement supplied as an argument needs
1.183 +** to be recompiled. A statement needs to be recompiled whenever the
1.184 +** execution environment changes in a way that would alter the program
1.185 +** that sqlite3_prepare() generates. For example, if new functions or
1.186 +** collating sequences are registered or if an authorizer function is
1.187 +** added or changed.
1.188 +*/
1.189 +int sqlite3_expired(sqlite3_stmt *pStmt){
1.190 + Vdbe *p = (Vdbe*)pStmt;
1.191 + return p==0 || p->expired;
1.192 +}
1.193 +#endif
1.194 +
1.195 +/*
1.196 +** The following routine destroys a virtual machine that is created by
1.197 +** the sqlite3_compile() routine. The integer returned is an SQLITE_
1.198 +** success/failure code that describes the result of executing the virtual
1.199 +** machine.
1.200 +**
1.201 +** This routine sets the error code and string returned by
1.202 +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
1.203 +*/
1.204 +int sqlite3_finalize(sqlite3_stmt *pStmt){
1.205 + int rc;
1.206 + if( pStmt==0 ){
1.207 + rc = SQLITE_OK;
1.208 + }else{
1.209 + Vdbe *v = (Vdbe*)pStmt;
1.210 +#if SQLITE_THREADSAFE
1.211 + sqlite3_mutex *mutex = v->db->mutex;
1.212 +#endif
1.213 + sqlite3_mutex_enter(mutex);
1.214 + stmtLruRemove(v);
1.215 + rc = sqlite3VdbeFinalize(v);
1.216 + sqlite3_mutex_leave(mutex);
1.217 + }
1.218 + return rc;
1.219 +}
1.220 +
1.221 +/*
1.222 +** Terminate the current execution of an SQL statement and reset it
1.223 +** back to its starting state so that it can be reused. A success code from
1.224 +** the prior execution is returned.
1.225 +**
1.226 +** This routine sets the error code and string returned by
1.227 +** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
1.228 +*/
1.229 +int sqlite3_reset(sqlite3_stmt *pStmt){
1.230 + int rc;
1.231 + if( pStmt==0 ){
1.232 + rc = SQLITE_OK;
1.233 + }else{
1.234 + Vdbe *v = (Vdbe*)pStmt;
1.235 + sqlite3_mutex_enter(v->db->mutex);
1.236 + rc = sqlite3VdbeReset(v);
1.237 + stmtLruAdd(v);
1.238 + sqlite3VdbeMakeReady(v, -1, 0, 0, 0);
1.239 + assert( (rc & (v->db->errMask))==rc );
1.240 + sqlite3_mutex_leave(v->db->mutex);
1.241 + }
1.242 + return rc;
1.243 +}
1.244 +
1.245 +/*
1.246 +** Set all the parameters in the compiled SQL statement to NULL.
1.247 +*/
1.248 +int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
1.249 + int i;
1.250 + int rc = SQLITE_OK;
1.251 + Vdbe *p = (Vdbe*)pStmt;
1.252 +#if SQLITE_THREADSAFE
1.253 + sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
1.254 +#endif
1.255 + sqlite3_mutex_enter(mutex);
1.256 + for(i=0; i<p->nVar; i++){
1.257 + sqlite3VdbeMemRelease(&p->aVar[i]);
1.258 + p->aVar[i].flags = MEM_Null;
1.259 + }
1.260 + sqlite3_mutex_leave(mutex);
1.261 + return rc;
1.262 +}
1.263 +
1.264 +
1.265 +/**************************** sqlite3_value_ *******************************
1.266 +** The following routines extract information from a Mem or sqlite3_value
1.267 +** structure.
1.268 +*/
1.269 +const void *sqlite3_value_blob(sqlite3_value *pVal){
1.270 + Mem *p = (Mem*)pVal;
1.271 + if( p->flags & (MEM_Blob|MEM_Str) ){
1.272 + sqlite3VdbeMemExpandBlob(p);
1.273 + p->flags &= ~MEM_Str;
1.274 + p->flags |= MEM_Blob;
1.275 + return p->z;
1.276 + }else{
1.277 + return sqlite3_value_text(pVal);
1.278 + }
1.279 +}
1.280 +int sqlite3_value_bytes(sqlite3_value *pVal){
1.281 + return sqlite3ValueBytes(pVal, SQLITE_UTF8);
1.282 +}
1.283 +int sqlite3_value_bytes16(sqlite3_value *pVal){
1.284 + return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
1.285 +}
1.286 +double sqlite3_value_double(sqlite3_value *pVal){
1.287 + return sqlite3VdbeRealValue((Mem*)pVal);
1.288 +}
1.289 +int sqlite3_value_int(sqlite3_value *pVal){
1.290 + return sqlite3VdbeIntValue((Mem*)pVal);
1.291 +}
1.292 +sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
1.293 + return sqlite3VdbeIntValue((Mem*)pVal);
1.294 +}
1.295 +const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
1.296 + return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
1.297 +}
1.298 +#ifndef SQLITE_OMIT_UTF16
1.299 +const void *sqlite3_value_text16(sqlite3_value* pVal){
1.300 + return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
1.301 +}
1.302 +const void *sqlite3_value_text16be(sqlite3_value *pVal){
1.303 + return sqlite3ValueText(pVal, SQLITE_UTF16BE);
1.304 +}
1.305 +const void *sqlite3_value_text16le(sqlite3_value *pVal){
1.306 + return sqlite3ValueText(pVal, SQLITE_UTF16LE);
1.307 +}
1.308 +#endif /* SQLITE_OMIT_UTF16 */
1.309 +int sqlite3_value_type(sqlite3_value* pVal){
1.310 + return pVal->type;
1.311 +}
1.312 +
1.313 +/**************************** sqlite3_result_ *******************************
1.314 +** The following routines are used by user-defined functions to specify
1.315 +** the function result.
1.316 +*/
1.317 +void sqlite3_result_blob(
1.318 + sqlite3_context *pCtx,
1.319 + const void *z,
1.320 + int n,
1.321 + void (*xDel)(void *)
1.322 +){
1.323 + assert( n>=0 );
1.324 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.325 + sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);
1.326 +}
1.327 +void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
1.328 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.329 + sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
1.330 +}
1.331 +void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
1.332 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.333 + pCtx->isError = SQLITE_ERROR;
1.334 + sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
1.335 +}
1.336 +#ifndef SQLITE_OMIT_UTF16
1.337 +void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
1.338 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.339 + pCtx->isError = SQLITE_ERROR;
1.340 + sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
1.341 +}
1.342 +#endif
1.343 +void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
1.344 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.345 + sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
1.346 +}
1.347 +void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
1.348 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.349 + sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
1.350 +}
1.351 +void sqlite3_result_null(sqlite3_context *pCtx){
1.352 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.353 + sqlite3VdbeMemSetNull(&pCtx->s);
1.354 +}
1.355 +void sqlite3_result_text(
1.356 + sqlite3_context *pCtx,
1.357 + const char *z,
1.358 + int n,
1.359 + void (*xDel)(void *)
1.360 +){
1.361 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.362 + sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);
1.363 +}
1.364 +#ifndef SQLITE_OMIT_UTF16
1.365 +void sqlite3_result_text16(
1.366 + sqlite3_context *pCtx,
1.367 + const void *z,
1.368 + int n,
1.369 + void (*xDel)(void *)
1.370 +){
1.371 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.372 + sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
1.373 +}
1.374 +void sqlite3_result_text16be(
1.375 + sqlite3_context *pCtx,
1.376 + const void *z,
1.377 + int n,
1.378 + void (*xDel)(void *)
1.379 +){
1.380 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.381 + sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);
1.382 +}
1.383 +void sqlite3_result_text16le(
1.384 + sqlite3_context *pCtx,
1.385 + const void *z,
1.386 + int n,
1.387 + void (*xDel)(void *)
1.388 +){
1.389 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.390 + sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);
1.391 +}
1.392 +#endif /* SQLITE_OMIT_UTF16 */
1.393 +void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
1.394 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.395 + sqlite3VdbeMemCopy(&pCtx->s, pValue);
1.396 +}
1.397 +void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
1.398 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.399 + sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
1.400 +}
1.401 +void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
1.402 + pCtx->isError = errCode;
1.403 +}
1.404 +
1.405 +/* Force an SQLITE_TOOBIG error. */
1.406 +void sqlite3_result_error_toobig(sqlite3_context *pCtx){
1.407 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.408 + pCtx->isError = SQLITE_TOOBIG;
1.409 + sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1,
1.410 + SQLITE_UTF8, SQLITE_STATIC);
1.411 +}
1.412 +
1.413 +/* An SQLITE_NOMEM error. */
1.414 +void sqlite3_result_error_nomem(sqlite3_context *pCtx){
1.415 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.416 + sqlite3VdbeMemSetNull(&pCtx->s);
1.417 + pCtx->isError = SQLITE_NOMEM;
1.418 + pCtx->s.db->mallocFailed = 1;
1.419 +}
1.420 +
1.421 +/*
1.422 +** Execute the statement pStmt, either until a row of data is ready, the
1.423 +** statement is completely executed or an error occurs.
1.424 +**
1.425 +** This routine implements the bulk of the logic behind the sqlite_step()
1.426 +** API. The only thing omitted is the automatic recompile if a
1.427 +** schema change has occurred. That detail is handled by the
1.428 +** outer sqlite3_step() wrapper procedure.
1.429 +*/
1.430 +static int sqlite3Step(Vdbe *p){
1.431 + sqlite3 *db;
1.432 + int rc;
1.433 +
1.434 + assert(p);
1.435 + if( p->magic!=VDBE_MAGIC_RUN ){
1.436 + return SQLITE_MISUSE;
1.437 + }
1.438 +
1.439 + /* Assert that malloc() has not failed */
1.440 + db = p->db;
1.441 + if( db->mallocFailed ){
1.442 + return SQLITE_NOMEM;
1.443 + }
1.444 +
1.445 + if( p->pc<=0 && p->expired ){
1.446 + if( p->rc==SQLITE_OK ){
1.447 + p->rc = SQLITE_SCHEMA;
1.448 + }
1.449 + rc = SQLITE_ERROR;
1.450 + goto end_of_step;
1.451 + }
1.452 + if( sqlite3SafetyOn(db) ){
1.453 + p->rc = SQLITE_MISUSE;
1.454 + return SQLITE_MISUSE;
1.455 + }
1.456 + if( p->pc<0 ){
1.457 + /* If there are no other statements currently running, then
1.458 + ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
1.459 + ** from interrupting a statement that has not yet started.
1.460 + */
1.461 + if( db->activeVdbeCnt==0 ){
1.462 + db->u1.isInterrupted = 0;
1.463 + }
1.464 +
1.465 +#ifndef SQLITE_OMIT_TRACE
1.466 + if( db->xProfile && !db->init.busy ){
1.467 + double rNow;
1.468 + sqlite3OsCurrentTime(db->pVfs, &rNow);
1.469 + p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;
1.470 + }
1.471 +#endif
1.472 +
1.473 + db->activeVdbeCnt++;
1.474 + p->pc = 0;
1.475 + stmtLruRemove(p);
1.476 + }
1.477 +#ifndef SQLITE_OMIT_EXPLAIN
1.478 + if( p->explain ){
1.479 + rc = sqlite3VdbeList(p);
1.480 + }else
1.481 +#endif /* SQLITE_OMIT_EXPLAIN */
1.482 + {
1.483 + rc = sqlite3VdbeExec(p);
1.484 + }
1.485 +
1.486 + if( sqlite3SafetyOff(db) ){
1.487 + rc = SQLITE_MISUSE;
1.488 + }
1.489 +
1.490 +#ifndef SQLITE_OMIT_TRACE
1.491 + /* Invoke the profile callback if there is one
1.492 + */
1.493 + if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->nOp>0
1.494 + && p->aOp[0].opcode==OP_Trace && p->aOp[0].p4.z!=0 ){
1.495 + double rNow;
1.496 + u64 elapseTime;
1.497 +
1.498 + sqlite3OsCurrentTime(db->pVfs, &rNow);
1.499 + elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;
1.500 + db->xProfile(db->pProfileArg, p->aOp[0].p4.z, elapseTime);
1.501 + }
1.502 +#endif
1.503 +
1.504 + db->errCode = rc;
1.505 + /*sqlite3Error(p->db, rc, 0);*/
1.506 + p->rc = sqlite3ApiExit(p->db, p->rc);
1.507 +end_of_step:
1.508 + assert( (rc&0xff)==rc );
1.509 + if( p->zSql && (rc&0xff)<SQLITE_ROW ){
1.510 + /* This behavior occurs if sqlite3_prepare_v2() was used to build
1.511 + ** the prepared statement. Return error codes directly */
1.512 + p->db->errCode = p->rc;
1.513 + /* sqlite3Error(p->db, p->rc, 0); */
1.514 + return p->rc;
1.515 + }else{
1.516 + /* This is for legacy sqlite3_prepare() builds and when the code
1.517 + ** is SQLITE_ROW or SQLITE_DONE */
1.518 + return rc;
1.519 + }
1.520 +}
1.521 +
1.522 +/*
1.523 +** This is the top-level implementation of sqlite3_step(). Call
1.524 +** sqlite3Step() to do most of the work. If a schema error occurs,
1.525 +** call sqlite3Reprepare() and try again.
1.526 +*/
1.527 +#ifdef SQLITE_OMIT_PARSER
1.528 +int sqlite3_step(sqlite3_stmt *pStmt){
1.529 + int rc = SQLITE_MISUSE;
1.530 + if( pStmt ){
1.531 + Vdbe *v;
1.532 + v = (Vdbe*)pStmt;
1.533 + sqlite3_mutex_enter(v->db->mutex);
1.534 + rc = sqlite3Step(v);
1.535 + sqlite3_mutex_leave(v->db->mutex);
1.536 + }
1.537 + return rc;
1.538 +}
1.539 +#else
1.540 +int sqlite3_step(sqlite3_stmt *pStmt){
1.541 + int rc = SQLITE_MISUSE;
1.542 + if( pStmt ){
1.543 + int cnt = 0;
1.544 + Vdbe *v = (Vdbe*)pStmt;
1.545 + sqlite3 *db = v->db;
1.546 + sqlite3_mutex_enter(db->mutex);
1.547 + while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
1.548 + && cnt++ < 5
1.549 + && vdbeReprepare(v) ){
1.550 + sqlite3_reset(pStmt);
1.551 + v->expired = 0;
1.552 + }
1.553 + if( rc==SQLITE_SCHEMA && v->zSql && db->pErr ){
1.554 + /* This case occurs after failing to recompile an sql statement.
1.555 + ** The error message from the SQL compiler has already been loaded
1.556 + ** into the database handle. This block copies the error message
1.557 + ** from the database handle into the statement and sets the statement
1.558 + ** program counter to 0 to ensure that when the statement is
1.559 + ** finalized or reset the parser error message is available via
1.560 + ** sqlite3_errmsg() and sqlite3_errcode().
1.561 + */
1.562 + const char *zErr = (const char *)sqlite3_value_text(db->pErr);
1.563 + sqlite3DbFree(db, v->zErrMsg);
1.564 + if( !db->mallocFailed ){
1.565 + v->zErrMsg = sqlite3DbStrDup(db, zErr);
1.566 + } else {
1.567 + v->zErrMsg = 0;
1.568 + v->rc = SQLITE_NOMEM;
1.569 + }
1.570 + }
1.571 + rc = sqlite3ApiExit(db, rc);
1.572 + sqlite3_mutex_leave(db->mutex);
1.573 + }
1.574 + return rc;
1.575 +}
1.576 +#endif
1.577 +
1.578 +/*
1.579 +** Extract the user data from a sqlite3_context structure and return a
1.580 +** pointer to it.
1.581 +*/
1.582 +void *sqlite3_user_data(sqlite3_context *p){
1.583 + assert( p && p->pFunc );
1.584 + return p->pFunc->pUserData;
1.585 +}
1.586 +
1.587 +/*
1.588 +** Extract the user data from a sqlite3_context structure and return a
1.589 +** pointer to it.
1.590 +*/
1.591 +sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
1.592 + assert( p && p->pFunc );
1.593 + return p->s.db;
1.594 +}
1.595 +
1.596 +/*
1.597 +** The following is the implementation of an SQL function that always
1.598 +** fails with an error message stating that the function is used in the
1.599 +** wrong context. The sqlite3_overload_function() API might construct
1.600 +** SQL function that use this routine so that the functions will exist
1.601 +** for name resolution but are actually overloaded by the xFindFunction
1.602 +** method of virtual tables.
1.603 +*/
1.604 +void sqlite3InvalidFunction(
1.605 + sqlite3_context *context, /* The function calling context */
1.606 + int argc, /* Number of arguments to the function */
1.607 + sqlite3_value **argv /* Value of each argument */
1.608 +){
1.609 + const char *zName = context->pFunc->zName;
1.610 + char *zErr;
1.611 + zErr = sqlite3MPrintf(0,
1.612 + "unable to use function %s in the requested context", zName);
1.613 + sqlite3_result_error(context, zErr, -1);
1.614 + sqlite3_free(zErr);
1.615 +}
1.616 +
1.617 +/*
1.618 +** Allocate or return the aggregate context for a user function. A new
1.619 +** context is allocated on the first call. Subsequent calls return the
1.620 +** same context that was returned on prior calls.
1.621 +*/
1.622 +void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
1.623 + Mem *pMem;
1.624 + assert( p && p->pFunc && p->pFunc->xStep );
1.625 + assert( sqlite3_mutex_held(p->s.db->mutex) );
1.626 + pMem = p->pMem;
1.627 + if( (pMem->flags & MEM_Agg)==0 ){
1.628 + if( nByte==0 ){
1.629 + sqlite3VdbeMemReleaseExternal(pMem);
1.630 + pMem->flags = MEM_Null;
1.631 + pMem->z = 0;
1.632 + }else{
1.633 + sqlite3VdbeMemGrow(pMem, nByte, 0);
1.634 + pMem->flags = MEM_Agg;
1.635 + pMem->u.pDef = p->pFunc;
1.636 + if( pMem->z ){
1.637 + memset(pMem->z, 0, nByte);
1.638 + }
1.639 + }
1.640 + }
1.641 + return (void*)pMem->z;
1.642 +}
1.643 +
1.644 +/*
1.645 +** Return the auxilary data pointer, if any, for the iArg'th argument to
1.646 +** the user-function defined by pCtx.
1.647 +*/
1.648 +void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
1.649 + VdbeFunc *pVdbeFunc;
1.650 +
1.651 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.652 + pVdbeFunc = pCtx->pVdbeFunc;
1.653 + if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
1.654 + return 0;
1.655 + }
1.656 + return pVdbeFunc->apAux[iArg].pAux;
1.657 +}
1.658 +
1.659 +/*
1.660 +** Set the auxilary data pointer and delete function, for the iArg'th
1.661 +** argument to the user-function defined by pCtx. Any previous value is
1.662 +** deleted by calling the delete function specified when it was set.
1.663 +*/
1.664 +void sqlite3_set_auxdata(
1.665 + sqlite3_context *pCtx,
1.666 + int iArg,
1.667 + void *pAux,
1.668 + void (*xDelete)(void*)
1.669 +){
1.670 + struct AuxData *pAuxData;
1.671 + VdbeFunc *pVdbeFunc;
1.672 + if( iArg<0 ) goto failed;
1.673 +
1.674 + assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.675 + pVdbeFunc = pCtx->pVdbeFunc;
1.676 + if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
1.677 + int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
1.678 + int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
1.679 + pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
1.680 + if( !pVdbeFunc ){
1.681 + goto failed;
1.682 + }
1.683 + pCtx->pVdbeFunc = pVdbeFunc;
1.684 + memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
1.685 + pVdbeFunc->nAux = iArg+1;
1.686 + pVdbeFunc->pFunc = pCtx->pFunc;
1.687 + }
1.688 +
1.689 + pAuxData = &pVdbeFunc->apAux[iArg];
1.690 + if( pAuxData->pAux && pAuxData->xDelete ){
1.691 + pAuxData->xDelete(pAuxData->pAux);
1.692 + }
1.693 + pAuxData->pAux = pAux;
1.694 + pAuxData->xDelete = xDelete;
1.695 + return;
1.696 +
1.697 +failed:
1.698 + if( xDelete ){
1.699 + xDelete(pAux);
1.700 + }
1.701 +}
1.702 +
1.703 +#ifndef SQLITE_OMIT_DEPRECATED
1.704 +/*
1.705 +** Return the number of times the Step function of a aggregate has been
1.706 +** called.
1.707 +**
1.708 +** This function is deprecated. Do not use it for new code. It is
1.709 +** provide only to avoid breaking legacy code. New aggregate function
1.710 +** implementations should keep their own counts within their aggregate
1.711 +** context.
1.712 +*/
1.713 +int sqlite3_aggregate_count(sqlite3_context *p){
1.714 + assert( p && p->pFunc && p->pFunc->xStep );
1.715 + return p->pMem->n;
1.716 +}
1.717 +#endif
1.718 +
1.719 +/*
1.720 +** Return the number of columns in the result set for the statement pStmt.
1.721 +*/
1.722 +int sqlite3_column_count(sqlite3_stmt *pStmt){
1.723 + Vdbe *pVm = (Vdbe *)pStmt;
1.724 + return pVm ? pVm->nResColumn : 0;
1.725 +}
1.726 +
1.727 +/*
1.728 +** Return the number of values available from the current row of the
1.729 +** currently executing statement pStmt.
1.730 +*/
1.731 +int sqlite3_data_count(sqlite3_stmt *pStmt){
1.732 + Vdbe *pVm = (Vdbe *)pStmt;
1.733 + if( pVm==0 || pVm->pResultSet==0 ) return 0;
1.734 + return pVm->nResColumn;
1.735 +}
1.736 +
1.737 +
1.738 +/*
1.739 +** Check to see if column iCol of the given statement is valid. If
1.740 +** it is, return a pointer to the Mem for the value of that column.
1.741 +** If iCol is not valid, return a pointer to a Mem which has a value
1.742 +** of NULL.
1.743 +*/
1.744 +static Mem *columnMem(sqlite3_stmt *pStmt, int i){
1.745 + Vdbe *pVm;
1.746 + int vals;
1.747 + Mem *pOut;
1.748 +
1.749 + pVm = (Vdbe *)pStmt;
1.750 + if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
1.751 + sqlite3_mutex_enter(pVm->db->mutex);
1.752 + vals = sqlite3_data_count(pStmt);
1.753 + pOut = &pVm->pResultSet[i];
1.754 + }else{
1.755 + static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };
1.756 + if( pVm->db ){
1.757 + sqlite3_mutex_enter(pVm->db->mutex);
1.758 + sqlite3Error(pVm->db, SQLITE_RANGE, 0);
1.759 + }
1.760 + pOut = (Mem*)&nullMem;
1.761 + }
1.762 + return pOut;
1.763 +}
1.764 +
1.765 +/*
1.766 +** This function is called after invoking an sqlite3_value_XXX function on a
1.767 +** column value (i.e. a value returned by evaluating an SQL expression in the
1.768 +** select list of a SELECT statement) that may cause a malloc() failure. If
1.769 +** malloc() has failed, the threads mallocFailed flag is cleared and the result
1.770 +** code of statement pStmt set to SQLITE_NOMEM.
1.771 +**
1.772 +** Specifically, this is called from within:
1.773 +**
1.774 +** sqlite3_column_int()
1.775 +** sqlite3_column_int64()
1.776 +** sqlite3_column_text()
1.777 +** sqlite3_column_text16()
1.778 +** sqlite3_column_real()
1.779 +** sqlite3_column_bytes()
1.780 +** sqlite3_column_bytes16()
1.781 +**
1.782 +** But not for sqlite3_column_blob(), which never calls malloc().
1.783 +*/
1.784 +static void columnMallocFailure(sqlite3_stmt *pStmt)
1.785 +{
1.786 + /* If malloc() failed during an encoding conversion within an
1.787 + ** sqlite3_column_XXX API, then set the return code of the statement to
1.788 + ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
1.789 + ** and _finalize() will return NOMEM.
1.790 + */
1.791 + Vdbe *p = (Vdbe *)pStmt;
1.792 + if( p ){
1.793 + p->rc = sqlite3ApiExit(p->db, p->rc);
1.794 + sqlite3_mutex_leave(p->db->mutex);
1.795 + }
1.796 +}
1.797 +
1.798 +/**************************** sqlite3_column_ *******************************
1.799 +** The following routines are used to access elements of the current row
1.800 +** in the result set.
1.801 +*/
1.802 +const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
1.803 + const void *val;
1.804 + val = sqlite3_value_blob( columnMem(pStmt,i) );
1.805 + /* Even though there is no encoding conversion, value_blob() might
1.806 + ** need to call malloc() to expand the result of a zeroblob()
1.807 + ** expression.
1.808 + */
1.809 + columnMallocFailure(pStmt);
1.810 + return val;
1.811 +}
1.812 +int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
1.813 + int val = sqlite3_value_bytes( columnMem(pStmt,i) );
1.814 + columnMallocFailure(pStmt);
1.815 + return val;
1.816 +}
1.817 +int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
1.818 + int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
1.819 + columnMallocFailure(pStmt);
1.820 + return val;
1.821 +}
1.822 +double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
1.823 + double val = sqlite3_value_double( columnMem(pStmt,i) );
1.824 + columnMallocFailure(pStmt);
1.825 + return val;
1.826 +}
1.827 +int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
1.828 + int val = sqlite3_value_int( columnMem(pStmt,i) );
1.829 + columnMallocFailure(pStmt);
1.830 + return val;
1.831 +}
1.832 +sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
1.833 + sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
1.834 + columnMallocFailure(pStmt);
1.835 + return val;
1.836 +}
1.837 +const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
1.838 + const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
1.839 + columnMallocFailure(pStmt);
1.840 + return val;
1.841 +}
1.842 +sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
1.843 + Mem *pOut = columnMem(pStmt, i);
1.844 + if( pOut->flags&MEM_Static ){
1.845 + pOut->flags &= ~MEM_Static;
1.846 + pOut->flags |= MEM_Ephem;
1.847 + }
1.848 + columnMallocFailure(pStmt);
1.849 + return (sqlite3_value *)pOut;
1.850 +}
1.851 +#ifndef SQLITE_OMIT_UTF16
1.852 +const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
1.853 + const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
1.854 + columnMallocFailure(pStmt);
1.855 + return val;
1.856 +}
1.857 +#endif /* SQLITE_OMIT_UTF16 */
1.858 +int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
1.859 + int iType = sqlite3_value_type( columnMem(pStmt,i) );
1.860 + columnMallocFailure(pStmt);
1.861 + return iType;
1.862 +}
1.863 +
1.864 +/* The following function is experimental and subject to change or
1.865 +** removal */
1.866 +/*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
1.867 +** return sqlite3_value_numeric_type( columnMem(pStmt,i) );
1.868 +**}
1.869 +*/
1.870 +
1.871 +/*
1.872 +** Convert the N-th element of pStmt->pColName[] into a string using
1.873 +** xFunc() then return that string. If N is out of range, return 0.
1.874 +**
1.875 +** There are up to 5 names for each column. useType determines which
1.876 +** name is returned. Here are the names:
1.877 +**
1.878 +** 0 The column name as it should be displayed for output
1.879 +** 1 The datatype name for the column
1.880 +** 2 The name of the database that the column derives from
1.881 +** 3 The name of the table that the column derives from
1.882 +** 4 The name of the table column that the result column derives from
1.883 +**
1.884 +** If the result is not a simple column reference (if it is an expression
1.885 +** or a constant) then useTypes 2, 3, and 4 return NULL.
1.886 +*/
1.887 +static const void *columnName(
1.888 + sqlite3_stmt *pStmt,
1.889 + int N,
1.890 + const void *(*xFunc)(Mem*),
1.891 + int useType
1.892 +){
1.893 + const void *ret = 0;
1.894 + Vdbe *p = (Vdbe *)pStmt;
1.895 + int n;
1.896 +
1.897 +
1.898 + if( p!=0 ){
1.899 + n = sqlite3_column_count(pStmt);
1.900 + if( N<n && N>=0 ){
1.901 + N += useType*n;
1.902 + sqlite3_mutex_enter(p->db->mutex);
1.903 + ret = xFunc(&p->aColName[N]);
1.904 +
1.905 + /* A malloc may have failed inside of the xFunc() call. If this
1.906 + ** is the case, clear the mallocFailed flag and return NULL.
1.907 + */
1.908 + if( p->db && p->db->mallocFailed ){
1.909 + p->db->mallocFailed = 0;
1.910 + ret = 0;
1.911 + }
1.912 + sqlite3_mutex_leave(p->db->mutex);
1.913 + }
1.914 + }
1.915 + return ret;
1.916 +}
1.917 +
1.918 +/*
1.919 +** Return the name of the Nth column of the result set returned by SQL
1.920 +** statement pStmt.
1.921 +*/
1.922 +const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
1.923 + return columnName(
1.924 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
1.925 +}
1.926 +#ifndef SQLITE_OMIT_UTF16
1.927 +const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
1.928 + return columnName(
1.929 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
1.930 +}
1.931 +#endif
1.932 +
1.933 +/*
1.934 +** Constraint: If you have ENABLE_COLUMN_METADATA then you must
1.935 +** not define OMIT_DECLTYPE.
1.936 +*/
1.937 +#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
1.938 +# error "Must not define both SQLITE_OMIT_DECLTYPE \
1.939 + and SQLITE_ENABLE_COLUMN_METADATA"
1.940 +#endif
1.941 +
1.942 +#ifndef SQLITE_OMIT_DECLTYPE
1.943 +/*
1.944 +** Return the column declaration type (if applicable) of the 'i'th column
1.945 +** of the result set of SQL statement pStmt.
1.946 +*/
1.947 +const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
1.948 + return columnName(
1.949 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
1.950 +}
1.951 +#ifndef SQLITE_OMIT_UTF16
1.952 +const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
1.953 + return columnName(
1.954 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
1.955 +}
1.956 +#endif /* SQLITE_OMIT_UTF16 */
1.957 +#endif /* SQLITE_OMIT_DECLTYPE */
1.958 +
1.959 +#ifdef SQLITE_ENABLE_COLUMN_METADATA
1.960 +/*
1.961 +** Return the name of the database from which a result column derives.
1.962 +** NULL is returned if the result column is an expression or constant or
1.963 +** anything else which is not an unabiguous reference to a database column.
1.964 +*/
1.965 +const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
1.966 + return columnName(
1.967 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
1.968 +}
1.969 +#ifndef SQLITE_OMIT_UTF16
1.970 +const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
1.971 + return columnName(
1.972 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
1.973 +}
1.974 +#endif /* SQLITE_OMIT_UTF16 */
1.975 +
1.976 +/*
1.977 +** Return the name of the table from which a result column derives.
1.978 +** NULL is returned if the result column is an expression or constant or
1.979 +** anything else which is not an unabiguous reference to a database column.
1.980 +*/
1.981 +const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
1.982 + return columnName(
1.983 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
1.984 +}
1.985 +#ifndef SQLITE_OMIT_UTF16
1.986 +const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
1.987 + return columnName(
1.988 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
1.989 +}
1.990 +#endif /* SQLITE_OMIT_UTF16 */
1.991 +
1.992 +/*
1.993 +** Return the name of the table column from which a result column derives.
1.994 +** NULL is returned if the result column is an expression or constant or
1.995 +** anything else which is not an unabiguous reference to a database column.
1.996 +*/
1.997 +const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
1.998 + return columnName(
1.999 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
1.1000 +}
1.1001 +#ifndef SQLITE_OMIT_UTF16
1.1002 +const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
1.1003 + return columnName(
1.1004 + pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
1.1005 +}
1.1006 +#endif /* SQLITE_OMIT_UTF16 */
1.1007 +#endif /* SQLITE_ENABLE_COLUMN_METADATA */
1.1008 +
1.1009 +
1.1010 +/******************************* sqlite3_bind_ ***************************
1.1011 +**
1.1012 +** Routines used to attach values to wildcards in a compiled SQL statement.
1.1013 +*/
1.1014 +/*
1.1015 +** Unbind the value bound to variable i in virtual machine p. This is the
1.1016 +** the same as binding a NULL value to the column. If the "i" parameter is
1.1017 +** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
1.1018 +**
1.1019 +** A successful evaluation of this routine acquires the mutex on p.
1.1020 +** the mutex is released if any kind of error occurs.
1.1021 +**
1.1022 +** The error code stored in database p->db is overwritten with the return
1.1023 +** value in any case.
1.1024 +*/
1.1025 +static int vdbeUnbind(Vdbe *p, int i){
1.1026 + Mem *pVar;
1.1027 + if( p==0 ) return SQLITE_MISUSE;
1.1028 + sqlite3_mutex_enter(p->db->mutex);
1.1029 + if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
1.1030 + sqlite3Error(p->db, SQLITE_MISUSE, 0);
1.1031 + sqlite3_mutex_leave(p->db->mutex);
1.1032 + return SQLITE_MISUSE;
1.1033 + }
1.1034 + if( i<1 || i>p->nVar ){
1.1035 + sqlite3Error(p->db, SQLITE_RANGE, 0);
1.1036 + sqlite3_mutex_leave(p->db->mutex);
1.1037 + return SQLITE_RANGE;
1.1038 + }
1.1039 + i--;
1.1040 + pVar = &p->aVar[i];
1.1041 + sqlite3VdbeMemRelease(pVar);
1.1042 + pVar->flags = MEM_Null;
1.1043 + sqlite3Error(p->db, SQLITE_OK, 0);
1.1044 + return SQLITE_OK;
1.1045 +}
1.1046 +
1.1047 +/*
1.1048 +** Bind a text or BLOB value.
1.1049 +*/
1.1050 +static int bindText(
1.1051 + sqlite3_stmt *pStmt, /* The statement to bind against */
1.1052 + int i, /* Index of the parameter to bind */
1.1053 + const void *zData, /* Pointer to the data to be bound */
1.1054 + int nData, /* Number of bytes of data to be bound */
1.1055 + void (*xDel)(void*), /* Destructor for the data */
1.1056 + int encoding /* Encoding for the data */
1.1057 +){
1.1058 + Vdbe *p = (Vdbe *)pStmt;
1.1059 + Mem *pVar;
1.1060 + int rc;
1.1061 +
1.1062 + rc = vdbeUnbind(p, i);
1.1063 + if( rc==SQLITE_OK ){
1.1064 + if( zData!=0 ){
1.1065 + pVar = &p->aVar[i-1];
1.1066 + rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
1.1067 + if( rc==SQLITE_OK && encoding!=0 ){
1.1068 + rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
1.1069 + }
1.1070 + sqlite3Error(p->db, rc, 0);
1.1071 + rc = sqlite3ApiExit(p->db, rc);
1.1072 + }
1.1073 + sqlite3_mutex_leave(p->db->mutex);
1.1074 + }
1.1075 + return rc;
1.1076 +}
1.1077 +
1.1078 +
1.1079 +/*
1.1080 +** Bind a blob value to an SQL statement variable.
1.1081 +*/
1.1082 +int sqlite3_bind_blob(
1.1083 + sqlite3_stmt *pStmt,
1.1084 + int i,
1.1085 + const void *zData,
1.1086 + int nData,
1.1087 + void (*xDel)(void*)
1.1088 +){
1.1089 + return bindText(pStmt, i, zData, nData, xDel, 0);
1.1090 +}
1.1091 +int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
1.1092 + int rc;
1.1093 + Vdbe *p = (Vdbe *)pStmt;
1.1094 + rc = vdbeUnbind(p, i);
1.1095 + if( rc==SQLITE_OK ){
1.1096 + sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
1.1097 + sqlite3_mutex_leave(p->db->mutex);
1.1098 + }
1.1099 + return rc;
1.1100 +}
1.1101 +int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
1.1102 + return sqlite3_bind_int64(p, i, (i64)iValue);
1.1103 +}
1.1104 +int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
1.1105 + int rc;
1.1106 + Vdbe *p = (Vdbe *)pStmt;
1.1107 + rc = vdbeUnbind(p, i);
1.1108 + if( rc==SQLITE_OK ){
1.1109 + sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
1.1110 + sqlite3_mutex_leave(p->db->mutex);
1.1111 + }
1.1112 + return rc;
1.1113 +}
1.1114 +int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
1.1115 + int rc;
1.1116 + Vdbe *p = (Vdbe*)pStmt;
1.1117 + rc = vdbeUnbind(p, i);
1.1118 + if( rc==SQLITE_OK ){
1.1119 + sqlite3_mutex_leave(p->db->mutex);
1.1120 + }
1.1121 + return rc;
1.1122 +}
1.1123 +int sqlite3_bind_text(
1.1124 + sqlite3_stmt *pStmt,
1.1125 + int i,
1.1126 + const char *zData,
1.1127 + int nData,
1.1128 + void (*xDel)(void*)
1.1129 +){
1.1130 + return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
1.1131 +}
1.1132 +#ifndef SQLITE_OMIT_UTF16
1.1133 +int sqlite3_bind_text16(
1.1134 + sqlite3_stmt *pStmt,
1.1135 + int i,
1.1136 + const void *zData,
1.1137 + int nData,
1.1138 + void (*xDel)(void*)
1.1139 +){
1.1140 + return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
1.1141 +}
1.1142 +#endif /* SQLITE_OMIT_UTF16 */
1.1143 +int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
1.1144 + int rc;
1.1145 + Vdbe *p = (Vdbe *)pStmt;
1.1146 + rc = vdbeUnbind(p, i);
1.1147 + if( rc==SQLITE_OK ){
1.1148 + rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);
1.1149 + if( rc==SQLITE_OK ){
1.1150 + rc = sqlite3VdbeChangeEncoding(&p->aVar[i-1], ENC(p->db));
1.1151 + }
1.1152 + sqlite3_mutex_leave(p->db->mutex);
1.1153 + }
1.1154 + rc = sqlite3ApiExit(p->db, rc);
1.1155 + return rc;
1.1156 +}
1.1157 +int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
1.1158 + int rc;
1.1159 + Vdbe *p = (Vdbe *)pStmt;
1.1160 + rc = vdbeUnbind(p, i);
1.1161 + if( rc==SQLITE_OK ){
1.1162 + sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
1.1163 + sqlite3_mutex_leave(p->db->mutex);
1.1164 + }
1.1165 + return rc;
1.1166 +}
1.1167 +
1.1168 +/*
1.1169 +** Return the number of wildcards that can be potentially bound to.
1.1170 +** This routine is added to support DBD::SQLite.
1.1171 +*/
1.1172 +int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
1.1173 + Vdbe *p = (Vdbe*)pStmt;
1.1174 + return p ? p->nVar : 0;
1.1175 +}
1.1176 +
1.1177 +/*
1.1178 +** Create a mapping from variable numbers to variable names
1.1179 +** in the Vdbe.azVar[] array, if such a mapping does not already
1.1180 +** exist.
1.1181 +*/
1.1182 +static void createVarMap(Vdbe *p){
1.1183 + if( !p->okVar ){
1.1184 + sqlite3_mutex_enter(p->db->mutex);
1.1185 + if( !p->okVar ){
1.1186 + int j;
1.1187 + Op *pOp;
1.1188 + for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
1.1189 + if( pOp->opcode==OP_Variable ){
1.1190 + assert( pOp->p1>0 && pOp->p1<=p->nVar );
1.1191 + p->azVar[pOp->p1-1] = pOp->p4.z;
1.1192 + }
1.1193 + }
1.1194 + p->okVar = 1;
1.1195 + }
1.1196 + sqlite3_mutex_leave(p->db->mutex);
1.1197 + }
1.1198 +}
1.1199 +
1.1200 +/*
1.1201 +** Return the name of a wildcard parameter. Return NULL if the index
1.1202 +** is out of range or if the wildcard is unnamed.
1.1203 +**
1.1204 +** The result is always UTF-8.
1.1205 +*/
1.1206 +const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
1.1207 + Vdbe *p = (Vdbe*)pStmt;
1.1208 + if( p==0 || i<1 || i>p->nVar ){
1.1209 + return 0;
1.1210 + }
1.1211 + createVarMap(p);
1.1212 + return p->azVar[i-1];
1.1213 +}
1.1214 +
1.1215 +/*
1.1216 +** Given a wildcard parameter name, return the index of the variable
1.1217 +** with that name. If there is no variable with the given name,
1.1218 +** return 0.
1.1219 +*/
1.1220 +int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
1.1221 + Vdbe *p = (Vdbe*)pStmt;
1.1222 + int i;
1.1223 + if( p==0 ){
1.1224 + return 0;
1.1225 + }
1.1226 + createVarMap(p);
1.1227 + if( zName ){
1.1228 + for(i=0; i<p->nVar; i++){
1.1229 + const char *z = p->azVar[i];
1.1230 + if( z && strcmp(z,zName)==0 ){
1.1231 + return i+1;
1.1232 + }
1.1233 + }
1.1234 + }
1.1235 + return 0;
1.1236 +}
1.1237 +
1.1238 +/*
1.1239 +** Transfer all bindings from the first statement over to the second.
1.1240 +** If the two statements contain a different number of bindings, then
1.1241 +** an SQLITE_ERROR is returned.
1.1242 +*/
1.1243 +int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
1.1244 + Vdbe *pFrom = (Vdbe*)pFromStmt;
1.1245 + Vdbe *pTo = (Vdbe*)pToStmt;
1.1246 + int i, rc = SQLITE_OK;
1.1247 + if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)
1.1248 + || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)
1.1249 + || pTo->db!=pFrom->db ){
1.1250 + return SQLITE_MISUSE;
1.1251 + }
1.1252 + if( pFrom->nVar!=pTo->nVar ){
1.1253 + return SQLITE_ERROR;
1.1254 + }
1.1255 + sqlite3_mutex_enter(pTo->db->mutex);
1.1256 + for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){
1.1257 + sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
1.1258 + }
1.1259 + sqlite3_mutex_leave(pTo->db->mutex);
1.1260 + assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
1.1261 + return rc;
1.1262 +}
1.1263 +
1.1264 +#ifndef SQLITE_OMIT_DEPRECATED
1.1265 +/*
1.1266 +** Deprecated external interface. Internal/core SQLite code
1.1267 +** should call sqlite3TransferBindings.
1.1268 +*/
1.1269 +int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
1.1270 + return sqlite3TransferBindings(pFromStmt, pToStmt);
1.1271 +}
1.1272 +#endif
1.1273 +
1.1274 +/*
1.1275 +** Return the sqlite3* database handle to which the prepared statement given
1.1276 +** in the argument belongs. This is the same database handle that was
1.1277 +** the first argument to the sqlite3_prepare() that was used to create
1.1278 +** the statement in the first place.
1.1279 +*/
1.1280 +sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
1.1281 + return pStmt ? ((Vdbe*)pStmt)->db : 0;
1.1282 +}
1.1283 +
1.1284 +/*
1.1285 +** Return a pointer to the next prepared statement after pStmt associated
1.1286 +** with database connection pDb. If pStmt is NULL, return the first
1.1287 +** prepared statement for the database connection. Return NULL if there
1.1288 +** are no more.
1.1289 +*/
1.1290 +sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
1.1291 + sqlite3_stmt *pNext;
1.1292 + sqlite3_mutex_enter(pDb->mutex);
1.1293 + if( pStmt==0 ){
1.1294 + pNext = (sqlite3_stmt*)pDb->pVdbe;
1.1295 + }else{
1.1296 + pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
1.1297 + }
1.1298 + sqlite3_mutex_leave(pDb->mutex);
1.1299 + return pNext;
1.1300 +}
1.1301 +
1.1302 +/*
1.1303 +** Return the value of a status counter for a prepared statement
1.1304 +*/
1.1305 +int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
1.1306 + Vdbe *pVdbe = (Vdbe*)pStmt;
1.1307 + int v = pVdbe->aCounter[op-1];
1.1308 + if( resetFlag ) pVdbe->aCounter[op-1] = 0;
1.1309 + return v;
1.1310 +}