blob: 29a2a429bc207c679433454e2171aedc6ecc189d [file] [log] [blame]
drh4f26d6c2004-05-26 23:25:30 +00001/*
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
shaneeec556d2008-10-12 00:27:53 +000019#ifndef SQLITE_OMIT_DEPRECATED
drhd89bd002005-01-22 03:03:54 +000020/*
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.
drhd89bd002005-01-22 03:03:54 +000027*/
28int sqlite3_expired(sqlite3_stmt *pStmt){
29 Vdbe *p = (Vdbe*)pStmt;
30 return p==0 || p->expired;
31}
shaneeec556d2008-10-12 00:27:53 +000032#endif
drhd89bd002005-01-22 03:03:54 +000033
drhe30f4422007-08-21 16:15:55 +000034/*
drh413c3d32010-02-23 20:11:56 +000035** 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*/
39static 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}
47static 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/*
drhe30f4422007-08-21 16:15:55 +000057** 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*/
65int sqlite3_finalize(sqlite3_stmt *pStmt){
66 int rc;
67 if( pStmt==0 ){
68 rc = SQLITE_OK;
69 }else{
70 Vdbe *v = (Vdbe*)pStmt;
danielk1977238746a2009-03-19 18:51:06 +000071 sqlite3 *db = v->db;
drh0ae0bfd2010-01-31 15:14:37 +000072#if SQLITE_THREADSAFE
73 sqlite3_mutex *mutex;
74#endif
drh413c3d32010-02-23 20:11:56 +000075 if( vdbeSafety(v) ) return SQLITE_MISUSE_BKPT;
drh18472fa2008-10-07 15:25:48 +000076#if SQLITE_THREADSAFE
drh0ae0bfd2010-01-31 15:14:37 +000077 mutex = v->db->mutex;
drh7e8b8482008-01-23 03:03:05 +000078#endif
drh86f8c192007-08-22 00:39:19 +000079 sqlite3_mutex_enter(mutex);
drhe30f4422007-08-21 16:15:55 +000080 rc = sqlite3VdbeFinalize(v);
danielk1977238746a2009-03-19 18:51:06 +000081 rc = sqlite3ApiExit(db, rc);
drh86f8c192007-08-22 00:39:19 +000082 sqlite3_mutex_leave(mutex);
drhe30f4422007-08-21 16:15:55 +000083 }
84 return rc;
85}
86
87/*
88** Terminate the current execution of an SQL statement and reset it
89** back to its starting state so that it can be reused. A success code from
90** the prior execution is returned.
91**
92** This routine sets the error code and string returned by
93** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
94*/
95int sqlite3_reset(sqlite3_stmt *pStmt){
96 int rc;
97 if( pStmt==0 ){
98 rc = SQLITE_OK;
99 }else{
100 Vdbe *v = (Vdbe*)pStmt;
101 sqlite3_mutex_enter(v->db->mutex);
drhc890fec2008-08-01 20:10:08 +0000102 rc = sqlite3VdbeReset(v);
dane0af83a2009-09-08 19:15:01 +0000103 sqlite3VdbeMakeReady(v, -1, 0, 0, 0, 0, 0);
drhe30f4422007-08-21 16:15:55 +0000104 assert( (rc & (v->db->errMask))==rc );
danielk1977238746a2009-03-19 18:51:06 +0000105 rc = sqlite3ApiExit(v->db, rc);
drhe30f4422007-08-21 16:15:55 +0000106 sqlite3_mutex_leave(v->db->mutex);
107 }
108 return rc;
109}
110
111/*
112** Set all the parameters in the compiled SQL statement to NULL.
113*/
114int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
115 int i;
116 int rc = SQLITE_OK;
drh7297d1f2008-05-09 14:39:44 +0000117 Vdbe *p = (Vdbe*)pStmt;
drh18472fa2008-10-07 15:25:48 +0000118#if SQLITE_THREADSAFE
drh7e8b8482008-01-23 03:03:05 +0000119 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
120#endif
121 sqlite3_mutex_enter(mutex);
drh7297d1f2008-05-09 14:39:44 +0000122 for(i=0; i<p->nVar; i++){
123 sqlite3VdbeMemRelease(&p->aVar[i]);
124 p->aVar[i].flags = MEM_Null;
drhe30f4422007-08-21 16:15:55 +0000125 }
danc94b8592009-10-20 07:01:24 +0000126 if( p->isPrepareV2 && p->expmask ){
127 p->expired = 1;
128 }
drh7e8b8482008-01-23 03:03:05 +0000129 sqlite3_mutex_leave(mutex);
drhe30f4422007-08-21 16:15:55 +0000130 return rc;
131}
132
133
drh4f26d6c2004-05-26 23:25:30 +0000134/**************************** sqlite3_value_ *******************************
135** The following routines extract information from a Mem or sqlite3_value
136** structure.
137*/
138const void *sqlite3_value_blob(sqlite3_value *pVal){
139 Mem *p = (Mem*)pVal;
140 if( p->flags & (MEM_Blob|MEM_Str) ){
drhb21c8cd2007-08-21 19:33:56 +0000141 sqlite3VdbeMemExpandBlob(p);
drh1f0feef2007-05-15 13:27:07 +0000142 p->flags &= ~MEM_Str;
143 p->flags |= MEM_Blob;
drh4f26d6c2004-05-26 23:25:30 +0000144 return p->z;
145 }else{
146 return sqlite3_value_text(pVal);
147 }
148}
149int sqlite3_value_bytes(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000150 return sqlite3ValueBytes(pVal, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +0000151}
152int sqlite3_value_bytes16(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000153 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +0000154}
155double sqlite3_value_double(sqlite3_value *pVal){
drh6a6124e2004-06-27 01:56:33 +0000156 return sqlite3VdbeRealValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000157}
158int sqlite3_value_int(sqlite3_value *pVal){
drhb27b7f52008-12-10 18:03:45 +0000159 return (int)sqlite3VdbeIntValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000160}
drhefad9992004-06-22 12:13:55 +0000161sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
drh6a6124e2004-06-27 01:56:33 +0000162 return sqlite3VdbeIntValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000163}
164const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000165 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +0000166}
drh6c626082004-11-14 21:56:29 +0000167#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000168const void *sqlite3_value_text16(sqlite3_value* pVal){
drhb21c8cd2007-08-21 19:33:56 +0000169 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +0000170}
danielk1977d8123362004-06-12 09:25:12 +0000171const void *sqlite3_value_text16be(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000172 return sqlite3ValueText(pVal, SQLITE_UTF16BE);
danielk1977d8123362004-06-12 09:25:12 +0000173}
174const void *sqlite3_value_text16le(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000175 return sqlite3ValueText(pVal, SQLITE_UTF16LE);
danielk1977d8123362004-06-12 09:25:12 +0000176}
drh6c626082004-11-14 21:56:29 +0000177#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000178int sqlite3_value_type(sqlite3_value* pVal){
drhf4479502004-05-27 03:12:53 +0000179 return pVal->type;
drh4f26d6c2004-05-26 23:25:30 +0000180}
181
182/**************************** sqlite3_result_ *******************************
183** The following routines are used by user-defined functions to specify
184** the function result.
drh4c8555f2009-06-25 01:47:11 +0000185**
186** The setStrOrError() funtion calls sqlite3VdbeMemSetStr() to store the
187** result as a string or blob but if the string or blob is too large, it
188** then sets the error code to SQLITE_TOOBIG
drh4f26d6c2004-05-26 23:25:30 +0000189*/
drh4c8555f2009-06-25 01:47:11 +0000190static void setResultStrOrError(
191 sqlite3_context *pCtx, /* Function context */
192 const char *z, /* String pointer */
193 int n, /* Bytes in string, or negative */
194 u8 enc, /* Encoding of z. 0 for BLOBs */
195 void (*xDel)(void*) /* Destructor function */
196){
197 if( sqlite3VdbeMemSetStr(&pCtx->s, z, n, enc, xDel)==SQLITE_TOOBIG ){
198 sqlite3_result_error_toobig(pCtx);
199 }
200}
drh4f26d6c2004-05-26 23:25:30 +0000201void sqlite3_result_blob(
202 sqlite3_context *pCtx,
203 const void *z,
204 int n,
danielk1977d8123362004-06-12 09:25:12 +0000205 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000206){
drh5708d2d2005-06-22 10:53:59 +0000207 assert( n>=0 );
drh32bc3f62007-08-21 20:25:39 +0000208 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000209 setResultStrOrError(pCtx, z, n, 0, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000210}
211void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
drh32bc3f62007-08-21 20:25:39 +0000212 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000213 sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
214}
215void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
drh32bc3f62007-08-21 20:25:39 +0000216 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh69544ec2008-02-06 14:11:34 +0000217 pCtx->isError = SQLITE_ERROR;
drhb21c8cd2007-08-21 19:33:56 +0000218 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +0000219}
danielk1977a1686c92006-01-23 07:52:37 +0000220#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000221void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
drh32bc3f62007-08-21 20:25:39 +0000222 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh69544ec2008-02-06 14:11:34 +0000223 pCtx->isError = SQLITE_ERROR;
drhb21c8cd2007-08-21 19:33:56 +0000224 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +0000225}
danielk1977a1686c92006-01-23 07:52:37 +0000226#endif
drhf4479502004-05-27 03:12:53 +0000227void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
drh32bc3f62007-08-21 20:25:39 +0000228 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000229 sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
230}
231void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
drh32bc3f62007-08-21 20:25:39 +0000232 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000233 sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
234}
235void sqlite3_result_null(sqlite3_context *pCtx){
drh32bc3f62007-08-21 20:25:39 +0000236 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhf4479502004-05-27 03:12:53 +0000237 sqlite3VdbeMemSetNull(&pCtx->s);
drh4f26d6c2004-05-26 23:25:30 +0000238}
239void sqlite3_result_text(
240 sqlite3_context *pCtx,
241 const char *z,
242 int n,
danielk1977d8123362004-06-12 09:25:12 +0000243 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000244){
drh32bc3f62007-08-21 20:25:39 +0000245 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000246 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000247}
drh6c626082004-11-14 21:56:29 +0000248#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000249void sqlite3_result_text16(
250 sqlite3_context *pCtx,
251 const void *z,
252 int n,
danielk1977d8123362004-06-12 09:25:12 +0000253 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000254){
drh32bc3f62007-08-21 20:25:39 +0000255 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000256 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
danielk1977d8123362004-06-12 09:25:12 +0000257}
258void sqlite3_result_text16be(
259 sqlite3_context *pCtx,
260 const void *z,
261 int n,
262 void (*xDel)(void *)
263){
drh32bc3f62007-08-21 20:25:39 +0000264 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000265 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
danielk1977d8123362004-06-12 09:25:12 +0000266}
267void sqlite3_result_text16le(
268 sqlite3_context *pCtx,
269 const void *z,
270 int n,
271 void (*xDel)(void *)
272){
drh32bc3f62007-08-21 20:25:39 +0000273 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000274 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000275}
drh6c626082004-11-14 21:56:29 +0000276#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000277void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
drh32bc3f62007-08-21 20:25:39 +0000278 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000279 sqlite3VdbeMemCopy(&pCtx->s, pValue);
drh4f26d6c2004-05-26 23:25:30 +0000280}
drhb026e052007-05-02 01:34:31 +0000281void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
drh32bc3f62007-08-21 20:25:39 +0000282 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb026e052007-05-02 01:34:31 +0000283 sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
284}
drh69544ec2008-02-06 14:11:34 +0000285void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
286 pCtx->isError = errCode;
drh51c7d862009-04-27 18:46:06 +0000287 if( pCtx->s.flags & MEM_Null ){
288 sqlite3VdbeMemSetStr(&pCtx->s, sqlite3ErrStr(errCode), -1,
289 SQLITE_UTF8, SQLITE_STATIC);
290 }
drh69544ec2008-02-06 14:11:34 +0000291}
drh4f26d6c2004-05-26 23:25:30 +0000292
drha0206bc2007-05-08 15:15:02 +0000293/* Force an SQLITE_TOOBIG error. */
294void sqlite3_result_error_toobig(sqlite3_context *pCtx){
drh32bc3f62007-08-21 20:25:39 +0000295 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhbb4957f2008-03-20 14:03:29 +0000296 pCtx->isError = SQLITE_TOOBIG;
297 sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1,
298 SQLITE_UTF8, SQLITE_STATIC);
drha0206bc2007-05-08 15:15:02 +0000299}
300
danielk1977a1644fd2007-08-29 12:31:25 +0000301/* An SQLITE_NOMEM error. */
302void sqlite3_result_error_nomem(sqlite3_context *pCtx){
303 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
304 sqlite3VdbeMemSetNull(&pCtx->s);
drh69544ec2008-02-06 14:11:34 +0000305 pCtx->isError = SQLITE_NOMEM;
danielk1977a1644fd2007-08-29 12:31:25 +0000306 pCtx->s.db->mallocFailed = 1;
307}
drh4f26d6c2004-05-26 23:25:30 +0000308
309/*
310** Execute the statement pStmt, either until a row of data is ready, the
311** statement is completely executed or an error occurs.
drhb900aaf2006-11-09 00:24:53 +0000312**
313** This routine implements the bulk of the logic behind the sqlite_step()
314** API. The only thing omitted is the automatic recompile if a
315** schema change has occurred. That detail is handled by the
316** outer sqlite3_step() wrapper procedure.
drh4f26d6c2004-05-26 23:25:30 +0000317*/
drhb900aaf2006-11-09 00:24:53 +0000318static int sqlite3Step(Vdbe *p){
drh9bb575f2004-09-06 17:24:11 +0000319 sqlite3 *db;
drh4f26d6c2004-05-26 23:25:30 +0000320 int rc;
321
danielk1977a185ddb2007-11-15 16:04:15 +0000322 assert(p);
323 if( p->magic!=VDBE_MAGIC_RUN ){
drh3674bfd2010-04-17 12:53:19 +0000324 /* We used to require that sqlite3_reset() be called before retrying
325 ** sqlite3_step() after any error. But after 3.6.23, we changed this
326 ** so that sqlite3_reset() would be called automatically instead of
327 ** throwing the error.
328 */
329 sqlite3_reset((sqlite3_stmt*)p);
drhf1bfe9a2007-10-17 01:44:20 +0000330 }
331
dan14d4cc42010-01-20 14:25:37 +0000332 /* Check that malloc() has not failed. If it has, return early. */
drh17435752007-08-16 04:30:38 +0000333 db = p->db;
drhc456e572008-08-11 18:44:58 +0000334 if( db->mallocFailed ){
dan14d4cc42010-01-20 14:25:37 +0000335 p->rc = SQLITE_NOMEM;
drhc456e572008-08-11 18:44:58 +0000336 return SQLITE_NOMEM;
337 }
danielk1977261919c2005-12-06 12:52:59 +0000338
danielk1977a21c6b62005-01-24 10:25:59 +0000339 if( p->pc<=0 && p->expired ){
drhbee80652010-02-25 21:27:58 +0000340 p->rc = SQLITE_SCHEMA;
drhb900aaf2006-11-09 00:24:53 +0000341 rc = SQLITE_ERROR;
342 goto end_of_step;
danielk1977a21c6b62005-01-24 10:25:59 +0000343 }
danielk19771d850a72004-05-31 08:26:49 +0000344 if( p->pc<0 ){
drh15ca1df2006-07-26 13:43:30 +0000345 /* If there are no other statements currently running, then
346 ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
347 ** from interrupting a statement that has not yet started.
348 */
349 if( db->activeVdbeCnt==0 ){
350 db->u1.isInterrupted = 0;
351 }
352
dan1da40a32009-09-19 17:00:31 +0000353 assert( db->writeVdbeCnt>0 || db->autoCommit==0 || db->nDeferredCons==0 );
354
drh19e2d372005-08-29 23:00:03 +0000355#ifndef SQLITE_OMIT_TRACE
drh19e2d372005-08-29 23:00:03 +0000356 if( db->xProfile && !db->init.busy ){
357 double rNow;
danielk1977b4b47412007-08-17 15:53:36 +0000358 sqlite3OsCurrentTime(db->pVfs, &rNow);
drhb27b7f52008-12-10 18:03:45 +0000359 p->startTime = (u64)((rNow - (int)rNow)*3600.0*24.0*1000000000.0);
drh19e2d372005-08-29 23:00:03 +0000360 }
361#endif
drhc16a03b2004-09-15 13:38:10 +0000362
danielk19771d850a72004-05-31 08:26:49 +0000363 db->activeVdbeCnt++;
drhad4a4b82008-11-05 16:37:34 +0000364 if( p->readOnly==0 ) db->writeVdbeCnt++;
danielk19771d850a72004-05-31 08:26:49 +0000365 p->pc = 0;
366 }
drhb7f91642004-10-31 02:22:47 +0000367#ifndef SQLITE_OMIT_EXPLAIN
drh4f26d6c2004-05-26 23:25:30 +0000368 if( p->explain ){
369 rc = sqlite3VdbeList(p);
drhb7f91642004-10-31 02:22:47 +0000370 }else
371#endif /* SQLITE_OMIT_EXPLAIN */
372 {
drh4f26d6c2004-05-26 23:25:30 +0000373 rc = sqlite3VdbeExec(p);
374 }
375
drh19e2d372005-08-29 23:00:03 +0000376#ifndef SQLITE_OMIT_TRACE
377 /* Invoke the profile callback if there is one
378 */
danielk19776ab3a2e2009-02-19 14:39:25 +0000379 if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){
drh19e2d372005-08-29 23:00:03 +0000380 double rNow;
381 u64 elapseTime;
382
danielk1977b4b47412007-08-17 15:53:36 +0000383 sqlite3OsCurrentTime(db->pVfs, &rNow);
drhb27b7f52008-12-10 18:03:45 +0000384 elapseTime = (u64)((rNow - (int)rNow)*3600.0*24.0*1000000000.0);
385 elapseTime -= p->startTime;
danielk19776ab3a2e2009-02-19 14:39:25 +0000386 db->xProfile(db->pProfileArg, p->zSql, elapseTime);
drh19e2d372005-08-29 23:00:03 +0000387 }
388#endif
389
drh80cc85b2008-07-23 21:07:25 +0000390 db->errCode = rc;
danielk1977357864e2009-03-25 15:43:08 +0000391 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
392 p->rc = SQLITE_NOMEM;
drhb900aaf2006-11-09 00:24:53 +0000393 }
danielk1977357864e2009-03-25 15:43:08 +0000394end_of_step:
395 /* At this point local variable rc holds the value that should be
396 ** returned if this statement was compiled using the legacy
397 ** sqlite3_prepare() interface. According to the docs, this can only
398 ** be one of the values in the first assert() below. Variable p->rc
399 ** contains the value that would be returned if sqlite3_finalize()
400 ** were called on statement p.
401 */
402 assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR
403 || rc==SQLITE_BUSY || rc==SQLITE_MISUSE
404 );
405 assert( p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE );
406 if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
407 /* If this statement was prepared using sqlite3_prepare_v2(), and an
408 ** error has occured, then return the error code in p->rc to the
409 ** caller. Set the error code in the database handle to the same value.
410 */
411 rc = db->errCode = p->rc;
412 }
413 return (rc&db->errMask);
drhb900aaf2006-11-09 00:24:53 +0000414}
415
416/*
417** This is the top-level implementation of sqlite3_step(). Call
418** sqlite3Step() to do most of the work. If a schema error occurs,
419** call sqlite3Reprepare() and try again.
420*/
drhb900aaf2006-11-09 00:24:53 +0000421int sqlite3_step(sqlite3_stmt *pStmt){
drha6129fa2010-02-24 17:15:19 +0000422 int rc = SQLITE_OK; /* Result from sqlite3Step() */
423 int rc2 = SQLITE_OK; /* Result from sqlite3Reprepare() */
424 Vdbe *v = (Vdbe*)pStmt; /* the prepared statement */
425 int cnt = 0; /* Counter to prevent infinite loop of reprepares */
426 sqlite3 *db; /* The database connection */
427
drh413c3d32010-02-23 20:11:56 +0000428 if( vdbeSafetyNotNull(v) ){
429 return SQLITE_MISUSE_BKPT;
danielk19778e556522007-11-13 10:30:24 +0000430 }
drh413c3d32010-02-23 20:11:56 +0000431 db = v->db;
432 sqlite3_mutex_enter(db->mutex);
433 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
434 && cnt++ < 5
drha6129fa2010-02-24 17:15:19 +0000435 && (rc2 = rc = sqlite3Reprepare(v))==SQLITE_OK ){
drh413c3d32010-02-23 20:11:56 +0000436 sqlite3_reset(pStmt);
437 v->expired = 0;
438 }
drhbee80652010-02-25 21:27:58 +0000439 if( rc2!=SQLITE_OK && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
drh413c3d32010-02-23 20:11:56 +0000440 /* This case occurs after failing to recompile an sql statement.
441 ** The error message from the SQL compiler has already been loaded
442 ** into the database handle. This block copies the error message
443 ** from the database handle into the statement and sets the statement
444 ** program counter to 0 to ensure that when the statement is
445 ** finalized or reset the parser error message is available via
446 ** sqlite3_errmsg() and sqlite3_errcode().
447 */
448 const char *zErr = (const char *)sqlite3_value_text(db->pErr);
449 sqlite3DbFree(db, v->zErrMsg);
450 if( !db->mallocFailed ){
451 v->zErrMsg = sqlite3DbStrDup(db, zErr);
drha6129fa2010-02-24 17:15:19 +0000452 v->rc = rc2;
drh413c3d32010-02-23 20:11:56 +0000453 } else {
454 v->zErrMsg = 0;
drha6129fa2010-02-24 17:15:19 +0000455 v->rc = rc = SQLITE_NOMEM;
drh413c3d32010-02-23 20:11:56 +0000456 }
457 }
458 rc = sqlite3ApiExit(db, rc);
459 sqlite3_mutex_leave(db->mutex);
danielk197776e8d1a2006-01-18 18:22:43 +0000460 return rc;
drh4f26d6c2004-05-26 23:25:30 +0000461}
462
463/*
drheb2e1762004-05-27 01:53:56 +0000464** Extract the user data from a sqlite3_context structure and return a
465** pointer to it.
466*/
467void *sqlite3_user_data(sqlite3_context *p){
468 assert( p && p->pFunc );
469 return p->pFunc->pUserData;
470}
471
472/*
drhfa4a4b92008-03-19 21:45:51 +0000473** Extract the user data from a sqlite3_context structure and return a
474** pointer to it.
475*/
476sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
477 assert( p && p->pFunc );
478 return p->s.db;
479}
480
481/*
drhb7481e72006-09-16 21:45:14 +0000482** The following is the implementation of an SQL function that always
483** fails with an error message stating that the function is used in the
484** wrong context. The sqlite3_overload_function() API might construct
485** SQL function that use this routine so that the functions will exist
486** for name resolution but are actually overloaded by the xFindFunction
487** method of virtual tables.
488*/
489void sqlite3InvalidFunction(
490 sqlite3_context *context, /* The function calling context */
danielk197762c14b32008-11-19 09:05:26 +0000491 int NotUsed, /* Number of arguments to the function */
492 sqlite3_value **NotUsed2 /* Value of each argument */
drhb7481e72006-09-16 21:45:14 +0000493){
494 const char *zName = context->pFunc->zName;
495 char *zErr;
danielk197762c14b32008-11-19 09:05:26 +0000496 UNUSED_PARAMETER2(NotUsed, NotUsed2);
drhbc6160b2009-04-08 15:45:31 +0000497 zErr = sqlite3_mprintf(
drhb7481e72006-09-16 21:45:14 +0000498 "unable to use function %s in the requested context", zName);
499 sqlite3_result_error(context, zErr, -1);
danielk19771e536952007-08-16 10:09:01 +0000500 sqlite3_free(zErr);
drhb7481e72006-09-16 21:45:14 +0000501}
502
503/*
drheb2e1762004-05-27 01:53:56 +0000504** Allocate or return the aggregate context for a user function. A new
505** context is allocated on the first call. Subsequent calls return the
506** same context that was returned on prior calls.
drheb2e1762004-05-27 01:53:56 +0000507*/
508void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
drhb21c8cd2007-08-21 19:33:56 +0000509 Mem *pMem;
drh825c6622005-09-08 19:01:05 +0000510 assert( p && p->pFunc && p->pFunc->xStep );
drhb21c8cd2007-08-21 19:33:56 +0000511 assert( sqlite3_mutex_held(p->s.db->mutex) );
512 pMem = p->pMem;
drhd68eee02009-12-11 03:44:18 +0000513 testcase( nByte<0 );
drha10a34b2005-09-07 22:09:48 +0000514 if( (pMem->flags & MEM_Agg)==0 ){
drhd68eee02009-12-11 03:44:18 +0000515 if( nByte<=0 ){
danielk19775f096132008-03-28 15:44:09 +0000516 sqlite3VdbeMemReleaseExternal(pMem);
517 pMem->flags = MEM_Null;
drha10a34b2005-09-07 22:09:48 +0000518 pMem->z = 0;
drheb2e1762004-05-27 01:53:56 +0000519 }else{
danielk19775f096132008-03-28 15:44:09 +0000520 sqlite3VdbeMemGrow(pMem, nByte, 0);
drha10a34b2005-09-07 22:09:48 +0000521 pMem->flags = MEM_Agg;
drh3c024d62007-03-30 11:23:45 +0000522 pMem->u.pDef = p->pFunc;
danielk19775f096132008-03-28 15:44:09 +0000523 if( pMem->z ){
524 memset(pMem->z, 0, nByte);
525 }
drheb2e1762004-05-27 01:53:56 +0000526 }
527 }
drhabfcea22005-09-06 20:36:48 +0000528 return (void*)pMem->z;
drheb2e1762004-05-27 01:53:56 +0000529}
530
531/*
danielk1977682f68b2004-06-05 10:22:17 +0000532** Return the auxilary data pointer, if any, for the iArg'th argument to
533** the user-function defined by pCtx.
534*/
535void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
drhb21c8cd2007-08-21 19:33:56 +0000536 VdbeFunc *pVdbeFunc;
537
538 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
539 pVdbeFunc = pCtx->pVdbeFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000540 if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
541 return 0;
542 }
drhf92c7ff2004-06-19 15:40:23 +0000543 return pVdbeFunc->apAux[iArg].pAux;
danielk1977682f68b2004-06-05 10:22:17 +0000544}
545
546/*
547** Set the auxilary data pointer and delete function, for the iArg'th
548** argument to the user-function defined by pCtx. Any previous value is
549** deleted by calling the delete function specified when it was set.
550*/
551void sqlite3_set_auxdata(
552 sqlite3_context *pCtx,
553 int iArg,
554 void *pAux,
555 void (*xDelete)(void*)
556){
557 struct AuxData *pAuxData;
drhf92c7ff2004-06-19 15:40:23 +0000558 VdbeFunc *pVdbeFunc;
danielk1977e0fc5262007-07-26 06:50:05 +0000559 if( iArg<0 ) goto failed;
danielk1977682f68b2004-06-05 10:22:17 +0000560
drhb21c8cd2007-08-21 19:33:56 +0000561 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhf92c7ff2004-06-19 15:40:23 +0000562 pVdbeFunc = pCtx->pVdbeFunc;
563 if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
danielk197731dad9d2007-08-16 11:36:15 +0000564 int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
drhf92c7ff2004-06-19 15:40:23 +0000565 int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
danielk197726783a52007-08-29 14:06:22 +0000566 pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
drh17435752007-08-16 04:30:38 +0000567 if( !pVdbeFunc ){
drh17435752007-08-16 04:30:38 +0000568 goto failed;
569 }
drh53f733c2005-09-16 02:38:09 +0000570 pCtx->pVdbeFunc = pVdbeFunc;
danielk197731dad9d2007-08-16 11:36:15 +0000571 memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
drh998da3a2004-06-19 15:22:56 +0000572 pVdbeFunc->nAux = iArg+1;
573 pVdbeFunc->pFunc = pCtx->pFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000574 }
575
drhf92c7ff2004-06-19 15:40:23 +0000576 pAuxData = &pVdbeFunc->apAux[iArg];
danielk1977682f68b2004-06-05 10:22:17 +0000577 if( pAuxData->pAux && pAuxData->xDelete ){
578 pAuxData->xDelete(pAuxData->pAux);
579 }
580 pAuxData->pAux = pAux;
581 pAuxData->xDelete = xDelete;
danielk1977e0fc5262007-07-26 06:50:05 +0000582 return;
583
584failed:
585 if( xDelete ){
586 xDelete(pAux);
587 }
danielk1977682f68b2004-06-05 10:22:17 +0000588}
589
shaneeec556d2008-10-12 00:27:53 +0000590#ifndef SQLITE_OMIT_DEPRECATED
danielk1977682f68b2004-06-05 10:22:17 +0000591/*
drheb2e1762004-05-27 01:53:56 +0000592** Return the number of times the Step function of a aggregate has been
593** called.
594**
drhcf85a512006-02-09 18:35:29 +0000595** This function is deprecated. Do not use it for new code. It is
596** provide only to avoid breaking legacy code. New aggregate function
597** implementations should keep their own counts within their aggregate
598** context.
drheb2e1762004-05-27 01:53:56 +0000599*/
600int sqlite3_aggregate_count(sqlite3_context *p){
shanee34c6472009-03-05 04:23:47 +0000601 assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
drhabfcea22005-09-06 20:36:48 +0000602 return p->pMem->n;
drheb2e1762004-05-27 01:53:56 +0000603}
shaneeec556d2008-10-12 00:27:53 +0000604#endif
drheb2e1762004-05-27 01:53:56 +0000605
606/*
drh4f26d6c2004-05-26 23:25:30 +0000607** Return the number of columns in the result set for the statement pStmt.
608*/
609int sqlite3_column_count(sqlite3_stmt *pStmt){
610 Vdbe *pVm = (Vdbe *)pStmt;
drh1bcdb0c2004-08-28 14:49:46 +0000611 return pVm ? pVm->nResColumn : 0;
drh4f26d6c2004-05-26 23:25:30 +0000612}
613
614/*
615** Return the number of values available from the current row of the
616** currently executing statement pStmt.
617*/
618int sqlite3_data_count(sqlite3_stmt *pStmt){
619 Vdbe *pVm = (Vdbe *)pStmt;
drhd4e70eb2008-01-02 00:34:36 +0000620 if( pVm==0 || pVm->pResultSet==0 ) return 0;
drh4f26d6c2004-05-26 23:25:30 +0000621 return pVm->nResColumn;
622}
623
624
625/*
626** Check to see if column iCol of the given statement is valid. If
627** it is, return a pointer to the Mem for the value of that column.
628** If iCol is not valid, return a pointer to a Mem which has a value
629** of NULL.
630*/
631static Mem *columnMem(sqlite3_stmt *pStmt, int i){
drh32bc3f62007-08-21 20:25:39 +0000632 Vdbe *pVm;
633 int vals;
634 Mem *pOut;
635
636 pVm = (Vdbe *)pStmt;
drhd4e70eb2008-01-02 00:34:36 +0000637 if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
drh32bc3f62007-08-21 20:25:39 +0000638 sqlite3_mutex_enter(pVm->db->mutex);
639 vals = sqlite3_data_count(pStmt);
drhd4e70eb2008-01-02 00:34:36 +0000640 pOut = &pVm->pResultSet[i];
drh32bc3f62007-08-21 20:25:39 +0000641 }else{
danielk197741f5b042009-06-06 14:13:26 +0000642 /* If the value passed as the second argument is out of range, return
643 ** a pointer to the following static Mem object which contains the
644 ** value SQL NULL. Even though the Mem structure contains an element
645 ** of type i64, on certain architecture (x86) with certain compiler
646 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
647 ** instead of an 8-byte one. This all works fine, except that when
648 ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
649 ** that a Mem structure is located on an 8-byte boundary. To prevent
650 ** this assert() from failing, when building with SQLITE_DEBUG defined
651 ** using gcc, force nullMem to be 8-byte aligned using the magical
652 ** __attribute__((aligned(8))) macro. */
653 static const Mem nullMem
654#if defined(SQLITE_DEBUG) && defined(__GNUC__)
655 __attribute__((aligned(8)))
656#endif
657 = {{0}, (double)0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };
658
drh9b4ea4a2009-04-10 20:32:00 +0000659 if( pVm && ALWAYS(pVm->db) ){
drh27641702007-08-22 02:56:42 +0000660 sqlite3_mutex_enter(pVm->db->mutex);
661 sqlite3Error(pVm->db, SQLITE_RANGE, 0);
662 }
drh32bc3f62007-08-21 20:25:39 +0000663 pOut = (Mem*)&nullMem;
drh4f26d6c2004-05-26 23:25:30 +0000664 }
drh32bc3f62007-08-21 20:25:39 +0000665 return pOut;
drh4f26d6c2004-05-26 23:25:30 +0000666}
667
danielk19772e588c72005-12-09 14:25:08 +0000668/*
669** This function is called after invoking an sqlite3_value_XXX function on a
670** column value (i.e. a value returned by evaluating an SQL expression in the
671** select list of a SELECT statement) that may cause a malloc() failure. If
672** malloc() has failed, the threads mallocFailed flag is cleared and the result
673** code of statement pStmt set to SQLITE_NOMEM.
674**
drh32bc3f62007-08-21 20:25:39 +0000675** Specifically, this is called from within:
danielk19772e588c72005-12-09 14:25:08 +0000676**
677** sqlite3_column_int()
678** sqlite3_column_int64()
679** sqlite3_column_text()
680** sqlite3_column_text16()
681** sqlite3_column_real()
682** sqlite3_column_bytes()
683** sqlite3_column_bytes16()
684**
685** But not for sqlite3_column_blob(), which never calls malloc().
686*/
687static void columnMallocFailure(sqlite3_stmt *pStmt)
688{
689 /* If malloc() failed during an encoding conversion within an
690 ** sqlite3_column_XXX API, then set the return code of the statement to
691 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
692 ** and _finalize() will return NOMEM.
693 */
danielk197754f01982006-01-18 15:25:17 +0000694 Vdbe *p = (Vdbe *)pStmt;
drh32bc3f62007-08-21 20:25:39 +0000695 if( p ){
696 p->rc = sqlite3ApiExit(p->db, p->rc);
697 sqlite3_mutex_leave(p->db->mutex);
698 }
danielk19772e588c72005-12-09 14:25:08 +0000699}
700
drh4f26d6c2004-05-26 23:25:30 +0000701/**************************** sqlite3_column_ *******************************
702** The following routines are used to access elements of the current row
703** in the result set.
704*/
danielk1977c572ef72004-05-27 09:28:41 +0000705const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000706 const void *val;
danielk19772e588c72005-12-09 14:25:08 +0000707 val = sqlite3_value_blob( columnMem(pStmt,i) );
danielk1977c9cf9012007-05-30 10:36:47 +0000708 /* Even though there is no encoding conversion, value_blob() might
709 ** need to call malloc() to expand the result of a zeroblob()
710 ** expression.
711 */
712 columnMallocFailure(pStmt);
danielk19772e588c72005-12-09 14:25:08 +0000713 return val;
danielk1977c572ef72004-05-27 09:28:41 +0000714}
drh4f26d6c2004-05-26 23:25:30 +0000715int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000716 int val = sqlite3_value_bytes( columnMem(pStmt,i) );
717 columnMallocFailure(pStmt);
718 return val;
drh4f26d6c2004-05-26 23:25:30 +0000719}
720int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000721 int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
722 columnMallocFailure(pStmt);
723 return val;
drh4f26d6c2004-05-26 23:25:30 +0000724}
725double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000726 double val = sqlite3_value_double( columnMem(pStmt,i) );
727 columnMallocFailure(pStmt);
728 return val;
drh4f26d6c2004-05-26 23:25:30 +0000729}
730int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000731 int val = sqlite3_value_int( columnMem(pStmt,i) );
732 columnMallocFailure(pStmt);
733 return val;
drh4f26d6c2004-05-26 23:25:30 +0000734}
drhefad9992004-06-22 12:13:55 +0000735sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000736 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
737 columnMallocFailure(pStmt);
738 return val;
drh4f26d6c2004-05-26 23:25:30 +0000739}
740const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000741 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
742 columnMallocFailure(pStmt);
743 return val;
drh4f26d6c2004-05-26 23:25:30 +0000744}
drhd1e47332005-06-26 17:55:33 +0000745sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
danielk1977d0ffa1e2008-10-13 10:37:49 +0000746 Mem *pOut = columnMem(pStmt, i);
747 if( pOut->flags&MEM_Static ){
748 pOut->flags &= ~MEM_Static;
749 pOut->flags |= MEM_Ephem;
750 }
drh32bc3f62007-08-21 20:25:39 +0000751 columnMallocFailure(pStmt);
danielk1977d0ffa1e2008-10-13 10:37:49 +0000752 return (sqlite3_value *)pOut;
drhd1e47332005-06-26 17:55:33 +0000753}
drh6c626082004-11-14 21:56:29 +0000754#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000755const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000756 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
757 columnMallocFailure(pStmt);
758 return val;
drh4f26d6c2004-05-26 23:25:30 +0000759}
drh6c626082004-11-14 21:56:29 +0000760#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000761int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
drh32bc3f62007-08-21 20:25:39 +0000762 int iType = sqlite3_value_type( columnMem(pStmt,i) );
763 columnMallocFailure(pStmt);
764 return iType;
drh4f26d6c2004-05-26 23:25:30 +0000765}
766
drh29d72102006-02-09 22:13:41 +0000767/* The following function is experimental and subject to change or
768** removal */
769/*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
770** return sqlite3_value_numeric_type( columnMem(pStmt,i) );
771**}
772*/
773
drh5e2517e2004-09-24 23:59:12 +0000774/*
775** Convert the N-th element of pStmt->pColName[] into a string using
776** xFunc() then return that string. If N is out of range, return 0.
drhe590fbd2005-05-20 19:36:01 +0000777**
778** There are up to 5 names for each column. useType determines which
779** name is returned. Here are the names:
780**
781** 0 The column name as it should be displayed for output
782** 1 The datatype name for the column
783** 2 The name of the database that the column derives from
784** 3 The name of the table that the column derives from
785** 4 The name of the table column that the result column derives from
786**
787** If the result is not a simple column reference (if it is an expression
788** or a constant) then useTypes 2, 3, and 4 return NULL.
drh5e2517e2004-09-24 23:59:12 +0000789*/
790static const void *columnName(
791 sqlite3_stmt *pStmt,
792 int N,
793 const void *(*xFunc)(Mem*),
794 int useType
795){
drh32bc3f62007-08-21 20:25:39 +0000796 const void *ret = 0;
drh5e2517e2004-09-24 23:59:12 +0000797 Vdbe *p = (Vdbe *)pStmt;
drh32bc3f62007-08-21 20:25:39 +0000798 int n;
drhc6c7fd52009-04-08 23:05:28 +0000799 sqlite3 *db = p->db;
drh32bc3f62007-08-21 20:25:39 +0000800
drh9b4ea4a2009-04-10 20:32:00 +0000801 assert( db!=0 );
802 n = sqlite3_column_count(pStmt);
803 if( N<n && N>=0 ){
804 N += useType*n;
805 sqlite3_mutex_enter(db->mutex);
806 assert( db->mallocFailed==0 );
807 ret = xFunc(&p->aColName[N]);
808 /* A malloc may have failed inside of the xFunc() call. If this
809 ** is the case, clear the mallocFailed flag and return NULL.
810 */
811 if( db->mallocFailed ){
812 db->mallocFailed = 0;
813 ret = 0;
drh32bc3f62007-08-21 20:25:39 +0000814 }
drh9b4ea4a2009-04-10 20:32:00 +0000815 sqlite3_mutex_leave(db->mutex);
drh5e2517e2004-09-24 23:59:12 +0000816 }
danielk197700fd9572005-12-07 06:27:43 +0000817 return ret;
drh5e2517e2004-09-24 23:59:12 +0000818}
819
drh4f26d6c2004-05-26 23:25:30 +0000820/*
821** Return the name of the Nth column of the result set returned by SQL
822** statement pStmt.
823*/
824const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000825 return columnName(
826 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
drh4f26d6c2004-05-26 23:25:30 +0000827}
drhe590fbd2005-05-20 19:36:01 +0000828#ifndef SQLITE_OMIT_UTF16
829const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000830 return columnName(
831 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
drhe590fbd2005-05-20 19:36:01 +0000832}
833#endif
drh4f26d6c2004-05-26 23:25:30 +0000834
835/*
drh3f913572008-03-22 01:07:17 +0000836** Constraint: If you have ENABLE_COLUMN_METADATA then you must
837** not define OMIT_DECLTYPE.
838*/
839#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
840# error "Must not define both SQLITE_OMIT_DECLTYPE \
841 and SQLITE_ENABLE_COLUMN_METADATA"
842#endif
843
844#ifndef SQLITE_OMIT_DECLTYPE
845/*
drh6c626082004-11-14 21:56:29 +0000846** Return the column declaration type (if applicable) of the 'i'th column
drhe590fbd2005-05-20 19:36:01 +0000847** of the result set of SQL statement pStmt.
drh6c626082004-11-14 21:56:29 +0000848*/
849const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000850 return columnName(
851 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
drh6c626082004-11-14 21:56:29 +0000852}
drh6c626082004-11-14 21:56:29 +0000853#ifndef SQLITE_OMIT_UTF16
danielk197776d505b2004-05-28 13:13:02 +0000854const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000855 return columnName(
856 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
drh4f26d6c2004-05-26 23:25:30 +0000857}
drh6c626082004-11-14 21:56:29 +0000858#endif /* SQLITE_OMIT_UTF16 */
drh3f913572008-03-22 01:07:17 +0000859#endif /* SQLITE_OMIT_DECLTYPE */
drh4f26d6c2004-05-26 23:25:30 +0000860
danielk19774b1ae992006-02-10 03:06:10 +0000861#ifdef SQLITE_ENABLE_COLUMN_METADATA
drhe590fbd2005-05-20 19:36:01 +0000862/*
863** Return the name of the database from which a result column derives.
864** NULL is returned if the result column is an expression or constant or
865** anything else which is not an unabiguous reference to a database column.
866*/
867const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000868 return columnName(
869 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
drhe590fbd2005-05-20 19:36:01 +0000870}
871#ifndef SQLITE_OMIT_UTF16
872const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000873 return columnName(
874 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
drhe590fbd2005-05-20 19:36:01 +0000875}
876#endif /* SQLITE_OMIT_UTF16 */
877
878/*
879** Return the name of the table from which a result column derives.
880** NULL is returned if the result column is an expression or constant or
881** anything else which is not an unabiguous reference to a database column.
882*/
883const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000884 return columnName(
885 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
drhe590fbd2005-05-20 19:36:01 +0000886}
887#ifndef SQLITE_OMIT_UTF16
888const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000889 return columnName(
890 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
drhe590fbd2005-05-20 19:36:01 +0000891}
892#endif /* SQLITE_OMIT_UTF16 */
893
894/*
895** Return the name of the table column from which a result column derives.
896** NULL is returned if the result column is an expression or constant or
897** anything else which is not an unabiguous reference to a database column.
898*/
899const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000900 return columnName(
901 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
drhe590fbd2005-05-20 19:36:01 +0000902}
903#ifndef SQLITE_OMIT_UTF16
904const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000905 return columnName(
906 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
drhe590fbd2005-05-20 19:36:01 +0000907}
908#endif /* SQLITE_OMIT_UTF16 */
danielk19774b1ae992006-02-10 03:06:10 +0000909#endif /* SQLITE_ENABLE_COLUMN_METADATA */
drhe590fbd2005-05-20 19:36:01 +0000910
911
drh4f26d6c2004-05-26 23:25:30 +0000912/******************************* sqlite3_bind_ ***************************
913**
914** Routines used to attach values to wildcards in a compiled SQL statement.
915*/
916/*
917** Unbind the value bound to variable i in virtual machine p. This is the
918** the same as binding a NULL value to the column. If the "i" parameter is
919** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
920**
drh488e7b62008-10-06 12:46:43 +0000921** A successful evaluation of this routine acquires the mutex on p.
922** the mutex is released if any kind of error occurs.
923**
drh4f26d6c2004-05-26 23:25:30 +0000924** The error code stored in database p->db is overwritten with the return
925** value in any case.
926*/
927static int vdbeUnbind(Vdbe *p, int i){
928 Mem *pVar;
drh413c3d32010-02-23 20:11:56 +0000929 if( vdbeSafetyNotNull(p) ){
930 return SQLITE_MISUSE_BKPT;
931 }
drh488e7b62008-10-06 12:46:43 +0000932 sqlite3_mutex_enter(p->db->mutex);
933 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
934 sqlite3Error(p->db, SQLITE_MISUSE, 0);
935 sqlite3_mutex_leave(p->db->mutex);
drh413c3d32010-02-23 20:11:56 +0000936 sqlite3_log(SQLITE_MISUSE,
937 "bind on a busy prepared statement: [%s]", p->zSql);
938 return SQLITE_MISUSE_BKPT;
drh4f26d6c2004-05-26 23:25:30 +0000939 }
940 if( i<1 || i>p->nVar ){
941 sqlite3Error(p->db, SQLITE_RANGE, 0);
drh488e7b62008-10-06 12:46:43 +0000942 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +0000943 return SQLITE_RANGE;
944 }
945 i--;
drh290c1942004-08-21 17:54:45 +0000946 pVar = &p->aVar[i];
danielk1977d8123362004-06-12 09:25:12 +0000947 sqlite3VdbeMemRelease(pVar);
drh4f26d6c2004-05-26 23:25:30 +0000948 pVar->flags = MEM_Null;
949 sqlite3Error(p->db, SQLITE_OK, 0);
dan937d0de2009-10-15 18:35:38 +0000950
dan1d2ce4f2009-10-19 18:11:09 +0000951 /* If the bit corresponding to this variable in Vdbe.expmask is set, then
952 ** binding a new value to this variable invalidates the current query plan.
953 */
drh823e09a2009-10-19 20:15:38 +0000954 if( p->isPrepareV2 &&
955 ((i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff)
956 ){
dan937d0de2009-10-15 18:35:38 +0000957 p->expired = 1;
958 }
drh4f26d6c2004-05-26 23:25:30 +0000959 return SQLITE_OK;
960}
961
962/*
drh5e2517e2004-09-24 23:59:12 +0000963** Bind a text or BLOB value.
drh4f26d6c2004-05-26 23:25:30 +0000964*/
drh5e2517e2004-09-24 23:59:12 +0000965static int bindText(
drh605264d2007-08-21 15:13:19 +0000966 sqlite3_stmt *pStmt, /* The statement to bind against */
967 int i, /* Index of the parameter to bind */
968 const void *zData, /* Pointer to the data to be bound */
969 int nData, /* Number of bytes of data to be bound */
970 void (*xDel)(void*), /* Destructor for the data */
drhb27b7f52008-12-10 18:03:45 +0000971 u8 encoding /* Encoding for the data */
drh4f26d6c2004-05-26 23:25:30 +0000972){
973 Vdbe *p = (Vdbe *)pStmt;
974 Mem *pVar;
975 int rc;
976
977 rc = vdbeUnbind(p, i);
drh488e7b62008-10-06 12:46:43 +0000978 if( rc==SQLITE_OK ){
979 if( zData!=0 ){
980 pVar = &p->aVar[i-1];
981 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
982 if( rc==SQLITE_OK && encoding!=0 ){
983 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
984 }
985 sqlite3Error(p->db, rc, 0);
986 rc = sqlite3ApiExit(p->db, rc);
drh27641702007-08-22 02:56:42 +0000987 }
drh488e7b62008-10-06 12:46:43 +0000988 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +0000989 }
drh605264d2007-08-21 15:13:19 +0000990 return rc;
drh4f26d6c2004-05-26 23:25:30 +0000991}
drh5e2517e2004-09-24 23:59:12 +0000992
993
994/*
995** Bind a blob value to an SQL statement variable.
996*/
997int sqlite3_bind_blob(
998 sqlite3_stmt *pStmt,
999 int i,
1000 const void *zData,
1001 int nData,
1002 void (*xDel)(void*)
1003){
1004 return bindText(pStmt, i, zData, nData, xDel, 0);
1005}
drh4f26d6c2004-05-26 23:25:30 +00001006int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
1007 int rc;
1008 Vdbe *p = (Vdbe *)pStmt;
drh4f26d6c2004-05-26 23:25:30 +00001009 rc = vdbeUnbind(p, i);
1010 if( rc==SQLITE_OK ){
drh290c1942004-08-21 17:54:45 +00001011 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
drh488e7b62008-10-06 12:46:43 +00001012 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +00001013 }
danielk1977f4618892004-06-28 13:09:11 +00001014 return rc;
drh4f26d6c2004-05-26 23:25:30 +00001015}
1016int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
drhefad9992004-06-22 12:13:55 +00001017 return sqlite3_bind_int64(p, i, (i64)iValue);
drh4f26d6c2004-05-26 23:25:30 +00001018}
drhefad9992004-06-22 12:13:55 +00001019int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
drh4f26d6c2004-05-26 23:25:30 +00001020 int rc;
1021 Vdbe *p = (Vdbe *)pStmt;
1022 rc = vdbeUnbind(p, i);
1023 if( rc==SQLITE_OK ){
drh290c1942004-08-21 17:54:45 +00001024 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
drh488e7b62008-10-06 12:46:43 +00001025 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +00001026 }
1027 return rc;
1028}
drh605264d2007-08-21 15:13:19 +00001029int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
1030 int rc;
1031 Vdbe *p = (Vdbe*)pStmt;
drh605264d2007-08-21 15:13:19 +00001032 rc = vdbeUnbind(p, i);
drh488e7b62008-10-06 12:46:43 +00001033 if( rc==SQLITE_OK ){
1034 sqlite3_mutex_leave(p->db->mutex);
1035 }
drh605264d2007-08-21 15:13:19 +00001036 return rc;
drh4f26d6c2004-05-26 23:25:30 +00001037}
1038int sqlite3_bind_text(
1039 sqlite3_stmt *pStmt,
1040 int i,
1041 const char *zData,
1042 int nData,
danielk1977d8123362004-06-12 09:25:12 +00001043 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +00001044){
drh5e2517e2004-09-24 23:59:12 +00001045 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +00001046}
drh6c626082004-11-14 21:56:29 +00001047#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +00001048int sqlite3_bind_text16(
1049 sqlite3_stmt *pStmt,
1050 int i,
1051 const void *zData,
1052 int nData,
danielk1977d8123362004-06-12 09:25:12 +00001053 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +00001054){
drh5e2517e2004-09-24 23:59:12 +00001055 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +00001056}
drh6c626082004-11-14 21:56:29 +00001057#endif /* SQLITE_OMIT_UTF16 */
danielk197726e41442006-06-14 15:16:35 +00001058int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
1059 int rc;
drh29def562009-04-14 12:43:33 +00001060 switch( pValue->type ){
drh29def562009-04-14 12:43:33 +00001061 case SQLITE_INTEGER: {
1062 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
1063 break;
1064 }
1065 case SQLITE_FLOAT: {
1066 rc = sqlite3_bind_double(pStmt, i, pValue->r);
1067 break;
1068 }
1069 case SQLITE_BLOB: {
1070 if( pValue->flags & MEM_Zero ){
1071 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
1072 }else{
1073 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
1074 }
1075 break;
1076 }
1077 case SQLITE_TEXT: {
drhac80db72009-04-14 12:58:20 +00001078 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
1079 pValue->enc);
1080 break;
1081 }
1082 default: {
1083 rc = sqlite3_bind_null(pStmt, i);
drh29def562009-04-14 12:43:33 +00001084 break;
1085 }
danielk197726e41442006-06-14 15:16:35 +00001086 }
1087 return rc;
1088}
drhb026e052007-05-02 01:34:31 +00001089int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
1090 int rc;
1091 Vdbe *p = (Vdbe *)pStmt;
1092 rc = vdbeUnbind(p, i);
1093 if( rc==SQLITE_OK ){
1094 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
drh488e7b62008-10-06 12:46:43 +00001095 sqlite3_mutex_leave(p->db->mutex);
drhb026e052007-05-02 01:34:31 +00001096 }
1097 return rc;
1098}
drh75f6a032004-07-15 14:15:00 +00001099
1100/*
1101** Return the number of wildcards that can be potentially bound to.
1102** This routine is added to support DBD::SQLite.
drh75f6a032004-07-15 14:15:00 +00001103*/
1104int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
drh92febd92004-08-20 18:34:20 +00001105 Vdbe *p = (Vdbe*)pStmt;
1106 return p ? p->nVar : 0;
drh75f6a032004-07-15 14:15:00 +00001107}
drh895d7472004-08-20 16:02:39 +00001108
1109/*
drhfa6bc002004-09-07 16:19:52 +00001110** Create a mapping from variable numbers to variable names
1111** in the Vdbe.azVar[] array, if such a mapping does not already
1112** exist.
drh895d7472004-08-20 16:02:39 +00001113*/
drhfa6bc002004-09-07 16:19:52 +00001114static void createVarMap(Vdbe *p){
drh895d7472004-08-20 16:02:39 +00001115 if( !p->okVar ){
drh0f5ea0b2009-04-09 14:02:44 +00001116 int j;
1117 Op *pOp;
drh605264d2007-08-21 15:13:19 +00001118 sqlite3_mutex_enter(p->db->mutex);
drh0f5ea0b2009-04-09 14:02:44 +00001119 /* The race condition here is harmless. If two threads call this
1120 ** routine on the same Vdbe at the same time, they both might end
1121 ** up initializing the Vdbe.azVar[] array. That is a little extra
1122 ** work but it results in the same answer.
1123 */
1124 for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
1125 if( pOp->opcode==OP_Variable ){
1126 assert( pOp->p1>0 && pOp->p1<=p->nVar );
1127 p->azVar[pOp->p1-1] = pOp->p4.z;
drh895d7472004-08-20 16:02:39 +00001128 }
1129 }
drh0f5ea0b2009-04-09 14:02:44 +00001130 p->okVar = 1;
drh605264d2007-08-21 15:13:19 +00001131 sqlite3_mutex_leave(p->db->mutex);
drh895d7472004-08-20 16:02:39 +00001132 }
drhfa6bc002004-09-07 16:19:52 +00001133}
1134
1135/*
1136** Return the name of a wildcard parameter. Return NULL if the index
1137** is out of range or if the wildcard is unnamed.
1138**
1139** The result is always UTF-8.
1140*/
1141const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
1142 Vdbe *p = (Vdbe*)pStmt;
1143 if( p==0 || i<1 || i>p->nVar ){
1144 return 0;
1145 }
1146 createVarMap(p);
drh895d7472004-08-20 16:02:39 +00001147 return p->azVar[i-1];
1148}
drhfa6bc002004-09-07 16:19:52 +00001149
1150/*
1151** Given a wildcard parameter name, return the index of the variable
1152** with that name. If there is no variable with the given name,
1153** return 0.
1154*/
drh5f18a222009-11-26 14:01:53 +00001155int sqlite3VdbeParameterIndex(Vdbe *p, const char *zName, int nName){
drhfa6bc002004-09-07 16:19:52 +00001156 int i;
1157 if( p==0 ){
1158 return 0;
1159 }
1160 createVarMap(p);
drh6a8903c2004-12-10 18:00:04 +00001161 if( zName ){
1162 for(i=0; i<p->nVar; i++){
1163 const char *z = p->azVar[i];
drh5f18a222009-11-26 14:01:53 +00001164 if( z && memcmp(z,zName,nName)==0 && z[nName]==0 ){
drh6a8903c2004-12-10 18:00:04 +00001165 return i+1;
1166 }
drhfa6bc002004-09-07 16:19:52 +00001167 }
1168 }
1169 return 0;
1170}
drh5f18a222009-11-26 14:01:53 +00001171int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
1172 return sqlite3VdbeParameterIndex((Vdbe*)pStmt, zName, sqlite3Strlen30(zName));
1173}
drhf8db1bc2005-04-22 02:38:37 +00001174
drh51942bc2005-06-12 22:01:42 +00001175/*
drhf8db1bc2005-04-22 02:38:37 +00001176** Transfer all bindings from the first statement over to the second.
drhf8db1bc2005-04-22 02:38:37 +00001177*/
shane145834a2008-09-04 12:03:42 +00001178int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
drhf8db1bc2005-04-22 02:38:37 +00001179 Vdbe *pFrom = (Vdbe*)pFromStmt;
1180 Vdbe *pTo = (Vdbe*)pToStmt;
drh0f5ea0b2009-04-09 14:02:44 +00001181 int i;
1182 assert( pTo->db==pFrom->db );
1183 assert( pTo->nVar==pFrom->nVar );
drh27641702007-08-22 02:56:42 +00001184 sqlite3_mutex_enter(pTo->db->mutex);
drh0f5ea0b2009-04-09 14:02:44 +00001185 for(i=0; i<pFrom->nVar; i++){
drh643167f2008-01-22 21:30:53 +00001186 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
drhf8db1bc2005-04-22 02:38:37 +00001187 }
drh27641702007-08-22 02:56:42 +00001188 sqlite3_mutex_leave(pTo->db->mutex);
drh0f5ea0b2009-04-09 14:02:44 +00001189 return SQLITE_OK;
drhf8db1bc2005-04-22 02:38:37 +00001190}
drh51942bc2005-06-12 22:01:42 +00001191
shaneeec556d2008-10-12 00:27:53 +00001192#ifndef SQLITE_OMIT_DEPRECATED
drh51942bc2005-06-12 22:01:42 +00001193/*
shane145834a2008-09-04 12:03:42 +00001194** Deprecated external interface. Internal/core SQLite code
1195** should call sqlite3TransferBindings.
drh0f5ea0b2009-04-09 14:02:44 +00001196**
1197** Is is misuse to call this routine with statements from different
1198** database connections. But as this is a deprecated interface, we
1199** will not bother to check for that condition.
1200**
1201** If the two statements contain a different number of bindings, then
1202** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise
1203** SQLITE_OK is returned.
shane145834a2008-09-04 12:03:42 +00001204*/
1205int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
drh0f5ea0b2009-04-09 14:02:44 +00001206 Vdbe *pFrom = (Vdbe*)pFromStmt;
1207 Vdbe *pTo = (Vdbe*)pToStmt;
1208 if( pFrom->nVar!=pTo->nVar ){
1209 return SQLITE_ERROR;
1210 }
danc94b8592009-10-20 07:01:24 +00001211 if( pTo->isPrepareV2 && pTo->expmask ){
1212 pTo->expired = 1;
1213 }
1214 if( pFrom->isPrepareV2 && pFrom->expmask ){
1215 pFrom->expired = 1;
1216 }
shane145834a2008-09-04 12:03:42 +00001217 return sqlite3TransferBindings(pFromStmt, pToStmt);
1218}
shaneeec556d2008-10-12 00:27:53 +00001219#endif
shane145834a2008-09-04 12:03:42 +00001220
1221/*
drh51942bc2005-06-12 22:01:42 +00001222** Return the sqlite3* database handle to which the prepared statement given
1223** in the argument belongs. This is the same database handle that was
1224** the first argument to the sqlite3_prepare() that was used to create
1225** the statement in the first place.
1226*/
1227sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
1228 return pStmt ? ((Vdbe*)pStmt)->db : 0;
1229}
drhbb5a9c32008-06-19 02:52:25 +00001230
1231/*
1232** Return a pointer to the next prepared statement after pStmt associated
1233** with database connection pDb. If pStmt is NULL, return the first
1234** prepared statement for the database connection. Return NULL if there
1235** are no more.
1236*/
1237sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
1238 sqlite3_stmt *pNext;
1239 sqlite3_mutex_enter(pDb->mutex);
1240 if( pStmt==0 ){
1241 pNext = (sqlite3_stmt*)pDb->pVdbe;
1242 }else{
1243 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
1244 }
1245 sqlite3_mutex_leave(pDb->mutex);
1246 return pNext;
1247}
drhd1d38482008-10-07 23:46:38 +00001248
1249/*
1250** Return the value of a status counter for a prepared statement
1251*/
1252int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
1253 Vdbe *pVdbe = (Vdbe*)pStmt;
1254 int v = pVdbe->aCounter[op-1];
1255 if( resetFlag ) pVdbe->aCounter[op-1] = 0;
1256 return v;
1257}