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 #ifndef SQLITE_OMIT_TRACE 57 /* 58 ** Invoke the profile callback. This routine is only called if we already 59 ** know that the profile callback is defined and needs to be invoked. 60 */ 61 static SQLITE_NOINLINE void invokeProfileCallback(sqlite3 *db, Vdbe *p){ 62 sqlite3_int64 iNow; 63 sqlite3_int64 iElapse; 64 assert( p->startTime>0 ); 65 assert( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 ); 66 assert( db->init.busy==0 ); 67 assert( p->zSql!=0 ); 68 sqlite3OsCurrentTimeInt64(db->pVfs, &iNow); 69 iElapse = (iNow - p->startTime)*1000000; 70 #ifndef SQLITE_OMIT_DEPRECATED 71 if( db->xProfile ){ 72 db->xProfile(db->pProfileArg, p->zSql, iElapse); 73 } 74 #endif 75 if( db->mTrace & SQLITE_TRACE_PROFILE ){ 76 db->trace.xV2(SQLITE_TRACE_PROFILE, db->pTraceArg, p, (void*)&iElapse); 77 } 78 p->startTime = 0; 79 } 80 /* 81 ** The checkProfileCallback(DB,P) macro checks to see if a profile callback 82 ** is needed, and it invokes the callback if it is needed. 83 */ 84 # define checkProfileCallback(DB,P) \ 85 if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); } 86 #else 87 # define checkProfileCallback(DB,P) /*no-op*/ 88 #endif 89 90 /* 91 ** The following routine destroys a virtual machine that is created by 92 ** the sqlite3_compile() routine. The integer returned is an SQLITE_ 93 ** success/failure code that describes the result of executing the virtual 94 ** machine. 95 ** 96 ** This routine sets the error code and string returned by 97 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). 98 */ 99 int sqlite3_finalize(sqlite3_stmt *pStmt){ 100 int rc; 101 if( pStmt==0 ){ 102 /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL 103 ** pointer is a harmless no-op. */ 104 rc = SQLITE_OK; 105 }else{ 106 Vdbe *v = (Vdbe*)pStmt; 107 sqlite3 *db = v->db; 108 if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT; 109 sqlite3_mutex_enter(db->mutex); 110 checkProfileCallback(db, v); 111 assert( v->eVdbeState>=VDBE_READY_STATE ); 112 rc = sqlite3VdbeReset(v); 113 sqlite3VdbeDelete(v); 114 rc = sqlite3ApiExit(db, rc); 115 sqlite3LeaveMutexAndCloseZombie(db); 116 } 117 return rc; 118 } 119 120 /* 121 ** Terminate the current execution of an SQL statement and reset it 122 ** back to its starting state so that it can be reused. A success code from 123 ** the prior execution is returned. 124 ** 125 ** This routine sets the error code and string returned by 126 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). 127 */ 128 int sqlite3_reset(sqlite3_stmt *pStmt){ 129 int rc; 130 if( pStmt==0 ){ 131 rc = SQLITE_OK; 132 }else{ 133 Vdbe *v = (Vdbe*)pStmt; 134 sqlite3 *db = v->db; 135 sqlite3_mutex_enter(db->mutex); 136 checkProfileCallback(db, v); 137 rc = sqlite3VdbeReset(v); 138 sqlite3VdbeRewind(v); 139 assert( (rc & (db->errMask))==rc ); 140 rc = sqlite3ApiExit(db, rc); 141 sqlite3_mutex_leave(db->mutex); 142 } 143 return rc; 144 } 145 146 /* 147 ** Set all the parameters in the compiled SQL statement to NULL. 148 */ 149 int sqlite3_clear_bindings(sqlite3_stmt *pStmt){ 150 int i; 151 int rc = SQLITE_OK; 152 Vdbe *p = (Vdbe*)pStmt; 153 #if SQLITE_THREADSAFE 154 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex; 155 #endif 156 sqlite3_mutex_enter(mutex); 157 for(i=0; i<p->nVar; i++){ 158 sqlite3VdbeMemRelease(&p->aVar[i]); 159 p->aVar[i].flags = MEM_Null; 160 } 161 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 ); 162 if( p->expmask ){ 163 p->expired = 1; 164 } 165 sqlite3_mutex_leave(mutex); 166 return rc; 167 } 168 169 170 /**************************** sqlite3_value_ ******************************* 171 ** The following routines extract information from a Mem or sqlite3_value 172 ** structure. 173 */ 174 const void *sqlite3_value_blob(sqlite3_value *pVal){ 175 Mem *p = (Mem*)pVal; 176 if( p->flags & (MEM_Blob|MEM_Str) ){ 177 if( ExpandBlob(p)!=SQLITE_OK ){ 178 assert( p->flags==MEM_Null && p->z==0 ); 179 return 0; 180 } 181 p->flags |= MEM_Blob; 182 return p->n ? p->z : 0; 183 }else{ 184 return sqlite3_value_text(pVal); 185 } 186 } 187 int sqlite3_value_bytes(sqlite3_value *pVal){ 188 return sqlite3ValueBytes(pVal, SQLITE_UTF8); 189 } 190 int sqlite3_value_bytes16(sqlite3_value *pVal){ 191 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE); 192 } 193 double sqlite3_value_double(sqlite3_value *pVal){ 194 return sqlite3VdbeRealValue((Mem*)pVal); 195 } 196 int sqlite3_value_int(sqlite3_value *pVal){ 197 return (int)sqlite3VdbeIntValue((Mem*)pVal); 198 } 199 sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){ 200 return sqlite3VdbeIntValue((Mem*)pVal); 201 } 202 unsigned int sqlite3_value_subtype(sqlite3_value *pVal){ 203 Mem *pMem = (Mem*)pVal; 204 return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0); 205 } 206 void *sqlite3_value_pointer(sqlite3_value *pVal, const char *zPType){ 207 Mem *p = (Mem*)pVal; 208 if( (p->flags&(MEM_TypeMask|MEM_Term|MEM_Subtype)) == 209 (MEM_Null|MEM_Term|MEM_Subtype) 210 && zPType!=0 211 && p->eSubtype=='p' 212 && strcmp(p->u.zPType, zPType)==0 213 ){ 214 return (void*)p->z; 215 }else{ 216 return 0; 217 } 218 } 219 const unsigned char *sqlite3_value_text(sqlite3_value *pVal){ 220 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8); 221 } 222 #ifndef SQLITE_OMIT_UTF16 223 const void *sqlite3_value_text16(sqlite3_value* pVal){ 224 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); 225 } 226 const void *sqlite3_value_text16be(sqlite3_value *pVal){ 227 return sqlite3ValueText(pVal, SQLITE_UTF16BE); 228 } 229 const void *sqlite3_value_text16le(sqlite3_value *pVal){ 230 return sqlite3ValueText(pVal, SQLITE_UTF16LE); 231 } 232 #endif /* SQLITE_OMIT_UTF16 */ 233 /* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five 234 ** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating 235 ** point number string BLOB NULL 236 */ 237 int sqlite3_value_type(sqlite3_value* pVal){ 238 static const u8 aType[] = { 239 SQLITE_BLOB, /* 0x00 (not possible) */ 240 SQLITE_NULL, /* 0x01 NULL */ 241 SQLITE_TEXT, /* 0x02 TEXT */ 242 SQLITE_NULL, /* 0x03 (not possible) */ 243 SQLITE_INTEGER, /* 0x04 INTEGER */ 244 SQLITE_NULL, /* 0x05 (not possible) */ 245 SQLITE_INTEGER, /* 0x06 INTEGER + TEXT */ 246 SQLITE_NULL, /* 0x07 (not possible) */ 247 SQLITE_FLOAT, /* 0x08 FLOAT */ 248 SQLITE_NULL, /* 0x09 (not possible) */ 249 SQLITE_FLOAT, /* 0x0a FLOAT + TEXT */ 250 SQLITE_NULL, /* 0x0b (not possible) */ 251 SQLITE_INTEGER, /* 0x0c (not possible) */ 252 SQLITE_NULL, /* 0x0d (not possible) */ 253 SQLITE_INTEGER, /* 0x0e (not possible) */ 254 SQLITE_NULL, /* 0x0f (not possible) */ 255 SQLITE_BLOB, /* 0x10 BLOB */ 256 SQLITE_NULL, /* 0x11 (not possible) */ 257 SQLITE_TEXT, /* 0x12 (not possible) */ 258 SQLITE_NULL, /* 0x13 (not possible) */ 259 SQLITE_INTEGER, /* 0x14 INTEGER + BLOB */ 260 SQLITE_NULL, /* 0x15 (not possible) */ 261 SQLITE_INTEGER, /* 0x16 (not possible) */ 262 SQLITE_NULL, /* 0x17 (not possible) */ 263 SQLITE_FLOAT, /* 0x18 FLOAT + BLOB */ 264 SQLITE_NULL, /* 0x19 (not possible) */ 265 SQLITE_FLOAT, /* 0x1a (not possible) */ 266 SQLITE_NULL, /* 0x1b (not possible) */ 267 SQLITE_INTEGER, /* 0x1c (not possible) */ 268 SQLITE_NULL, /* 0x1d (not possible) */ 269 SQLITE_INTEGER, /* 0x1e (not possible) */ 270 SQLITE_NULL, /* 0x1f (not possible) */ 271 SQLITE_FLOAT, /* 0x20 INTREAL */ 272 SQLITE_NULL, /* 0x21 (not possible) */ 273 SQLITE_TEXT, /* 0x22 INTREAL + TEXT */ 274 SQLITE_NULL, /* 0x23 (not possible) */ 275 SQLITE_FLOAT, /* 0x24 (not possible) */ 276 SQLITE_NULL, /* 0x25 (not possible) */ 277 SQLITE_FLOAT, /* 0x26 (not possible) */ 278 SQLITE_NULL, /* 0x27 (not possible) */ 279 SQLITE_FLOAT, /* 0x28 (not possible) */ 280 SQLITE_NULL, /* 0x29 (not possible) */ 281 SQLITE_FLOAT, /* 0x2a (not possible) */ 282 SQLITE_NULL, /* 0x2b (not possible) */ 283 SQLITE_FLOAT, /* 0x2c (not possible) */ 284 SQLITE_NULL, /* 0x2d (not possible) */ 285 SQLITE_FLOAT, /* 0x2e (not possible) */ 286 SQLITE_NULL, /* 0x2f (not possible) */ 287 SQLITE_BLOB, /* 0x30 (not possible) */ 288 SQLITE_NULL, /* 0x31 (not possible) */ 289 SQLITE_TEXT, /* 0x32 (not possible) */ 290 SQLITE_NULL, /* 0x33 (not possible) */ 291 SQLITE_FLOAT, /* 0x34 (not possible) */ 292 SQLITE_NULL, /* 0x35 (not possible) */ 293 SQLITE_FLOAT, /* 0x36 (not possible) */ 294 SQLITE_NULL, /* 0x37 (not possible) */ 295 SQLITE_FLOAT, /* 0x38 (not possible) */ 296 SQLITE_NULL, /* 0x39 (not possible) */ 297 SQLITE_FLOAT, /* 0x3a (not possible) */ 298 SQLITE_NULL, /* 0x3b (not possible) */ 299 SQLITE_FLOAT, /* 0x3c (not possible) */ 300 SQLITE_NULL, /* 0x3d (not possible) */ 301 SQLITE_FLOAT, /* 0x3e (not possible) */ 302 SQLITE_NULL, /* 0x3f (not possible) */ 303 }; 304 #ifdef SQLITE_DEBUG 305 { 306 int eType = SQLITE_BLOB; 307 if( pVal->flags & MEM_Null ){ 308 eType = SQLITE_NULL; 309 }else if( pVal->flags & (MEM_Real|MEM_IntReal) ){ 310 eType = SQLITE_FLOAT; 311 }else if( pVal->flags & MEM_Int ){ 312 eType = SQLITE_INTEGER; 313 }else if( pVal->flags & MEM_Str ){ 314 eType = SQLITE_TEXT; 315 } 316 assert( eType == aType[pVal->flags&MEM_AffMask] ); 317 } 318 #endif 319 return aType[pVal->flags&MEM_AffMask]; 320 } 321 int sqlite3_value_encoding(sqlite3_value *pVal){ 322 return pVal->enc; 323 } 324 325 /* Return true if a parameter to xUpdate represents an unchanged column */ 326 int sqlite3_value_nochange(sqlite3_value *pVal){ 327 return (pVal->flags&(MEM_Null|MEM_Zero))==(MEM_Null|MEM_Zero); 328 } 329 330 /* Return true if a parameter value originated from an sqlite3_bind() */ 331 int sqlite3_value_frombind(sqlite3_value *pVal){ 332 return (pVal->flags&MEM_FromBind)!=0; 333 } 334 335 /* Make a copy of an sqlite3_value object 336 */ 337 sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){ 338 sqlite3_value *pNew; 339 if( pOrig==0 ) return 0; 340 pNew = sqlite3_malloc( sizeof(*pNew) ); 341 if( pNew==0 ) return 0; 342 memset(pNew, 0, sizeof(*pNew)); 343 memcpy(pNew, pOrig, MEMCELLSIZE); 344 pNew->flags &= ~MEM_Dyn; 345 pNew->db = 0; 346 if( pNew->flags&(MEM_Str|MEM_Blob) ){ 347 pNew->flags &= ~(MEM_Static|MEM_Dyn); 348 pNew->flags |= MEM_Ephem; 349 if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){ 350 sqlite3ValueFree(pNew); 351 pNew = 0; 352 } 353 }else if( pNew->flags & MEM_Null ){ 354 /* Do not duplicate pointer values */ 355 pNew->flags &= ~(MEM_Term|MEM_Subtype); 356 } 357 return pNew; 358 } 359 360 /* Destroy an sqlite3_value object previously obtained from 361 ** sqlite3_value_dup(). 362 */ 363 void sqlite3_value_free(sqlite3_value *pOld){ 364 sqlite3ValueFree(pOld); 365 } 366 367 368 /**************************** sqlite3_result_ ******************************* 369 ** The following routines are used by user-defined functions to specify 370 ** the function result. 371 ** 372 ** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the 373 ** result as a string or blob. Appropriate errors are set if the string/blob 374 ** is too big or if an OOM occurs. 375 ** 376 ** The invokeValueDestructor(P,X) routine invokes destructor function X() 377 ** on value P is not going to be used and need to be destroyed. 378 */ 379 static void setResultStrOrError( 380 sqlite3_context *pCtx, /* Function context */ 381 const char *z, /* String pointer */ 382 int n, /* Bytes in string, or negative */ 383 u8 enc, /* Encoding of z. 0 for BLOBs */ 384 void (*xDel)(void*) /* Destructor function */ 385 ){ 386 Mem *pOut = pCtx->pOut; 387 int rc = sqlite3VdbeMemSetStr(pOut, z, n, enc, xDel); 388 if( rc ){ 389 if( rc==SQLITE_TOOBIG ){ 390 sqlite3_result_error_toobig(pCtx); 391 }else{ 392 /* The only errors possible from sqlite3VdbeMemSetStr are 393 ** SQLITE_TOOBIG and SQLITE_NOMEM */ 394 assert( rc==SQLITE_NOMEM ); 395 sqlite3_result_error_nomem(pCtx); 396 } 397 return; 398 } 399 sqlite3VdbeChangeEncoding(pOut, pCtx->enc); 400 if( sqlite3VdbeMemTooBig(pOut) ){ 401 sqlite3_result_error_toobig(pCtx); 402 } 403 } 404 static int invokeValueDestructor( 405 const void *p, /* Value to destroy */ 406 void (*xDel)(void*), /* The destructor */ 407 sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */ 408 ){ 409 assert( xDel!=SQLITE_DYNAMIC ); 410 if( xDel==0 ){ 411 /* noop */ 412 }else if( xDel==SQLITE_TRANSIENT ){ 413 /* noop */ 414 }else{ 415 xDel((void*)p); 416 } 417 sqlite3_result_error_toobig(pCtx); 418 return SQLITE_TOOBIG; 419 } 420 void sqlite3_result_blob( 421 sqlite3_context *pCtx, 422 const void *z, 423 int n, 424 void (*xDel)(void *) 425 ){ 426 assert( n>=0 ); 427 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 428 setResultStrOrError(pCtx, z, n, 0, xDel); 429 } 430 void sqlite3_result_blob64( 431 sqlite3_context *pCtx, 432 const void *z, 433 sqlite3_uint64 n, 434 void (*xDel)(void *) 435 ){ 436 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 437 assert( xDel!=SQLITE_DYNAMIC ); 438 if( n>0x7fffffff ){ 439 (void)invokeValueDestructor(z, xDel, pCtx); 440 }else{ 441 setResultStrOrError(pCtx, z, (int)n, 0, xDel); 442 } 443 } 444 void sqlite3_result_double(sqlite3_context *pCtx, double rVal){ 445 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 446 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal); 447 } 448 void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ 449 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 450 pCtx->isError = SQLITE_ERROR; 451 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT); 452 } 453 #ifndef SQLITE_OMIT_UTF16 454 void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){ 455 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 456 pCtx->isError = SQLITE_ERROR; 457 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT); 458 } 459 #endif 460 void sqlite3_result_int(sqlite3_context *pCtx, int iVal){ 461 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 462 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal); 463 } 464 void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){ 465 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 466 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal); 467 } 468 void sqlite3_result_null(sqlite3_context *pCtx){ 469 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 470 sqlite3VdbeMemSetNull(pCtx->pOut); 471 } 472 void sqlite3_result_pointer( 473 sqlite3_context *pCtx, 474 void *pPtr, 475 const char *zPType, 476 void (*xDestructor)(void*) 477 ){ 478 Mem *pOut = pCtx->pOut; 479 assert( sqlite3_mutex_held(pOut->db->mutex) ); 480 sqlite3VdbeMemRelease(pOut); 481 pOut->flags = MEM_Null; 482 sqlite3VdbeMemSetPointer(pOut, pPtr, zPType, xDestructor); 483 } 484 void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){ 485 Mem *pOut = pCtx->pOut; 486 assert( sqlite3_mutex_held(pOut->db->mutex) ); 487 pOut->eSubtype = eSubtype & 0xff; 488 pOut->flags |= MEM_Subtype; 489 } 490 void sqlite3_result_text( 491 sqlite3_context *pCtx, 492 const char *z, 493 int n, 494 void (*xDel)(void *) 495 ){ 496 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 497 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel); 498 } 499 void sqlite3_result_text64( 500 sqlite3_context *pCtx, 501 const char *z, 502 sqlite3_uint64 n, 503 void (*xDel)(void *), 504 unsigned char enc 505 ){ 506 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 507 assert( xDel!=SQLITE_DYNAMIC ); 508 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; 509 if( n>0x7fffffff ){ 510 (void)invokeValueDestructor(z, xDel, pCtx); 511 }else{ 512 setResultStrOrError(pCtx, z, (int)n, enc, xDel); 513 } 514 } 515 #ifndef SQLITE_OMIT_UTF16 516 void sqlite3_result_text16( 517 sqlite3_context *pCtx, 518 const void *z, 519 int n, 520 void (*xDel)(void *) 521 ){ 522 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 523 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel); 524 } 525 void sqlite3_result_text16be( 526 sqlite3_context *pCtx, 527 const void *z, 528 int n, 529 void (*xDel)(void *) 530 ){ 531 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 532 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel); 533 } 534 void sqlite3_result_text16le( 535 sqlite3_context *pCtx, 536 const void *z, 537 int n, 538 void (*xDel)(void *) 539 ){ 540 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 541 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel); 542 } 543 #endif /* SQLITE_OMIT_UTF16 */ 544 void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){ 545 Mem *pOut = pCtx->pOut; 546 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 547 sqlite3VdbeMemCopy(pOut, pValue); 548 sqlite3VdbeChangeEncoding(pOut, pCtx->enc); 549 if( sqlite3VdbeMemTooBig(pOut) ){ 550 sqlite3_result_error_toobig(pCtx); 551 } 552 } 553 void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){ 554 sqlite3_result_zeroblob64(pCtx, n>0 ? n : 0); 555 } 556 int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){ 557 Mem *pOut = pCtx->pOut; 558 assert( sqlite3_mutex_held(pOut->db->mutex) ); 559 if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){ 560 sqlite3_result_error_toobig(pCtx); 561 return SQLITE_TOOBIG; 562 } 563 #ifndef SQLITE_OMIT_INCRBLOB 564 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); 565 return SQLITE_OK; 566 #else 567 return sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); 568 #endif 569 } 570 void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){ 571 pCtx->isError = errCode ? errCode : -1; 572 #ifdef SQLITE_DEBUG 573 if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode; 574 #endif 575 if( pCtx->pOut->flags & MEM_Null ){ 576 setResultStrOrError(pCtx, sqlite3ErrStr(errCode), -1, SQLITE_UTF8, 577 SQLITE_STATIC); 578 } 579 } 580 581 /* Force an SQLITE_TOOBIG error. */ 582 void sqlite3_result_error_toobig(sqlite3_context *pCtx){ 583 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 584 pCtx->isError = SQLITE_TOOBIG; 585 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, 586 SQLITE_UTF8, SQLITE_STATIC); 587 } 588 589 /* An SQLITE_NOMEM error. */ 590 void sqlite3_result_error_nomem(sqlite3_context *pCtx){ 591 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 592 sqlite3VdbeMemSetNull(pCtx->pOut); 593 pCtx->isError = SQLITE_NOMEM_BKPT; 594 sqlite3OomFault(pCtx->pOut->db); 595 } 596 597 #ifndef SQLITE_UNTESTABLE 598 /* Force the INT64 value currently stored as the result to be 599 ** a MEM_IntReal value. See the SQLITE_TESTCTRL_RESULT_INTREAL 600 ** test-control. 601 */ 602 void sqlite3ResultIntReal(sqlite3_context *pCtx){ 603 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 604 if( pCtx->pOut->flags & MEM_Int ){ 605 pCtx->pOut->flags &= ~MEM_Int; 606 pCtx->pOut->flags |= MEM_IntReal; 607 } 608 } 609 #endif 610 611 612 /* 613 ** This function is called after a transaction has been committed. It 614 ** invokes callbacks registered with sqlite3_wal_hook() as required. 615 */ 616 static int doWalCallbacks(sqlite3 *db){ 617 int rc = SQLITE_OK; 618 #ifndef SQLITE_OMIT_WAL 619 int i; 620 for(i=0; i<db->nDb; i++){ 621 Btree *pBt = db->aDb[i].pBt; 622 if( pBt ){ 623 int nEntry; 624 sqlite3BtreeEnter(pBt); 625 nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt)); 626 sqlite3BtreeLeave(pBt); 627 if( nEntry>0 && db->xWalCallback && rc==SQLITE_OK ){ 628 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zDbSName, nEntry); 629 } 630 } 631 } 632 #endif 633 return rc; 634 } 635 636 637 /* 638 ** Execute the statement pStmt, either until a row of data is ready, the 639 ** statement is completely executed or an error occurs. 640 ** 641 ** This routine implements the bulk of the logic behind the sqlite_step() 642 ** API. The only thing omitted is the automatic recompile if a 643 ** schema change has occurred. That detail is handled by the 644 ** outer sqlite3_step() wrapper procedure. 645 */ 646 static int sqlite3Step(Vdbe *p){ 647 sqlite3 *db; 648 int rc; 649 650 assert(p); 651 db = p->db; 652 if( p->eVdbeState!=VDBE_RUN_STATE ){ 653 restart_step: 654 if( p->eVdbeState==VDBE_READY_STATE ){ 655 if( p->expired ){ 656 p->rc = SQLITE_SCHEMA; 657 rc = SQLITE_ERROR; 658 if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){ 659 /* If this statement was prepared using saved SQL and an 660 ** error has occurred, then return the error code in p->rc to the 661 ** caller. Set the error code in the database handle to the same 662 ** value. 663 */ 664 rc = sqlite3VdbeTransferError(p); 665 } 666 goto end_of_step; 667 } 668 669 /* If there are no other statements currently running, then 670 ** reset the interrupt flag. This prevents a call to sqlite3_interrupt 671 ** from interrupting a statement that has not yet started. 672 */ 673 if( db->nVdbeActive==0 ){ 674 AtomicStore(&db->u1.isInterrupted, 0); 675 } 676 677 assert( db->nVdbeWrite>0 || db->autoCommit==0 678 || (db->nDeferredCons==0 && db->nDeferredImmCons==0) 679 ); 680 681 #ifndef SQLITE_OMIT_TRACE 682 if( (db->mTrace & (SQLITE_TRACE_PROFILE|SQLITE_TRACE_XPROFILE))!=0 683 && !db->init.busy && p->zSql ){ 684 sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime); 685 }else{ 686 assert( p->startTime==0 ); 687 } 688 #endif 689 690 db->nVdbeActive++; 691 if( p->readOnly==0 ) db->nVdbeWrite++; 692 if( p->bIsReader ) db->nVdbeRead++; 693 p->pc = 0; 694 p->eVdbeState = VDBE_RUN_STATE; 695 }else 696 697 if( ALWAYS(p->eVdbeState==VDBE_HALT_STATE) ){ 698 /* We used to require that sqlite3_reset() be called before retrying 699 ** sqlite3_step() after any error or after SQLITE_DONE. But beginning 700 ** with version 3.7.0, we changed this so that sqlite3_reset() would 701 ** be called automatically instead of throwing the SQLITE_MISUSE error. 702 ** This "automatic-reset" change is not technically an incompatibility, 703 ** since any application that receives an SQLITE_MISUSE is broken by 704 ** definition. 705 ** 706 ** Nevertheless, some published applications that were originally written 707 ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE 708 ** returns, and those were broken by the automatic-reset change. As a 709 ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the 710 ** legacy behavior of returning SQLITE_MISUSE for cases where the 711 ** previous sqlite3_step() returned something other than a SQLITE_LOCKED 712 ** or SQLITE_BUSY error. 713 */ 714 #ifdef SQLITE_OMIT_AUTORESET 715 if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){ 716 sqlite3_reset((sqlite3_stmt*)p); 717 }else{ 718 return SQLITE_MISUSE_BKPT; 719 } 720 #else 721 sqlite3_reset((sqlite3_stmt*)p); 722 #endif 723 assert( p->eVdbeState==VDBE_READY_STATE ); 724 goto restart_step; 725 } 726 } 727 728 #ifdef SQLITE_DEBUG 729 p->rcApp = SQLITE_OK; 730 #endif 731 #ifndef SQLITE_OMIT_EXPLAIN 732 if( p->explain ){ 733 rc = sqlite3VdbeList(p); 734 }else 735 #endif /* SQLITE_OMIT_EXPLAIN */ 736 { 737 db->nVdbeExec++; 738 rc = sqlite3VdbeExec(p); 739 db->nVdbeExec--; 740 } 741 742 if( rc==SQLITE_ROW ){ 743 assert( p->rc==SQLITE_OK ); 744 assert( db->mallocFailed==0 ); 745 db->errCode = SQLITE_ROW; 746 return SQLITE_ROW; 747 }else{ 748 #ifndef SQLITE_OMIT_TRACE 749 /* If the statement completed successfully, invoke the profile callback */ 750 checkProfileCallback(db, p); 751 #endif 752 753 if( rc==SQLITE_DONE && db->autoCommit ){ 754 assert( p->rc==SQLITE_OK ); 755 p->rc = doWalCallbacks(db); 756 if( p->rc!=SQLITE_OK ){ 757 rc = SQLITE_ERROR; 758 } 759 }else if( rc!=SQLITE_DONE && (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ){ 760 /* If this statement was prepared using saved SQL and an 761 ** error has occurred, then return the error code in p->rc to the 762 ** caller. Set the error code in the database handle to the same value. 763 */ 764 rc = sqlite3VdbeTransferError(p); 765 } 766 } 767 768 db->errCode = rc; 769 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){ 770 p->rc = SQLITE_NOMEM_BKPT; 771 if( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 ) rc = p->rc; 772 } 773 end_of_step: 774 /* There are only a limited number of result codes allowed from the 775 ** statements prepared using the legacy sqlite3_prepare() interface */ 776 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 777 || rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR 778 || (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE 779 ); 780 return (rc&db->errMask); 781 } 782 783 /* 784 ** This is the top-level implementation of sqlite3_step(). Call 785 ** sqlite3Step() to do most of the work. If a schema error occurs, 786 ** call sqlite3Reprepare() and try again. 787 */ 788 int sqlite3_step(sqlite3_stmt *pStmt){ 789 int rc = SQLITE_OK; /* Result from sqlite3Step() */ 790 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */ 791 int cnt = 0; /* Counter to prevent infinite loop of reprepares */ 792 sqlite3 *db; /* The database connection */ 793 794 if( vdbeSafetyNotNull(v) ){ 795 return SQLITE_MISUSE_BKPT; 796 } 797 db = v->db; 798 sqlite3_mutex_enter(db->mutex); 799 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA 800 && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){ 801 int savedPc = v->pc; 802 rc = sqlite3Reprepare(v); 803 if( rc!=SQLITE_OK ){ 804 /* This case occurs after failing to recompile an sql statement. 805 ** The error message from the SQL compiler has already been loaded 806 ** into the database handle. This block copies the error message 807 ** from the database handle into the statement and sets the statement 808 ** program counter to 0 to ensure that when the statement is 809 ** finalized or reset the parser error message is available via 810 ** sqlite3_errmsg() and sqlite3_errcode(). 811 */ 812 const char *zErr = (const char *)sqlite3_value_text(db->pErr); 813 sqlite3DbFree(db, v->zErrMsg); 814 if( !db->mallocFailed ){ 815 v->zErrMsg = sqlite3DbStrDup(db, zErr); 816 v->rc = rc = sqlite3ApiExit(db, rc); 817 } else { 818 v->zErrMsg = 0; 819 v->rc = rc = SQLITE_NOMEM_BKPT; 820 } 821 break; 822 } 823 sqlite3_reset(pStmt); 824 if( savedPc>=0 ){ 825 /* Setting minWriteFileFormat to 254 is a signal to the OP_Init and 826 ** OP_Trace opcodes to *not* perform SQLITE_TRACE_STMT because it has 827 ** already been done once on a prior invocation that failed due to 828 ** SQLITE_SCHEMA. tag-20220401a */ 829 v->minWriteFileFormat = 254; 830 } 831 assert( v->expired==0 ); 832 } 833 sqlite3_mutex_leave(db->mutex); 834 return rc; 835 } 836 837 838 /* 839 ** Extract the user data from a sqlite3_context structure and return a 840 ** pointer to it. 841 */ 842 void *sqlite3_user_data(sqlite3_context *p){ 843 assert( p && p->pFunc ); 844 return p->pFunc->pUserData; 845 } 846 847 /* 848 ** Extract the user data from a sqlite3_context structure and return a 849 ** pointer to it. 850 ** 851 ** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface 852 ** returns a copy of the pointer to the database connection (the 1st 853 ** parameter) of the sqlite3_create_function() and 854 ** sqlite3_create_function16() routines that originally registered the 855 ** application defined function. 856 */ 857 sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){ 858 assert( p && p->pOut ); 859 return p->pOut->db; 860 } 861 862 /* 863 ** If this routine is invoked from within an xColumn method of a virtual 864 ** table, then it returns true if and only if the the call is during an 865 ** UPDATE operation and the value of the column will not be modified 866 ** by the UPDATE. 867 ** 868 ** If this routine is called from any context other than within the 869 ** xColumn method of a virtual table, then the return value is meaningless 870 ** and arbitrary. 871 ** 872 ** Virtual table implements might use this routine to optimize their 873 ** performance by substituting a NULL result, or some other light-weight 874 ** value, as a signal to the xUpdate routine that the column is unchanged. 875 */ 876 int sqlite3_vtab_nochange(sqlite3_context *p){ 877 assert( p ); 878 return sqlite3_value_nochange(p->pOut); 879 } 880 881 /* 882 ** Implementation of sqlite3_vtab_in_first() (if bNext==0) and 883 ** sqlite3_vtab_in_next() (if bNext!=0). 884 */ 885 static int valueFromValueList( 886 sqlite3_value *pVal, /* Pointer to the ValueList object */ 887 sqlite3_value **ppOut, /* Store the next value from the list here */ 888 int bNext /* 1 for _next(). 0 for _first() */ 889 ){ 890 int rc; 891 ValueList *pRhs; 892 893 *ppOut = 0; 894 if( pVal==0 ) return SQLITE_MISUSE; 895 pRhs = (ValueList*)sqlite3_value_pointer(pVal, "ValueList"); 896 if( pRhs==0 ) return SQLITE_MISUSE; 897 if( bNext ){ 898 rc = sqlite3BtreeNext(pRhs->pCsr, 0); 899 }else{ 900 int dummy = 0; 901 rc = sqlite3BtreeFirst(pRhs->pCsr, &dummy); 902 assert( rc==SQLITE_OK || sqlite3BtreeEof(pRhs->pCsr) ); 903 if( sqlite3BtreeEof(pRhs->pCsr) ) rc = SQLITE_DONE; 904 } 905 if( rc==SQLITE_OK ){ 906 u32 sz; /* Size of current row in bytes */ 907 Mem sMem; /* Raw content of current row */ 908 memset(&sMem, 0, sizeof(sMem)); 909 sz = sqlite3BtreePayloadSize(pRhs->pCsr); 910 rc = sqlite3VdbeMemFromBtreeZeroOffset(pRhs->pCsr,(int)sz,&sMem); 911 if( rc==SQLITE_OK ){ 912 u8 *zBuf = (u8*)sMem.z; 913 u32 iSerial; 914 sqlite3_value *pOut = pRhs->pOut; 915 int iOff = 1 + getVarint32(&zBuf[1], iSerial); 916 sqlite3VdbeSerialGet(&zBuf[iOff], iSerial, pOut); 917 pOut->enc = ENC(pOut->db); 918 if( (pOut->flags & MEM_Ephem)!=0 && sqlite3VdbeMemMakeWriteable(pOut) ){ 919 rc = SQLITE_NOMEM; 920 }else{ 921 *ppOut = pOut; 922 } 923 } 924 sqlite3VdbeMemRelease(&sMem); 925 } 926 return rc; 927 } 928 929 /* 930 ** Set the iterator value pVal to point to the first value in the set. 931 ** Set (*ppOut) to point to this value before returning. 932 */ 933 int sqlite3_vtab_in_first(sqlite3_value *pVal, sqlite3_value **ppOut){ 934 return valueFromValueList(pVal, ppOut, 0); 935 } 936 937 /* 938 ** Set the iterator value pVal to point to the next value in the set. 939 ** Set (*ppOut) to point to this value before returning. 940 */ 941 int sqlite3_vtab_in_next(sqlite3_value *pVal, sqlite3_value **ppOut){ 942 return valueFromValueList(pVal, ppOut, 1); 943 } 944 945 /* 946 ** Return the current time for a statement. If the current time 947 ** is requested more than once within the same run of a single prepared 948 ** statement, the exact same time is returned for each invocation regardless 949 ** of the amount of time that elapses between invocations. In other words, 950 ** the time returned is always the time of the first call. 951 */ 952 sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){ 953 int rc; 954 #ifndef SQLITE_ENABLE_STAT4 955 sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime; 956 assert( p->pVdbe!=0 ); 957 #else 958 sqlite3_int64 iTime = 0; 959 sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime; 960 #endif 961 if( *piTime==0 ){ 962 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime); 963 if( rc ) *piTime = 0; 964 } 965 return *piTime; 966 } 967 968 /* 969 ** Create a new aggregate context for p and return a pointer to 970 ** its pMem->z element. 971 */ 972 static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){ 973 Mem *pMem = p->pMem; 974 assert( (pMem->flags & MEM_Agg)==0 ); 975 if( nByte<=0 ){ 976 sqlite3VdbeMemSetNull(pMem); 977 pMem->z = 0; 978 }else{ 979 sqlite3VdbeMemClearAndResize(pMem, nByte); 980 pMem->flags = MEM_Agg; 981 pMem->u.pDef = p->pFunc; 982 if( pMem->z ){ 983 memset(pMem->z, 0, nByte); 984 } 985 } 986 return (void*)pMem->z; 987 } 988 989 /* 990 ** Allocate or return the aggregate context for a user function. A new 991 ** context is allocated on the first call. Subsequent calls return the 992 ** same context that was returned on prior calls. 993 */ 994 void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){ 995 assert( p && p->pFunc && p->pFunc->xFinalize ); 996 assert( sqlite3_mutex_held(p->pOut->db->mutex) ); 997 testcase( nByte<0 ); 998 if( (p->pMem->flags & MEM_Agg)==0 ){ 999 return createAggContext(p, nByte); 1000 }else{ 1001 return (void*)p->pMem->z; 1002 } 1003 } 1004 1005 /* 1006 ** Return the auxiliary data pointer, if any, for the iArg'th argument to 1007 ** the user-function defined by pCtx. 1008 ** 1009 ** The left-most argument is 0. 1010 ** 1011 ** Undocumented behavior: If iArg is negative then access a cache of 1012 ** auxiliary data pointers that is available to all functions within a 1013 ** single prepared statement. The iArg values must match. 1014 */ 1015 void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){ 1016 AuxData *pAuxData; 1017 1018 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 1019 #if SQLITE_ENABLE_STAT4 1020 if( pCtx->pVdbe==0 ) return 0; 1021 #else 1022 assert( pCtx->pVdbe!=0 ); 1023 #endif 1024 for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){ 1025 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){ 1026 return pAuxData->pAux; 1027 } 1028 } 1029 return 0; 1030 } 1031 1032 /* 1033 ** Set the auxiliary data pointer and delete function, for the iArg'th 1034 ** argument to the user-function defined by pCtx. Any previous value is 1035 ** deleted by calling the delete function specified when it was set. 1036 ** 1037 ** The left-most argument is 0. 1038 ** 1039 ** Undocumented behavior: If iArg is negative then make the data available 1040 ** to all functions within the current prepared statement using iArg as an 1041 ** access code. 1042 */ 1043 void sqlite3_set_auxdata( 1044 sqlite3_context *pCtx, 1045 int iArg, 1046 void *pAux, 1047 void (*xDelete)(void*) 1048 ){ 1049 AuxData *pAuxData; 1050 Vdbe *pVdbe = pCtx->pVdbe; 1051 1052 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); 1053 #ifdef SQLITE_ENABLE_STAT4 1054 if( pVdbe==0 ) goto failed; 1055 #else 1056 assert( pVdbe!=0 ); 1057 #endif 1058 1059 for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNextAux){ 1060 if( pAuxData->iAuxArg==iArg && (pAuxData->iAuxOp==pCtx->iOp || iArg<0) ){ 1061 break; 1062 } 1063 } 1064 if( pAuxData==0 ){ 1065 pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData)); 1066 if( !pAuxData ) goto failed; 1067 pAuxData->iAuxOp = pCtx->iOp; 1068 pAuxData->iAuxArg = iArg; 1069 pAuxData->pNextAux = pVdbe->pAuxData; 1070 pVdbe->pAuxData = pAuxData; 1071 if( pCtx->isError==0 ) pCtx->isError = -1; 1072 }else if( pAuxData->xDeleteAux ){ 1073 pAuxData->xDeleteAux(pAuxData->pAux); 1074 } 1075 1076 pAuxData->pAux = pAux; 1077 pAuxData->xDeleteAux = xDelete; 1078 return; 1079 1080 failed: 1081 if( xDelete ){ 1082 xDelete(pAux); 1083 } 1084 } 1085 1086 #ifndef SQLITE_OMIT_DEPRECATED 1087 /* 1088 ** Return the number of times the Step function of an aggregate has been 1089 ** called. 1090 ** 1091 ** This function is deprecated. Do not use it for new code. It is 1092 ** provide only to avoid breaking legacy code. New aggregate function 1093 ** implementations should keep their own counts within their aggregate 1094 ** context. 1095 */ 1096 int sqlite3_aggregate_count(sqlite3_context *p){ 1097 assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize ); 1098 return p->pMem->n; 1099 } 1100 #endif 1101 1102 /* 1103 ** Return the number of columns in the result set for the statement pStmt. 1104 */ 1105 int sqlite3_column_count(sqlite3_stmt *pStmt){ 1106 Vdbe *pVm = (Vdbe *)pStmt; 1107 return pVm ? pVm->nResColumn : 0; 1108 } 1109 1110 /* 1111 ** Return the number of values available from the current row of the 1112 ** currently executing statement pStmt. 1113 */ 1114 int sqlite3_data_count(sqlite3_stmt *pStmt){ 1115 Vdbe *pVm = (Vdbe *)pStmt; 1116 if( pVm==0 || pVm->pResultSet==0 ) return 0; 1117 return pVm->nResColumn; 1118 } 1119 1120 /* 1121 ** Return a pointer to static memory containing an SQL NULL value. 1122 */ 1123 static const Mem *columnNullValue(void){ 1124 /* Even though the Mem structure contains an element 1125 ** of type i64, on certain architectures (x86) with certain compiler 1126 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary 1127 ** instead of an 8-byte one. This all works fine, except that when 1128 ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s 1129 ** that a Mem structure is located on an 8-byte boundary. To prevent 1130 ** these assert()s from failing, when building with SQLITE_DEBUG defined 1131 ** using gcc, we force nullMem to be 8-byte aligned using the magical 1132 ** __attribute__((aligned(8))) macro. */ 1133 static const Mem nullMem 1134 #if defined(SQLITE_DEBUG) && defined(__GNUC__) 1135 __attribute__((aligned(8))) 1136 #endif 1137 = { 1138 /* .u = */ {0}, 1139 /* .z = */ (char*)0, 1140 /* .n = */ (int)0, 1141 /* .flags = */ (u16)MEM_Null, 1142 /* .enc = */ (u8)0, 1143 /* .eSubtype = */ (u8)0, 1144 /* .db = */ (sqlite3*)0, 1145 /* .szMalloc = */ (int)0, 1146 /* .uTemp = */ (u32)0, 1147 /* .zMalloc = */ (char*)0, 1148 /* .xDel = */ (void(*)(void*))0, 1149 #ifdef SQLITE_DEBUG 1150 /* .pScopyFrom = */ (Mem*)0, 1151 /* .mScopyFlags= */ 0, 1152 #endif 1153 }; 1154 return &nullMem; 1155 } 1156 1157 /* 1158 ** Check to see if column iCol of the given statement is valid. If 1159 ** it is, return a pointer to the Mem for the value of that column. 1160 ** If iCol is not valid, return a pointer to a Mem which has a value 1161 ** of NULL. 1162 */ 1163 static Mem *columnMem(sqlite3_stmt *pStmt, int i){ 1164 Vdbe *pVm; 1165 Mem *pOut; 1166 1167 pVm = (Vdbe *)pStmt; 1168 if( pVm==0 ) return (Mem*)columnNullValue(); 1169 assert( pVm->db ); 1170 sqlite3_mutex_enter(pVm->db->mutex); 1171 if( pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){ 1172 pOut = &pVm->pResultSet[i]; 1173 }else{ 1174 sqlite3Error(pVm->db, SQLITE_RANGE); 1175 pOut = (Mem*)columnNullValue(); 1176 } 1177 return pOut; 1178 } 1179 1180 /* 1181 ** This function is called after invoking an sqlite3_value_XXX function on a 1182 ** column value (i.e. a value returned by evaluating an SQL expression in the 1183 ** select list of a SELECT statement) that may cause a malloc() failure. If 1184 ** malloc() has failed, the threads mallocFailed flag is cleared and the result 1185 ** code of statement pStmt set to SQLITE_NOMEM. 1186 ** 1187 ** Specifically, this is called from within: 1188 ** 1189 ** sqlite3_column_int() 1190 ** sqlite3_column_int64() 1191 ** sqlite3_column_text() 1192 ** sqlite3_column_text16() 1193 ** sqlite3_column_real() 1194 ** sqlite3_column_bytes() 1195 ** sqlite3_column_bytes16() 1196 ** sqiite3_column_blob() 1197 */ 1198 static void columnMallocFailure(sqlite3_stmt *pStmt) 1199 { 1200 /* If malloc() failed during an encoding conversion within an 1201 ** sqlite3_column_XXX API, then set the return code of the statement to 1202 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR 1203 ** and _finalize() will return NOMEM. 1204 */ 1205 Vdbe *p = (Vdbe *)pStmt; 1206 if( p ){ 1207 assert( p->db!=0 ); 1208 assert( sqlite3_mutex_held(p->db->mutex) ); 1209 p->rc = sqlite3ApiExit(p->db, p->rc); 1210 sqlite3_mutex_leave(p->db->mutex); 1211 } 1212 } 1213 1214 /**************************** sqlite3_column_ ******************************* 1215 ** The following routines are used to access elements of the current row 1216 ** in the result set. 1217 */ 1218 const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){ 1219 const void *val; 1220 val = sqlite3_value_blob( columnMem(pStmt,i) ); 1221 /* Even though there is no encoding conversion, value_blob() might 1222 ** need to call malloc() to expand the result of a zeroblob() 1223 ** expression. 1224 */ 1225 columnMallocFailure(pStmt); 1226 return val; 1227 } 1228 int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){ 1229 int val = sqlite3_value_bytes( columnMem(pStmt,i) ); 1230 columnMallocFailure(pStmt); 1231 return val; 1232 } 1233 int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){ 1234 int val = sqlite3_value_bytes16( columnMem(pStmt,i) ); 1235 columnMallocFailure(pStmt); 1236 return val; 1237 } 1238 double sqlite3_column_double(sqlite3_stmt *pStmt, int i){ 1239 double val = sqlite3_value_double( columnMem(pStmt,i) ); 1240 columnMallocFailure(pStmt); 1241 return val; 1242 } 1243 int sqlite3_column_int(sqlite3_stmt *pStmt, int i){ 1244 int val = sqlite3_value_int( columnMem(pStmt,i) ); 1245 columnMallocFailure(pStmt); 1246 return val; 1247 } 1248 sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){ 1249 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) ); 1250 columnMallocFailure(pStmt); 1251 return val; 1252 } 1253 const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){ 1254 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) ); 1255 columnMallocFailure(pStmt); 1256 return val; 1257 } 1258 sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){ 1259 Mem *pOut = columnMem(pStmt, i); 1260 if( pOut->flags&MEM_Static ){ 1261 pOut->flags &= ~MEM_Static; 1262 pOut->flags |= MEM_Ephem; 1263 } 1264 columnMallocFailure(pStmt); 1265 return (sqlite3_value *)pOut; 1266 } 1267 #ifndef SQLITE_OMIT_UTF16 1268 const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){ 1269 const void *val = sqlite3_value_text16( columnMem(pStmt,i) ); 1270 columnMallocFailure(pStmt); 1271 return val; 1272 } 1273 #endif /* SQLITE_OMIT_UTF16 */ 1274 int sqlite3_column_type(sqlite3_stmt *pStmt, int i){ 1275 int iType = sqlite3_value_type( columnMem(pStmt,i) ); 1276 columnMallocFailure(pStmt); 1277 return iType; 1278 } 1279 1280 /* 1281 ** Convert the N-th element of pStmt->pColName[] into a string using 1282 ** xFunc() then return that string. If N is out of range, return 0. 1283 ** 1284 ** There are up to 5 names for each column. useType determines which 1285 ** name is returned. Here are the names: 1286 ** 1287 ** 0 The column name as it should be displayed for output 1288 ** 1 The datatype name for the column 1289 ** 2 The name of the database that the column derives from 1290 ** 3 The name of the table that the column derives from 1291 ** 4 The name of the table column that the result column derives from 1292 ** 1293 ** If the result is not a simple column reference (if it is an expression 1294 ** or a constant) then useTypes 2, 3, and 4 return NULL. 1295 */ 1296 static const void *columnName( 1297 sqlite3_stmt *pStmt, /* The statement */ 1298 int N, /* Which column to get the name for */ 1299 int useUtf16, /* True to return the name as UTF16 */ 1300 int useType /* What type of name */ 1301 ){ 1302 const void *ret; 1303 Vdbe *p; 1304 int n; 1305 sqlite3 *db; 1306 #ifdef SQLITE_ENABLE_API_ARMOR 1307 if( pStmt==0 ){ 1308 (void)SQLITE_MISUSE_BKPT; 1309 return 0; 1310 } 1311 #endif 1312 ret = 0; 1313 p = (Vdbe *)pStmt; 1314 db = p->db; 1315 assert( db!=0 ); 1316 n = sqlite3_column_count(pStmt); 1317 if( N<n && N>=0 ){ 1318 N += useType*n; 1319 sqlite3_mutex_enter(db->mutex); 1320 assert( db->mallocFailed==0 ); 1321 #ifndef SQLITE_OMIT_UTF16 1322 if( useUtf16 ){ 1323 ret = sqlite3_value_text16((sqlite3_value*)&p->aColName[N]); 1324 }else 1325 #endif 1326 { 1327 ret = sqlite3_value_text((sqlite3_value*)&p->aColName[N]); 1328 } 1329 /* A malloc may have failed inside of the _text() call. If this 1330 ** is the case, clear the mallocFailed flag and return NULL. 1331 */ 1332 if( db->mallocFailed ){ 1333 sqlite3OomClear(db); 1334 ret = 0; 1335 } 1336 sqlite3_mutex_leave(db->mutex); 1337 } 1338 return ret; 1339 } 1340 1341 /* 1342 ** Return the name of the Nth column of the result set returned by SQL 1343 ** statement pStmt. 1344 */ 1345 const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){ 1346 return columnName(pStmt, N, 0, COLNAME_NAME); 1347 } 1348 #ifndef SQLITE_OMIT_UTF16 1349 const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){ 1350 return columnName(pStmt, N, 1, COLNAME_NAME); 1351 } 1352 #endif 1353 1354 /* 1355 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must 1356 ** not define OMIT_DECLTYPE. 1357 */ 1358 #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA) 1359 # error "Must not define both SQLITE_OMIT_DECLTYPE \ 1360 and SQLITE_ENABLE_COLUMN_METADATA" 1361 #endif 1362 1363 #ifndef SQLITE_OMIT_DECLTYPE 1364 /* 1365 ** Return the column declaration type (if applicable) of the 'i'th column 1366 ** of the result set of SQL statement pStmt. 1367 */ 1368 const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){ 1369 return columnName(pStmt, N, 0, COLNAME_DECLTYPE); 1370 } 1371 #ifndef SQLITE_OMIT_UTF16 1372 const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){ 1373 return columnName(pStmt, N, 1, COLNAME_DECLTYPE); 1374 } 1375 #endif /* SQLITE_OMIT_UTF16 */ 1376 #endif /* SQLITE_OMIT_DECLTYPE */ 1377 1378 #ifdef SQLITE_ENABLE_COLUMN_METADATA 1379 /* 1380 ** Return the name of the database from which a result column derives. 1381 ** NULL is returned if the result column is an expression or constant or 1382 ** anything else which is not an unambiguous reference to a database column. 1383 */ 1384 const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){ 1385 return columnName(pStmt, N, 0, COLNAME_DATABASE); 1386 } 1387 #ifndef SQLITE_OMIT_UTF16 1388 const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){ 1389 return columnName(pStmt, N, 1, COLNAME_DATABASE); 1390 } 1391 #endif /* SQLITE_OMIT_UTF16 */ 1392 1393 /* 1394 ** Return the name of the table from which a result column derives. 1395 ** NULL is returned if the result column is an expression or constant or 1396 ** anything else which is not an unambiguous reference to a database column. 1397 */ 1398 const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){ 1399 return columnName(pStmt, N, 0, COLNAME_TABLE); 1400 } 1401 #ifndef SQLITE_OMIT_UTF16 1402 const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){ 1403 return columnName(pStmt, N, 1, COLNAME_TABLE); 1404 } 1405 #endif /* SQLITE_OMIT_UTF16 */ 1406 1407 /* 1408 ** Return the name of the table column from which a result column derives. 1409 ** NULL is returned if the result column is an expression or constant or 1410 ** anything else which is not an unambiguous reference to a database column. 1411 */ 1412 const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){ 1413 return columnName(pStmt, N, 0, COLNAME_COLUMN); 1414 } 1415 #ifndef SQLITE_OMIT_UTF16 1416 const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){ 1417 return columnName(pStmt, N, 1, COLNAME_COLUMN); 1418 } 1419 #endif /* SQLITE_OMIT_UTF16 */ 1420 #endif /* SQLITE_ENABLE_COLUMN_METADATA */ 1421 1422 1423 /******************************* sqlite3_bind_ *************************** 1424 ** 1425 ** Routines used to attach values to wildcards in a compiled SQL statement. 1426 */ 1427 /* 1428 ** Unbind the value bound to variable i in virtual machine p. This is the 1429 ** the same as binding a NULL value to the column. If the "i" parameter is 1430 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK. 1431 ** 1432 ** A successful evaluation of this routine acquires the mutex on p. 1433 ** the mutex is released if any kind of error occurs. 1434 ** 1435 ** The error code stored in database p->db is overwritten with the return 1436 ** value in any case. 1437 */ 1438 static int vdbeUnbind(Vdbe *p, unsigned int i){ 1439 Mem *pVar; 1440 if( vdbeSafetyNotNull(p) ){ 1441 return SQLITE_MISUSE_BKPT; 1442 } 1443 sqlite3_mutex_enter(p->db->mutex); 1444 if( p->eVdbeState!=VDBE_READY_STATE ){ 1445 sqlite3Error(p->db, SQLITE_MISUSE); 1446 sqlite3_mutex_leave(p->db->mutex); 1447 sqlite3_log(SQLITE_MISUSE, 1448 "bind on a busy prepared statement: [%s]", p->zSql); 1449 return SQLITE_MISUSE_BKPT; 1450 } 1451 if( i>=(unsigned int)p->nVar ){ 1452 sqlite3Error(p->db, SQLITE_RANGE); 1453 sqlite3_mutex_leave(p->db->mutex); 1454 return SQLITE_RANGE; 1455 } 1456 pVar = &p->aVar[i]; 1457 sqlite3VdbeMemRelease(pVar); 1458 pVar->flags = MEM_Null; 1459 p->db->errCode = SQLITE_OK; 1460 1461 /* If the bit corresponding to this variable in Vdbe.expmask is set, then 1462 ** binding a new value to this variable invalidates the current query plan. 1463 ** 1464 ** IMPLEMENTATION-OF: R-57496-20354 If the specific value bound to a host 1465 ** parameter in the WHERE clause might influence the choice of query plan 1466 ** for a statement, then the statement will be automatically recompiled, 1467 ** as if there had been a schema change, on the first sqlite3_step() call 1468 ** following any change to the bindings of that parameter. 1469 */ 1470 assert( (p->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || p->expmask==0 ); 1471 if( p->expmask!=0 && (p->expmask & (i>=31 ? 0x80000000 : (u32)1<<i))!=0 ){ 1472 p->expired = 1; 1473 } 1474 return SQLITE_OK; 1475 } 1476 1477 /* 1478 ** Bind a text or BLOB value. 1479 */ 1480 static int bindText( 1481 sqlite3_stmt *pStmt, /* The statement to bind against */ 1482 int i, /* Index of the parameter to bind */ 1483 const void *zData, /* Pointer to the data to be bound */ 1484 i64 nData, /* Number of bytes of data to be bound */ 1485 void (*xDel)(void*), /* Destructor for the data */ 1486 u8 encoding /* Encoding for the data */ 1487 ){ 1488 Vdbe *p = (Vdbe *)pStmt; 1489 Mem *pVar; 1490 int rc; 1491 1492 rc = vdbeUnbind(p, (u32)(i-1)); 1493 if( rc==SQLITE_OK ){ 1494 if( zData!=0 ){ 1495 pVar = &p->aVar[i-1]; 1496 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel); 1497 if( rc==SQLITE_OK && encoding!=0 ){ 1498 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db)); 1499 } 1500 if( rc ){ 1501 sqlite3Error(p->db, rc); 1502 rc = sqlite3ApiExit(p->db, rc); 1503 } 1504 } 1505 sqlite3_mutex_leave(p->db->mutex); 1506 }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){ 1507 xDel((void*)zData); 1508 } 1509 return rc; 1510 } 1511 1512 1513 /* 1514 ** Bind a blob value to an SQL statement variable. 1515 */ 1516 int sqlite3_bind_blob( 1517 sqlite3_stmt *pStmt, 1518 int i, 1519 const void *zData, 1520 int nData, 1521 void (*xDel)(void*) 1522 ){ 1523 #ifdef SQLITE_ENABLE_API_ARMOR 1524 if( nData<0 ) return SQLITE_MISUSE_BKPT; 1525 #endif 1526 return bindText(pStmt, i, zData, nData, xDel, 0); 1527 } 1528 int sqlite3_bind_blob64( 1529 sqlite3_stmt *pStmt, 1530 int i, 1531 const void *zData, 1532 sqlite3_uint64 nData, 1533 void (*xDel)(void*) 1534 ){ 1535 assert( xDel!=SQLITE_DYNAMIC ); 1536 return bindText(pStmt, i, zData, nData, xDel, 0); 1537 } 1538 int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){ 1539 int rc; 1540 Vdbe *p = (Vdbe *)pStmt; 1541 rc = vdbeUnbind(p, (u32)(i-1)); 1542 if( rc==SQLITE_OK ){ 1543 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue); 1544 sqlite3_mutex_leave(p->db->mutex); 1545 } 1546 return rc; 1547 } 1548 int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){ 1549 return sqlite3_bind_int64(p, i, (i64)iValue); 1550 } 1551 int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){ 1552 int rc; 1553 Vdbe *p = (Vdbe *)pStmt; 1554 rc = vdbeUnbind(p, (u32)(i-1)); 1555 if( rc==SQLITE_OK ){ 1556 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue); 1557 sqlite3_mutex_leave(p->db->mutex); 1558 } 1559 return rc; 1560 } 1561 int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){ 1562 int rc; 1563 Vdbe *p = (Vdbe*)pStmt; 1564 rc = vdbeUnbind(p, (u32)(i-1)); 1565 if( rc==SQLITE_OK ){ 1566 sqlite3_mutex_leave(p->db->mutex); 1567 } 1568 return rc; 1569 } 1570 int sqlite3_bind_pointer( 1571 sqlite3_stmt *pStmt, 1572 int i, 1573 void *pPtr, 1574 const char *zPTtype, 1575 void (*xDestructor)(void*) 1576 ){ 1577 int rc; 1578 Vdbe *p = (Vdbe*)pStmt; 1579 rc = vdbeUnbind(p, (u32)(i-1)); 1580 if( rc==SQLITE_OK ){ 1581 sqlite3VdbeMemSetPointer(&p->aVar[i-1], pPtr, zPTtype, xDestructor); 1582 sqlite3_mutex_leave(p->db->mutex); 1583 }else if( xDestructor ){ 1584 xDestructor(pPtr); 1585 } 1586 return rc; 1587 } 1588 int sqlite3_bind_text( 1589 sqlite3_stmt *pStmt, 1590 int i, 1591 const char *zData, 1592 int nData, 1593 void (*xDel)(void*) 1594 ){ 1595 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8); 1596 } 1597 int sqlite3_bind_text64( 1598 sqlite3_stmt *pStmt, 1599 int i, 1600 const char *zData, 1601 sqlite3_uint64 nData, 1602 void (*xDel)(void*), 1603 unsigned char enc 1604 ){ 1605 assert( xDel!=SQLITE_DYNAMIC ); 1606 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; 1607 return bindText(pStmt, i, zData, nData, xDel, enc); 1608 } 1609 #ifndef SQLITE_OMIT_UTF16 1610 int sqlite3_bind_text16( 1611 sqlite3_stmt *pStmt, 1612 int i, 1613 const void *zData, 1614 int nData, 1615 void (*xDel)(void*) 1616 ){ 1617 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE); 1618 } 1619 #endif /* SQLITE_OMIT_UTF16 */ 1620 int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){ 1621 int rc; 1622 switch( sqlite3_value_type((sqlite3_value*)pValue) ){ 1623 case SQLITE_INTEGER: { 1624 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i); 1625 break; 1626 } 1627 case SQLITE_FLOAT: { 1628 assert( pValue->flags & (MEM_Real|MEM_IntReal) ); 1629 rc = sqlite3_bind_double(pStmt, i, 1630 (pValue->flags & MEM_Real) ? pValue->u.r : (double)pValue->u.i 1631 ); 1632 break; 1633 } 1634 case SQLITE_BLOB: { 1635 if( pValue->flags & MEM_Zero ){ 1636 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero); 1637 }else{ 1638 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT); 1639 } 1640 break; 1641 } 1642 case SQLITE_TEXT: { 1643 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT, 1644 pValue->enc); 1645 break; 1646 } 1647 default: { 1648 rc = sqlite3_bind_null(pStmt, i); 1649 break; 1650 } 1651 } 1652 return rc; 1653 } 1654 int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){ 1655 int rc; 1656 Vdbe *p = (Vdbe *)pStmt; 1657 rc = vdbeUnbind(p, (u32)(i-1)); 1658 if( rc==SQLITE_OK ){ 1659 #ifndef SQLITE_OMIT_INCRBLOB 1660 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); 1661 #else 1662 rc = sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); 1663 #endif 1664 sqlite3_mutex_leave(p->db->mutex); 1665 } 1666 return rc; 1667 } 1668 int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){ 1669 int rc; 1670 Vdbe *p = (Vdbe *)pStmt; 1671 sqlite3_mutex_enter(p->db->mutex); 1672 if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){ 1673 rc = SQLITE_TOOBIG; 1674 }else{ 1675 assert( (n & 0x7FFFFFFF)==n ); 1676 rc = sqlite3_bind_zeroblob(pStmt, i, n); 1677 } 1678 rc = sqlite3ApiExit(p->db, rc); 1679 sqlite3_mutex_leave(p->db->mutex); 1680 return rc; 1681 } 1682 1683 /* 1684 ** Return the number of wildcards that can be potentially bound to. 1685 ** This routine is added to support DBD::SQLite. 1686 */ 1687 int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){ 1688 Vdbe *p = (Vdbe*)pStmt; 1689 return p ? p->nVar : 0; 1690 } 1691 1692 /* 1693 ** Return the name of a wildcard parameter. Return NULL if the index 1694 ** is out of range or if the wildcard is unnamed. 1695 ** 1696 ** The result is always UTF-8. 1697 */ 1698 const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){ 1699 Vdbe *p = (Vdbe*)pStmt; 1700 if( p==0 ) return 0; 1701 return sqlite3VListNumToName(p->pVList, i); 1702 } 1703 1704 /* 1705 ** Given a wildcard parameter name, return the index of the variable 1706 ** with that name. If there is no variable with the given name, 1707 ** return 0. 1708 */ 1709 int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){ 1710 if( p==0 || zName==0 ) return 0; 1711 return sqlite3VListNameToNum(p->pVList, zName, nName); 1712 } 1713 int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){ 1714 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName)); 1715 } 1716 1717 /* 1718 ** Transfer all bindings from the first statement over to the second. 1719 */ 1720 int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ 1721 Vdbe *pFrom = (Vdbe*)pFromStmt; 1722 Vdbe *pTo = (Vdbe*)pToStmt; 1723 int i; 1724 assert( pTo->db==pFrom->db ); 1725 assert( pTo->nVar==pFrom->nVar ); 1726 sqlite3_mutex_enter(pTo->db->mutex); 1727 for(i=0; i<pFrom->nVar; i++){ 1728 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]); 1729 } 1730 sqlite3_mutex_leave(pTo->db->mutex); 1731 return SQLITE_OK; 1732 } 1733 1734 #ifndef SQLITE_OMIT_DEPRECATED 1735 /* 1736 ** Deprecated external interface. Internal/core SQLite code 1737 ** should call sqlite3TransferBindings. 1738 ** 1739 ** It is misuse to call this routine with statements from different 1740 ** database connections. But as this is a deprecated interface, we 1741 ** will not bother to check for that condition. 1742 ** 1743 ** If the two statements contain a different number of bindings, then 1744 ** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise 1745 ** SQLITE_OK is returned. 1746 */ 1747 int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ 1748 Vdbe *pFrom = (Vdbe*)pFromStmt; 1749 Vdbe *pTo = (Vdbe*)pToStmt; 1750 if( pFrom->nVar!=pTo->nVar ){ 1751 return SQLITE_ERROR; 1752 } 1753 assert( (pTo->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pTo->expmask==0 ); 1754 if( pTo->expmask ){ 1755 pTo->expired = 1; 1756 } 1757 assert( (pFrom->prepFlags & SQLITE_PREPARE_SAVESQL)!=0 || pFrom->expmask==0 ); 1758 if( pFrom->expmask ){ 1759 pFrom->expired = 1; 1760 } 1761 return sqlite3TransferBindings(pFromStmt, pToStmt); 1762 } 1763 #endif 1764 1765 /* 1766 ** Return the sqlite3* database handle to which the prepared statement given 1767 ** in the argument belongs. This is the same database handle that was 1768 ** the first argument to the sqlite3_prepare() that was used to create 1769 ** the statement in the first place. 1770 */ 1771 sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){ 1772 return pStmt ? ((Vdbe*)pStmt)->db : 0; 1773 } 1774 1775 /* 1776 ** Return true if the prepared statement is guaranteed to not modify the 1777 ** database. 1778 */ 1779 int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){ 1780 return pStmt ? ((Vdbe*)pStmt)->readOnly : 1; 1781 } 1782 1783 /* 1784 ** Return 1 if the statement is an EXPLAIN and return 2 if the 1785 ** statement is an EXPLAIN QUERY PLAN 1786 */ 1787 int sqlite3_stmt_isexplain(sqlite3_stmt *pStmt){ 1788 return pStmt ? ((Vdbe*)pStmt)->explain : 0; 1789 } 1790 1791 /* 1792 ** Return true if the prepared statement is in need of being reset. 1793 */ 1794 int sqlite3_stmt_busy(sqlite3_stmt *pStmt){ 1795 Vdbe *v = (Vdbe*)pStmt; 1796 return v!=0 && v->eVdbeState==VDBE_RUN_STATE; 1797 } 1798 1799 /* 1800 ** Return a pointer to the next prepared statement after pStmt associated 1801 ** with database connection pDb. If pStmt is NULL, return the first 1802 ** prepared statement for the database connection. Return NULL if there 1803 ** are no more. 1804 */ 1805 sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){ 1806 sqlite3_stmt *pNext; 1807 #ifdef SQLITE_ENABLE_API_ARMOR 1808 if( !sqlite3SafetyCheckOk(pDb) ){ 1809 (void)SQLITE_MISUSE_BKPT; 1810 return 0; 1811 } 1812 #endif 1813 sqlite3_mutex_enter(pDb->mutex); 1814 if( pStmt==0 ){ 1815 pNext = (sqlite3_stmt*)pDb->pVdbe; 1816 }else{ 1817 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pVNext; 1818 } 1819 sqlite3_mutex_leave(pDb->mutex); 1820 return pNext; 1821 } 1822 1823 /* 1824 ** Return the value of a status counter for a prepared statement 1825 */ 1826 int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){ 1827 Vdbe *pVdbe = (Vdbe*)pStmt; 1828 u32 v; 1829 #ifdef SQLITE_ENABLE_API_ARMOR 1830 if( !pStmt 1831 || (op!=SQLITE_STMTSTATUS_MEMUSED && (op<0||op>=ArraySize(pVdbe->aCounter))) 1832 ){ 1833 (void)SQLITE_MISUSE_BKPT; 1834 return 0; 1835 } 1836 #endif 1837 if( op==SQLITE_STMTSTATUS_MEMUSED ){ 1838 sqlite3 *db = pVdbe->db; 1839 sqlite3_mutex_enter(db->mutex); 1840 v = 0; 1841 db->pnBytesFreed = (int*)&v; 1842 assert( db->lookaside.pEnd==db->lookaside.pTrueEnd ); 1843 db->lookaside.pEnd = db->lookaside.pStart; 1844 sqlite3VdbeDelete(pVdbe); 1845 db->pnBytesFreed = 0; 1846 db->lookaside.pEnd = db->lookaside.pTrueEnd; 1847 sqlite3_mutex_leave(db->mutex); 1848 }else{ 1849 v = pVdbe->aCounter[op]; 1850 if( resetFlag ) pVdbe->aCounter[op] = 0; 1851 } 1852 return (int)v; 1853 } 1854 1855 /* 1856 ** Return the SQL associated with a prepared statement 1857 */ 1858 const char *sqlite3_sql(sqlite3_stmt *pStmt){ 1859 Vdbe *p = (Vdbe *)pStmt; 1860 return p ? p->zSql : 0; 1861 } 1862 1863 /* 1864 ** Return the SQL associated with a prepared statement with 1865 ** bound parameters expanded. Space to hold the returned string is 1866 ** obtained from sqlite3_malloc(). The caller is responsible for 1867 ** freeing the returned string by passing it to sqlite3_free(). 1868 ** 1869 ** The SQLITE_TRACE_SIZE_LIMIT puts an upper bound on the size of 1870 ** expanded bound parameters. 1871 */ 1872 char *sqlite3_expanded_sql(sqlite3_stmt *pStmt){ 1873 #ifdef SQLITE_OMIT_TRACE 1874 return 0; 1875 #else 1876 char *z = 0; 1877 const char *zSql = sqlite3_sql(pStmt); 1878 if( zSql ){ 1879 Vdbe *p = (Vdbe *)pStmt; 1880 sqlite3_mutex_enter(p->db->mutex); 1881 z = sqlite3VdbeExpandSql(p, zSql); 1882 sqlite3_mutex_leave(p->db->mutex); 1883 } 1884 return z; 1885 #endif 1886 } 1887 1888 #ifdef SQLITE_ENABLE_NORMALIZE 1889 /* 1890 ** Return the normalized SQL associated with a prepared statement. 1891 */ 1892 const char *sqlite3_normalized_sql(sqlite3_stmt *pStmt){ 1893 Vdbe *p = (Vdbe *)pStmt; 1894 if( p==0 ) return 0; 1895 if( p->zNormSql==0 && ALWAYS(p->zSql!=0) ){ 1896 sqlite3_mutex_enter(p->db->mutex); 1897 p->zNormSql = sqlite3Normalize(p, p->zSql); 1898 sqlite3_mutex_leave(p->db->mutex); 1899 } 1900 return p->zNormSql; 1901 } 1902 #endif /* SQLITE_ENABLE_NORMALIZE */ 1903 1904 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 1905 /* 1906 ** Allocate and populate an UnpackedRecord structure based on the serialized 1907 ** record in nKey/pKey. Return a pointer to the new UnpackedRecord structure 1908 ** if successful, or a NULL pointer if an OOM error is encountered. 1909 */ 1910 static UnpackedRecord *vdbeUnpackRecord( 1911 KeyInfo *pKeyInfo, 1912 int nKey, 1913 const void *pKey 1914 ){ 1915 UnpackedRecord *pRet; /* Return value */ 1916 1917 pRet = sqlite3VdbeAllocUnpackedRecord(pKeyInfo); 1918 if( pRet ){ 1919 memset(pRet->aMem, 0, sizeof(Mem)*(pKeyInfo->nKeyField+1)); 1920 sqlite3VdbeRecordUnpack(pKeyInfo, nKey, pKey, pRet); 1921 } 1922 return pRet; 1923 } 1924 1925 /* 1926 ** This function is called from within a pre-update callback to retrieve 1927 ** a field of the row currently being updated or deleted. 1928 */ 1929 int sqlite3_preupdate_old(sqlite3 *db, int iIdx, sqlite3_value **ppValue){ 1930 PreUpdate *p = db->pPreUpdate; 1931 Mem *pMem; 1932 int rc = SQLITE_OK; 1933 1934 /* Test that this call is being made from within an SQLITE_DELETE or 1935 ** SQLITE_UPDATE pre-update callback, and that iIdx is within range. */ 1936 if( !p || p->op==SQLITE_INSERT ){ 1937 rc = SQLITE_MISUSE_BKPT; 1938 goto preupdate_old_out; 1939 } 1940 if( p->pPk ){ 1941 iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx); 1942 } 1943 if( iIdx>=p->pCsr->nField || iIdx<0 ){ 1944 rc = SQLITE_RANGE; 1945 goto preupdate_old_out; 1946 } 1947 1948 /* If the old.* record has not yet been loaded into memory, do so now. */ 1949 if( p->pUnpacked==0 ){ 1950 u32 nRec; 1951 u8 *aRec; 1952 1953 assert( p->pCsr->eCurType==CURTYPE_BTREE ); 1954 nRec = sqlite3BtreePayloadSize(p->pCsr->uc.pCursor); 1955 aRec = sqlite3DbMallocRaw(db, nRec); 1956 if( !aRec ) goto preupdate_old_out; 1957 rc = sqlite3BtreePayload(p->pCsr->uc.pCursor, 0, nRec, aRec); 1958 if( rc==SQLITE_OK ){ 1959 p->pUnpacked = vdbeUnpackRecord(&p->keyinfo, nRec, aRec); 1960 if( !p->pUnpacked ) rc = SQLITE_NOMEM; 1961 } 1962 if( rc!=SQLITE_OK ){ 1963 sqlite3DbFree(db, aRec); 1964 goto preupdate_old_out; 1965 } 1966 p->aRecord = aRec; 1967 } 1968 1969 pMem = *ppValue = &p->pUnpacked->aMem[iIdx]; 1970 if( iIdx==p->pTab->iPKey ){ 1971 sqlite3VdbeMemSetInt64(pMem, p->iKey1); 1972 }else if( iIdx>=p->pUnpacked->nField ){ 1973 *ppValue = (sqlite3_value *)columnNullValue(); 1974 }else if( p->pTab->aCol[iIdx].affinity==SQLITE_AFF_REAL ){ 1975 if( pMem->flags & (MEM_Int|MEM_IntReal) ){ 1976 testcase( pMem->flags & MEM_Int ); 1977 testcase( pMem->flags & MEM_IntReal ); 1978 sqlite3VdbeMemRealify(pMem); 1979 } 1980 } 1981 1982 preupdate_old_out: 1983 sqlite3Error(db, rc); 1984 return sqlite3ApiExit(db, rc); 1985 } 1986 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ 1987 1988 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 1989 /* 1990 ** This function is called from within a pre-update callback to retrieve 1991 ** the number of columns in the row being updated, deleted or inserted. 1992 */ 1993 int sqlite3_preupdate_count(sqlite3 *db){ 1994 PreUpdate *p = db->pPreUpdate; 1995 return (p ? p->keyinfo.nKeyField : 0); 1996 } 1997 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ 1998 1999 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 2000 /* 2001 ** This function is designed to be called from within a pre-update callback 2002 ** only. It returns zero if the change that caused the callback was made 2003 ** immediately by a user SQL statement. Or, if the change was made by a 2004 ** trigger program, it returns the number of trigger programs currently 2005 ** on the stack (1 for a top-level trigger, 2 for a trigger fired by a 2006 ** top-level trigger etc.). 2007 ** 2008 ** For the purposes of the previous paragraph, a foreign key CASCADE, SET NULL 2009 ** or SET DEFAULT action is considered a trigger. 2010 */ 2011 int sqlite3_preupdate_depth(sqlite3 *db){ 2012 PreUpdate *p = db->pPreUpdate; 2013 return (p ? p->v->nFrame : 0); 2014 } 2015 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ 2016 2017 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 2018 /* 2019 ** This function is designed to be called from within a pre-update callback 2020 ** only. 2021 */ 2022 int sqlite3_preupdate_blobwrite(sqlite3 *db){ 2023 PreUpdate *p = db->pPreUpdate; 2024 return (p ? p->iBlobWrite : -1); 2025 } 2026 #endif 2027 2028 #ifdef SQLITE_ENABLE_PREUPDATE_HOOK 2029 /* 2030 ** This function is called from within a pre-update callback to retrieve 2031 ** a field of the row currently being updated or inserted. 2032 */ 2033 int sqlite3_preupdate_new(sqlite3 *db, int iIdx, sqlite3_value **ppValue){ 2034 PreUpdate *p = db->pPreUpdate; 2035 int rc = SQLITE_OK; 2036 Mem *pMem; 2037 2038 if( !p || p->op==SQLITE_DELETE ){ 2039 rc = SQLITE_MISUSE_BKPT; 2040 goto preupdate_new_out; 2041 } 2042 if( p->pPk && p->op!=SQLITE_UPDATE ){ 2043 iIdx = sqlite3TableColumnToIndex(p->pPk, iIdx); 2044 } 2045 if( iIdx>=p->pCsr->nField || iIdx<0 ){ 2046 rc = SQLITE_RANGE; 2047 goto preupdate_new_out; 2048 } 2049 2050 if( p->op==SQLITE_INSERT ){ 2051 /* For an INSERT, memory cell p->iNewReg contains the serialized record 2052 ** that is being inserted. Deserialize it. */ 2053 UnpackedRecord *pUnpack = p->pNewUnpacked; 2054 if( !pUnpack ){ 2055 Mem *pData = &p->v->aMem[p->iNewReg]; 2056 rc = ExpandBlob(pData); 2057 if( rc!=SQLITE_OK ) goto preupdate_new_out; 2058 pUnpack = vdbeUnpackRecord(&p->keyinfo, pData->n, pData->z); 2059 if( !pUnpack ){ 2060 rc = SQLITE_NOMEM; 2061 goto preupdate_new_out; 2062 } 2063 p->pNewUnpacked = pUnpack; 2064 } 2065 pMem = &pUnpack->aMem[iIdx]; 2066 if( iIdx==p->pTab->iPKey ){ 2067 sqlite3VdbeMemSetInt64(pMem, p->iKey2); 2068 }else if( iIdx>=pUnpack->nField ){ 2069 pMem = (sqlite3_value *)columnNullValue(); 2070 } 2071 }else{ 2072 /* For an UPDATE, memory cell (p->iNewReg+1+iIdx) contains the required 2073 ** value. Make a copy of the cell contents and return a pointer to it. 2074 ** It is not safe to return a pointer to the memory cell itself as the 2075 ** caller may modify the value text encoding. 2076 */ 2077 assert( p->op==SQLITE_UPDATE ); 2078 if( !p->aNew ){ 2079 p->aNew = (Mem *)sqlite3DbMallocZero(db, sizeof(Mem) * p->pCsr->nField); 2080 if( !p->aNew ){ 2081 rc = SQLITE_NOMEM; 2082 goto preupdate_new_out; 2083 } 2084 } 2085 assert( iIdx>=0 && iIdx<p->pCsr->nField ); 2086 pMem = &p->aNew[iIdx]; 2087 if( pMem->flags==0 ){ 2088 if( iIdx==p->pTab->iPKey ){ 2089 sqlite3VdbeMemSetInt64(pMem, p->iKey2); 2090 }else{ 2091 rc = sqlite3VdbeMemCopy(pMem, &p->v->aMem[p->iNewReg+1+iIdx]); 2092 if( rc!=SQLITE_OK ) goto preupdate_new_out; 2093 } 2094 } 2095 } 2096 *ppValue = pMem; 2097 2098 preupdate_new_out: 2099 sqlite3Error(db, rc); 2100 return sqlite3ApiExit(db, rc); 2101 } 2102 #endif /* SQLITE_ENABLE_PREUPDATE_HOOK */ 2103 2104 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS 2105 /* 2106 ** Return status data for a single loop within query pStmt. 2107 */ 2108 int sqlite3_stmt_scanstatus( 2109 sqlite3_stmt *pStmt, /* Prepared statement being queried */ 2110 int idx, /* Index of loop to report on */ 2111 int iScanStatusOp, /* Which metric to return */ 2112 void *pOut /* OUT: Write the answer here */ 2113 ){ 2114 Vdbe *p = (Vdbe*)pStmt; 2115 ScanStatus *pScan; 2116 if( idx<0 || idx>=p->nScan ) return 1; 2117 pScan = &p->aScan[idx]; 2118 switch( iScanStatusOp ){ 2119 case SQLITE_SCANSTAT_NLOOP: { 2120 *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop]; 2121 break; 2122 } 2123 case SQLITE_SCANSTAT_NVISIT: { 2124 *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit]; 2125 break; 2126 } 2127 case SQLITE_SCANSTAT_EST: { 2128 double r = 1.0; 2129 LogEst x = pScan->nEst; 2130 while( x<100 ){ 2131 x += 10; 2132 r *= 0.5; 2133 } 2134 *(double*)pOut = r*sqlite3LogEstToInt(x); 2135 break; 2136 } 2137 case SQLITE_SCANSTAT_NAME: { 2138 *(const char**)pOut = pScan->zName; 2139 break; 2140 } 2141 case SQLITE_SCANSTAT_EXPLAIN: { 2142 if( pScan->addrExplain ){ 2143 *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z; 2144 }else{ 2145 *(const char**)pOut = 0; 2146 } 2147 break; 2148 } 2149 case SQLITE_SCANSTAT_SELECTID: { 2150 if( pScan->addrExplain ){ 2151 *(int*)pOut = p->aOp[ pScan->addrExplain ].p1; 2152 }else{ 2153 *(int*)pOut = -1; 2154 } 2155 break; 2156 } 2157 default: { 2158 return 1; 2159 } 2160 } 2161 return 0; 2162 } 2163 2164 /* 2165 ** Zero all counters associated with the sqlite3_stmt_scanstatus() data. 2166 */ 2167 void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){ 2168 Vdbe *p = (Vdbe*)pStmt; 2169 memset(p->anExec, 0, p->nOp * sizeof(i64)); 2170 } 2171 #endif /* SQLITE_ENABLE_STMT_SCANSTATUS */ 2172