1.1 --- a/extensions/sqlite/sqlite-source/vdbeapi.c Fri Mar 28 06:21:34 2008 +0000
1.2 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000
1.3 @@ -1,1066 +0,0 @@
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 -#include "sqliteInt.h"
1.20 -#include "vdbeInt.h"
1.21 -
1.22 -/*
1.23 -** Return TRUE (non-zero) of the statement supplied as an argument needs
1.24 -** to be recompiled. A statement needs to be recompiled whenever the
1.25 -** execution environment changes in a way that would alter the program
1.26 -** that sqlite3_prepare() generates. For example, if new functions or
1.27 -** collating sequences are registered or if an authorizer function is
1.28 -** added or changed.
1.29 -*/
1.30 -int sqlite3_expired(sqlite3_stmt *pStmt){
1.31 - Vdbe *p = (Vdbe*)pStmt;
1.32 - return p==0 || p->expired;
1.33 -}
1.34 -
1.35 -/*
1.36 -** The following routine destroys a virtual machine that is created by
1.37 -** the sqlite3_compile() routine. The integer returned is an SQLITE_
1.38 -** success/failure code that describes the result of executing the virtual
1.39 -** machine.
1.40 -**
1.41 -** This routine sets the error code and string returned by
1.42 -** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
1.43 -*/
1.44 -int sqlite3_finalize(sqlite3_stmt *pStmt){
1.45 - int rc;
1.46 - if( pStmt==0 ){
1.47 - rc = SQLITE_OK;
1.48 - }else{
1.49 - Vdbe *v = (Vdbe*)pStmt;
1.50 - sqlite3_mutex *mutex = v->db->mutex;
1.51 - sqlite3_mutex_enter(mutex);
1.52 - rc = sqlite3VdbeFinalize(v);
1.53 - sqlite3_mutex_leave(mutex);
1.54 - }
1.55 - return rc;
1.56 -}
1.57 -
1.58 -/*
1.59 -** Terminate the current execution of an SQL statement and reset it
1.60 -** back to its starting state so that it can be reused. A success code from
1.61 -** the prior execution is returned.
1.62 -**
1.63 -** This routine sets the error code and string returned by
1.64 -** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
1.65 -*/
1.66 -int sqlite3_reset(sqlite3_stmt *pStmt){
1.67 - int rc;
1.68 - if( pStmt==0 ){
1.69 - rc = SQLITE_OK;
1.70 - }else{
1.71 - Vdbe *v = (Vdbe*)pStmt;
1.72 - sqlite3_mutex_enter(v->db->mutex);
1.73 - rc = sqlite3VdbeReset(v);
1.74 - sqlite3VdbeMakeReady(v, -1, 0, 0, 0);
1.75 - assert( (rc & (v->db->errMask))==rc );
1.76 - sqlite3_mutex_leave(v->db->mutex);
1.77 - }
1.78 - return rc;
1.79 -}
1.80 -
1.81 -/*
1.82 -** Set all the parameters in the compiled SQL statement to NULL.
1.83 -*/
1.84 -int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
1.85 - int i;
1.86 - int rc = SQLITE_OK;
1.87 - Vdbe *v = (Vdbe*)pStmt;
1.88 - sqlite3_mutex_enter(v->db->mutex);
1.89 - for(i=1; rc==SQLITE_OK && i<=sqlite3_bind_parameter_count(pStmt); i++){
1.90 - rc = sqlite3_bind_null(pStmt, i);
1.91 - }
1.92 - sqlite3_mutex_leave(v->db->mutex);
1.93 - return rc;
1.94 -}
1.95 -
1.96 -
1.97 -/**************************** sqlite3_value_ *******************************
1.98 -** The following routines extract information from a Mem or sqlite3_value
1.99 -** structure.
1.100 -*/
1.101 -const void *sqlite3_value_blob(sqlite3_value *pVal){
1.102 - Mem *p = (Mem*)pVal;
1.103 - if( p->flags & (MEM_Blob|MEM_Str) ){
1.104 - sqlite3VdbeMemExpandBlob(p);
1.105 - p->flags &= ~MEM_Str;
1.106 - p->flags |= MEM_Blob;
1.107 - return p->z;
1.108 - }else{
1.109 - return sqlite3_value_text(pVal);
1.110 - }
1.111 -}
1.112 -int sqlite3_value_bytes(sqlite3_value *pVal){
1.113 - return sqlite3ValueBytes(pVal, SQLITE_UTF8);
1.114 -}
1.115 -int sqlite3_value_bytes16(sqlite3_value *pVal){
1.116 - return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
1.117 -}
1.118 -double sqlite3_value_double(sqlite3_value *pVal){
1.119 - return sqlite3VdbeRealValue((Mem*)pVal);
1.120 -}
1.121 -int sqlite3_value_int(sqlite3_value *pVal){
1.122 - return sqlite3VdbeIntValue((Mem*)pVal);
1.123 -}
1.124 -sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
1.125 - return sqlite3VdbeIntValue((Mem*)pVal);
1.126 -}
1.127 -const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
1.128 - return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
1.129 -}
1.130 -#ifndef SQLITE_OMIT_UTF16
1.131 -const void *sqlite3_value_text16(sqlite3_value* pVal){
1.132 - return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
1.133 -}
1.134 -const void *sqlite3_value_text16be(sqlite3_value *pVal){
1.135 - return sqlite3ValueText(pVal, SQLITE_UTF16BE);
1.136 -}
1.137 -const void *sqlite3_value_text16le(sqlite3_value *pVal){
1.138 - return sqlite3ValueText(pVal, SQLITE_UTF16LE);
1.139 -}
1.140 -#endif /* SQLITE_OMIT_UTF16 */
1.141 -int sqlite3_value_type(sqlite3_value* pVal){
1.142 - return pVal->type;
1.143 -}
1.144 -
1.145 -/**************************** sqlite3_result_ *******************************
1.146 -** The following routines are used by user-defined functions to specify
1.147 -** the function result.
1.148 -*/
1.149 -void sqlite3_result_blob(
1.150 - sqlite3_context *pCtx,
1.151 - const void *z,
1.152 - int n,
1.153 - void (*xDel)(void *)
1.154 -){
1.155 - assert( n>=0 );
1.156 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.157 - sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);
1.158 -}
1.159 -void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
1.160 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.161 - sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
1.162 -}
1.163 -void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
1.164 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.165 - pCtx->isError = 1;
1.166 - sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
1.167 -}
1.168 -#ifndef SQLITE_OMIT_UTF16
1.169 -void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
1.170 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.171 - pCtx->isError = 1;
1.172 - sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
1.173 -}
1.174 -#endif
1.175 -void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
1.176 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.177 - sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
1.178 -}
1.179 -void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
1.180 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.181 - sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
1.182 -}
1.183 -void sqlite3_result_null(sqlite3_context *pCtx){
1.184 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.185 - sqlite3VdbeMemSetNull(&pCtx->s);
1.186 -}
1.187 -void sqlite3_result_text(
1.188 - sqlite3_context *pCtx,
1.189 - const char *z,
1.190 - int n,
1.191 - void (*xDel)(void *)
1.192 -){
1.193 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.194 - sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);
1.195 -}
1.196 -#ifndef SQLITE_OMIT_UTF16
1.197 -void sqlite3_result_text16(
1.198 - sqlite3_context *pCtx,
1.199 - const void *z,
1.200 - int n,
1.201 - void (*xDel)(void *)
1.202 -){
1.203 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.204 - sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
1.205 -}
1.206 -void sqlite3_result_text16be(
1.207 - sqlite3_context *pCtx,
1.208 - const void *z,
1.209 - int n,
1.210 - void (*xDel)(void *)
1.211 -){
1.212 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.213 - sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);
1.214 -}
1.215 -void sqlite3_result_text16le(
1.216 - sqlite3_context *pCtx,
1.217 - const void *z,
1.218 - int n,
1.219 - void (*xDel)(void *)
1.220 -){
1.221 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.222 - sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);
1.223 -}
1.224 -#endif /* SQLITE_OMIT_UTF16 */
1.225 -void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
1.226 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.227 - sqlite3VdbeMemCopy(&pCtx->s, pValue);
1.228 -}
1.229 -void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
1.230 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.231 - sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
1.232 -}
1.233 -
1.234 -/* Force an SQLITE_TOOBIG error. */
1.235 -void sqlite3_result_error_toobig(sqlite3_context *pCtx){
1.236 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.237 - sqlite3VdbeMemSetZeroBlob(&pCtx->s, SQLITE_MAX_LENGTH+1);
1.238 -}
1.239 -
1.240 -/* An SQLITE_NOMEM error. */
1.241 -void sqlite3_result_error_nomem(sqlite3_context *pCtx){
1.242 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.243 - sqlite3VdbeMemSetNull(&pCtx->s);
1.244 - pCtx->isError = 1;
1.245 - pCtx->s.db->mallocFailed = 1;
1.246 -}
1.247 -
1.248 -/*
1.249 -** Execute the statement pStmt, either until a row of data is ready, the
1.250 -** statement is completely executed or an error occurs.
1.251 -**
1.252 -** This routine implements the bulk of the logic behind the sqlite_step()
1.253 -** API. The only thing omitted is the automatic recompile if a
1.254 -** schema change has occurred. That detail is handled by the
1.255 -** outer sqlite3_step() wrapper procedure.
1.256 -*/
1.257 -static int sqlite3Step(Vdbe *p){
1.258 - sqlite3 *db;
1.259 - int rc;
1.260 -
1.261 - /* Assert that malloc() has not failed */
1.262 - db = p->db;
1.263 - assert( !db->mallocFailed );
1.264 -
1.265 - if( p==0 || p->magic!=VDBE_MAGIC_RUN ){
1.266 - return SQLITE_MISUSE;
1.267 - }
1.268 - if( p->aborted ){
1.269 - return SQLITE_ABORT;
1.270 - }
1.271 - if( p->pc<=0 && p->expired ){
1.272 - if( p->rc==SQLITE_OK ){
1.273 - p->rc = SQLITE_SCHEMA;
1.274 - }
1.275 - rc = SQLITE_ERROR;
1.276 - goto end_of_step;
1.277 - }
1.278 - if( sqlite3SafetyOn(db) ){
1.279 - p->rc = SQLITE_MISUSE;
1.280 - return SQLITE_MISUSE;
1.281 - }
1.282 - if( p->pc<0 ){
1.283 - /* If there are no other statements currently running, then
1.284 - ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
1.285 - ** from interrupting a statement that has not yet started.
1.286 - */
1.287 - if( db->activeVdbeCnt==0 ){
1.288 - db->u1.isInterrupted = 0;
1.289 - }
1.290 -
1.291 -#ifndef SQLITE_OMIT_TRACE
1.292 - /* Invoke the trace callback if there is one
1.293 - */
1.294 - if( db->xTrace && !db->init.busy ){
1.295 - assert( p->nOp>0 );
1.296 - assert( p->aOp[p->nOp-1].opcode==OP_Noop );
1.297 - assert( p->aOp[p->nOp-1].p3!=0 );
1.298 - assert( p->aOp[p->nOp-1].p3type==P3_DYNAMIC );
1.299 - sqlite3SafetyOff(db);
1.300 - db->xTrace(db->pTraceArg, p->aOp[p->nOp-1].p3);
1.301 - if( sqlite3SafetyOn(db) ){
1.302 - p->rc = SQLITE_MISUSE;
1.303 - return SQLITE_MISUSE;
1.304 - }
1.305 - }
1.306 - if( db->xProfile && !db->init.busy ){
1.307 - double rNow;
1.308 - sqlite3OsCurrentTime(db->pVfs, &rNow);
1.309 - p->startTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0;
1.310 - }
1.311 -#endif
1.312 -
1.313 - /* Print a copy of SQL as it is executed if the SQL_TRACE pragma is turned
1.314 - ** on in debugging mode.
1.315 - */
1.316 -#ifdef SQLITE_DEBUG
1.317 - if( (db->flags & SQLITE_SqlTrace)!=0 ){
1.318 - sqlite3DebugPrintf("SQL-trace: %s\n", p->aOp[p->nOp-1].p3);
1.319 - }
1.320 -#endif /* SQLITE_DEBUG */
1.321 -
1.322 - db->activeVdbeCnt++;
1.323 - p->pc = 0;
1.324 - }
1.325 -#ifndef SQLITE_OMIT_EXPLAIN
1.326 - if( p->explain ){
1.327 - rc = sqlite3VdbeList(p);
1.328 - }else
1.329 -#endif /* SQLITE_OMIT_EXPLAIN */
1.330 - {
1.331 - rc = sqlite3VdbeExec(p);
1.332 - }
1.333 -
1.334 - if( sqlite3SafetyOff(db) ){
1.335 - rc = SQLITE_MISUSE;
1.336 - }
1.337 -
1.338 -#ifndef SQLITE_OMIT_TRACE
1.339 - /* Invoke the profile callback if there is one
1.340 - */
1.341 - if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy ){
1.342 - double rNow;
1.343 - u64 elapseTime;
1.344 -
1.345 - sqlite3OsCurrentTime(db->pVfs, &rNow);
1.346 - elapseTime = (rNow - (int)rNow)*3600.0*24.0*1000000000.0 - p->startTime;
1.347 - assert( p->nOp>0 );
1.348 - assert( p->aOp[p->nOp-1].opcode==OP_Noop );
1.349 - assert( p->aOp[p->nOp-1].p3!=0 );
1.350 - assert( p->aOp[p->nOp-1].p3type==P3_DYNAMIC );
1.351 - db->xProfile(db->pProfileArg, p->aOp[p->nOp-1].p3, elapseTime);
1.352 - }
1.353 -#endif
1.354 -
1.355 - sqlite3Error(p->db, rc, 0);
1.356 - p->rc = sqlite3ApiExit(p->db, p->rc);
1.357 -end_of_step:
1.358 - assert( (rc&0xff)==rc );
1.359 - if( p->zSql && (rc&0xff)<SQLITE_ROW ){
1.360 - /* This behavior occurs if sqlite3_prepare_v2() was used to build
1.361 - ** the prepared statement. Return error codes directly */
1.362 - sqlite3Error(p->db, p->rc, 0);
1.363 - return p->rc;
1.364 - }else{
1.365 - /* This is for legacy sqlite3_prepare() builds and when the code
1.366 - ** is SQLITE_ROW or SQLITE_DONE */
1.367 - return rc;
1.368 - }
1.369 -}
1.370 -
1.371 -/*
1.372 -** This is the top-level implementation of sqlite3_step(). Call
1.373 -** sqlite3Step() to do most of the work. If a schema error occurs,
1.374 -** call sqlite3Reprepare() and try again.
1.375 -*/
1.376 -#ifdef SQLITE_OMIT_PARSER
1.377 -int sqlite3_step(sqlite3_stmt *pStmt){
1.378 - int rc;
1.379 - Vdbe *v;
1.380 - v = (Vdbe*)pStmt;
1.381 - sqlite3_mutex_enter(v->db->mutex);
1.382 - rc = sqlite3Step(v);
1.383 - sqlite3_mutex_leave(v->db->mutex);
1.384 - return rc;
1.385 -}
1.386 -#else
1.387 -int sqlite3_step(sqlite3_stmt *pStmt){
1.388 - int cnt = 0;
1.389 - int rc;
1.390 - Vdbe *v = (Vdbe*)pStmt;
1.391 - sqlite3_mutex_enter(v->db->mutex);
1.392 - while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
1.393 - && cnt++ < 5
1.394 - && sqlite3Reprepare(v) ){
1.395 - sqlite3_reset(pStmt);
1.396 - v->expired = 0;
1.397 - }
1.398 - sqlite3_mutex_leave(v->db->mutex);
1.399 - return rc;
1.400 -}
1.401 -#endif
1.402 -
1.403 -/*
1.404 -** Extract the user data from a sqlite3_context structure and return a
1.405 -** pointer to it.
1.406 -*/
1.407 -void *sqlite3_user_data(sqlite3_context *p){
1.408 - assert( p && p->pFunc );
1.409 - return p->pFunc->pUserData;
1.410 -}
1.411 -
1.412 -/*
1.413 -** The following is the implementation of an SQL function that always
1.414 -** fails with an error message stating that the function is used in the
1.415 -** wrong context. The sqlite3_overload_function() API might construct
1.416 -** SQL function that use this routine so that the functions will exist
1.417 -** for name resolution but are actually overloaded by the xFindFunction
1.418 -** method of virtual tables.
1.419 -*/
1.420 -void sqlite3InvalidFunction(
1.421 - sqlite3_context *context, /* The function calling context */
1.422 - int argc, /* Number of arguments to the function */
1.423 - sqlite3_value **argv /* Value of each argument */
1.424 -){
1.425 - const char *zName = context->pFunc->zName;
1.426 - char *zErr;
1.427 - zErr = sqlite3MPrintf(0,
1.428 - "unable to use function %s in the requested context", zName);
1.429 - sqlite3_result_error(context, zErr, -1);
1.430 - sqlite3_free(zErr);
1.431 -}
1.432 -
1.433 -/*
1.434 -** Allocate or return the aggregate context for a user function. A new
1.435 -** context is allocated on the first call. Subsequent calls return the
1.436 -** same context that was returned on prior calls.
1.437 -*/
1.438 -void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
1.439 - Mem *pMem;
1.440 - assert( p && p->pFunc && p->pFunc->xStep );
1.441 - assert( sqlite3_mutex_held(p->s.db->mutex) );
1.442 - pMem = p->pMem;
1.443 - if( (pMem->flags & MEM_Agg)==0 ){
1.444 - if( nByte==0 ){
1.445 - assert( pMem->flags==MEM_Null );
1.446 - pMem->z = 0;
1.447 - }else{
1.448 - pMem->flags = MEM_Agg;
1.449 - pMem->xDel = sqlite3_free;
1.450 - pMem->u.pDef = p->pFunc;
1.451 - if( nByte<=NBFS ){
1.452 - pMem->z = pMem->zShort;
1.453 - memset(pMem->z, 0, nByte);
1.454 - }else{
1.455 - pMem->z = sqlite3DbMallocZero(p->s.db, nByte);
1.456 - }
1.457 - }
1.458 - }
1.459 - return (void*)pMem->z;
1.460 -}
1.461 -
1.462 -/*
1.463 -** Return the auxilary data pointer, if any, for the iArg'th argument to
1.464 -** the user-function defined by pCtx.
1.465 -*/
1.466 -void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
1.467 - VdbeFunc *pVdbeFunc;
1.468 -
1.469 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.470 - pVdbeFunc = pCtx->pVdbeFunc;
1.471 - if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
1.472 - return 0;
1.473 - }
1.474 - return pVdbeFunc->apAux[iArg].pAux;
1.475 -}
1.476 -
1.477 -/*
1.478 -** Set the auxilary data pointer and delete function, for the iArg'th
1.479 -** argument to the user-function defined by pCtx. Any previous value is
1.480 -** deleted by calling the delete function specified when it was set.
1.481 -*/
1.482 -void sqlite3_set_auxdata(
1.483 - sqlite3_context *pCtx,
1.484 - int iArg,
1.485 - void *pAux,
1.486 - void (*xDelete)(void*)
1.487 -){
1.488 - struct AuxData *pAuxData;
1.489 - VdbeFunc *pVdbeFunc;
1.490 - if( iArg<0 ) goto failed;
1.491 -
1.492 - assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
1.493 - pVdbeFunc = pCtx->pVdbeFunc;
1.494 - if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
1.495 - int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
1.496 - int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
1.497 - pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
1.498 - if( !pVdbeFunc ){
1.499 - goto failed;
1.500 - }
1.501 - pCtx->pVdbeFunc = pVdbeFunc;
1.502 - memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
1.503 - pVdbeFunc->nAux = iArg+1;
1.504 - pVdbeFunc->pFunc = pCtx->pFunc;
1.505 - }
1.506 -
1.507 - pAuxData = &pVdbeFunc->apAux[iArg];
1.508 - if( pAuxData->pAux && pAuxData->xDelete ){
1.509 - pAuxData->xDelete(pAuxData->pAux);
1.510 - }
1.511 - pAuxData->pAux = pAux;
1.512 - pAuxData->xDelete = xDelete;
1.513 - return;
1.514 -
1.515 -failed:
1.516 - if( xDelete ){
1.517 - xDelete(pAux);
1.518 - }
1.519 -}
1.520 -
1.521 -/*
1.522 -** Return the number of times the Step function of a aggregate has been
1.523 -** called.
1.524 -**
1.525 -** This function is deprecated. Do not use it for new code. It is
1.526 -** provide only to avoid breaking legacy code. New aggregate function
1.527 -** implementations should keep their own counts within their aggregate
1.528 -** context.
1.529 -*/
1.530 -int sqlite3_aggregate_count(sqlite3_context *p){
1.531 - assert( p && p->pFunc && p->pFunc->xStep );
1.532 - return p->pMem->n;
1.533 -}
1.534 -
1.535 -/*
1.536 -** Return the number of columns in the result set for the statement pStmt.
1.537 -*/
1.538 -int sqlite3_column_count(sqlite3_stmt *pStmt){
1.539 - Vdbe *pVm = (Vdbe *)pStmt;
1.540 - return pVm ? pVm->nResColumn : 0;
1.541 -}
1.542 -
1.543 -/*
1.544 -** Return the number of values available from the current row of the
1.545 -** currently executing statement pStmt.
1.546 -*/
1.547 -int sqlite3_data_count(sqlite3_stmt *pStmt){
1.548 - Vdbe *pVm = (Vdbe *)pStmt;
1.549 - if( pVm==0 || !pVm->resOnStack ) return 0;
1.550 - return pVm->nResColumn;
1.551 -}
1.552 -
1.553 -
1.554 -/*
1.555 -** Check to see if column iCol of the given statement is valid. If
1.556 -** it is, return a pointer to the Mem for the value of that column.
1.557 -** If iCol is not valid, return a pointer to a Mem which has a value
1.558 -** of NULL.
1.559 -*/
1.560 -static Mem *columnMem(sqlite3_stmt *pStmt, int i){
1.561 - Vdbe *pVm;
1.562 - int vals;
1.563 - Mem *pOut;
1.564 -
1.565 - pVm = (Vdbe *)pStmt;
1.566 - if( pVm && pVm->resOnStack && i<pVm->nResColumn && i>=0 ){
1.567 - sqlite3_mutex_enter(pVm->db->mutex);
1.568 - vals = sqlite3_data_count(pStmt);
1.569 - pOut = &pVm->pTos[(1-vals)+i];
1.570 - }else{
1.571 - static const Mem nullMem = {{0}, 0.0, 0, "", 0, MEM_Null, SQLITE_NULL };
1.572 - if( pVm->db ){
1.573 - sqlite3_mutex_enter(pVm->db->mutex);
1.574 - sqlite3Error(pVm->db, SQLITE_RANGE, 0);
1.575 - }
1.576 - pOut = (Mem*)&nullMem;
1.577 - }
1.578 - return pOut;
1.579 -}
1.580 -
1.581 -/*
1.582 -** This function is called after invoking an sqlite3_value_XXX function on a
1.583 -** column value (i.e. a value returned by evaluating an SQL expression in the
1.584 -** select list of a SELECT statement) that may cause a malloc() failure. If
1.585 -** malloc() has failed, the threads mallocFailed flag is cleared and the result
1.586 -** code of statement pStmt set to SQLITE_NOMEM.
1.587 -**
1.588 -** Specifically, this is called from within:
1.589 -**
1.590 -** sqlite3_column_int()
1.591 -** sqlite3_column_int64()
1.592 -** sqlite3_column_text()
1.593 -** sqlite3_column_text16()
1.594 -** sqlite3_column_real()
1.595 -** sqlite3_column_bytes()
1.596 -** sqlite3_column_bytes16()
1.597 -**
1.598 -** But not for sqlite3_column_blob(), which never calls malloc().
1.599 -*/
1.600 -static void columnMallocFailure(sqlite3_stmt *pStmt)
1.601 -{
1.602 - /* If malloc() failed during an encoding conversion within an
1.603 - ** sqlite3_column_XXX API, then set the return code of the statement to
1.604 - ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
1.605 - ** and _finalize() will return NOMEM.
1.606 - */
1.607 - Vdbe *p = (Vdbe *)pStmt;
1.608 - if( p ){
1.609 - p->rc = sqlite3ApiExit(p->db, p->rc);
1.610 - sqlite3_mutex_leave(p->db->mutex);
1.611 - }
1.612 -}
1.613 -
1.614 -/**************************** sqlite3_column_ *******************************
1.615 -** The following routines are used to access elements of the current row
1.616 -** in the result set.
1.617 -*/
1.618 -const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
1.619 - const void *val;
1.620 - val = sqlite3_value_blob( columnMem(pStmt,i) );
1.621 - /* Even though there is no encoding conversion, value_blob() might
1.622 - ** need to call malloc() to expand the result of a zeroblob()
1.623 - ** expression.
1.624 - */
1.625 - columnMallocFailure(pStmt);
1.626 - return val;
1.627 -}
1.628 -int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
1.629 - int val = sqlite3_value_bytes( columnMem(pStmt,i) );
1.630 - columnMallocFailure(pStmt);
1.631 - return val;
1.632 -}
1.633 -int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
1.634 - int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
1.635 - columnMallocFailure(pStmt);
1.636 - return val;
1.637 -}
1.638 -double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
1.639 - double val = sqlite3_value_double( columnMem(pStmt,i) );
1.640 - columnMallocFailure(pStmt);
1.641 - return val;
1.642 -}
1.643 -int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
1.644 - int val = sqlite3_value_int( columnMem(pStmt,i) );
1.645 - columnMallocFailure(pStmt);
1.646 - return val;
1.647 -}
1.648 -sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
1.649 - sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
1.650 - columnMallocFailure(pStmt);
1.651 - return val;
1.652 -}
1.653 -const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
1.654 - const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
1.655 - columnMallocFailure(pStmt);
1.656 - return val;
1.657 -}
1.658 -sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
1.659 - sqlite3_value *pOut = columnMem(pStmt, i);
1.660 - columnMallocFailure(pStmt);
1.661 - return pOut;
1.662 -}
1.663 -#ifndef SQLITE_OMIT_UTF16
1.664 -const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
1.665 - const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
1.666 - columnMallocFailure(pStmt);
1.667 - return val;
1.668 -}
1.669 -#endif /* SQLITE_OMIT_UTF16 */
1.670 -int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
1.671 - int iType = sqlite3_value_type( columnMem(pStmt,i) );
1.672 - columnMallocFailure(pStmt);
1.673 - return iType;
1.674 -}
1.675 -
1.676 -/* The following function is experimental and subject to change or
1.677 -** removal */
1.678 -/*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
1.679 -** return sqlite3_value_numeric_type( columnMem(pStmt,i) );
1.680 -**}
1.681 -*/
1.682 -
1.683 -/*
1.684 -** Convert the N-th element of pStmt->pColName[] into a string using
1.685 -** xFunc() then return that string. If N is out of range, return 0.
1.686 -**
1.687 -** There are up to 5 names for each column. useType determines which
1.688 -** name is returned. Here are the names:
1.689 -**
1.690 -** 0 The column name as it should be displayed for output
1.691 -** 1 The datatype name for the column
1.692 -** 2 The name of the database that the column derives from
1.693 -** 3 The name of the table that the column derives from
1.694 -** 4 The name of the table column that the result column derives from
1.695 -**
1.696 -** If the result is not a simple column reference (if it is an expression
1.697 -** or a constant) then useTypes 2, 3, and 4 return NULL.
1.698 -*/
1.699 -static const void *columnName(
1.700 - sqlite3_stmt *pStmt,
1.701 - int N,
1.702 - const void *(*xFunc)(Mem*),
1.703 - int useType
1.704 -){
1.705 - const void *ret = 0;
1.706 - Vdbe *p = (Vdbe *)pStmt;
1.707 - int n;
1.708 -
1.709 -
1.710 - if( p!=0 ){
1.711 - n = sqlite3_column_count(pStmt);
1.712 - if( N<n && N>=0 ){
1.713 - N += useType*n;
1.714 - sqlite3_mutex_enter(p->db->mutex);
1.715 - ret = xFunc(&p->aColName[N]);
1.716 -
1.717 - /* A malloc may have failed inside of the xFunc() call. If this
1.718 - ** is the case, clear the mallocFailed flag and return NULL.
1.719 - */
1.720 - if( p->db && p->db->mallocFailed ){
1.721 - p->db->mallocFailed = 0;
1.722 - ret = 0;
1.723 - }
1.724 - sqlite3_mutex_leave(p->db->mutex);
1.725 - }
1.726 - }
1.727 - return ret;
1.728 -}
1.729 -
1.730 -/*
1.731 -** Return the name of the Nth column of the result set returned by SQL
1.732 -** statement pStmt.
1.733 -*/
1.734 -const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
1.735 - return columnName(
1.736 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
1.737 -}
1.738 -#ifndef SQLITE_OMIT_UTF16
1.739 -const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
1.740 - return columnName(
1.741 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
1.742 -}
1.743 -#endif
1.744 -
1.745 -/*
1.746 -** Return the column declaration type (if applicable) of the 'i'th column
1.747 -** of the result set of SQL statement pStmt.
1.748 -*/
1.749 -const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
1.750 - return columnName(
1.751 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
1.752 -}
1.753 -#ifndef SQLITE_OMIT_UTF16
1.754 -const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
1.755 - return columnName(
1.756 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
1.757 -}
1.758 -#endif /* SQLITE_OMIT_UTF16 */
1.759 -
1.760 -#ifdef SQLITE_ENABLE_COLUMN_METADATA
1.761 -/*
1.762 -** Return the name of the database from which a result column derives.
1.763 -** NULL is returned if the result column is an expression or constant or
1.764 -** anything else which is not an unabiguous reference to a database column.
1.765 -*/
1.766 -const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
1.767 - return columnName(
1.768 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
1.769 -}
1.770 -#ifndef SQLITE_OMIT_UTF16
1.771 -const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
1.772 - return columnName(
1.773 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
1.774 -}
1.775 -#endif /* SQLITE_OMIT_UTF16 */
1.776 -
1.777 -/*
1.778 -** Return the name of the table from which a result column derives.
1.779 -** NULL is returned if the result column is an expression or constant or
1.780 -** anything else which is not an unabiguous reference to a database column.
1.781 -*/
1.782 -const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
1.783 - return columnName(
1.784 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
1.785 -}
1.786 -#ifndef SQLITE_OMIT_UTF16
1.787 -const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
1.788 - return columnName(
1.789 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
1.790 -}
1.791 -#endif /* SQLITE_OMIT_UTF16 */
1.792 -
1.793 -/*
1.794 -** Return the name of the table column from which a result column derives.
1.795 -** NULL is returned if the result column is an expression or constant or
1.796 -** anything else which is not an unabiguous reference to a database column.
1.797 -*/
1.798 -const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
1.799 - return columnName(
1.800 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
1.801 -}
1.802 -#ifndef SQLITE_OMIT_UTF16
1.803 -const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
1.804 - return columnName(
1.805 - pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
1.806 -}
1.807 -#endif /* SQLITE_OMIT_UTF16 */
1.808 -#endif /* SQLITE_ENABLE_COLUMN_METADATA */
1.809 -
1.810 -
1.811 -/******************************* sqlite3_bind_ ***************************
1.812 -**
1.813 -** Routines used to attach values to wildcards in a compiled SQL statement.
1.814 -*/
1.815 -/*
1.816 -** Unbind the value bound to variable i in virtual machine p. This is the
1.817 -** the same as binding a NULL value to the column. If the "i" parameter is
1.818 -** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
1.819 -**
1.820 -** The error code stored in database p->db is overwritten with the return
1.821 -** value in any case.
1.822 -*/
1.823 -static int vdbeUnbind(Vdbe *p, int i){
1.824 - Mem *pVar;
1.825 - if( p==0 || p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
1.826 - if( p ) sqlite3Error(p->db, SQLITE_MISUSE, 0);
1.827 - return SQLITE_MISUSE;
1.828 - }
1.829 - if( i<1 || i>p->nVar ){
1.830 - sqlite3Error(p->db, SQLITE_RANGE, 0);
1.831 - return SQLITE_RANGE;
1.832 - }
1.833 - i--;
1.834 - pVar = &p->aVar[i];
1.835 - sqlite3VdbeMemRelease(pVar);
1.836 - pVar->flags = MEM_Null;
1.837 - sqlite3Error(p->db, SQLITE_OK, 0);
1.838 - return SQLITE_OK;
1.839 -}
1.840 -
1.841 -/*
1.842 -** Bind a text or BLOB value.
1.843 -*/
1.844 -static int bindText(
1.845 - sqlite3_stmt *pStmt, /* The statement to bind against */
1.846 - int i, /* Index of the parameter to bind */
1.847 - const void *zData, /* Pointer to the data to be bound */
1.848 - int nData, /* Number of bytes of data to be bound */
1.849 - void (*xDel)(void*), /* Destructor for the data */
1.850 - int encoding /* Encoding for the data */
1.851 -){
1.852 - Vdbe *p = (Vdbe *)pStmt;
1.853 - Mem *pVar;
1.854 - int rc;
1.855 -
1.856 - if( p==0 ){
1.857 - return SQLITE_MISUSE;
1.858 - }
1.859 - sqlite3_mutex_enter(p->db->mutex);
1.860 - rc = vdbeUnbind(p, i);
1.861 - if( rc==SQLITE_OK && zData!=0 ){
1.862 - pVar = &p->aVar[i-1];
1.863 - rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
1.864 - if( rc==SQLITE_OK && encoding!=0 ){
1.865 - rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
1.866 - }
1.867 - sqlite3Error(p->db, rc, 0);
1.868 - rc = sqlite3ApiExit(p->db, rc);
1.869 - }
1.870 - sqlite3_mutex_leave(p->db->mutex);
1.871 - return rc;
1.872 -}
1.873 -
1.874 -
1.875 -/*
1.876 -** Bind a blob value to an SQL statement variable.
1.877 -*/
1.878 -int sqlite3_bind_blob(
1.879 - sqlite3_stmt *pStmt,
1.880 - int i,
1.881 - const void *zData,
1.882 - int nData,
1.883 - void (*xDel)(void*)
1.884 -){
1.885 - return bindText(pStmt, i, zData, nData, xDel, 0);
1.886 -}
1.887 -int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
1.888 - int rc;
1.889 - Vdbe *p = (Vdbe *)pStmt;
1.890 - sqlite3_mutex_enter(p->db->mutex);
1.891 - rc = vdbeUnbind(p, i);
1.892 - if( rc==SQLITE_OK ){
1.893 - sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
1.894 - }
1.895 - sqlite3_mutex_leave(p->db->mutex);
1.896 - return rc;
1.897 -}
1.898 -int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
1.899 - return sqlite3_bind_int64(p, i, (i64)iValue);
1.900 -}
1.901 -int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
1.902 - int rc;
1.903 - Vdbe *p = (Vdbe *)pStmt;
1.904 - sqlite3_mutex_enter(p->db->mutex);
1.905 - rc = vdbeUnbind(p, i);
1.906 - if( rc==SQLITE_OK ){
1.907 - sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
1.908 - }
1.909 - sqlite3_mutex_leave(p->db->mutex);
1.910 - return rc;
1.911 -}
1.912 -int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
1.913 - int rc;
1.914 - Vdbe *p = (Vdbe*)pStmt;
1.915 - sqlite3_mutex_enter(p->db->mutex);
1.916 - rc = vdbeUnbind(p, i);
1.917 - sqlite3_mutex_leave(p->db->mutex);
1.918 - return rc;
1.919 -}
1.920 -int sqlite3_bind_text(
1.921 - sqlite3_stmt *pStmt,
1.922 - int i,
1.923 - const char *zData,
1.924 - int nData,
1.925 - void (*xDel)(void*)
1.926 -){
1.927 - return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
1.928 -}
1.929 -#ifndef SQLITE_OMIT_UTF16
1.930 -int sqlite3_bind_text16(
1.931 - sqlite3_stmt *pStmt,
1.932 - int i,
1.933 - const void *zData,
1.934 - int nData,
1.935 - void (*xDel)(void*)
1.936 -){
1.937 - return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
1.938 -}
1.939 -#endif /* SQLITE_OMIT_UTF16 */
1.940 -int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
1.941 - int rc;
1.942 - Vdbe *p = (Vdbe *)pStmt;
1.943 - sqlite3_mutex_enter(p->db->mutex);
1.944 - rc = vdbeUnbind(p, i);
1.945 - if( rc==SQLITE_OK ){
1.946 - rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);
1.947 - }
1.948 - sqlite3_mutex_leave(p->db->mutex);
1.949 - return rc;
1.950 -}
1.951 -int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
1.952 - int rc;
1.953 - Vdbe *p = (Vdbe *)pStmt;
1.954 - sqlite3_mutex_enter(p->db->mutex);
1.955 - rc = vdbeUnbind(p, i);
1.956 - if( rc==SQLITE_OK ){
1.957 - sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
1.958 - }
1.959 - sqlite3_mutex_leave(p->db->mutex);
1.960 - return rc;
1.961 -}
1.962 -
1.963 -/*
1.964 -** Return the number of wildcards that can be potentially bound to.
1.965 -** This routine is added to support DBD::SQLite.
1.966 -*/
1.967 -int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
1.968 - Vdbe *p = (Vdbe*)pStmt;
1.969 - return p ? p->nVar : 0;
1.970 -}
1.971 -
1.972 -/*
1.973 -** Create a mapping from variable numbers to variable names
1.974 -** in the Vdbe.azVar[] array, if such a mapping does not already
1.975 -** exist.
1.976 -*/
1.977 -static void createVarMap(Vdbe *p){
1.978 - if( !p->okVar ){
1.979 - sqlite3_mutex_enter(p->db->mutex);
1.980 - if( !p->okVar ){
1.981 - int j;
1.982 - Op *pOp;
1.983 - for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
1.984 - if( pOp->opcode==OP_Variable ){
1.985 - assert( pOp->p1>0 && pOp->p1<=p->nVar );
1.986 - p->azVar[pOp->p1-1] = pOp->p3;
1.987 - }
1.988 - }
1.989 - p->okVar = 1;
1.990 - }
1.991 - sqlite3_mutex_leave(p->db->mutex);
1.992 - }
1.993 -}
1.994 -
1.995 -/*
1.996 -** Return the name of a wildcard parameter. Return NULL if the index
1.997 -** is out of range or if the wildcard is unnamed.
1.998 -**
1.999 -** The result is always UTF-8.
1.1000 -*/
1.1001 -const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
1.1002 - Vdbe *p = (Vdbe*)pStmt;
1.1003 - if( p==0 || i<1 || i>p->nVar ){
1.1004 - return 0;
1.1005 - }
1.1006 - createVarMap(p);
1.1007 - return p->azVar[i-1];
1.1008 -}
1.1009 -
1.1010 -/*
1.1011 -** Given a wildcard parameter name, return the index of the variable
1.1012 -** with that name. If there is no variable with the given name,
1.1013 -** return 0.
1.1014 -*/
1.1015 -int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
1.1016 - Vdbe *p = (Vdbe*)pStmt;
1.1017 - int i;
1.1018 - if( p==0 ){
1.1019 - return 0;
1.1020 - }
1.1021 - createVarMap(p);
1.1022 - if( zName ){
1.1023 - for(i=0; i<p->nVar; i++){
1.1024 - const char *z = p->azVar[i];
1.1025 - if( z && strcmp(z,zName)==0 ){
1.1026 - return i+1;
1.1027 - }
1.1028 - }
1.1029 - }
1.1030 - return 0;
1.1031 -}
1.1032 -
1.1033 -/*
1.1034 -** Transfer all bindings from the first statement over to the second.
1.1035 -** If the two statements contain a different number of bindings, then
1.1036 -** an SQLITE_ERROR is returned.
1.1037 -*/
1.1038 -int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
1.1039 - Vdbe *pFrom = (Vdbe*)pFromStmt;
1.1040 - Vdbe *pTo = (Vdbe*)pToStmt;
1.1041 - int i, rc = SQLITE_OK;
1.1042 - if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)
1.1043 - || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)
1.1044 - || pTo->db!=pFrom->db ){
1.1045 - return SQLITE_MISUSE;
1.1046 - }
1.1047 - if( pFrom->nVar!=pTo->nVar ){
1.1048 - return SQLITE_ERROR;
1.1049 - }
1.1050 - sqlite3_mutex_enter(pTo->db->mutex);
1.1051 - for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){
1.1052 - sqlite3MallocDisallow();
1.1053 - rc = sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
1.1054 - sqlite3MallocAllow();
1.1055 - }
1.1056 - sqlite3_mutex_leave(pTo->db->mutex);
1.1057 - assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
1.1058 - return rc;
1.1059 -}
1.1060 -
1.1061 -/*
1.1062 -** Return the sqlite3* database handle to which the prepared statement given
1.1063 -** in the argument belongs. This is the same database handle that was
1.1064 -** the first argument to the sqlite3_prepare() that was used to create
1.1065 -** the statement in the first place.
1.1066 -*/
1.1067 -sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
1.1068 - return pStmt ? ((Vdbe*)pStmt)->db : 0;
1.1069 -}
