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