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