| OLD | NEW |
|---|
| (Empty) |
| 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 assert( p->startTime>0 ); | |
| 64 assert( db->xProfile!=0 ); | |
| 65 assert( db->init.busy==0 ); | |
| 66 assert( p->zSql!=0 ); | |
| 67 sqlite3OsCurrentTimeInt64(db->pVfs, &iNow); | |
| 68 db->xProfile(db->pProfileArg, p->zSql, (iNow - p->startTime)*1000000); | |
| 69 p->startTime = 0; | |
| 70 } | |
| 71 /* | |
| 72 ** The checkProfileCallback(DB,P) macro checks to see if a profile callback | |
| 73 ** is needed, and it invokes the callback if it is needed. | |
| 74 */ | |
| 75 # define checkProfileCallback(DB,P) \ | |
| 76 if( ((P)->startTime)>0 ){ invokeProfileCallback(DB,P); } | |
| 77 #else | |
| 78 # define checkProfileCallback(DB,P) /*no-op*/ | |
| 79 #endif | |
| 80 | |
| 81 /* | |
| 82 ** The following routine destroys a virtual machine that is created by | |
| 83 ** the sqlite3_compile() routine. The integer returned is an SQLITE_ | |
| 84 ** success/failure code that describes the result of executing the virtual | |
| 85 ** machine. | |
| 86 ** | |
| 87 ** This routine sets the error code and string returned by | |
| 88 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). | |
| 89 */ | |
| 90 int sqlite3_finalize(sqlite3_stmt *pStmt){ | |
| 91 int rc; | |
| 92 if( pStmt==0 ){ | |
| 93 /* IMPLEMENTATION-OF: R-57228-12904 Invoking sqlite3_finalize() on a NULL | |
| 94 ** pointer is a harmless no-op. */ | |
| 95 rc = SQLITE_OK; | |
| 96 }else{ | |
| 97 Vdbe *v = (Vdbe*)pStmt; | |
| 98 sqlite3 *db = v->db; | |
| 99 if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT; | |
| 100 sqlite3_mutex_enter(db->mutex); | |
| 101 checkProfileCallback(db, v); | |
| 102 rc = sqlite3VdbeFinalize(v); | |
| 103 rc = sqlite3ApiExit(db, rc); | |
| 104 sqlite3LeaveMutexAndCloseZombie(db); | |
| 105 } | |
| 106 return rc; | |
| 107 } | |
| 108 | |
| 109 /* | |
| 110 ** Terminate the current execution of an SQL statement and reset it | |
| 111 ** back to its starting state so that it can be reused. A success code from | |
| 112 ** the prior execution is returned. | |
| 113 ** | |
| 114 ** This routine sets the error code and string returned by | |
| 115 ** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16(). | |
| 116 */ | |
| 117 int sqlite3_reset(sqlite3_stmt *pStmt){ | |
| 118 int rc; | |
| 119 if( pStmt==0 ){ | |
| 120 rc = SQLITE_OK; | |
| 121 }else{ | |
| 122 Vdbe *v = (Vdbe*)pStmt; | |
| 123 sqlite3 *db = v->db; | |
| 124 sqlite3_mutex_enter(db->mutex); | |
| 125 checkProfileCallback(db, v); | |
| 126 rc = sqlite3VdbeReset(v); | |
| 127 sqlite3VdbeRewind(v); | |
| 128 assert( (rc & (db->errMask))==rc ); | |
| 129 rc = sqlite3ApiExit(db, rc); | |
| 130 sqlite3_mutex_leave(db->mutex); | |
| 131 } | |
| 132 return rc; | |
| 133 } | |
| 134 | |
| 135 /* | |
| 136 ** Set all the parameters in the compiled SQL statement to NULL. | |
| 137 */ | |
| 138 int sqlite3_clear_bindings(sqlite3_stmt *pStmt){ | |
| 139 int i; | |
| 140 int rc = SQLITE_OK; | |
| 141 Vdbe *p = (Vdbe*)pStmt; | |
| 142 #if SQLITE_THREADSAFE | |
| 143 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex; | |
| 144 #endif | |
| 145 sqlite3_mutex_enter(mutex); | |
| 146 for(i=0; i<p->nVar; i++){ | |
| 147 sqlite3VdbeMemRelease(&p->aVar[i]); | |
| 148 p->aVar[i].flags = MEM_Null; | |
| 149 } | |
| 150 if( p->isPrepareV2 && p->expmask ){ | |
| 151 p->expired = 1; | |
| 152 } | |
| 153 sqlite3_mutex_leave(mutex); | |
| 154 return rc; | |
| 155 } | |
| 156 | |
| 157 | |
| 158 /**************************** sqlite3_value_ ******************************* | |
| 159 ** The following routines extract information from a Mem or sqlite3_value | |
| 160 ** structure. | |
| 161 */ | |
| 162 const void *sqlite3_value_blob(sqlite3_value *pVal){ | |
| 163 Mem *p = (Mem*)pVal; | |
| 164 if( p->flags & (MEM_Blob|MEM_Str) ){ | |
| 165 if( sqlite3VdbeMemExpandBlob(p)!=SQLITE_OK ){ | |
| 166 assert( p->flags==MEM_Null && p->z==0 ); | |
| 167 return 0; | |
| 168 } | |
| 169 p->flags |= MEM_Blob; | |
| 170 return p->n ? p->z : 0; | |
| 171 }else{ | |
| 172 return sqlite3_value_text(pVal); | |
| 173 } | |
| 174 } | |
| 175 int sqlite3_value_bytes(sqlite3_value *pVal){ | |
| 176 return sqlite3ValueBytes(pVal, SQLITE_UTF8); | |
| 177 } | |
| 178 int sqlite3_value_bytes16(sqlite3_value *pVal){ | |
| 179 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE); | |
| 180 } | |
| 181 double sqlite3_value_double(sqlite3_value *pVal){ | |
| 182 return sqlite3VdbeRealValue((Mem*)pVal); | |
| 183 } | |
| 184 int sqlite3_value_int(sqlite3_value *pVal){ | |
| 185 return (int)sqlite3VdbeIntValue((Mem*)pVal); | |
| 186 } | |
| 187 sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){ | |
| 188 return sqlite3VdbeIntValue((Mem*)pVal); | |
| 189 } | |
| 190 unsigned int sqlite3_value_subtype(sqlite3_value *pVal){ | |
| 191 return ((Mem*)pVal)->eSubtype; | |
| 192 } | |
| 193 const unsigned char *sqlite3_value_text(sqlite3_value *pVal){ | |
| 194 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8); | |
| 195 } | |
| 196 #ifndef SQLITE_OMIT_UTF16 | |
| 197 const void *sqlite3_value_text16(sqlite3_value* pVal){ | |
| 198 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE); | |
| 199 } | |
| 200 const void *sqlite3_value_text16be(sqlite3_value *pVal){ | |
| 201 return sqlite3ValueText(pVal, SQLITE_UTF16BE); | |
| 202 } | |
| 203 const void *sqlite3_value_text16le(sqlite3_value *pVal){ | |
| 204 return sqlite3ValueText(pVal, SQLITE_UTF16LE); | |
| 205 } | |
| 206 #endif /* SQLITE_OMIT_UTF16 */ | |
| 207 /* EVIDENCE-OF: R-12793-43283 Every value in SQLite has one of five | |
| 208 ** fundamental datatypes: 64-bit signed integer 64-bit IEEE floating | |
| 209 ** point number string BLOB NULL | |
| 210 */ | |
| 211 int sqlite3_value_type(sqlite3_value* pVal){ | |
| 212 static const u8 aType[] = { | |
| 213 SQLITE_BLOB, /* 0x00 */ | |
| 214 SQLITE_NULL, /* 0x01 */ | |
| 215 SQLITE_TEXT, /* 0x02 */ | |
| 216 SQLITE_NULL, /* 0x03 */ | |
| 217 SQLITE_INTEGER, /* 0x04 */ | |
| 218 SQLITE_NULL, /* 0x05 */ | |
| 219 SQLITE_INTEGER, /* 0x06 */ | |
| 220 SQLITE_NULL, /* 0x07 */ | |
| 221 SQLITE_FLOAT, /* 0x08 */ | |
| 222 SQLITE_NULL, /* 0x09 */ | |
| 223 SQLITE_FLOAT, /* 0x0a */ | |
| 224 SQLITE_NULL, /* 0x0b */ | |
| 225 SQLITE_INTEGER, /* 0x0c */ | |
| 226 SQLITE_NULL, /* 0x0d */ | |
| 227 SQLITE_INTEGER, /* 0x0e */ | |
| 228 SQLITE_NULL, /* 0x0f */ | |
| 229 SQLITE_BLOB, /* 0x10 */ | |
| 230 SQLITE_NULL, /* 0x11 */ | |
| 231 SQLITE_TEXT, /* 0x12 */ | |
| 232 SQLITE_NULL, /* 0x13 */ | |
| 233 SQLITE_INTEGER, /* 0x14 */ | |
| 234 SQLITE_NULL, /* 0x15 */ | |
| 235 SQLITE_INTEGER, /* 0x16 */ | |
| 236 SQLITE_NULL, /* 0x17 */ | |
| 237 SQLITE_FLOAT, /* 0x18 */ | |
| 238 SQLITE_NULL, /* 0x19 */ | |
| 239 SQLITE_FLOAT, /* 0x1a */ | |
| 240 SQLITE_NULL, /* 0x1b */ | |
| 241 SQLITE_INTEGER, /* 0x1c */ | |
| 242 SQLITE_NULL, /* 0x1d */ | |
| 243 SQLITE_INTEGER, /* 0x1e */ | |
| 244 SQLITE_NULL, /* 0x1f */ | |
| 245 }; | |
| 246 return aType[pVal->flags&MEM_AffMask]; | |
| 247 } | |
| 248 | |
| 249 /* Make a copy of an sqlite3_value object | |
| 250 */ | |
| 251 sqlite3_value *sqlite3_value_dup(const sqlite3_value *pOrig){ | |
| 252 sqlite3_value *pNew; | |
| 253 if( pOrig==0 ) return 0; | |
| 254 pNew = sqlite3_malloc( sizeof(*pNew) ); | |
| 255 if( pNew==0 ) return 0; | |
| 256 memset(pNew, 0, sizeof(*pNew)); | |
| 257 memcpy(pNew, pOrig, MEMCELLSIZE); | |
| 258 pNew->flags &= ~MEM_Dyn; | |
| 259 pNew->db = 0; | |
| 260 if( pNew->flags&(MEM_Str|MEM_Blob) ){ | |
| 261 pNew->flags &= ~(MEM_Static|MEM_Dyn); | |
| 262 pNew->flags |= MEM_Ephem; | |
| 263 if( sqlite3VdbeMemMakeWriteable(pNew)!=SQLITE_OK ){ | |
| 264 sqlite3ValueFree(pNew); | |
| 265 pNew = 0; | |
| 266 } | |
| 267 } | |
| 268 return pNew; | |
| 269 } | |
| 270 | |
| 271 /* Destroy an sqlite3_value object previously obtained from | |
| 272 ** sqlite3_value_dup(). | |
| 273 */ | |
| 274 void sqlite3_value_free(sqlite3_value *pOld){ | |
| 275 sqlite3ValueFree(pOld); | |
| 276 } | |
| 277 | |
| 278 | |
| 279 /**************************** sqlite3_result_ ******************************* | |
| 280 ** The following routines are used by user-defined functions to specify | |
| 281 ** the function result. | |
| 282 ** | |
| 283 ** The setStrOrError() function calls sqlite3VdbeMemSetStr() to store the | |
| 284 ** result as a string or blob but if the string or blob is too large, it | |
| 285 ** then sets the error code to SQLITE_TOOBIG | |
| 286 ** | |
| 287 ** The invokeValueDestructor(P,X) routine invokes destructor function X() | |
| 288 ** on value P is not going to be used and need to be destroyed. | |
| 289 */ | |
| 290 static void setResultStrOrError( | |
| 291 sqlite3_context *pCtx, /* Function context */ | |
| 292 const char *z, /* String pointer */ | |
| 293 int n, /* Bytes in string, or negative */ | |
| 294 u8 enc, /* Encoding of z. 0 for BLOBs */ | |
| 295 void (*xDel)(void*) /* Destructor function */ | |
| 296 ){ | |
| 297 if( sqlite3VdbeMemSetStr(pCtx->pOut, z, n, enc, xDel)==SQLITE_TOOBIG ){ | |
| 298 sqlite3_result_error_toobig(pCtx); | |
| 299 } | |
| 300 } | |
| 301 static int invokeValueDestructor( | |
| 302 const void *p, /* Value to destroy */ | |
| 303 void (*xDel)(void*), /* The destructor */ | |
| 304 sqlite3_context *pCtx /* Set a SQLITE_TOOBIG error if no NULL */ | |
| 305 ){ | |
| 306 assert( xDel!=SQLITE_DYNAMIC ); | |
| 307 if( xDel==0 ){ | |
| 308 /* noop */ | |
| 309 }else if( xDel==SQLITE_TRANSIENT ){ | |
| 310 /* noop */ | |
| 311 }else{ | |
| 312 xDel((void*)p); | |
| 313 } | |
| 314 if( pCtx ) sqlite3_result_error_toobig(pCtx); | |
| 315 return SQLITE_TOOBIG; | |
| 316 } | |
| 317 void sqlite3_result_blob( | |
| 318 sqlite3_context *pCtx, | |
| 319 const void *z, | |
| 320 int n, | |
| 321 void (*xDel)(void *) | |
| 322 ){ | |
| 323 assert( n>=0 ); | |
| 324 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 325 setResultStrOrError(pCtx, z, n, 0, xDel); | |
| 326 } | |
| 327 void sqlite3_result_blob64( | |
| 328 sqlite3_context *pCtx, | |
| 329 const void *z, | |
| 330 sqlite3_uint64 n, | |
| 331 void (*xDel)(void *) | |
| 332 ){ | |
| 333 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 334 assert( xDel!=SQLITE_DYNAMIC ); | |
| 335 if( n>0x7fffffff ){ | |
| 336 (void)invokeValueDestructor(z, xDel, pCtx); | |
| 337 }else{ | |
| 338 setResultStrOrError(pCtx, z, (int)n, 0, xDel); | |
| 339 } | |
| 340 } | |
| 341 void sqlite3_result_double(sqlite3_context *pCtx, double rVal){ | |
| 342 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 343 sqlite3VdbeMemSetDouble(pCtx->pOut, rVal); | |
| 344 } | |
| 345 void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){ | |
| 346 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 347 pCtx->isError = SQLITE_ERROR; | |
| 348 pCtx->fErrorOrAux = 1; | |
| 349 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF8, SQLITE_TRANSIENT); | |
| 350 } | |
| 351 #ifndef SQLITE_OMIT_UTF16 | |
| 352 void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){ | |
| 353 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 354 pCtx->isError = SQLITE_ERROR; | |
| 355 pCtx->fErrorOrAux = 1; | |
| 356 sqlite3VdbeMemSetStr(pCtx->pOut, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT); | |
| 357 } | |
| 358 #endif | |
| 359 void sqlite3_result_int(sqlite3_context *pCtx, int iVal){ | |
| 360 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 361 sqlite3VdbeMemSetInt64(pCtx->pOut, (i64)iVal); | |
| 362 } | |
| 363 void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){ | |
| 364 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 365 sqlite3VdbeMemSetInt64(pCtx->pOut, iVal); | |
| 366 } | |
| 367 void sqlite3_result_null(sqlite3_context *pCtx){ | |
| 368 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 369 sqlite3VdbeMemSetNull(pCtx->pOut); | |
| 370 } | |
| 371 void sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){ | |
| 372 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 373 pCtx->pOut->eSubtype = eSubtype & 0xff; | |
| 374 } | |
| 375 void sqlite3_result_text( | |
| 376 sqlite3_context *pCtx, | |
| 377 const char *z, | |
| 378 int n, | |
| 379 void (*xDel)(void *) | |
| 380 ){ | |
| 381 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 382 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel); | |
| 383 } | |
| 384 void sqlite3_result_text64( | |
| 385 sqlite3_context *pCtx, | |
| 386 const char *z, | |
| 387 sqlite3_uint64 n, | |
| 388 void (*xDel)(void *), | |
| 389 unsigned char enc | |
| 390 ){ | |
| 391 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 392 assert( xDel!=SQLITE_DYNAMIC ); | |
| 393 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; | |
| 394 if( n>0x7fffffff ){ | |
| 395 (void)invokeValueDestructor(z, xDel, pCtx); | |
| 396 }else{ | |
| 397 setResultStrOrError(pCtx, z, (int)n, enc, xDel); | |
| 398 } | |
| 399 } | |
| 400 #ifndef SQLITE_OMIT_UTF16 | |
| 401 void sqlite3_result_text16( | |
| 402 sqlite3_context *pCtx, | |
| 403 const void *z, | |
| 404 int n, | |
| 405 void (*xDel)(void *) | |
| 406 ){ | |
| 407 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 408 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel); | |
| 409 } | |
| 410 void sqlite3_result_text16be( | |
| 411 sqlite3_context *pCtx, | |
| 412 const void *z, | |
| 413 int n, | |
| 414 void (*xDel)(void *) | |
| 415 ){ | |
| 416 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 417 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel); | |
| 418 } | |
| 419 void sqlite3_result_text16le( | |
| 420 sqlite3_context *pCtx, | |
| 421 const void *z, | |
| 422 int n, | |
| 423 void (*xDel)(void *) | |
| 424 ){ | |
| 425 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 426 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel); | |
| 427 } | |
| 428 #endif /* SQLITE_OMIT_UTF16 */ | |
| 429 void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){ | |
| 430 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 431 sqlite3VdbeMemCopy(pCtx->pOut, pValue); | |
| 432 } | |
| 433 void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){ | |
| 434 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 435 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, n); | |
| 436 } | |
| 437 int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){ | |
| 438 Mem *pOut = pCtx->pOut; | |
| 439 assert( sqlite3_mutex_held(pOut->db->mutex) ); | |
| 440 if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){ | |
| 441 return SQLITE_TOOBIG; | |
| 442 } | |
| 443 sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n); | |
| 444 return SQLITE_OK; | |
| 445 } | |
| 446 void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){ | |
| 447 pCtx->isError = errCode; | |
| 448 pCtx->fErrorOrAux = 1; | |
| 449 #ifdef SQLITE_DEBUG | |
| 450 if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode; | |
| 451 #endif | |
| 452 if( pCtx->pOut->flags & MEM_Null ){ | |
| 453 sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1, | |
| 454 SQLITE_UTF8, SQLITE_STATIC); | |
| 455 } | |
| 456 } | |
| 457 | |
| 458 /* Force an SQLITE_TOOBIG error. */ | |
| 459 void sqlite3_result_error_toobig(sqlite3_context *pCtx){ | |
| 460 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 461 pCtx->isError = SQLITE_TOOBIG; | |
| 462 pCtx->fErrorOrAux = 1; | |
| 463 sqlite3VdbeMemSetStr(pCtx->pOut, "string or blob too big", -1, | |
| 464 SQLITE_UTF8, SQLITE_STATIC); | |
| 465 } | |
| 466 | |
| 467 /* An SQLITE_NOMEM error. */ | |
| 468 void sqlite3_result_error_nomem(sqlite3_context *pCtx){ | |
| 469 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 470 sqlite3VdbeMemSetNull(pCtx->pOut); | |
| 471 pCtx->isError = SQLITE_NOMEM; | |
| 472 pCtx->fErrorOrAux = 1; | |
| 473 pCtx->pOut->db->mallocFailed = 1; | |
| 474 } | |
| 475 | |
| 476 /* | |
| 477 ** This function is called after a transaction has been committed. It | |
| 478 ** invokes callbacks registered with sqlite3_wal_hook() as required. | |
| 479 */ | |
| 480 static int doWalCallbacks(sqlite3 *db){ | |
| 481 int rc = SQLITE_OK; | |
| 482 #ifndef SQLITE_OMIT_WAL | |
| 483 int i; | |
| 484 for(i=0; i<db->nDb; i++){ | |
| 485 Btree *pBt = db->aDb[i].pBt; | |
| 486 if( pBt ){ | |
| 487 int nEntry; | |
| 488 sqlite3BtreeEnter(pBt); | |
| 489 nEntry = sqlite3PagerWalCallback(sqlite3BtreePager(pBt)); | |
| 490 sqlite3BtreeLeave(pBt); | |
| 491 if( db->xWalCallback && nEntry>0 && rc==SQLITE_OK ){ | |
| 492 rc = db->xWalCallback(db->pWalArg, db, db->aDb[i].zName, nEntry); | |
| 493 } | |
| 494 } | |
| 495 } | |
| 496 #endif | |
| 497 return rc; | |
| 498 } | |
| 499 | |
| 500 | |
| 501 /* | |
| 502 ** Execute the statement pStmt, either until a row of data is ready, the | |
| 503 ** statement is completely executed or an error occurs. | |
| 504 ** | |
| 505 ** This routine implements the bulk of the logic behind the sqlite_step() | |
| 506 ** API. The only thing omitted is the automatic recompile if a | |
| 507 ** schema change has occurred. That detail is handled by the | |
| 508 ** outer sqlite3_step() wrapper procedure. | |
| 509 */ | |
| 510 static int sqlite3Step(Vdbe *p){ | |
| 511 sqlite3 *db; | |
| 512 int rc; | |
| 513 | |
| 514 assert(p); | |
| 515 if( p->magic!=VDBE_MAGIC_RUN ){ | |
| 516 /* We used to require that sqlite3_reset() be called before retrying | |
| 517 ** sqlite3_step() after any error or after SQLITE_DONE. But beginning | |
| 518 ** with version 3.7.0, we changed this so that sqlite3_reset() would | |
| 519 ** be called automatically instead of throwing the SQLITE_MISUSE error. | |
| 520 ** This "automatic-reset" change is not technically an incompatibility, | |
| 521 ** since any application that receives an SQLITE_MISUSE is broken by | |
| 522 ** definition. | |
| 523 ** | |
| 524 ** Nevertheless, some published applications that were originally written | |
| 525 ** for version 3.6.23 or earlier do in fact depend on SQLITE_MISUSE | |
| 526 ** returns, and those were broken by the automatic-reset change. As a | |
| 527 ** a work-around, the SQLITE_OMIT_AUTORESET compile-time restores the | |
| 528 ** legacy behavior of returning SQLITE_MISUSE for cases where the | |
| 529 ** previous sqlite3_step() returned something other than a SQLITE_LOCKED | |
| 530 ** or SQLITE_BUSY error. | |
| 531 */ | |
| 532 #ifdef SQLITE_OMIT_AUTORESET | |
| 533 if( (rc = p->rc&0xff)==SQLITE_BUSY || rc==SQLITE_LOCKED ){ | |
| 534 sqlite3_reset((sqlite3_stmt*)p); | |
| 535 }else{ | |
| 536 return SQLITE_MISUSE_BKPT; | |
| 537 } | |
| 538 #else | |
| 539 sqlite3_reset((sqlite3_stmt*)p); | |
| 540 #endif | |
| 541 } | |
| 542 | |
| 543 /* Check that malloc() has not failed. If it has, return early. */ | |
| 544 db = p->db; | |
| 545 if( db->mallocFailed ){ | |
| 546 p->rc = SQLITE_NOMEM; | |
| 547 return SQLITE_NOMEM; | |
| 548 } | |
| 549 | |
| 550 if( p->pc<=0 && p->expired ){ | |
| 551 p->rc = SQLITE_SCHEMA; | |
| 552 rc = SQLITE_ERROR; | |
| 553 goto end_of_step; | |
| 554 } | |
| 555 if( p->pc<0 ){ | |
| 556 /* If there are no other statements currently running, then | |
| 557 ** reset the interrupt flag. This prevents a call to sqlite3_interrupt | |
| 558 ** from interrupting a statement that has not yet started. | |
| 559 */ | |
| 560 if( db->nVdbeActive==0 ){ | |
| 561 db->u1.isInterrupted = 0; | |
| 562 } | |
| 563 | |
| 564 assert( db->nVdbeWrite>0 || db->autoCommit==0 | |
| 565 || (db->nDeferredCons==0 && db->nDeferredImmCons==0) | |
| 566 ); | |
| 567 | |
| 568 #ifndef SQLITE_OMIT_TRACE | |
| 569 if( db->xProfile && !db->init.busy && p->zSql ){ | |
| 570 sqlite3OsCurrentTimeInt64(db->pVfs, &p->startTime); | |
| 571 }else{ | |
| 572 assert( p->startTime==0 ); | |
| 573 } | |
| 574 #endif | |
| 575 | |
| 576 db->nVdbeActive++; | |
| 577 if( p->readOnly==0 ) db->nVdbeWrite++; | |
| 578 if( p->bIsReader ) db->nVdbeRead++; | |
| 579 p->pc = 0; | |
| 580 } | |
| 581 #ifdef SQLITE_DEBUG | |
| 582 p->rcApp = SQLITE_OK; | |
| 583 #endif | |
| 584 #ifndef SQLITE_OMIT_EXPLAIN | |
| 585 if( p->explain ){ | |
| 586 rc = sqlite3VdbeList(p); | |
| 587 }else | |
| 588 #endif /* SQLITE_OMIT_EXPLAIN */ | |
| 589 { | |
| 590 db->nVdbeExec++; | |
| 591 rc = sqlite3VdbeExec(p); | |
| 592 db->nVdbeExec--; | |
| 593 } | |
| 594 | |
| 595 #ifndef SQLITE_OMIT_TRACE | |
| 596 /* If the statement completed successfully, invoke the profile callback */ | |
| 597 if( rc!=SQLITE_ROW ) checkProfileCallback(db, p); | |
| 598 #endif | |
| 599 | |
| 600 if( rc==SQLITE_DONE ){ | |
| 601 assert( p->rc==SQLITE_OK ); | |
| 602 p->rc = doWalCallbacks(db); | |
| 603 if( p->rc!=SQLITE_OK ){ | |
| 604 rc = SQLITE_ERROR; | |
| 605 } | |
| 606 } | |
| 607 | |
| 608 db->errCode = rc; | |
| 609 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){ | |
| 610 p->rc = SQLITE_NOMEM; | |
| 611 } | |
| 612 end_of_step: | |
| 613 /* At this point local variable rc holds the value that should be | |
| 614 ** returned if this statement was compiled using the legacy | |
| 615 ** sqlite3_prepare() interface. According to the docs, this can only | |
| 616 ** be one of the values in the first assert() below. Variable p->rc | |
| 617 ** contains the value that would be returned if sqlite3_finalize() | |
| 618 ** were called on statement p. | |
| 619 */ | |
| 620 assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR | |
| 621 || (rc&0xff)==SQLITE_BUSY || rc==SQLITE_MISUSE | |
| 622 ); | |
| 623 assert( (p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE) || p->rc==p->rcApp ); | |
| 624 if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){ | |
| 625 /* If this statement was prepared using sqlite3_prepare_v2(), and an | |
| 626 ** error has occurred, then return the error code in p->rc to the | |
| 627 ** caller. Set the error code in the database handle to the same value. | |
| 628 */ | |
| 629 rc = sqlite3VdbeTransferError(p); | |
| 630 } | |
| 631 return (rc&db->errMask); | |
| 632 } | |
| 633 | |
| 634 /* | |
| 635 ** This is the top-level implementation of sqlite3_step(). Call | |
| 636 ** sqlite3Step() to do most of the work. If a schema error occurs, | |
| 637 ** call sqlite3Reprepare() and try again. | |
| 638 */ | |
| 639 int sqlite3_step(sqlite3_stmt *pStmt){ | |
| 640 int rc = SQLITE_OK; /* Result from sqlite3Step() */ | |
| 641 int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */ | |
| 642 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */ | |
| 643 int cnt = 0; /* Counter to prevent infinite loop of reprepares */ | |
| 644 sqlite3 *db; /* The database connection */ | |
| 645 | |
| 646 if( vdbeSafetyNotNull(v) ){ | |
| 647 return SQLITE_MISUSE_BKPT; | |
| 648 } | |
| 649 db = v->db; | |
| 650 sqlite3_mutex_enter(db->mutex); | |
| 651 v->doingRerun = 0; | |
| 652 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA | |
| 653 && cnt++ < SQLITE_MAX_SCHEMA_RETRY ){ | |
| 654 int savedPc = v->pc; | |
| 655 rc2 = rc = sqlite3Reprepare(v); | |
| 656 if( rc!=SQLITE_OK) break; | |
| 657 sqlite3_reset(pStmt); | |
| 658 if( savedPc>=0 ) v->doingRerun = 1; | |
| 659 assert( v->expired==0 ); | |
| 660 } | |
| 661 if( rc2!=SQLITE_OK ){ | |
| 662 /* This case occurs after failing to recompile an sql statement. | |
| 663 ** The error message from the SQL compiler has already been loaded | |
| 664 ** into the database handle. This block copies the error message | |
| 665 ** from the database handle into the statement and sets the statement | |
| 666 ** program counter to 0 to ensure that when the statement is | |
| 667 ** finalized or reset the parser error message is available via | |
| 668 ** sqlite3_errmsg() and sqlite3_errcode(). | |
| 669 */ | |
| 670 const char *zErr = (const char *)sqlite3_value_text(db->pErr); | |
| 671 sqlite3DbFree(db, v->zErrMsg); | |
| 672 if( !db->mallocFailed ){ | |
| 673 v->zErrMsg = sqlite3DbStrDup(db, zErr); | |
| 674 v->rc = rc2; | |
| 675 } else { | |
| 676 v->zErrMsg = 0; | |
| 677 v->rc = rc = SQLITE_NOMEM; | |
| 678 } | |
| 679 } | |
| 680 rc = sqlite3ApiExit(db, rc); | |
| 681 sqlite3_mutex_leave(db->mutex); | |
| 682 return rc; | |
| 683 } | |
| 684 | |
| 685 | |
| 686 /* | |
| 687 ** Extract the user data from a sqlite3_context structure and return a | |
| 688 ** pointer to it. | |
| 689 */ | |
| 690 void *sqlite3_user_data(sqlite3_context *p){ | |
| 691 assert( p && p->pFunc ); | |
| 692 return p->pFunc->pUserData; | |
| 693 } | |
| 694 | |
| 695 /* | |
| 696 ** Extract the user data from a sqlite3_context structure and return a | |
| 697 ** pointer to it. | |
| 698 ** | |
| 699 ** IMPLEMENTATION-OF: R-46798-50301 The sqlite3_context_db_handle() interface | |
| 700 ** returns a copy of the pointer to the database connection (the 1st | |
| 701 ** parameter) of the sqlite3_create_function() and | |
| 702 ** sqlite3_create_function16() routines that originally registered the | |
| 703 ** application defined function. | |
| 704 */ | |
| 705 sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){ | |
| 706 assert( p && p->pOut ); | |
| 707 return p->pOut->db; | |
| 708 } | |
| 709 | |
| 710 /* | |
| 711 ** Return the current time for a statement. If the current time | |
| 712 ** is requested more than once within the same run of a single prepared | |
| 713 ** statement, the exact same time is returned for each invocation regardless | |
| 714 ** of the amount of time that elapses between invocations. In other words, | |
| 715 ** the time returned is always the time of the first call. | |
| 716 */ | |
| 717 sqlite3_int64 sqlite3StmtCurrentTime(sqlite3_context *p){ | |
| 718 int rc; | |
| 719 #ifndef SQLITE_ENABLE_STAT3_OR_STAT4 | |
| 720 sqlite3_int64 *piTime = &p->pVdbe->iCurrentTime; | |
| 721 assert( p->pVdbe!=0 ); | |
| 722 #else | |
| 723 sqlite3_int64 iTime = 0; | |
| 724 sqlite3_int64 *piTime = p->pVdbe!=0 ? &p->pVdbe->iCurrentTime : &iTime; | |
| 725 #endif | |
| 726 if( *piTime==0 ){ | |
| 727 rc = sqlite3OsCurrentTimeInt64(p->pOut->db->pVfs, piTime); | |
| 728 if( rc ) *piTime = 0; | |
| 729 } | |
| 730 return *piTime; | |
| 731 } | |
| 732 | |
| 733 /* | |
| 734 ** The following is the implementation of an SQL function that always | |
| 735 ** fails with an error message stating that the function is used in the | |
| 736 ** wrong context. The sqlite3_overload_function() API might construct | |
| 737 ** SQL function that use this routine so that the functions will exist | |
| 738 ** for name resolution but are actually overloaded by the xFindFunction | |
| 739 ** method of virtual tables. | |
| 740 */ | |
| 741 void sqlite3InvalidFunction( | |
| 742 sqlite3_context *context, /* The function calling context */ | |
| 743 int NotUsed, /* Number of arguments to the function */ | |
| 744 sqlite3_value **NotUsed2 /* Value of each argument */ | |
| 745 ){ | |
| 746 const char *zName = context->pFunc->zName; | |
| 747 char *zErr; | |
| 748 UNUSED_PARAMETER2(NotUsed, NotUsed2); | |
| 749 zErr = sqlite3_mprintf( | |
| 750 "unable to use function %s in the requested context", zName); | |
| 751 sqlite3_result_error(context, zErr, -1); | |
| 752 sqlite3_free(zErr); | |
| 753 } | |
| 754 | |
| 755 /* | |
| 756 ** Create a new aggregate context for p and return a pointer to | |
| 757 ** its pMem->z element. | |
| 758 */ | |
| 759 static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){ | |
| 760 Mem *pMem = p->pMem; | |
| 761 assert( (pMem->flags & MEM_Agg)==0 ); | |
| 762 if( nByte<=0 ){ | |
| 763 sqlite3VdbeMemSetNull(pMem); | |
| 764 pMem->z = 0; | |
| 765 }else{ | |
| 766 sqlite3VdbeMemClearAndResize(pMem, nByte); | |
| 767 pMem->flags = MEM_Agg; | |
| 768 pMem->u.pDef = p->pFunc; | |
| 769 if( pMem->z ){ | |
| 770 memset(pMem->z, 0, nByte); | |
| 771 } | |
| 772 } | |
| 773 return (void*)pMem->z; | |
| 774 } | |
| 775 | |
| 776 /* | |
| 777 ** Allocate or return the aggregate context for a user function. A new | |
| 778 ** context is allocated on the first call. Subsequent calls return the | |
| 779 ** same context that was returned on prior calls. | |
| 780 */ | |
| 781 void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){ | |
| 782 assert( p && p->pFunc && p->pFunc->xStep ); | |
| 783 assert( sqlite3_mutex_held(p->pOut->db->mutex) ); | |
| 784 testcase( nByte<0 ); | |
| 785 if( (p->pMem->flags & MEM_Agg)==0 ){ | |
| 786 return createAggContext(p, nByte); | |
| 787 }else{ | |
| 788 return (void*)p->pMem->z; | |
| 789 } | |
| 790 } | |
| 791 | |
| 792 /* | |
| 793 ** Return the auxiliary data pointer, if any, for the iArg'th argument to | |
| 794 ** the user-function defined by pCtx. | |
| 795 */ | |
| 796 void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){ | |
| 797 AuxData *pAuxData; | |
| 798 | |
| 799 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 800 #if SQLITE_ENABLE_STAT3_OR_STAT4 | |
| 801 if( pCtx->pVdbe==0 ) return 0; | |
| 802 #else | |
| 803 assert( pCtx->pVdbe!=0 ); | |
| 804 #endif | |
| 805 for(pAuxData=pCtx->pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){ | |
| 806 if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break; | |
| 807 } | |
| 808 | |
| 809 return (pAuxData ? pAuxData->pAux : 0); | |
| 810 } | |
| 811 | |
| 812 /* | |
| 813 ** Set the auxiliary data pointer and delete function, for the iArg'th | |
| 814 ** argument to the user-function defined by pCtx. Any previous value is | |
| 815 ** deleted by calling the delete function specified when it was set. | |
| 816 */ | |
| 817 void sqlite3_set_auxdata( | |
| 818 sqlite3_context *pCtx, | |
| 819 int iArg, | |
| 820 void *pAux, | |
| 821 void (*xDelete)(void*) | |
| 822 ){ | |
| 823 AuxData *pAuxData; | |
| 824 Vdbe *pVdbe = pCtx->pVdbe; | |
| 825 | |
| 826 assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) ); | |
| 827 if( iArg<0 ) goto failed; | |
| 828 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4 | |
| 829 if( pVdbe==0 ) goto failed; | |
| 830 #else | |
| 831 assert( pVdbe!=0 ); | |
| 832 #endif | |
| 833 | |
| 834 for(pAuxData=pVdbe->pAuxData; pAuxData; pAuxData=pAuxData->pNext){ | |
| 835 if( pAuxData->iOp==pCtx->iOp && pAuxData->iArg==iArg ) break; | |
| 836 } | |
| 837 if( pAuxData==0 ){ | |
| 838 pAuxData = sqlite3DbMallocZero(pVdbe->db, sizeof(AuxData)); | |
| 839 if( !pAuxData ) goto failed; | |
| 840 pAuxData->iOp = pCtx->iOp; | |
| 841 pAuxData->iArg = iArg; | |
| 842 pAuxData->pNext = pVdbe->pAuxData; | |
| 843 pVdbe->pAuxData = pAuxData; | |
| 844 if( pCtx->fErrorOrAux==0 ){ | |
| 845 pCtx->isError = 0; | |
| 846 pCtx->fErrorOrAux = 1; | |
| 847 } | |
| 848 }else if( pAuxData->xDelete ){ | |
| 849 pAuxData->xDelete(pAuxData->pAux); | |
| 850 } | |
| 851 | |
| 852 pAuxData->pAux = pAux; | |
| 853 pAuxData->xDelete = xDelete; | |
| 854 return; | |
| 855 | |
| 856 failed: | |
| 857 if( xDelete ){ | |
| 858 xDelete(pAux); | |
| 859 } | |
| 860 } | |
| 861 | |
| 862 #ifndef SQLITE_OMIT_DEPRECATED | |
| 863 /* | |
| 864 ** Return the number of times the Step function of an aggregate has been | |
| 865 ** called. | |
| 866 ** | |
| 867 ** This function is deprecated. Do not use it for new code. It is | |
| 868 ** provide only to avoid breaking legacy code. New aggregate function | |
| 869 ** implementations should keep their own counts within their aggregate | |
| 870 ** context. | |
| 871 */ | |
| 872 int sqlite3_aggregate_count(sqlite3_context *p){ | |
| 873 assert( p && p->pMem && p->pFunc && p->pFunc->xStep ); | |
| 874 return p->pMem->n; | |
| 875 } | |
| 876 #endif | |
| 877 | |
| 878 /* | |
| 879 ** Return the number of columns in the result set for the statement pStmt. | |
| 880 */ | |
| 881 int sqlite3_column_count(sqlite3_stmt *pStmt){ | |
| 882 Vdbe *pVm = (Vdbe *)pStmt; | |
| 883 return pVm ? pVm->nResColumn : 0; | |
| 884 } | |
| 885 | |
| 886 /* | |
| 887 ** Return the number of values available from the current row of the | |
| 888 ** currently executing statement pStmt. | |
| 889 */ | |
| 890 int sqlite3_data_count(sqlite3_stmt *pStmt){ | |
| 891 Vdbe *pVm = (Vdbe *)pStmt; | |
| 892 if( pVm==0 || pVm->pResultSet==0 ) return 0; | |
| 893 return pVm->nResColumn; | |
| 894 } | |
| 895 | |
| 896 /* | |
| 897 ** Return a pointer to static memory containing an SQL NULL value. | |
| 898 */ | |
| 899 static const Mem *columnNullValue(void){ | |
| 900 /* Even though the Mem structure contains an element | |
| 901 ** of type i64, on certain architectures (x86) with certain compiler | |
| 902 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary | |
| 903 ** instead of an 8-byte one. This all works fine, except that when | |
| 904 ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s | |
| 905 ** that a Mem structure is located on an 8-byte boundary. To prevent | |
| 906 ** these assert()s from failing, when building with SQLITE_DEBUG defined | |
| 907 ** using gcc, we force nullMem to be 8-byte aligned using the magical | |
| 908 ** __attribute__((aligned(8))) macro. */ | |
| 909 static const Mem nullMem | |
| 910 #if defined(SQLITE_DEBUG) && defined(__GNUC__) | |
| 911 __attribute__((aligned(8))) | |
| 912 #endif | |
| 913 = { | |
| 914 /* .u = */ {0}, | |
| 915 /* .flags = */ (u16)MEM_Null, | |
| 916 /* .enc = */ (u8)0, | |
| 917 /* .eSubtype = */ (u8)0, | |
| 918 /* .n = */ (int)0, | |
| 919 /* .z = */ (char*)0, | |
| 920 /* .zMalloc = */ (char*)0, | |
| 921 /* .szMalloc = */ (int)0, | |
| 922 /* .uTemp = */ (u32)0, | |
| 923 /* .db = */ (sqlite3*)0, | |
| 924 /* .xDel = */ (void(*)(void*))0, | |
| 925 #ifdef SQLITE_DEBUG | |
| 926 /* .pScopyFrom = */ (Mem*)0, | |
| 927 /* .pFiller = */ (void*)0, | |
| 928 #endif | |
| 929 }; | |
| 930 return &nullMem; | |
| 931 } | |
| 932 | |
| 933 /* | |
| 934 ** Check to see if column iCol of the given statement is valid. If | |
| 935 ** it is, return a pointer to the Mem for the value of that column. | |
| 936 ** If iCol is not valid, return a pointer to a Mem which has a value | |
| 937 ** of NULL. | |
| 938 */ | |
| 939 static Mem *columnMem(sqlite3_stmt *pStmt, int i){ | |
| 940 Vdbe *pVm; | |
| 941 Mem *pOut; | |
| 942 | |
| 943 pVm = (Vdbe *)pStmt; | |
| 944 if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){ | |
| 945 sqlite3_mutex_enter(pVm->db->mutex); | |
| 946 pOut = &pVm->pResultSet[i]; | |
| 947 }else{ | |
| 948 if( pVm && ALWAYS(pVm->db) ){ | |
| 949 sqlite3_mutex_enter(pVm->db->mutex); | |
| 950 sqlite3Error(pVm->db, SQLITE_RANGE); | |
| 951 } | |
| 952 pOut = (Mem*)columnNullValue(); | |
| 953 } | |
| 954 return pOut; | |
| 955 } | |
| 956 | |
| 957 /* | |
| 958 ** This function is called after invoking an sqlite3_value_XXX function on a | |
| 959 ** column value (i.e. a value returned by evaluating an SQL expression in the | |
| 960 ** select list of a SELECT statement) that may cause a malloc() failure. If | |
| 961 ** malloc() has failed, the threads mallocFailed flag is cleared and the result | |
| 962 ** code of statement pStmt set to SQLITE_NOMEM. | |
| 963 ** | |
| 964 ** Specifically, this is called from within: | |
| 965 ** | |
| 966 ** sqlite3_column_int() | |
| 967 ** sqlite3_column_int64() | |
| 968 ** sqlite3_column_text() | |
| 969 ** sqlite3_column_text16() | |
| 970 ** sqlite3_column_real() | |
| 971 ** sqlite3_column_bytes() | |
| 972 ** sqlite3_column_bytes16() | |
| 973 ** sqiite3_column_blob() | |
| 974 */ | |
| 975 static void columnMallocFailure(sqlite3_stmt *pStmt) | |
| 976 { | |
| 977 /* If malloc() failed during an encoding conversion within an | |
| 978 ** sqlite3_column_XXX API, then set the return code of the statement to | |
| 979 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR | |
| 980 ** and _finalize() will return NOMEM. | |
| 981 */ | |
| 982 Vdbe *p = (Vdbe *)pStmt; | |
| 983 if( p ){ | |
| 984 p->rc = sqlite3ApiExit(p->db, p->rc); | |
| 985 sqlite3_mutex_leave(p->db->mutex); | |
| 986 } | |
| 987 } | |
| 988 | |
| 989 /**************************** sqlite3_column_ ******************************* | |
| 990 ** The following routines are used to access elements of the current row | |
| 991 ** in the result set. | |
| 992 */ | |
| 993 const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){ | |
| 994 const void *val; | |
| 995 val = sqlite3_value_blob( columnMem(pStmt,i) ); | |
| 996 /* Even though there is no encoding conversion, value_blob() might | |
| 997 ** need to call malloc() to expand the result of a zeroblob() | |
| 998 ** expression. | |
| 999 */ | |
| 1000 columnMallocFailure(pStmt); | |
| 1001 return val; | |
| 1002 } | |
| 1003 int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){ | |
| 1004 int val = sqlite3_value_bytes( columnMem(pStmt,i) ); | |
| 1005 columnMallocFailure(pStmt); | |
| 1006 return val; | |
| 1007 } | |
| 1008 int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){ | |
| 1009 int val = sqlite3_value_bytes16( columnMem(pStmt,i) ); | |
| 1010 columnMallocFailure(pStmt); | |
| 1011 return val; | |
| 1012 } | |
| 1013 double sqlite3_column_double(sqlite3_stmt *pStmt, int i){ | |
| 1014 double val = sqlite3_value_double( columnMem(pStmt,i) ); | |
| 1015 columnMallocFailure(pStmt); | |
| 1016 return val; | |
| 1017 } | |
| 1018 int sqlite3_column_int(sqlite3_stmt *pStmt, int i){ | |
| 1019 int val = sqlite3_value_int( columnMem(pStmt,i) ); | |
| 1020 columnMallocFailure(pStmt); | |
| 1021 return val; | |
| 1022 } | |
| 1023 sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){ | |
| 1024 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) ); | |
| 1025 columnMallocFailure(pStmt); | |
| 1026 return val; | |
| 1027 } | |
| 1028 const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){ | |
| 1029 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) ); | |
| 1030 columnMallocFailure(pStmt); | |
| 1031 return val; | |
| 1032 } | |
| 1033 sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){ | |
| 1034 Mem *pOut = columnMem(pStmt, i); | |
| 1035 if( pOut->flags&MEM_Static ){ | |
| 1036 pOut->flags &= ~MEM_Static; | |
| 1037 pOut->flags |= MEM_Ephem; | |
| 1038 } | |
| 1039 columnMallocFailure(pStmt); | |
| 1040 return (sqlite3_value *)pOut; | |
| 1041 } | |
| 1042 #ifndef SQLITE_OMIT_UTF16 | |
| 1043 const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){ | |
| 1044 const void *val = sqlite3_value_text16( columnMem(pStmt,i) ); | |
| 1045 columnMallocFailure(pStmt); | |
| 1046 return val; | |
| 1047 } | |
| 1048 #endif /* SQLITE_OMIT_UTF16 */ | |
| 1049 int sqlite3_column_type(sqlite3_stmt *pStmt, int i){ | |
| 1050 int iType = sqlite3_value_type( columnMem(pStmt,i) ); | |
| 1051 columnMallocFailure(pStmt); | |
| 1052 return iType; | |
| 1053 } | |
| 1054 | |
| 1055 /* | |
| 1056 ** Convert the N-th element of pStmt->pColName[] into a string using | |
| 1057 ** xFunc() then return that string. If N is out of range, return 0. | |
| 1058 ** | |
| 1059 ** There are up to 5 names for each column. useType determines which | |
| 1060 ** name is returned. Here are the names: | |
| 1061 ** | |
| 1062 ** 0 The column name as it should be displayed for output | |
| 1063 ** 1 The datatype name for the column | |
| 1064 ** 2 The name of the database that the column derives from | |
| 1065 ** 3 The name of the table that the column derives from | |
| 1066 ** 4 The name of the table column that the result column derives from | |
| 1067 ** | |
| 1068 ** If the result is not a simple column reference (if it is an expression | |
| 1069 ** or a constant) then useTypes 2, 3, and 4 return NULL. | |
| 1070 */ | |
| 1071 static const void *columnName( | |
| 1072 sqlite3_stmt *pStmt, | |
| 1073 int N, | |
| 1074 const void *(*xFunc)(Mem*), | |
| 1075 int useType | |
| 1076 ){ | |
| 1077 const void *ret; | |
| 1078 Vdbe *p; | |
| 1079 int n; | |
| 1080 sqlite3 *db; | |
| 1081 #ifdef SQLITE_ENABLE_API_ARMOR | |
| 1082 if( pStmt==0 ){ | |
| 1083 (void)SQLITE_MISUSE_BKPT; | |
| 1084 return 0; | |
| 1085 } | |
| 1086 #endif | |
| 1087 ret = 0; | |
| 1088 p = (Vdbe *)pStmt; | |
| 1089 db = p->db; | |
| 1090 assert( db!=0 ); | |
| 1091 n = sqlite3_column_count(pStmt); | |
| 1092 if( N<n && N>=0 ){ | |
| 1093 N += useType*n; | |
| 1094 sqlite3_mutex_enter(db->mutex); | |
| 1095 assert( db->mallocFailed==0 ); | |
| 1096 ret = xFunc(&p->aColName[N]); | |
| 1097 /* A malloc may have failed inside of the xFunc() call. If this | |
| 1098 ** is the case, clear the mallocFailed flag and return NULL. | |
| 1099 */ | |
| 1100 if( db->mallocFailed ){ | |
| 1101 db->mallocFailed = 0; | |
| 1102 ret = 0; | |
| 1103 } | |
| 1104 sqlite3_mutex_leave(db->mutex); | |
| 1105 } | |
| 1106 return ret; | |
| 1107 } | |
| 1108 | |
| 1109 /* | |
| 1110 ** Return the name of the Nth column of the result set returned by SQL | |
| 1111 ** statement pStmt. | |
| 1112 */ | |
| 1113 const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){ | |
| 1114 return columnName( | |
| 1115 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME); | |
| 1116 } | |
| 1117 #ifndef SQLITE_OMIT_UTF16 | |
| 1118 const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){ | |
| 1119 return columnName( | |
| 1120 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME); | |
| 1121 } | |
| 1122 #endif | |
| 1123 | |
| 1124 /* | |
| 1125 ** Constraint: If you have ENABLE_COLUMN_METADATA then you must | |
| 1126 ** not define OMIT_DECLTYPE. | |
| 1127 */ | |
| 1128 #if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA) | |
| 1129 # error "Must not define both SQLITE_OMIT_DECLTYPE \ | |
| 1130 and SQLITE_ENABLE_COLUMN_METADATA" | |
| 1131 #endif | |
| 1132 | |
| 1133 #ifndef SQLITE_OMIT_DECLTYPE | |
| 1134 /* | |
| 1135 ** Return the column declaration type (if applicable) of the 'i'th column | |
| 1136 ** of the result set of SQL statement pStmt. | |
| 1137 */ | |
| 1138 const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){ | |
| 1139 return columnName( | |
| 1140 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE); | |
| 1141 } | |
| 1142 #ifndef SQLITE_OMIT_UTF16 | |
| 1143 const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){ | |
| 1144 return columnName( | |
| 1145 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE); | |
| 1146 } | |
| 1147 #endif /* SQLITE_OMIT_UTF16 */ | |
| 1148 #endif /* SQLITE_OMIT_DECLTYPE */ | |
| 1149 | |
| 1150 #ifdef SQLITE_ENABLE_COLUMN_METADATA | |
| 1151 /* | |
| 1152 ** Return the name of the database from which a result column derives. | |
| 1153 ** NULL is returned if the result column is an expression or constant or | |
| 1154 ** anything else which is not an unambiguous reference to a database column. | |
| 1155 */ | |
| 1156 const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){ | |
| 1157 return columnName( | |
| 1158 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE); | |
| 1159 } | |
| 1160 #ifndef SQLITE_OMIT_UTF16 | |
| 1161 const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){ | |
| 1162 return columnName( | |
| 1163 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE); | |
| 1164 } | |
| 1165 #endif /* SQLITE_OMIT_UTF16 */ | |
| 1166 | |
| 1167 /* | |
| 1168 ** Return the name of the table from which a result column derives. | |
| 1169 ** NULL is returned if the result column is an expression or constant or | |
| 1170 ** anything else which is not an unambiguous reference to a database column. | |
| 1171 */ | |
| 1172 const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){ | |
| 1173 return columnName( | |
| 1174 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE); | |
| 1175 } | |
| 1176 #ifndef SQLITE_OMIT_UTF16 | |
| 1177 const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){ | |
| 1178 return columnName( | |
| 1179 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE); | |
| 1180 } | |
| 1181 #endif /* SQLITE_OMIT_UTF16 */ | |
| 1182 | |
| 1183 /* | |
| 1184 ** Return the name of the table column from which a result column derives. | |
| 1185 ** NULL is returned if the result column is an expression or constant or | |
| 1186 ** anything else which is not an unambiguous reference to a database column. | |
| 1187 */ | |
| 1188 const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){ | |
| 1189 return columnName( | |
| 1190 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN); | |
| 1191 } | |
| 1192 #ifndef SQLITE_OMIT_UTF16 | |
| 1193 const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){ | |
| 1194 return columnName( | |
| 1195 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN); | |
| 1196 } | |
| 1197 #endif /* SQLITE_OMIT_UTF16 */ | |
| 1198 #endif /* SQLITE_ENABLE_COLUMN_METADATA */ | |
| 1199 | |
| 1200 | |
| 1201 /******************************* sqlite3_bind_ *************************** | |
| 1202 ** | |
| 1203 ** Routines used to attach values to wildcards in a compiled SQL statement. | |
| 1204 */ | |
| 1205 /* | |
| 1206 ** Unbind the value bound to variable i in virtual machine p. This is the | |
| 1207 ** the same as binding a NULL value to the column. If the "i" parameter is | |
| 1208 ** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK. | |
| 1209 ** | |
| 1210 ** A successful evaluation of this routine acquires the mutex on p. | |
| 1211 ** the mutex is released if any kind of error occurs. | |
| 1212 ** | |
| 1213 ** The error code stored in database p->db is overwritten with the return | |
| 1214 ** value in any case. | |
| 1215 */ | |
| 1216 static int vdbeUnbind(Vdbe *p, int i){ | |
| 1217 Mem *pVar; | |
| 1218 if( vdbeSafetyNotNull(p) ){ | |
| 1219 return SQLITE_MISUSE_BKPT; | |
| 1220 } | |
| 1221 sqlite3_mutex_enter(p->db->mutex); | |
| 1222 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){ | |
| 1223 sqlite3Error(p->db, SQLITE_MISUSE); | |
| 1224 sqlite3_mutex_leave(p->db->mutex); | |
| 1225 sqlite3_log(SQLITE_MISUSE, | |
| 1226 "bind on a busy prepared statement: [%s]", p->zSql); | |
| 1227 return SQLITE_MISUSE_BKPT; | |
| 1228 } | |
| 1229 if( i<1 || i>p->nVar ){ | |
| 1230 sqlite3Error(p->db, SQLITE_RANGE); | |
| 1231 sqlite3_mutex_leave(p->db->mutex); | |
| 1232 return SQLITE_RANGE; | |
| 1233 } | |
| 1234 i--; | |
| 1235 pVar = &p->aVar[i]; | |
| 1236 sqlite3VdbeMemRelease(pVar); | |
| 1237 pVar->flags = MEM_Null; | |
| 1238 sqlite3Error(p->db, SQLITE_OK); | |
| 1239 | |
| 1240 /* If the bit corresponding to this variable in Vdbe.expmask is set, then | |
| 1241 ** binding a new value to this variable invalidates the current query plan. | |
| 1242 ** | |
| 1243 ** IMPLEMENTATION-OF: R-48440-37595 If the specific value bound to host | |
| 1244 ** parameter in the WHERE clause might influence the choice of query plan | |
| 1245 ** for a statement, then the statement will be automatically recompiled, | |
| 1246 ** as if there had been a schema change, on the first sqlite3_step() call | |
| 1247 ** following any change to the bindings of that parameter. | |
| 1248 */ | |
| 1249 if( p->isPrepareV2 && | |
| 1250 ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff) | |
| 1251 ){ | |
| 1252 p->expired = 1; | |
| 1253 } | |
| 1254 return SQLITE_OK; | |
| 1255 } | |
| 1256 | |
| 1257 /* | |
| 1258 ** Bind a text or BLOB value. | |
| 1259 */ | |
| 1260 static int bindText( | |
| 1261 sqlite3_stmt *pStmt, /* The statement to bind against */ | |
| 1262 int i, /* Index of the parameter to bind */ | |
| 1263 const void *zData, /* Pointer to the data to be bound */ | |
| 1264 int nData, /* Number of bytes of data to be bound */ | |
| 1265 void (*xDel)(void*), /* Destructor for the data */ | |
| 1266 u8 encoding /* Encoding for the data */ | |
| 1267 ){ | |
| 1268 Vdbe *p = (Vdbe *)pStmt; | |
| 1269 Mem *pVar; | |
| 1270 int rc; | |
| 1271 | |
| 1272 rc = vdbeUnbind(p, i); | |
| 1273 if( rc==SQLITE_OK ){ | |
| 1274 if( zData!=0 ){ | |
| 1275 pVar = &p->aVar[i-1]; | |
| 1276 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel); | |
| 1277 if( rc==SQLITE_OK && encoding!=0 ){ | |
| 1278 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db)); | |
| 1279 } | |
| 1280 sqlite3Error(p->db, rc); | |
| 1281 rc = sqlite3ApiExit(p->db, rc); | |
| 1282 } | |
| 1283 sqlite3_mutex_leave(p->db->mutex); | |
| 1284 }else if( xDel!=SQLITE_STATIC && xDel!=SQLITE_TRANSIENT ){ | |
| 1285 xDel((void*)zData); | |
| 1286 } | |
| 1287 return rc; | |
| 1288 } | |
| 1289 | |
| 1290 | |
| 1291 /* | |
| 1292 ** Bind a blob value to an SQL statement variable. | |
| 1293 */ | |
| 1294 int sqlite3_bind_blob( | |
| 1295 sqlite3_stmt *pStmt, | |
| 1296 int i, | |
| 1297 const void *zData, | |
| 1298 int nData, | |
| 1299 void (*xDel)(void*) | |
| 1300 ){ | |
| 1301 return bindText(pStmt, i, zData, nData, xDel, 0); | |
| 1302 } | |
| 1303 int sqlite3_bind_blob64( | |
| 1304 sqlite3_stmt *pStmt, | |
| 1305 int i, | |
| 1306 const void *zData, | |
| 1307 sqlite3_uint64 nData, | |
| 1308 void (*xDel)(void*) | |
| 1309 ){ | |
| 1310 assert( xDel!=SQLITE_DYNAMIC ); | |
| 1311 if( nData>0x7fffffff ){ | |
| 1312 return invokeValueDestructor(zData, xDel, 0); | |
| 1313 }else{ | |
| 1314 return bindText(pStmt, i, zData, (int)nData, xDel, 0); | |
| 1315 } | |
| 1316 } | |
| 1317 int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){ | |
| 1318 int rc; | |
| 1319 Vdbe *p = (Vdbe *)pStmt; | |
| 1320 rc = vdbeUnbind(p, i); | |
| 1321 if( rc==SQLITE_OK ){ | |
| 1322 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue); | |
| 1323 sqlite3_mutex_leave(p->db->mutex); | |
| 1324 } | |
| 1325 return rc; | |
| 1326 } | |
| 1327 int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){ | |
| 1328 return sqlite3_bind_int64(p, i, (i64)iValue); | |
| 1329 } | |
| 1330 int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){ | |
| 1331 int rc; | |
| 1332 Vdbe *p = (Vdbe *)pStmt; | |
| 1333 rc = vdbeUnbind(p, i); | |
| 1334 if( rc==SQLITE_OK ){ | |
| 1335 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue); | |
| 1336 sqlite3_mutex_leave(p->db->mutex); | |
| 1337 } | |
| 1338 return rc; | |
| 1339 } | |
| 1340 int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){ | |
| 1341 int rc; | |
| 1342 Vdbe *p = (Vdbe*)pStmt; | |
| 1343 rc = vdbeUnbind(p, i); | |
| 1344 if( rc==SQLITE_OK ){ | |
| 1345 sqlite3_mutex_leave(p->db->mutex); | |
| 1346 } | |
| 1347 return rc; | |
| 1348 } | |
| 1349 int sqlite3_bind_text( | |
| 1350 sqlite3_stmt *pStmt, | |
| 1351 int i, | |
| 1352 const char *zData, | |
| 1353 int nData, | |
| 1354 void (*xDel)(void*) | |
| 1355 ){ | |
| 1356 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8); | |
| 1357 } | |
| 1358 int sqlite3_bind_text64( | |
| 1359 sqlite3_stmt *pStmt, | |
| 1360 int i, | |
| 1361 const char *zData, | |
| 1362 sqlite3_uint64 nData, | |
| 1363 void (*xDel)(void*), | |
| 1364 unsigned char enc | |
| 1365 ){ | |
| 1366 assert( xDel!=SQLITE_DYNAMIC ); | |
| 1367 if( nData>0x7fffffff ){ | |
| 1368 return invokeValueDestructor(zData, xDel, 0); | |
| 1369 }else{ | |
| 1370 if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE; | |
| 1371 return bindText(pStmt, i, zData, (int)nData, xDel, enc); | |
| 1372 } | |
| 1373 } | |
| 1374 #ifndef SQLITE_OMIT_UTF16 | |
| 1375 int sqlite3_bind_text16( | |
| 1376 sqlite3_stmt *pStmt, | |
| 1377 int i, | |
| 1378 const void *zData, | |
| 1379 int nData, | |
| 1380 void (*xDel)(void*) | |
| 1381 ){ | |
| 1382 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE); | |
| 1383 } | |
| 1384 #endif /* SQLITE_OMIT_UTF16 */ | |
| 1385 int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){ | |
| 1386 int rc; | |
| 1387 switch( sqlite3_value_type((sqlite3_value*)pValue) ){ | |
| 1388 case SQLITE_INTEGER: { | |
| 1389 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i); | |
| 1390 break; | |
| 1391 } | |
| 1392 case SQLITE_FLOAT: { | |
| 1393 rc = sqlite3_bind_double(pStmt, i, pValue->u.r); | |
| 1394 break; | |
| 1395 } | |
| 1396 case SQLITE_BLOB: { | |
| 1397 if( pValue->flags & MEM_Zero ){ | |
| 1398 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero); | |
| 1399 }else{ | |
| 1400 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT); | |
| 1401 } | |
| 1402 break; | |
| 1403 } | |
| 1404 case SQLITE_TEXT: { | |
| 1405 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT, | |
| 1406 pValue->enc); | |
| 1407 break; | |
| 1408 } | |
| 1409 default: { | |
| 1410 rc = sqlite3_bind_null(pStmt, i); | |
| 1411 break; | |
| 1412 } | |
| 1413 } | |
| 1414 return rc; | |
| 1415 } | |
| 1416 int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){ | |
| 1417 int rc; | |
| 1418 Vdbe *p = (Vdbe *)pStmt; | |
| 1419 rc = vdbeUnbind(p, i); | |
| 1420 if( rc==SQLITE_OK ){ | |
| 1421 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n); | |
| 1422 sqlite3_mutex_leave(p->db->mutex); | |
| 1423 } | |
| 1424 return rc; | |
| 1425 } | |
| 1426 int sqlite3_bind_zeroblob64(sqlite3_stmt *pStmt, int i, sqlite3_uint64 n){ | |
| 1427 int rc; | |
| 1428 Vdbe *p = (Vdbe *)pStmt; | |
| 1429 sqlite3_mutex_enter(p->db->mutex); | |
| 1430 if( n>(u64)p->db->aLimit[SQLITE_LIMIT_LENGTH] ){ | |
| 1431 rc = SQLITE_TOOBIG; | |
| 1432 }else{ | |
| 1433 assert( (n & 0x7FFFFFFF)==n ); | |
| 1434 rc = sqlite3_bind_zeroblob(pStmt, i, n); | |
| 1435 } | |
| 1436 rc = sqlite3ApiExit(p->db, rc); | |
| 1437 sqlite3_mutex_leave(p->db->mutex); | |
| 1438 return rc; | |
| 1439 } | |
| 1440 | |
| 1441 /* | |
| 1442 ** Return the number of wildcards that can be potentially bound to. | |
| 1443 ** This routine is added to support DBD::SQLite. | |
| 1444 */ | |
| 1445 int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){ | |
| 1446 Vdbe *p = (Vdbe*)pStmt; | |
| 1447 return p ? p->nVar : 0; | |
| 1448 } | |
| 1449 | |
| 1450 /* | |
| 1451 ** Return the name of a wildcard parameter. Return NULL if the index | |
| 1452 ** is out of range or if the wildcard is unnamed. | |
| 1453 ** | |
| 1454 ** The result is always UTF-8. | |
| 1455 */ | |
| 1456 const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){ | |
| 1457 Vdbe *p = (Vdbe*)pStmt; | |
| 1458 if( p==0 || i<1 || i>p->nzVar ){ | |
| 1459 return 0; | |
| 1460 } | |
| 1461 return p->azVar[i-1]; | |
| 1462 } | |
| 1463 | |
| 1464 /* | |
| 1465 ** Given a wildcard parameter name, return the index of the variable | |
| 1466 ** with that name. If there is no variable with the given name, | |
| 1467 ** return 0. | |
| 1468 */ | |
| 1469 int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){ | |
| 1470 int i; | |
| 1471 if( p==0 ){ | |
| 1472 return 0; | |
| 1473 } | |
| 1474 if( zName ){ | |
| 1475 for(i=0; i<p->nzVar; i++){ | |
| 1476 const char *z = p->azVar[i]; | |
| 1477 if( z && strncmp(z,zName,nName)==0 && z[nName]==0 ){ | |
| 1478 return i+1; | |
| 1479 } | |
| 1480 } | |
| 1481 } | |
| 1482 return 0; | |
| 1483 } | |
| 1484 int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){ | |
| 1485 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName)); | |
| 1486 } | |
| 1487 | |
| 1488 /* | |
| 1489 ** Transfer all bindings from the first statement over to the second. | |
| 1490 */ | |
| 1491 int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ | |
| 1492 Vdbe *pFrom = (Vdbe*)pFromStmt; | |
| 1493 Vdbe *pTo = (Vdbe*)pToStmt; | |
| 1494 int i; | |
| 1495 assert( pTo->db==pFrom->db ); | |
| 1496 assert( pTo->nVar==pFrom->nVar ); | |
| 1497 sqlite3_mutex_enter(pTo->db->mutex); | |
| 1498 for(i=0; i<pFrom->nVar; i++){ | |
| 1499 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]); | |
| 1500 } | |
| 1501 sqlite3_mutex_leave(pTo->db->mutex); | |
| 1502 return SQLITE_OK; | |
| 1503 } | |
| 1504 | |
| 1505 #ifndef SQLITE_OMIT_DEPRECATED | |
| 1506 /* | |
| 1507 ** Deprecated external interface. Internal/core SQLite code | |
| 1508 ** should call sqlite3TransferBindings. | |
| 1509 ** | |
| 1510 ** It is misuse to call this routine with statements from different | |
| 1511 ** database connections. But as this is a deprecated interface, we | |
| 1512 ** will not bother to check for that condition. | |
| 1513 ** | |
| 1514 ** If the two statements contain a different number of bindings, then | |
| 1515 ** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise | |
| 1516 ** SQLITE_OK is returned. | |
| 1517 */ | |
| 1518 int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){ | |
| 1519 Vdbe *pFrom = (Vdbe*)pFromStmt; | |
| 1520 Vdbe *pTo = (Vdbe*)pToStmt; | |
| 1521 if( pFrom->nVar!=pTo->nVar ){ | |
| 1522 return SQLITE_ERROR; | |
| 1523 } | |
| 1524 if( pTo->isPrepareV2 && pTo->expmask ){ | |
| 1525 pTo->expired = 1; | |
| 1526 } | |
| 1527 if( pFrom->isPrepareV2 && pFrom->expmask ){ | |
| 1528 pFrom->expired = 1; | |
| 1529 } | |
| 1530 return sqlite3TransferBindings(pFromStmt, pToStmt); | |
| 1531 } | |
| 1532 #endif | |
| 1533 | |
| 1534 /* | |
| 1535 ** Return the sqlite3* database handle to which the prepared statement given | |
| 1536 ** in the argument belongs. This is the same database handle that was | |
| 1537 ** the first argument to the sqlite3_prepare() that was used to create | |
| 1538 ** the statement in the first place. | |
| 1539 */ | |
| 1540 sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){ | |
| 1541 return pStmt ? ((Vdbe*)pStmt)->db : 0; | |
| 1542 } | |
| 1543 | |
| 1544 /* | |
| 1545 ** Return true if the prepared statement is guaranteed to not modify the | |
| 1546 ** database. | |
| 1547 */ | |
| 1548 int sqlite3_stmt_readonly(sqlite3_stmt *pStmt){ | |
| 1549 return pStmt ? ((Vdbe*)pStmt)->readOnly : 1; | |
| 1550 } | |
| 1551 | |
| 1552 /* | |
| 1553 ** Return true if the prepared statement is in need of being reset. | |
| 1554 */ | |
| 1555 int sqlite3_stmt_busy(sqlite3_stmt *pStmt){ | |
| 1556 Vdbe *v = (Vdbe*)pStmt; | |
| 1557 return v!=0 && v->pc>=0 && v->magic==VDBE_MAGIC_RUN; | |
| 1558 } | |
| 1559 | |
| 1560 /* | |
| 1561 ** Return a pointer to the next prepared statement after pStmt associated | |
| 1562 ** with database connection pDb. If pStmt is NULL, return the first | |
| 1563 ** prepared statement for the database connection. Return NULL if there | |
| 1564 ** are no more. | |
| 1565 */ | |
| 1566 sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){ | |
| 1567 sqlite3_stmt *pNext; | |
| 1568 #ifdef SQLITE_ENABLE_API_ARMOR | |
| 1569 if( !sqlite3SafetyCheckOk(pDb) ){ | |
| 1570 (void)SQLITE_MISUSE_BKPT; | |
| 1571 return 0; | |
| 1572 } | |
| 1573 #endif | |
| 1574 sqlite3_mutex_enter(pDb->mutex); | |
| 1575 if( pStmt==0 ){ | |
| 1576 pNext = (sqlite3_stmt*)pDb->pVdbe; | |
| 1577 }else{ | |
| 1578 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext; | |
| 1579 } | |
| 1580 sqlite3_mutex_leave(pDb->mutex); | |
| 1581 return pNext; | |
| 1582 } | |
| 1583 | |
| 1584 /* | |
| 1585 ** Return the value of a status counter for a prepared statement | |
| 1586 */ | |
| 1587 int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){ | |
| 1588 Vdbe *pVdbe = (Vdbe*)pStmt; | |
| 1589 u32 v; | |
| 1590 #ifdef SQLITE_ENABLE_API_ARMOR | |
| 1591 if( !pStmt ){ | |
| 1592 (void)SQLITE_MISUSE_BKPT; | |
| 1593 return 0; | |
| 1594 } | |
| 1595 #endif | |
| 1596 v = pVdbe->aCounter[op]; | |
| 1597 if( resetFlag ) pVdbe->aCounter[op] = 0; | |
| 1598 return (int)v; | |
| 1599 } | |
| 1600 | |
| 1601 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS | |
| 1602 /* | |
| 1603 ** Return status data for a single loop within query pStmt. | |
| 1604 */ | |
| 1605 int sqlite3_stmt_scanstatus( | |
| 1606 sqlite3_stmt *pStmt, /* Prepared statement being queried */ | |
| 1607 int idx, /* Index of loop to report on */ | |
| 1608 int iScanStatusOp, /* Which metric to return */ | |
| 1609 void *pOut /* OUT: Write the answer here */ | |
| 1610 ){ | |
| 1611 Vdbe *p = (Vdbe*)pStmt; | |
| 1612 ScanStatus *pScan; | |
| 1613 if( idx<0 || idx>=p->nScan ) return 1; | |
| 1614 pScan = &p->aScan[idx]; | |
| 1615 switch( iScanStatusOp ){ | |
| 1616 case SQLITE_SCANSTAT_NLOOP: { | |
| 1617 *(sqlite3_int64*)pOut = p->anExec[pScan->addrLoop]; | |
| 1618 break; | |
| 1619 } | |
| 1620 case SQLITE_SCANSTAT_NVISIT: { | |
| 1621 *(sqlite3_int64*)pOut = p->anExec[pScan->addrVisit]; | |
| 1622 break; | |
| 1623 } | |
| 1624 case SQLITE_SCANSTAT_EST: { | |
| 1625 double r = 1.0; | |
| 1626 LogEst x = pScan->nEst; | |
| 1627 while( x<100 ){ | |
| 1628 x += 10; | |
| 1629 r *= 0.5; | |
| 1630 } | |
| 1631 *(double*)pOut = r*sqlite3LogEstToInt(x); | |
| 1632 break; | |
| 1633 } | |
| 1634 case SQLITE_SCANSTAT_NAME: { | |
| 1635 *(const char**)pOut = pScan->zName; | |
| 1636 break; | |
| 1637 } | |
| 1638 case SQLITE_SCANSTAT_EXPLAIN: { | |
| 1639 if( pScan->addrExplain ){ | |
| 1640 *(const char**)pOut = p->aOp[ pScan->addrExplain ].p4.z; | |
| 1641 }else{ | |
| 1642 *(const char**)pOut = 0; | |
| 1643 } | |
| 1644 break; | |
| 1645 } | |
| 1646 case SQLITE_SCANSTAT_SELECTID: { | |
| 1647 if( pScan->addrExplain ){ | |
| 1648 *(int*)pOut = p->aOp[ pScan->addrExplain ].p1; | |
| 1649 }else{ | |
| 1650 *(int*)pOut = -1; | |
| 1651 } | |
| 1652 break; | |
| 1653 } | |
| 1654 default: { | |
| 1655 return 1; | |
| 1656 } | |
| 1657 } | |
| 1658 return 0; | |
| 1659 } | |
| 1660 | |
| 1661 /* | |
| 1662 ** Zero all counters associated with the sqlite3_stmt_scanstatus() data. | |
| 1663 */ | |
| 1664 void sqlite3_stmt_scanstatus_reset(sqlite3_stmt *pStmt){ | |
| 1665 Vdbe *p = (Vdbe*)pStmt; | |
| 1666 memset(p->anExec, 0, p->nOp * sizeof(i64)); | |
| 1667 } | |
| 1668 #endif /* SQLITE_ENABLE_STMT_SCANSTATUS */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2846743003:
[sql] Remove SQLite 3.10.2 reference directory. (Closed)
