blob: 3e7ac71815124c9023f651bc3700a59207757936 [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.
danielk1977822a5162008-05-16 04:51:54 +000015**
drh4c8555f2009-06-25 01:47:11 +000016** $Id: vdbeapi.c,v 1.167 2009/06/25 01:47:12 drh Exp $
drh4f26d6c2004-05-26 23:25:30 +000017*/
18#include "sqliteInt.h"
19#include "vdbeInt.h"
20
shaneeec556d2008-10-12 00:27:53 +000021#ifndef SQLITE_OMIT_DEPRECATED
drhd89bd002005-01-22 03:03:54 +000022/*
23** Return TRUE (non-zero) of the statement supplied as an argument needs
24** to be recompiled. A statement needs to be recompiled whenever the
25** execution environment changes in a way that would alter the program
26** that sqlite3_prepare() generates. For example, if new functions or
27** collating sequences are registered or if an authorizer function is
28** added or changed.
drhd89bd002005-01-22 03:03:54 +000029*/
30int sqlite3_expired(sqlite3_stmt *pStmt){
31 Vdbe *p = (Vdbe*)pStmt;
32 return p==0 || p->expired;
33}
shaneeec556d2008-10-12 00:27:53 +000034#endif
drhd89bd002005-01-22 03:03:54 +000035
drhe30f4422007-08-21 16:15:55 +000036/*
37** The following routine destroys a virtual machine that is created by
38** the sqlite3_compile() routine. The integer returned is an SQLITE_
39** success/failure code that describes the result of executing the virtual
40** machine.
41**
42** This routine sets the error code and string returned by
43** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
44*/
45int sqlite3_finalize(sqlite3_stmt *pStmt){
46 int rc;
47 if( pStmt==0 ){
48 rc = SQLITE_OK;
49 }else{
50 Vdbe *v = (Vdbe*)pStmt;
danielk1977238746a2009-03-19 18:51:06 +000051 sqlite3 *db = v->db;
drh18472fa2008-10-07 15:25:48 +000052#if SQLITE_THREADSAFE
drh86f8c192007-08-22 00:39:19 +000053 sqlite3_mutex *mutex = v->db->mutex;
drh7e8b8482008-01-23 03:03:05 +000054#endif
drh86f8c192007-08-22 00:39:19 +000055 sqlite3_mutex_enter(mutex);
drhe30f4422007-08-21 16:15:55 +000056 rc = sqlite3VdbeFinalize(v);
danielk1977238746a2009-03-19 18:51:06 +000057 rc = sqlite3ApiExit(db, rc);
drh86f8c192007-08-22 00:39:19 +000058 sqlite3_mutex_leave(mutex);
drhe30f4422007-08-21 16:15:55 +000059 }
60 return rc;
61}
62
63/*
64** Terminate the current execution of an SQL statement and reset it
65** back to its starting state so that it can be reused. A success code from
66** the prior execution is returned.
67**
68** This routine sets the error code and string returned by
69** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
70*/
71int sqlite3_reset(sqlite3_stmt *pStmt){
72 int rc;
73 if( pStmt==0 ){
74 rc = SQLITE_OK;
75 }else{
76 Vdbe *v = (Vdbe*)pStmt;
77 sqlite3_mutex_enter(v->db->mutex);
drhc890fec2008-08-01 20:10:08 +000078 rc = sqlite3VdbeReset(v);
dane0af83a2009-09-08 19:15:01 +000079 sqlite3VdbeMakeReady(v, -1, 0, 0, 0, 0, 0);
drhe30f4422007-08-21 16:15:55 +000080 assert( (rc & (v->db->errMask))==rc );
danielk1977238746a2009-03-19 18:51:06 +000081 rc = sqlite3ApiExit(v->db, rc);
drhe30f4422007-08-21 16:15:55 +000082 sqlite3_mutex_leave(v->db->mutex);
83 }
84 return rc;
85}
86
87/*
88** Set all the parameters in the compiled SQL statement to NULL.
89*/
90int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
91 int i;
92 int rc = SQLITE_OK;
drh7297d1f2008-05-09 14:39:44 +000093 Vdbe *p = (Vdbe*)pStmt;
drh18472fa2008-10-07 15:25:48 +000094#if SQLITE_THREADSAFE
drh7e8b8482008-01-23 03:03:05 +000095 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
96#endif
97 sqlite3_mutex_enter(mutex);
drh7297d1f2008-05-09 14:39:44 +000098 for(i=0; i<p->nVar; i++){
99 sqlite3VdbeMemRelease(&p->aVar[i]);
100 p->aVar[i].flags = MEM_Null;
drhe30f4422007-08-21 16:15:55 +0000101 }
drh7e8b8482008-01-23 03:03:05 +0000102 sqlite3_mutex_leave(mutex);
drhe30f4422007-08-21 16:15:55 +0000103 return rc;
104}
105
106
drh4f26d6c2004-05-26 23:25:30 +0000107/**************************** sqlite3_value_ *******************************
108** The following routines extract information from a Mem or sqlite3_value
109** structure.
110*/
111const void *sqlite3_value_blob(sqlite3_value *pVal){
112 Mem *p = (Mem*)pVal;
113 if( p->flags & (MEM_Blob|MEM_Str) ){
drhb21c8cd2007-08-21 19:33:56 +0000114 sqlite3VdbeMemExpandBlob(p);
drh1f0feef2007-05-15 13:27:07 +0000115 p->flags &= ~MEM_Str;
116 p->flags |= MEM_Blob;
drh4f26d6c2004-05-26 23:25:30 +0000117 return p->z;
118 }else{
119 return sqlite3_value_text(pVal);
120 }
121}
122int sqlite3_value_bytes(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000123 return sqlite3ValueBytes(pVal, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +0000124}
125int sqlite3_value_bytes16(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000126 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +0000127}
128double sqlite3_value_double(sqlite3_value *pVal){
drh6a6124e2004-06-27 01:56:33 +0000129 return sqlite3VdbeRealValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000130}
131int sqlite3_value_int(sqlite3_value *pVal){
drhb27b7f52008-12-10 18:03:45 +0000132 return (int)sqlite3VdbeIntValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000133}
drhefad9992004-06-22 12:13:55 +0000134sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
drh6a6124e2004-06-27 01:56:33 +0000135 return sqlite3VdbeIntValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000136}
137const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000138 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +0000139}
drh6c626082004-11-14 21:56:29 +0000140#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000141const void *sqlite3_value_text16(sqlite3_value* pVal){
drhb21c8cd2007-08-21 19:33:56 +0000142 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +0000143}
danielk1977d8123362004-06-12 09:25:12 +0000144const void *sqlite3_value_text16be(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000145 return sqlite3ValueText(pVal, SQLITE_UTF16BE);
danielk1977d8123362004-06-12 09:25:12 +0000146}
147const void *sqlite3_value_text16le(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000148 return sqlite3ValueText(pVal, SQLITE_UTF16LE);
danielk1977d8123362004-06-12 09:25:12 +0000149}
drh6c626082004-11-14 21:56:29 +0000150#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000151int sqlite3_value_type(sqlite3_value* pVal){
drhf4479502004-05-27 03:12:53 +0000152 return pVal->type;
drh4f26d6c2004-05-26 23:25:30 +0000153}
154
155/**************************** sqlite3_result_ *******************************
156** The following routines are used by user-defined functions to specify
157** the function result.
drh4c8555f2009-06-25 01:47:11 +0000158**
159** The setStrOrError() funtion calls sqlite3VdbeMemSetStr() to store the
160** result as a string or blob but if the string or blob is too large, it
161** then sets the error code to SQLITE_TOOBIG
drh4f26d6c2004-05-26 23:25:30 +0000162*/
drh4c8555f2009-06-25 01:47:11 +0000163static void setResultStrOrError(
164 sqlite3_context *pCtx, /* Function context */
165 const char *z, /* String pointer */
166 int n, /* Bytes in string, or negative */
167 u8 enc, /* Encoding of z. 0 for BLOBs */
168 void (*xDel)(void*) /* Destructor function */
169){
170 if( sqlite3VdbeMemSetStr(&pCtx->s, z, n, enc, xDel)==SQLITE_TOOBIG ){
171 sqlite3_result_error_toobig(pCtx);
172 }
173}
drh4f26d6c2004-05-26 23:25:30 +0000174void sqlite3_result_blob(
175 sqlite3_context *pCtx,
176 const void *z,
177 int n,
danielk1977d8123362004-06-12 09:25:12 +0000178 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000179){
drh5708d2d2005-06-22 10:53:59 +0000180 assert( n>=0 );
drh32bc3f62007-08-21 20:25:39 +0000181 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000182 setResultStrOrError(pCtx, z, n, 0, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000183}
184void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
drh32bc3f62007-08-21 20:25:39 +0000185 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000186 sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
187}
188void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
drh32bc3f62007-08-21 20:25:39 +0000189 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh69544ec2008-02-06 14:11:34 +0000190 pCtx->isError = SQLITE_ERROR;
drhb21c8cd2007-08-21 19:33:56 +0000191 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +0000192}
danielk1977a1686c92006-01-23 07:52:37 +0000193#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000194void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
drh32bc3f62007-08-21 20:25:39 +0000195 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh69544ec2008-02-06 14:11:34 +0000196 pCtx->isError = SQLITE_ERROR;
drhb21c8cd2007-08-21 19:33:56 +0000197 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +0000198}
danielk1977a1686c92006-01-23 07:52:37 +0000199#endif
drhf4479502004-05-27 03:12:53 +0000200void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
drh32bc3f62007-08-21 20:25:39 +0000201 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000202 sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
203}
204void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
drh32bc3f62007-08-21 20:25:39 +0000205 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000206 sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
207}
208void sqlite3_result_null(sqlite3_context *pCtx){
drh32bc3f62007-08-21 20:25:39 +0000209 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhf4479502004-05-27 03:12:53 +0000210 sqlite3VdbeMemSetNull(&pCtx->s);
drh4f26d6c2004-05-26 23:25:30 +0000211}
212void sqlite3_result_text(
213 sqlite3_context *pCtx,
214 const char *z,
215 int n,
danielk1977d8123362004-06-12 09:25:12 +0000216 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000217){
drh32bc3f62007-08-21 20:25:39 +0000218 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000219 setResultStrOrError(pCtx, z, n, SQLITE_UTF8, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000220}
drh6c626082004-11-14 21:56:29 +0000221#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000222void sqlite3_result_text16(
223 sqlite3_context *pCtx,
224 const void *z,
225 int n,
danielk1977d8123362004-06-12 09:25:12 +0000226 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000227){
drh32bc3f62007-08-21 20:25:39 +0000228 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000229 setResultStrOrError(pCtx, z, n, SQLITE_UTF16NATIVE, xDel);
danielk1977d8123362004-06-12 09:25:12 +0000230}
231void sqlite3_result_text16be(
232 sqlite3_context *pCtx,
233 const void *z,
234 int n,
235 void (*xDel)(void *)
236){
drh32bc3f62007-08-21 20:25:39 +0000237 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000238 setResultStrOrError(pCtx, z, n, SQLITE_UTF16BE, xDel);
danielk1977d8123362004-06-12 09:25:12 +0000239}
240void sqlite3_result_text16le(
241 sqlite3_context *pCtx,
242 const void *z,
243 int n,
244 void (*xDel)(void *)
245){
drh32bc3f62007-08-21 20:25:39 +0000246 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4c8555f2009-06-25 01:47:11 +0000247 setResultStrOrError(pCtx, z, n, SQLITE_UTF16LE, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000248}
drh6c626082004-11-14 21:56:29 +0000249#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000250void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
drh32bc3f62007-08-21 20:25:39 +0000251 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000252 sqlite3VdbeMemCopy(&pCtx->s, pValue);
drh4f26d6c2004-05-26 23:25:30 +0000253}
drhb026e052007-05-02 01:34:31 +0000254void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
drh32bc3f62007-08-21 20:25:39 +0000255 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb026e052007-05-02 01:34:31 +0000256 sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
257}
drh69544ec2008-02-06 14:11:34 +0000258void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
259 pCtx->isError = errCode;
drh51c7d862009-04-27 18:46:06 +0000260 if( pCtx->s.flags & MEM_Null ){
261 sqlite3VdbeMemSetStr(&pCtx->s, sqlite3ErrStr(errCode), -1,
262 SQLITE_UTF8, SQLITE_STATIC);
263 }
drh69544ec2008-02-06 14:11:34 +0000264}
drh4f26d6c2004-05-26 23:25:30 +0000265
drha0206bc2007-05-08 15:15:02 +0000266/* Force an SQLITE_TOOBIG error. */
267void sqlite3_result_error_toobig(sqlite3_context *pCtx){
drh32bc3f62007-08-21 20:25:39 +0000268 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhbb4957f2008-03-20 14:03:29 +0000269 pCtx->isError = SQLITE_TOOBIG;
270 sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1,
271 SQLITE_UTF8, SQLITE_STATIC);
drha0206bc2007-05-08 15:15:02 +0000272}
273
danielk1977a1644fd2007-08-29 12:31:25 +0000274/* An SQLITE_NOMEM error. */
275void sqlite3_result_error_nomem(sqlite3_context *pCtx){
276 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
277 sqlite3VdbeMemSetNull(&pCtx->s);
drh69544ec2008-02-06 14:11:34 +0000278 pCtx->isError = SQLITE_NOMEM;
danielk1977a1644fd2007-08-29 12:31:25 +0000279 pCtx->s.db->mallocFailed = 1;
280}
drh4f26d6c2004-05-26 23:25:30 +0000281
282/*
283** Execute the statement pStmt, either until a row of data is ready, the
284** statement is completely executed or an error occurs.
drhb900aaf2006-11-09 00:24:53 +0000285**
286** This routine implements the bulk of the logic behind the sqlite_step()
287** API. The only thing omitted is the automatic recompile if a
288** schema change has occurred. That detail is handled by the
289** outer sqlite3_step() wrapper procedure.
drh4f26d6c2004-05-26 23:25:30 +0000290*/
drhb900aaf2006-11-09 00:24:53 +0000291static int sqlite3Step(Vdbe *p){
drh9bb575f2004-09-06 17:24:11 +0000292 sqlite3 *db;
drh4f26d6c2004-05-26 23:25:30 +0000293 int rc;
294
danielk1977a185ddb2007-11-15 16:04:15 +0000295 assert(p);
296 if( p->magic!=VDBE_MAGIC_RUN ){
drhf1bfe9a2007-10-17 01:44:20 +0000297 return SQLITE_MISUSE;
298 }
299
danielk1977efaaf572006-01-16 11:29:19 +0000300 /* Assert that malloc() has not failed */
drh17435752007-08-16 04:30:38 +0000301 db = p->db;
drhc456e572008-08-11 18:44:58 +0000302 if( db->mallocFailed ){
303 return SQLITE_NOMEM;
304 }
danielk1977261919c2005-12-06 12:52:59 +0000305
danielk1977a21c6b62005-01-24 10:25:59 +0000306 if( p->pc<=0 && p->expired ){
drh7950acd2009-04-10 23:11:31 +0000307 if( ALWAYS(p->rc==SQLITE_OK) ){
danielk1977a21c6b62005-01-24 10:25:59 +0000308 p->rc = SQLITE_SCHEMA;
309 }
drhb900aaf2006-11-09 00:24:53 +0000310 rc = SQLITE_ERROR;
311 goto end_of_step;
danielk1977a21c6b62005-01-24 10:25:59 +0000312 }
drh4f26d6c2004-05-26 23:25:30 +0000313 if( sqlite3SafetyOn(db) ){
314 p->rc = SQLITE_MISUSE;
315 return SQLITE_MISUSE;
316 }
danielk19771d850a72004-05-31 08:26:49 +0000317 if( p->pc<0 ){
drh15ca1df2006-07-26 13:43:30 +0000318 /* If there are no other statements currently running, then
319 ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
320 ** from interrupting a statement that has not yet started.
321 */
322 if( db->activeVdbeCnt==0 ){
323 db->u1.isInterrupted = 0;
324 }
325
dan1da40a32009-09-19 17:00:31 +0000326 assert( db->writeVdbeCnt>0 || db->autoCommit==0 || db->nDeferredCons==0 );
327
drh19e2d372005-08-29 23:00:03 +0000328#ifndef SQLITE_OMIT_TRACE
drh19e2d372005-08-29 23:00:03 +0000329 if( db->xProfile && !db->init.busy ){
330 double rNow;
danielk1977b4b47412007-08-17 15:53:36 +0000331 sqlite3OsCurrentTime(db->pVfs, &rNow);
drhb27b7f52008-12-10 18:03:45 +0000332 p->startTime = (u64)((rNow - (int)rNow)*3600.0*24.0*1000000000.0);
drh19e2d372005-08-29 23:00:03 +0000333 }
334#endif
drhc16a03b2004-09-15 13:38:10 +0000335
danielk19771d850a72004-05-31 08:26:49 +0000336 db->activeVdbeCnt++;
drhad4a4b82008-11-05 16:37:34 +0000337 if( p->readOnly==0 ) db->writeVdbeCnt++;
danielk19771d850a72004-05-31 08:26:49 +0000338 p->pc = 0;
339 }
drhb7f91642004-10-31 02:22:47 +0000340#ifndef SQLITE_OMIT_EXPLAIN
drh4f26d6c2004-05-26 23:25:30 +0000341 if( p->explain ){
342 rc = sqlite3VdbeList(p);
drhb7f91642004-10-31 02:22:47 +0000343 }else
344#endif /* SQLITE_OMIT_EXPLAIN */
345 {
drh4f26d6c2004-05-26 23:25:30 +0000346 rc = sqlite3VdbeExec(p);
347 }
348
349 if( sqlite3SafetyOff(db) ){
350 rc = SQLITE_MISUSE;
351 }
352
drh19e2d372005-08-29 23:00:03 +0000353#ifndef SQLITE_OMIT_TRACE
354 /* Invoke the profile callback if there is one
355 */
danielk19776ab3a2e2009-02-19 14:39:25 +0000356 if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){
drh19e2d372005-08-29 23:00:03 +0000357 double rNow;
358 u64 elapseTime;
359
danielk1977b4b47412007-08-17 15:53:36 +0000360 sqlite3OsCurrentTime(db->pVfs, &rNow);
drhb27b7f52008-12-10 18:03:45 +0000361 elapseTime = (u64)((rNow - (int)rNow)*3600.0*24.0*1000000000.0);
362 elapseTime -= p->startTime;
danielk19776ab3a2e2009-02-19 14:39:25 +0000363 db->xProfile(db->pProfileArg, p->zSql, elapseTime);
drh19e2d372005-08-29 23:00:03 +0000364 }
365#endif
366
drh80cc85b2008-07-23 21:07:25 +0000367 db->errCode = rc;
danielk1977357864e2009-03-25 15:43:08 +0000368 if( SQLITE_NOMEM==sqlite3ApiExit(p->db, p->rc) ){
369 p->rc = SQLITE_NOMEM;
drhb900aaf2006-11-09 00:24:53 +0000370 }
danielk1977357864e2009-03-25 15:43:08 +0000371end_of_step:
372 /* At this point local variable rc holds the value that should be
373 ** returned if this statement was compiled using the legacy
374 ** sqlite3_prepare() interface. According to the docs, this can only
375 ** be one of the values in the first assert() below. Variable p->rc
376 ** contains the value that would be returned if sqlite3_finalize()
377 ** were called on statement p.
378 */
379 assert( rc==SQLITE_ROW || rc==SQLITE_DONE || rc==SQLITE_ERROR
380 || rc==SQLITE_BUSY || rc==SQLITE_MISUSE
381 );
382 assert( p->rc!=SQLITE_ROW && p->rc!=SQLITE_DONE );
383 if( p->isPrepareV2 && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
384 /* If this statement was prepared using sqlite3_prepare_v2(), and an
385 ** error has occured, then return the error code in p->rc to the
386 ** caller. Set the error code in the database handle to the same value.
387 */
388 rc = db->errCode = p->rc;
389 }
390 return (rc&db->errMask);
drhb900aaf2006-11-09 00:24:53 +0000391}
392
393/*
394** This is the top-level implementation of sqlite3_step(). Call
395** sqlite3Step() to do most of the work. If a schema error occurs,
396** call sqlite3Reprepare() and try again.
397*/
drhb900aaf2006-11-09 00:24:53 +0000398int sqlite3_step(sqlite3_stmt *pStmt){
danielk1977a185ddb2007-11-15 16:04:15 +0000399 int rc = SQLITE_MISUSE;
400 if( pStmt ){
401 int cnt = 0;
402 Vdbe *v = (Vdbe*)pStmt;
403 sqlite3 *db = v->db;
404 sqlite3_mutex_enter(db->mutex);
405 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
406 && cnt++ < 5
drh8bfdf722009-06-19 14:06:03 +0000407 && (rc = sqlite3Reprepare(v))==SQLITE_OK ){
danielk1977a185ddb2007-11-15 16:04:15 +0000408 sqlite3_reset(pStmt);
409 v->expired = 0;
danielk19778e556522007-11-13 10:30:24 +0000410 }
drh7950acd2009-04-10 23:11:31 +0000411 if( rc==SQLITE_SCHEMA && ALWAYS(v->isPrepareV2) && ALWAYS(db->pErr) ){
danielk1977a185ddb2007-11-15 16:04:15 +0000412 /* This case occurs after failing to recompile an sql statement.
413 ** The error message from the SQL compiler has already been loaded
414 ** into the database handle. This block copies the error message
415 ** from the database handle into the statement and sets the statement
416 ** program counter to 0 to ensure that when the statement is
417 ** finalized or reset the parser error message is available via
418 ** sqlite3_errmsg() and sqlite3_errcode().
419 */
420 const char *zErr = (const char *)sqlite3_value_text(db->pErr);
drh633e6d52008-07-28 19:34:53 +0000421 sqlite3DbFree(db, v->zErrMsg);
danielk1977a185ddb2007-11-15 16:04:15 +0000422 if( !db->mallocFailed ){
423 v->zErrMsg = sqlite3DbStrDup(db, zErr);
424 } else {
425 v->zErrMsg = 0;
426 v->rc = SQLITE_NOMEM;
427 }
428 }
429 rc = sqlite3ApiExit(db, rc);
430 sqlite3_mutex_leave(db->mutex);
danielk19778e556522007-11-13 10:30:24 +0000431 }
danielk197776e8d1a2006-01-18 18:22:43 +0000432 return rc;
drh4f26d6c2004-05-26 23:25:30 +0000433}
434
435/*
drheb2e1762004-05-27 01:53:56 +0000436** Extract the user data from a sqlite3_context structure and return a
437** pointer to it.
438*/
439void *sqlite3_user_data(sqlite3_context *p){
440 assert( p && p->pFunc );
441 return p->pFunc->pUserData;
442}
443
444/*
drhfa4a4b92008-03-19 21:45:51 +0000445** Extract the user data from a sqlite3_context structure and return a
446** pointer to it.
447*/
448sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
449 assert( p && p->pFunc );
450 return p->s.db;
451}
452
453/*
drhb7481e72006-09-16 21:45:14 +0000454** The following is the implementation of an SQL function that always
455** fails with an error message stating that the function is used in the
456** wrong context. The sqlite3_overload_function() API might construct
457** SQL function that use this routine so that the functions will exist
458** for name resolution but are actually overloaded by the xFindFunction
459** method of virtual tables.
460*/
461void sqlite3InvalidFunction(
462 sqlite3_context *context, /* The function calling context */
danielk197762c14b32008-11-19 09:05:26 +0000463 int NotUsed, /* Number of arguments to the function */
464 sqlite3_value **NotUsed2 /* Value of each argument */
drhb7481e72006-09-16 21:45:14 +0000465){
466 const char *zName = context->pFunc->zName;
467 char *zErr;
danielk197762c14b32008-11-19 09:05:26 +0000468 UNUSED_PARAMETER2(NotUsed, NotUsed2);
drhbc6160b2009-04-08 15:45:31 +0000469 zErr = sqlite3_mprintf(
drhb7481e72006-09-16 21:45:14 +0000470 "unable to use function %s in the requested context", zName);
471 sqlite3_result_error(context, zErr, -1);
danielk19771e536952007-08-16 10:09:01 +0000472 sqlite3_free(zErr);
drhb7481e72006-09-16 21:45:14 +0000473}
474
475/*
drheb2e1762004-05-27 01:53:56 +0000476** Allocate or return the aggregate context for a user function. A new
477** context is allocated on the first call. Subsequent calls return the
478** same context that was returned on prior calls.
drheb2e1762004-05-27 01:53:56 +0000479*/
480void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
drhb21c8cd2007-08-21 19:33:56 +0000481 Mem *pMem;
drh825c6622005-09-08 19:01:05 +0000482 assert( p && p->pFunc && p->pFunc->xStep );
drhb21c8cd2007-08-21 19:33:56 +0000483 assert( sqlite3_mutex_held(p->s.db->mutex) );
484 pMem = p->pMem;
drha10a34b2005-09-07 22:09:48 +0000485 if( (pMem->flags & MEM_Agg)==0 ){
486 if( nByte==0 ){
danielk19775f096132008-03-28 15:44:09 +0000487 sqlite3VdbeMemReleaseExternal(pMem);
488 pMem->flags = MEM_Null;
drha10a34b2005-09-07 22:09:48 +0000489 pMem->z = 0;
drheb2e1762004-05-27 01:53:56 +0000490 }else{
danielk19775f096132008-03-28 15:44:09 +0000491 sqlite3VdbeMemGrow(pMem, nByte, 0);
drha10a34b2005-09-07 22:09:48 +0000492 pMem->flags = MEM_Agg;
drh3c024d62007-03-30 11:23:45 +0000493 pMem->u.pDef = p->pFunc;
danielk19775f096132008-03-28 15:44:09 +0000494 if( pMem->z ){
495 memset(pMem->z, 0, nByte);
496 }
drheb2e1762004-05-27 01:53:56 +0000497 }
498 }
drhabfcea22005-09-06 20:36:48 +0000499 return (void*)pMem->z;
drheb2e1762004-05-27 01:53:56 +0000500}
501
502/*
danielk1977682f68b2004-06-05 10:22:17 +0000503** Return the auxilary data pointer, if any, for the iArg'th argument to
504** the user-function defined by pCtx.
505*/
506void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
drhb21c8cd2007-08-21 19:33:56 +0000507 VdbeFunc *pVdbeFunc;
508
509 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
510 pVdbeFunc = pCtx->pVdbeFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000511 if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
512 return 0;
513 }
drhf92c7ff2004-06-19 15:40:23 +0000514 return pVdbeFunc->apAux[iArg].pAux;
danielk1977682f68b2004-06-05 10:22:17 +0000515}
516
517/*
518** Set the auxilary data pointer and delete function, for the iArg'th
519** argument to the user-function defined by pCtx. Any previous value is
520** deleted by calling the delete function specified when it was set.
521*/
522void sqlite3_set_auxdata(
523 sqlite3_context *pCtx,
524 int iArg,
525 void *pAux,
526 void (*xDelete)(void*)
527){
528 struct AuxData *pAuxData;
drhf92c7ff2004-06-19 15:40:23 +0000529 VdbeFunc *pVdbeFunc;
danielk1977e0fc5262007-07-26 06:50:05 +0000530 if( iArg<0 ) goto failed;
danielk1977682f68b2004-06-05 10:22:17 +0000531
drhb21c8cd2007-08-21 19:33:56 +0000532 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhf92c7ff2004-06-19 15:40:23 +0000533 pVdbeFunc = pCtx->pVdbeFunc;
534 if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
danielk197731dad9d2007-08-16 11:36:15 +0000535 int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
drhf92c7ff2004-06-19 15:40:23 +0000536 int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
danielk197726783a52007-08-29 14:06:22 +0000537 pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
drh17435752007-08-16 04:30:38 +0000538 if( !pVdbeFunc ){
drh17435752007-08-16 04:30:38 +0000539 goto failed;
540 }
drh53f733c2005-09-16 02:38:09 +0000541 pCtx->pVdbeFunc = pVdbeFunc;
danielk197731dad9d2007-08-16 11:36:15 +0000542 memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
drh998da3a2004-06-19 15:22:56 +0000543 pVdbeFunc->nAux = iArg+1;
544 pVdbeFunc->pFunc = pCtx->pFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000545 }
546
drhf92c7ff2004-06-19 15:40:23 +0000547 pAuxData = &pVdbeFunc->apAux[iArg];
danielk1977682f68b2004-06-05 10:22:17 +0000548 if( pAuxData->pAux && pAuxData->xDelete ){
549 pAuxData->xDelete(pAuxData->pAux);
550 }
551 pAuxData->pAux = pAux;
552 pAuxData->xDelete = xDelete;
danielk1977e0fc5262007-07-26 06:50:05 +0000553 return;
554
555failed:
556 if( xDelete ){
557 xDelete(pAux);
558 }
danielk1977682f68b2004-06-05 10:22:17 +0000559}
560
shaneeec556d2008-10-12 00:27:53 +0000561#ifndef SQLITE_OMIT_DEPRECATED
danielk1977682f68b2004-06-05 10:22:17 +0000562/*
drheb2e1762004-05-27 01:53:56 +0000563** Return the number of times the Step function of a aggregate has been
564** called.
565**
drhcf85a512006-02-09 18:35:29 +0000566** This function is deprecated. Do not use it for new code. It is
567** provide only to avoid breaking legacy code. New aggregate function
568** implementations should keep their own counts within their aggregate
569** context.
drheb2e1762004-05-27 01:53:56 +0000570*/
571int sqlite3_aggregate_count(sqlite3_context *p){
shanee34c6472009-03-05 04:23:47 +0000572 assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
drhabfcea22005-09-06 20:36:48 +0000573 return p->pMem->n;
drheb2e1762004-05-27 01:53:56 +0000574}
shaneeec556d2008-10-12 00:27:53 +0000575#endif
drheb2e1762004-05-27 01:53:56 +0000576
577/*
drh4f26d6c2004-05-26 23:25:30 +0000578** Return the number of columns in the result set for the statement pStmt.
579*/
580int sqlite3_column_count(sqlite3_stmt *pStmt){
581 Vdbe *pVm = (Vdbe *)pStmt;
drh1bcdb0c2004-08-28 14:49:46 +0000582 return pVm ? pVm->nResColumn : 0;
drh4f26d6c2004-05-26 23:25:30 +0000583}
584
585/*
586** Return the number of values available from the current row of the
587** currently executing statement pStmt.
588*/
589int sqlite3_data_count(sqlite3_stmt *pStmt){
590 Vdbe *pVm = (Vdbe *)pStmt;
drhd4e70eb2008-01-02 00:34:36 +0000591 if( pVm==0 || pVm->pResultSet==0 ) return 0;
drh4f26d6c2004-05-26 23:25:30 +0000592 return pVm->nResColumn;
593}
594
595
596/*
597** Check to see if column iCol of the given statement is valid. If
598** it is, return a pointer to the Mem for the value of that column.
599** If iCol is not valid, return a pointer to a Mem which has a value
600** of NULL.
601*/
602static Mem *columnMem(sqlite3_stmt *pStmt, int i){
drh32bc3f62007-08-21 20:25:39 +0000603 Vdbe *pVm;
604 int vals;
605 Mem *pOut;
606
607 pVm = (Vdbe *)pStmt;
drhd4e70eb2008-01-02 00:34:36 +0000608 if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
drh32bc3f62007-08-21 20:25:39 +0000609 sqlite3_mutex_enter(pVm->db->mutex);
610 vals = sqlite3_data_count(pStmt);
drhd4e70eb2008-01-02 00:34:36 +0000611 pOut = &pVm->pResultSet[i];
drh32bc3f62007-08-21 20:25:39 +0000612 }else{
danielk197741f5b042009-06-06 14:13:26 +0000613 /* If the value passed as the second argument is out of range, return
614 ** a pointer to the following static Mem object which contains the
615 ** value SQL NULL. Even though the Mem structure contains an element
616 ** of type i64, on certain architecture (x86) with certain compiler
617 ** switches (-Os), gcc may align this Mem object on a 4-byte boundary
618 ** instead of an 8-byte one. This all works fine, except that when
619 ** running with SQLITE_DEBUG defined the SQLite code sometimes assert()s
620 ** that a Mem structure is located on an 8-byte boundary. To prevent
621 ** this assert() from failing, when building with SQLITE_DEBUG defined
622 ** using gcc, force nullMem to be 8-byte aligned using the magical
623 ** __attribute__((aligned(8))) macro. */
624 static const Mem nullMem
625#if defined(SQLITE_DEBUG) && defined(__GNUC__)
626 __attribute__((aligned(8)))
627#endif
628 = {{0}, (double)0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };
629
drh9b4ea4a2009-04-10 20:32:00 +0000630 if( pVm && ALWAYS(pVm->db) ){
drh27641702007-08-22 02:56:42 +0000631 sqlite3_mutex_enter(pVm->db->mutex);
632 sqlite3Error(pVm->db, SQLITE_RANGE, 0);
633 }
drh32bc3f62007-08-21 20:25:39 +0000634 pOut = (Mem*)&nullMem;
drh4f26d6c2004-05-26 23:25:30 +0000635 }
drh32bc3f62007-08-21 20:25:39 +0000636 return pOut;
drh4f26d6c2004-05-26 23:25:30 +0000637}
638
danielk19772e588c72005-12-09 14:25:08 +0000639/*
640** This function is called after invoking an sqlite3_value_XXX function on a
641** column value (i.e. a value returned by evaluating an SQL expression in the
642** select list of a SELECT statement) that may cause a malloc() failure. If
643** malloc() has failed, the threads mallocFailed flag is cleared and the result
644** code of statement pStmt set to SQLITE_NOMEM.
645**
drh32bc3f62007-08-21 20:25:39 +0000646** Specifically, this is called from within:
danielk19772e588c72005-12-09 14:25:08 +0000647**
648** sqlite3_column_int()
649** sqlite3_column_int64()
650** sqlite3_column_text()
651** sqlite3_column_text16()
652** sqlite3_column_real()
653** sqlite3_column_bytes()
654** sqlite3_column_bytes16()
655**
656** But not for sqlite3_column_blob(), which never calls malloc().
657*/
658static void columnMallocFailure(sqlite3_stmt *pStmt)
659{
660 /* If malloc() failed during an encoding conversion within an
661 ** sqlite3_column_XXX API, then set the return code of the statement to
662 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
663 ** and _finalize() will return NOMEM.
664 */
danielk197754f01982006-01-18 15:25:17 +0000665 Vdbe *p = (Vdbe *)pStmt;
drh32bc3f62007-08-21 20:25:39 +0000666 if( p ){
667 p->rc = sqlite3ApiExit(p->db, p->rc);
668 sqlite3_mutex_leave(p->db->mutex);
669 }
danielk19772e588c72005-12-09 14:25:08 +0000670}
671
drh4f26d6c2004-05-26 23:25:30 +0000672/**************************** sqlite3_column_ *******************************
673** The following routines are used to access elements of the current row
674** in the result set.
675*/
danielk1977c572ef72004-05-27 09:28:41 +0000676const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000677 const void *val;
danielk19772e588c72005-12-09 14:25:08 +0000678 val = sqlite3_value_blob( columnMem(pStmt,i) );
danielk1977c9cf9012007-05-30 10:36:47 +0000679 /* Even though there is no encoding conversion, value_blob() might
680 ** need to call malloc() to expand the result of a zeroblob()
681 ** expression.
682 */
683 columnMallocFailure(pStmt);
danielk19772e588c72005-12-09 14:25:08 +0000684 return val;
danielk1977c572ef72004-05-27 09:28:41 +0000685}
drh4f26d6c2004-05-26 23:25:30 +0000686int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000687 int val = sqlite3_value_bytes( columnMem(pStmt,i) );
688 columnMallocFailure(pStmt);
689 return val;
drh4f26d6c2004-05-26 23:25:30 +0000690}
691int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000692 int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
693 columnMallocFailure(pStmt);
694 return val;
drh4f26d6c2004-05-26 23:25:30 +0000695}
696double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000697 double val = sqlite3_value_double( columnMem(pStmt,i) );
698 columnMallocFailure(pStmt);
699 return val;
drh4f26d6c2004-05-26 23:25:30 +0000700}
701int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000702 int val = sqlite3_value_int( columnMem(pStmt,i) );
703 columnMallocFailure(pStmt);
704 return val;
drh4f26d6c2004-05-26 23:25:30 +0000705}
drhefad9992004-06-22 12:13:55 +0000706sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000707 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
708 columnMallocFailure(pStmt);
709 return val;
drh4f26d6c2004-05-26 23:25:30 +0000710}
711const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000712 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
713 columnMallocFailure(pStmt);
714 return val;
drh4f26d6c2004-05-26 23:25:30 +0000715}
drhd1e47332005-06-26 17:55:33 +0000716sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
danielk1977d0ffa1e2008-10-13 10:37:49 +0000717 Mem *pOut = columnMem(pStmt, i);
718 if( pOut->flags&MEM_Static ){
719 pOut->flags &= ~MEM_Static;
720 pOut->flags |= MEM_Ephem;
721 }
drh32bc3f62007-08-21 20:25:39 +0000722 columnMallocFailure(pStmt);
danielk1977d0ffa1e2008-10-13 10:37:49 +0000723 return (sqlite3_value *)pOut;
drhd1e47332005-06-26 17:55:33 +0000724}
drh6c626082004-11-14 21:56:29 +0000725#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000726const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000727 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
728 columnMallocFailure(pStmt);
729 return val;
drh4f26d6c2004-05-26 23:25:30 +0000730}
drh6c626082004-11-14 21:56:29 +0000731#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000732int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
drh32bc3f62007-08-21 20:25:39 +0000733 int iType = sqlite3_value_type( columnMem(pStmt,i) );
734 columnMallocFailure(pStmt);
735 return iType;
drh4f26d6c2004-05-26 23:25:30 +0000736}
737
drh29d72102006-02-09 22:13:41 +0000738/* The following function is experimental and subject to change or
739** removal */
740/*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
741** return sqlite3_value_numeric_type( columnMem(pStmt,i) );
742**}
743*/
744
drh5e2517e2004-09-24 23:59:12 +0000745/*
746** Convert the N-th element of pStmt->pColName[] into a string using
747** xFunc() then return that string. If N is out of range, return 0.
drhe590fbd2005-05-20 19:36:01 +0000748**
749** There are up to 5 names for each column. useType determines which
750** name is returned. Here are the names:
751**
752** 0 The column name as it should be displayed for output
753** 1 The datatype name for the column
754** 2 The name of the database that the column derives from
755** 3 The name of the table that the column derives from
756** 4 The name of the table column that the result column derives from
757**
758** If the result is not a simple column reference (if it is an expression
759** or a constant) then useTypes 2, 3, and 4 return NULL.
drh5e2517e2004-09-24 23:59:12 +0000760*/
761static const void *columnName(
762 sqlite3_stmt *pStmt,
763 int N,
764 const void *(*xFunc)(Mem*),
765 int useType
766){
drh32bc3f62007-08-21 20:25:39 +0000767 const void *ret = 0;
drh5e2517e2004-09-24 23:59:12 +0000768 Vdbe *p = (Vdbe *)pStmt;
drh32bc3f62007-08-21 20:25:39 +0000769 int n;
drhc6c7fd52009-04-08 23:05:28 +0000770 sqlite3 *db = p->db;
drh32bc3f62007-08-21 20:25:39 +0000771
drh9b4ea4a2009-04-10 20:32:00 +0000772 assert( db!=0 );
773 n = sqlite3_column_count(pStmt);
774 if( N<n && N>=0 ){
775 N += useType*n;
776 sqlite3_mutex_enter(db->mutex);
777 assert( db->mallocFailed==0 );
778 ret = xFunc(&p->aColName[N]);
779 /* A malloc may have failed inside of the xFunc() call. If this
780 ** is the case, clear the mallocFailed flag and return NULL.
781 */
782 if( db->mallocFailed ){
783 db->mallocFailed = 0;
784 ret = 0;
drh32bc3f62007-08-21 20:25:39 +0000785 }
drh9b4ea4a2009-04-10 20:32:00 +0000786 sqlite3_mutex_leave(db->mutex);
drh5e2517e2004-09-24 23:59:12 +0000787 }
danielk197700fd9572005-12-07 06:27:43 +0000788 return ret;
drh5e2517e2004-09-24 23:59:12 +0000789}
790
drh4f26d6c2004-05-26 23:25:30 +0000791/*
792** Return the name of the Nth column of the result set returned by SQL
793** statement pStmt.
794*/
795const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000796 return columnName(
797 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
drh4f26d6c2004-05-26 23:25:30 +0000798}
drhe590fbd2005-05-20 19:36:01 +0000799#ifndef SQLITE_OMIT_UTF16
800const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000801 return columnName(
802 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
drhe590fbd2005-05-20 19:36:01 +0000803}
804#endif
drh4f26d6c2004-05-26 23:25:30 +0000805
806/*
drh3f913572008-03-22 01:07:17 +0000807** Constraint: If you have ENABLE_COLUMN_METADATA then you must
808** not define OMIT_DECLTYPE.
809*/
810#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
811# error "Must not define both SQLITE_OMIT_DECLTYPE \
812 and SQLITE_ENABLE_COLUMN_METADATA"
813#endif
814
815#ifndef SQLITE_OMIT_DECLTYPE
816/*
drh6c626082004-11-14 21:56:29 +0000817** Return the column declaration type (if applicable) of the 'i'th column
drhe590fbd2005-05-20 19:36:01 +0000818** of the result set of SQL statement pStmt.
drh6c626082004-11-14 21:56:29 +0000819*/
820const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000821 return columnName(
822 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
drh6c626082004-11-14 21:56:29 +0000823}
drh6c626082004-11-14 21:56:29 +0000824#ifndef SQLITE_OMIT_UTF16
danielk197776d505b2004-05-28 13:13:02 +0000825const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000826 return columnName(
827 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
drh4f26d6c2004-05-26 23:25:30 +0000828}
drh6c626082004-11-14 21:56:29 +0000829#endif /* SQLITE_OMIT_UTF16 */
drh3f913572008-03-22 01:07:17 +0000830#endif /* SQLITE_OMIT_DECLTYPE */
drh4f26d6c2004-05-26 23:25:30 +0000831
danielk19774b1ae992006-02-10 03:06:10 +0000832#ifdef SQLITE_ENABLE_COLUMN_METADATA
drhe590fbd2005-05-20 19:36:01 +0000833/*
834** Return the name of the database from which a result column derives.
835** NULL is returned if the result column is an expression or constant or
836** anything else which is not an unabiguous reference to a database column.
837*/
838const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000839 return columnName(
840 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
drhe590fbd2005-05-20 19:36:01 +0000841}
842#ifndef SQLITE_OMIT_UTF16
843const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000844 return columnName(
845 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
drhe590fbd2005-05-20 19:36:01 +0000846}
847#endif /* SQLITE_OMIT_UTF16 */
848
849/*
850** Return the name of the table from which a result column derives.
851** NULL is returned if the result column is an expression or constant or
852** anything else which is not an unabiguous reference to a database column.
853*/
854const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000855 return columnName(
856 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
drhe590fbd2005-05-20 19:36:01 +0000857}
858#ifndef SQLITE_OMIT_UTF16
859const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000860 return columnName(
861 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
drhe590fbd2005-05-20 19:36:01 +0000862}
863#endif /* SQLITE_OMIT_UTF16 */
864
865/*
866** Return the name of the table column from which a result column derives.
867** NULL is returned if the result column is an expression or constant or
868** anything else which is not an unabiguous reference to a database column.
869*/
870const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000871 return columnName(
872 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
drhe590fbd2005-05-20 19:36:01 +0000873}
874#ifndef SQLITE_OMIT_UTF16
875const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000876 return columnName(
877 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
drhe590fbd2005-05-20 19:36:01 +0000878}
879#endif /* SQLITE_OMIT_UTF16 */
danielk19774b1ae992006-02-10 03:06:10 +0000880#endif /* SQLITE_ENABLE_COLUMN_METADATA */
drhe590fbd2005-05-20 19:36:01 +0000881
882
drh4f26d6c2004-05-26 23:25:30 +0000883/******************************* sqlite3_bind_ ***************************
884**
885** Routines used to attach values to wildcards in a compiled SQL statement.
886*/
887/*
888** Unbind the value bound to variable i in virtual machine p. This is the
889** the same as binding a NULL value to the column. If the "i" parameter is
890** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
891**
drh488e7b62008-10-06 12:46:43 +0000892** A successful evaluation of this routine acquires the mutex on p.
893** the mutex is released if any kind of error occurs.
894**
drh4f26d6c2004-05-26 23:25:30 +0000895** The error code stored in database p->db is overwritten with the return
896** value in any case.
897*/
898static int vdbeUnbind(Vdbe *p, int i){
899 Mem *pVar;
drh488e7b62008-10-06 12:46:43 +0000900 if( p==0 ) return SQLITE_MISUSE;
901 sqlite3_mutex_enter(p->db->mutex);
902 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
903 sqlite3Error(p->db, SQLITE_MISUSE, 0);
904 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +0000905 return SQLITE_MISUSE;
906 }
907 if( i<1 || i>p->nVar ){
908 sqlite3Error(p->db, SQLITE_RANGE, 0);
drh488e7b62008-10-06 12:46:43 +0000909 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +0000910 return SQLITE_RANGE;
911 }
912 i--;
drh290c1942004-08-21 17:54:45 +0000913 pVar = &p->aVar[i];
danielk1977d8123362004-06-12 09:25:12 +0000914 sqlite3VdbeMemRelease(pVar);
drh4f26d6c2004-05-26 23:25:30 +0000915 pVar->flags = MEM_Null;
916 sqlite3Error(p->db, SQLITE_OK, 0);
dan937d0de2009-10-15 18:35:38 +0000917
918 /* If the bit corresponding to this variable is set in Vdbe.opmask, set
919 ** the optimizable flag before returning. This tells the sqlite3_reoptimize()
920 ** function that the VM program may benefit from recompilation.
921 **
922 ** If the bit in Vdbe.expmask is set, then binding a new value to this
923 ** variable invalidates the current query plan. This comes about when the
924 ** variable is the RHS of a LIKE or GLOB operator and the LIKE/GLOB is
925 ** able to use an index. */
926 if( (i<32 && p->optmask & ((u32)1 << i)) || p->optmask==0xffffffff ){
927 p->optimizable = 1;
928 }
929 if( (i<32 && p->expmask & ((u32)1 << i)) || p->expmask==0xffffffff ){
930 p->expired = 1;
931 }
drh4f26d6c2004-05-26 23:25:30 +0000932 return SQLITE_OK;
933}
934
935/*
drh5e2517e2004-09-24 23:59:12 +0000936** Bind a text or BLOB value.
drh4f26d6c2004-05-26 23:25:30 +0000937*/
drh5e2517e2004-09-24 23:59:12 +0000938static int bindText(
drh605264d2007-08-21 15:13:19 +0000939 sqlite3_stmt *pStmt, /* The statement to bind against */
940 int i, /* Index of the parameter to bind */
941 const void *zData, /* Pointer to the data to be bound */
942 int nData, /* Number of bytes of data to be bound */
943 void (*xDel)(void*), /* Destructor for the data */
drhb27b7f52008-12-10 18:03:45 +0000944 u8 encoding /* Encoding for the data */
drh4f26d6c2004-05-26 23:25:30 +0000945){
946 Vdbe *p = (Vdbe *)pStmt;
947 Mem *pVar;
948 int rc;
949
950 rc = vdbeUnbind(p, i);
drh488e7b62008-10-06 12:46:43 +0000951 if( rc==SQLITE_OK ){
952 if( zData!=0 ){
953 pVar = &p->aVar[i-1];
954 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
955 if( rc==SQLITE_OK && encoding!=0 ){
956 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
957 }
958 sqlite3Error(p->db, rc, 0);
959 rc = sqlite3ApiExit(p->db, rc);
drh27641702007-08-22 02:56:42 +0000960 }
drh488e7b62008-10-06 12:46:43 +0000961 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +0000962 }
drh605264d2007-08-21 15:13:19 +0000963 return rc;
drh4f26d6c2004-05-26 23:25:30 +0000964}
drh5e2517e2004-09-24 23:59:12 +0000965
966
967/*
968** Bind a blob value to an SQL statement variable.
969*/
970int sqlite3_bind_blob(
971 sqlite3_stmt *pStmt,
972 int i,
973 const void *zData,
974 int nData,
975 void (*xDel)(void*)
976){
977 return bindText(pStmt, i, zData, nData, xDel, 0);
978}
drh4f26d6c2004-05-26 23:25:30 +0000979int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
980 int rc;
981 Vdbe *p = (Vdbe *)pStmt;
drh4f26d6c2004-05-26 23:25:30 +0000982 rc = vdbeUnbind(p, i);
983 if( rc==SQLITE_OK ){
drh290c1942004-08-21 17:54:45 +0000984 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
drh488e7b62008-10-06 12:46:43 +0000985 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +0000986 }
danielk1977f4618892004-06-28 13:09:11 +0000987 return rc;
drh4f26d6c2004-05-26 23:25:30 +0000988}
989int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
drhefad9992004-06-22 12:13:55 +0000990 return sqlite3_bind_int64(p, i, (i64)iValue);
drh4f26d6c2004-05-26 23:25:30 +0000991}
drhefad9992004-06-22 12:13:55 +0000992int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
drh4f26d6c2004-05-26 23:25:30 +0000993 int rc;
994 Vdbe *p = (Vdbe *)pStmt;
995 rc = vdbeUnbind(p, i);
996 if( rc==SQLITE_OK ){
drh290c1942004-08-21 17:54:45 +0000997 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
drh488e7b62008-10-06 12:46:43 +0000998 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +0000999 }
1000 return rc;
1001}
drh605264d2007-08-21 15:13:19 +00001002int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
1003 int rc;
1004 Vdbe *p = (Vdbe*)pStmt;
drh605264d2007-08-21 15:13:19 +00001005 rc = vdbeUnbind(p, i);
drh488e7b62008-10-06 12:46:43 +00001006 if( rc==SQLITE_OK ){
1007 sqlite3_mutex_leave(p->db->mutex);
1008 }
drh605264d2007-08-21 15:13:19 +00001009 return rc;
drh4f26d6c2004-05-26 23:25:30 +00001010}
1011int sqlite3_bind_text(
1012 sqlite3_stmt *pStmt,
1013 int i,
1014 const char *zData,
1015 int nData,
danielk1977d8123362004-06-12 09:25:12 +00001016 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +00001017){
drh5e2517e2004-09-24 23:59:12 +00001018 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +00001019}
drh6c626082004-11-14 21:56:29 +00001020#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +00001021int sqlite3_bind_text16(
1022 sqlite3_stmt *pStmt,
1023 int i,
1024 const void *zData,
1025 int nData,
danielk1977d8123362004-06-12 09:25:12 +00001026 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +00001027){
drh5e2517e2004-09-24 23:59:12 +00001028 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +00001029}
drh6c626082004-11-14 21:56:29 +00001030#endif /* SQLITE_OMIT_UTF16 */
danielk197726e41442006-06-14 15:16:35 +00001031int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
1032 int rc;
drh29def562009-04-14 12:43:33 +00001033 switch( pValue->type ){
drh29def562009-04-14 12:43:33 +00001034 case SQLITE_INTEGER: {
1035 rc = sqlite3_bind_int64(pStmt, i, pValue->u.i);
1036 break;
1037 }
1038 case SQLITE_FLOAT: {
1039 rc = sqlite3_bind_double(pStmt, i, pValue->r);
1040 break;
1041 }
1042 case SQLITE_BLOB: {
1043 if( pValue->flags & MEM_Zero ){
1044 rc = sqlite3_bind_zeroblob(pStmt, i, pValue->u.nZero);
1045 }else{
1046 rc = sqlite3_bind_blob(pStmt, i, pValue->z, pValue->n,SQLITE_TRANSIENT);
1047 }
1048 break;
1049 }
1050 case SQLITE_TEXT: {
drhac80db72009-04-14 12:58:20 +00001051 rc = bindText(pStmt,i, pValue->z, pValue->n, SQLITE_TRANSIENT,
1052 pValue->enc);
1053 break;
1054 }
1055 default: {
1056 rc = sqlite3_bind_null(pStmt, i);
drh29def562009-04-14 12:43:33 +00001057 break;
1058 }
danielk197726e41442006-06-14 15:16:35 +00001059 }
1060 return rc;
1061}
drhb026e052007-05-02 01:34:31 +00001062int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
1063 int rc;
1064 Vdbe *p = (Vdbe *)pStmt;
1065 rc = vdbeUnbind(p, i);
1066 if( rc==SQLITE_OK ){
1067 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
drh488e7b62008-10-06 12:46:43 +00001068 sqlite3_mutex_leave(p->db->mutex);
drhb026e052007-05-02 01:34:31 +00001069 }
1070 return rc;
1071}
drh75f6a032004-07-15 14:15:00 +00001072
1073/*
1074** Return the number of wildcards that can be potentially bound to.
1075** This routine is added to support DBD::SQLite.
drh75f6a032004-07-15 14:15:00 +00001076*/
1077int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
drh92febd92004-08-20 18:34:20 +00001078 Vdbe *p = (Vdbe*)pStmt;
1079 return p ? p->nVar : 0;
drh75f6a032004-07-15 14:15:00 +00001080}
drh895d7472004-08-20 16:02:39 +00001081
1082/*
drhfa6bc002004-09-07 16:19:52 +00001083** Create a mapping from variable numbers to variable names
1084** in the Vdbe.azVar[] array, if such a mapping does not already
1085** exist.
drh895d7472004-08-20 16:02:39 +00001086*/
drhfa6bc002004-09-07 16:19:52 +00001087static void createVarMap(Vdbe *p){
drh895d7472004-08-20 16:02:39 +00001088 if( !p->okVar ){
drh0f5ea0b2009-04-09 14:02:44 +00001089 int j;
1090 Op *pOp;
drh605264d2007-08-21 15:13:19 +00001091 sqlite3_mutex_enter(p->db->mutex);
drh0f5ea0b2009-04-09 14:02:44 +00001092 /* The race condition here is harmless. If two threads call this
1093 ** routine on the same Vdbe at the same time, they both might end
1094 ** up initializing the Vdbe.azVar[] array. That is a little extra
1095 ** work but it results in the same answer.
1096 */
1097 for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
1098 if( pOp->opcode==OP_Variable ){
1099 assert( pOp->p1>0 && pOp->p1<=p->nVar );
1100 p->azVar[pOp->p1-1] = pOp->p4.z;
drh895d7472004-08-20 16:02:39 +00001101 }
1102 }
drh0f5ea0b2009-04-09 14:02:44 +00001103 p->okVar = 1;
drh605264d2007-08-21 15:13:19 +00001104 sqlite3_mutex_leave(p->db->mutex);
drh895d7472004-08-20 16:02:39 +00001105 }
drhfa6bc002004-09-07 16:19:52 +00001106}
1107
1108/*
1109** Return the name of a wildcard parameter. Return NULL if the index
1110** is out of range or if the wildcard is unnamed.
1111**
1112** The result is always UTF-8.
1113*/
1114const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
1115 Vdbe *p = (Vdbe*)pStmt;
1116 if( p==0 || i<1 || i>p->nVar ){
1117 return 0;
1118 }
1119 createVarMap(p);
drh895d7472004-08-20 16:02:39 +00001120 return p->azVar[i-1];
1121}
drhfa6bc002004-09-07 16:19:52 +00001122
1123/*
1124** Given a wildcard parameter name, return the index of the variable
1125** with that name. If there is no variable with the given name,
1126** return 0.
1127*/
1128int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
1129 Vdbe *p = (Vdbe*)pStmt;
1130 int i;
1131 if( p==0 ){
1132 return 0;
1133 }
1134 createVarMap(p);
drh6a8903c2004-12-10 18:00:04 +00001135 if( zName ){
1136 for(i=0; i<p->nVar; i++){
1137 const char *z = p->azVar[i];
1138 if( z && strcmp(z,zName)==0 ){
1139 return i+1;
1140 }
drhfa6bc002004-09-07 16:19:52 +00001141 }
1142 }
1143 return 0;
1144}
drhf8db1bc2005-04-22 02:38:37 +00001145
drh51942bc2005-06-12 22:01:42 +00001146/*
drhf8db1bc2005-04-22 02:38:37 +00001147** Transfer all bindings from the first statement over to the second.
drhf8db1bc2005-04-22 02:38:37 +00001148*/
shane145834a2008-09-04 12:03:42 +00001149int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
drhf8db1bc2005-04-22 02:38:37 +00001150 Vdbe *pFrom = (Vdbe*)pFromStmt;
1151 Vdbe *pTo = (Vdbe*)pToStmt;
drh0f5ea0b2009-04-09 14:02:44 +00001152 int i;
1153 assert( pTo->db==pFrom->db );
1154 assert( pTo->nVar==pFrom->nVar );
drh27641702007-08-22 02:56:42 +00001155 sqlite3_mutex_enter(pTo->db->mutex);
drh0f5ea0b2009-04-09 14:02:44 +00001156 for(i=0; i<pFrom->nVar; i++){
drh643167f2008-01-22 21:30:53 +00001157 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
drhf8db1bc2005-04-22 02:38:37 +00001158 }
drh27641702007-08-22 02:56:42 +00001159 sqlite3_mutex_leave(pTo->db->mutex);
drh0f5ea0b2009-04-09 14:02:44 +00001160 return SQLITE_OK;
drhf8db1bc2005-04-22 02:38:37 +00001161}
drh51942bc2005-06-12 22:01:42 +00001162
shaneeec556d2008-10-12 00:27:53 +00001163#ifndef SQLITE_OMIT_DEPRECATED
drh51942bc2005-06-12 22:01:42 +00001164/*
shane145834a2008-09-04 12:03:42 +00001165** Deprecated external interface. Internal/core SQLite code
1166** should call sqlite3TransferBindings.
drh0f5ea0b2009-04-09 14:02:44 +00001167**
1168** Is is misuse to call this routine with statements from different
1169** database connections. But as this is a deprecated interface, we
1170** will not bother to check for that condition.
1171**
1172** If the two statements contain a different number of bindings, then
1173** an SQLITE_ERROR is returned. Nothing else can go wrong, so otherwise
1174** SQLITE_OK is returned.
shane145834a2008-09-04 12:03:42 +00001175*/
1176int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
drh0f5ea0b2009-04-09 14:02:44 +00001177 Vdbe *pFrom = (Vdbe*)pFromStmt;
1178 Vdbe *pTo = (Vdbe*)pToStmt;
1179 if( pFrom->nVar!=pTo->nVar ){
1180 return SQLITE_ERROR;
1181 }
shane145834a2008-09-04 12:03:42 +00001182 return sqlite3TransferBindings(pFromStmt, pToStmt);
1183}
shaneeec556d2008-10-12 00:27:53 +00001184#endif
shane145834a2008-09-04 12:03:42 +00001185
1186/*
drh51942bc2005-06-12 22:01:42 +00001187** Return the sqlite3* database handle to which the prepared statement given
1188** in the argument belongs. This is the same database handle that was
1189** the first argument to the sqlite3_prepare() that was used to create
1190** the statement in the first place.
1191*/
1192sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
1193 return pStmt ? ((Vdbe*)pStmt)->db : 0;
1194}
drhbb5a9c32008-06-19 02:52:25 +00001195
1196/*
1197** Return a pointer to the next prepared statement after pStmt associated
1198** with database connection pDb. If pStmt is NULL, return the first
1199** prepared statement for the database connection. Return NULL if there
1200** are no more.
1201*/
1202sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
1203 sqlite3_stmt *pNext;
1204 sqlite3_mutex_enter(pDb->mutex);
1205 if( pStmt==0 ){
1206 pNext = (sqlite3_stmt*)pDb->pVdbe;
1207 }else{
1208 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
1209 }
1210 sqlite3_mutex_leave(pDb->mutex);
1211 return pNext;
1212}
drhd1d38482008-10-07 23:46:38 +00001213
1214/*
1215** Return the value of a status counter for a prepared statement
1216*/
1217int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
1218 Vdbe *pVdbe = (Vdbe*)pStmt;
1219 int v = pVdbe->aCounter[op-1];
1220 if( resetFlag ) pVdbe->aCounter[op-1] = 0;
1221 return v;
1222}
dan937d0de2009-10-15 18:35:38 +00001223
1224/*
1225** If possible, optimize the statement for the current bindings.
1226*/
1227int sqlite3_reoptimize(sqlite3_stmt *pStmt){
1228 int rc = SQLITE_OK;
1229 Vdbe *v = (Vdbe *)pStmt;
1230 sqlite3 *db = v->db;
1231
1232 sqlite3_mutex_enter(db->mutex);
1233 if( v->isPrepareV2==0 || v->pc>0 ){
1234 rc = SQLITE_MISUSE;
1235 }else if( v->optimizable ){
1236 sqlite3 *db = v->db;
1237 sqlite3_mutex_enter(db->mutex);
1238 rc = sqlite3Reprepare(v);
1239 rc = sqlite3ApiExit(db, rc);
1240 }
1241 assert( rc!=SQLITE_OK || v->optimizable==0 );
1242 sqlite3_mutex_leave(db->mutex);
1243
1244 return rc;
1245}
1246