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