blob: 9762e380c32b4b785e2960bb7058a11e5dbe9a52 [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**
danielk1977238746a2009-03-19 18:51:06 +000016** $Id: vdbeapi.c,v 1.155 2009/03/19 18:51:07 danielk1977 Exp $
drh4f26d6c2004-05-26 23:25:30 +000017*/
18#include "sqliteInt.h"
19#include "vdbeInt.h"
20
danielk197767e3da72008-08-21 12:19:44 +000021#if 0 && defined(SQLITE_ENABLE_MEMORY_MANAGEMENT)
danielk1977dfb316d2008-03-26 18:34:43 +000022/*
23** The following structure contains pointers to the end points of a
24** doubly-linked list of all compiled SQL statements that may be holding
25** buffers eligible for release when the sqlite3_release_memory() interface is
26** invoked. Access to this list is protected by the SQLITE_MUTEX_STATIC_LRU2
27** mutex.
28**
29** Statements are added to the end of this list when sqlite3_reset() is
30** called. They are removed either when sqlite3_step() or sqlite3_finalize()
31** is called. When statements are added to this list, the associated
32** register array (p->aMem[1..p->nMem]) may contain dynamic buffers that
33** can be freed using sqlite3VdbeReleaseMemory().
34**
35** When statements are added or removed from this list, the mutex
36** associated with the Vdbe being added or removed (Vdbe.db->mutex) is
37** already held. The LRU2 mutex is then obtained, blocking if necessary,
38** the linked-list pointers manipulated and the LRU2 mutex relinquished.
39*/
40struct StatementLruList {
41 Vdbe *pFirst;
42 Vdbe *pLast;
43};
44static struct StatementLruList sqlite3LruStatements;
45
46/*
47** Check that the list looks to be internally consistent. This is used
48** as part of an assert() statement as follows:
49**
50** assert( stmtLruCheck() );
51*/
drh26e4a8b2008-05-01 17:16:52 +000052#ifndef NDEBUG
danielk1977dfb316d2008-03-26 18:34:43 +000053static int stmtLruCheck(){
54 Vdbe *p;
55 for(p=sqlite3LruStatements.pFirst; p; p=p->pLruNext){
56 assert(p->pLruNext || p==sqlite3LruStatements.pLast);
57 assert(!p->pLruNext || p->pLruNext->pLruPrev==p);
58 assert(p->pLruPrev || p==sqlite3LruStatements.pFirst);
59 assert(!p->pLruPrev || p->pLruPrev->pLruNext==p);
60 }
61 return 1;
62}
drh26e4a8b2008-05-01 17:16:52 +000063#endif
danielk1977dfb316d2008-03-26 18:34:43 +000064
65/*
66** Add vdbe p to the end of the statement lru list. It is assumed that
67** p is not already part of the list when this is called. The lru list
68** is protected by the SQLITE_MUTEX_STATIC_LRU mutex.
69*/
70static void stmtLruAdd(Vdbe *p){
danielk197759f8c082008-06-18 17:09:10 +000071 sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
danielk1977dfb316d2008-03-26 18:34:43 +000072
73 if( p->pLruPrev || p->pLruNext || sqlite3LruStatements.pFirst==p ){
danielk197759f8c082008-06-18 17:09:10 +000074 sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
danielk1977dfb316d2008-03-26 18:34:43 +000075 return;
76 }
77
78 assert( stmtLruCheck() );
79
80 if( !sqlite3LruStatements.pFirst ){
81 assert( !sqlite3LruStatements.pLast );
82 sqlite3LruStatements.pFirst = p;
83 sqlite3LruStatements.pLast = p;
84 }else{
85 assert( !sqlite3LruStatements.pLast->pLruNext );
86 p->pLruPrev = sqlite3LruStatements.pLast;
87 sqlite3LruStatements.pLast->pLruNext = p;
88 sqlite3LruStatements.pLast = p;
89 }
90
91 assert( stmtLruCheck() );
92
danielk197759f8c082008-06-18 17:09:10 +000093 sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
danielk1977dfb316d2008-03-26 18:34:43 +000094}
95
96/*
97** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is already held, remove
98** statement p from the least-recently-used statement list. If the
99** statement is not currently part of the list, this call is a no-op.
100*/
101static void stmtLruRemoveNomutex(Vdbe *p){
102 if( p->pLruPrev || p->pLruNext || p==sqlite3LruStatements.pFirst ){
103 assert( stmtLruCheck() );
104 if( p->pLruNext ){
105 p->pLruNext->pLruPrev = p->pLruPrev;
106 }else{
107 sqlite3LruStatements.pLast = p->pLruPrev;
108 }
109 if( p->pLruPrev ){
110 p->pLruPrev->pLruNext = p->pLruNext;
111 }else{
112 sqlite3LruStatements.pFirst = p->pLruNext;
113 }
114 p->pLruNext = 0;
115 p->pLruPrev = 0;
116 assert( stmtLruCheck() );
117 }
118}
119
120/*
121** Assuming the SQLITE_MUTEX_STATIC_LRU2 mutext is not held, remove
122** statement p from the least-recently-used statement list. If the
123** statement is not currently part of the list, this call is a no-op.
124*/
125static void stmtLruRemove(Vdbe *p){
danielk197759f8c082008-06-18 17:09:10 +0000126 sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
danielk1977dfb316d2008-03-26 18:34:43 +0000127 stmtLruRemoveNomutex(p);
danielk197759f8c082008-06-18 17:09:10 +0000128 sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
danielk1977dfb316d2008-03-26 18:34:43 +0000129}
130
131/*
132** Try to release n bytes of memory by freeing buffers associated
133** with the memory registers of currently unused vdbes.
134*/
135int sqlite3VdbeReleaseMemory(int n){
136 Vdbe *p;
137 Vdbe *pNext;
138 int nFree = 0;
139
danielk197759f8c082008-06-18 17:09:10 +0000140 sqlite3_mutex_enter(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
danielk1977dfb316d2008-03-26 18:34:43 +0000141 for(p=sqlite3LruStatements.pFirst; p && nFree<n; p=pNext){
142 pNext = p->pLruNext;
143
144 /* For each statement handle in the lru list, attempt to obtain the
145 ** associated database mutex. If it cannot be obtained, continue
146 ** to the next statement handle. It is not possible to block on
147 ** the database mutex - that could cause deadlock.
148 */
149 if( SQLITE_OK==sqlite3_mutex_try(p->db->mutex) ){
150 nFree += sqlite3VdbeReleaseBuffers(p);
151 stmtLruRemoveNomutex(p);
152 sqlite3_mutex_leave(p->db->mutex);
153 }
154 }
danielk197759f8c082008-06-18 17:09:10 +0000155 sqlite3_mutex_leave(sqlite3MutexAlloc(SQLITE_MUTEX_STATIC_LRU2));
danielk1977dfb316d2008-03-26 18:34:43 +0000156
157 return nFree;
158}
159
160/*
161** Call sqlite3Reprepare() on the statement. Remove it from the
162** lru list before doing so, as Reprepare() will free all the
163** memory register buffers anyway.
164*/
165int vdbeReprepare(Vdbe *p){
166 stmtLruRemove(p);
167 return sqlite3Reprepare(p);
168}
169
170#else /* !SQLITE_ENABLE_MEMORY_MANAGEMENT */
171 #define stmtLruRemove(x)
172 #define stmtLruAdd(x)
173 #define vdbeReprepare(x) sqlite3Reprepare(x)
174#endif
175
176
shaneeec556d2008-10-12 00:27:53 +0000177#ifndef SQLITE_OMIT_DEPRECATED
drhd89bd002005-01-22 03:03:54 +0000178/*
179** Return TRUE (non-zero) of the statement supplied as an argument needs
180** to be recompiled. A statement needs to be recompiled whenever the
181** execution environment changes in a way that would alter the program
182** that sqlite3_prepare() generates. For example, if new functions or
183** collating sequences are registered or if an authorizer function is
184** added or changed.
drhd89bd002005-01-22 03:03:54 +0000185*/
186int sqlite3_expired(sqlite3_stmt *pStmt){
187 Vdbe *p = (Vdbe*)pStmt;
188 return p==0 || p->expired;
189}
shaneeec556d2008-10-12 00:27:53 +0000190#endif
drhd89bd002005-01-22 03:03:54 +0000191
drhe30f4422007-08-21 16:15:55 +0000192/*
193** The following routine destroys a virtual machine that is created by
194** the sqlite3_compile() routine. The integer returned is an SQLITE_
195** success/failure code that describes the result of executing the virtual
196** machine.
197**
198** This routine sets the error code and string returned by
199** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
200*/
201int sqlite3_finalize(sqlite3_stmt *pStmt){
202 int rc;
203 if( pStmt==0 ){
204 rc = SQLITE_OK;
205 }else{
206 Vdbe *v = (Vdbe*)pStmt;
danielk1977238746a2009-03-19 18:51:06 +0000207 sqlite3 *db = v->db;
drh18472fa2008-10-07 15:25:48 +0000208#if SQLITE_THREADSAFE
drh86f8c192007-08-22 00:39:19 +0000209 sqlite3_mutex *mutex = v->db->mutex;
drh7e8b8482008-01-23 03:03:05 +0000210#endif
drh86f8c192007-08-22 00:39:19 +0000211 sqlite3_mutex_enter(mutex);
danielk1977dfb316d2008-03-26 18:34:43 +0000212 stmtLruRemove(v);
drhe30f4422007-08-21 16:15:55 +0000213 rc = sqlite3VdbeFinalize(v);
danielk1977238746a2009-03-19 18:51:06 +0000214 rc = sqlite3ApiExit(db, rc);
drh86f8c192007-08-22 00:39:19 +0000215 sqlite3_mutex_leave(mutex);
drhe30f4422007-08-21 16:15:55 +0000216 }
217 return rc;
218}
219
220/*
221** Terminate the current execution of an SQL statement and reset it
222** back to its starting state so that it can be reused. A success code from
223** the prior execution is returned.
224**
225** This routine sets the error code and string returned by
226** sqlite3_errcode(), sqlite3_errmsg() and sqlite3_errmsg16().
227*/
228int sqlite3_reset(sqlite3_stmt *pStmt){
229 int rc;
230 if( pStmt==0 ){
231 rc = SQLITE_OK;
232 }else{
233 Vdbe *v = (Vdbe*)pStmt;
234 sqlite3_mutex_enter(v->db->mutex);
drhc890fec2008-08-01 20:10:08 +0000235 rc = sqlite3VdbeReset(v);
danielk1977dfb316d2008-03-26 18:34:43 +0000236 stmtLruAdd(v);
drhe30f4422007-08-21 16:15:55 +0000237 sqlite3VdbeMakeReady(v, -1, 0, 0, 0);
238 assert( (rc & (v->db->errMask))==rc );
danielk1977238746a2009-03-19 18:51:06 +0000239 rc = sqlite3ApiExit(v->db, rc);
drhe30f4422007-08-21 16:15:55 +0000240 sqlite3_mutex_leave(v->db->mutex);
241 }
242 return rc;
243}
244
245/*
246** Set all the parameters in the compiled SQL statement to NULL.
247*/
248int sqlite3_clear_bindings(sqlite3_stmt *pStmt){
249 int i;
250 int rc = SQLITE_OK;
drh7297d1f2008-05-09 14:39:44 +0000251 Vdbe *p = (Vdbe*)pStmt;
drh18472fa2008-10-07 15:25:48 +0000252#if SQLITE_THREADSAFE
drh7e8b8482008-01-23 03:03:05 +0000253 sqlite3_mutex *mutex = ((Vdbe*)pStmt)->db->mutex;
254#endif
255 sqlite3_mutex_enter(mutex);
drh7297d1f2008-05-09 14:39:44 +0000256 for(i=0; i<p->nVar; i++){
257 sqlite3VdbeMemRelease(&p->aVar[i]);
258 p->aVar[i].flags = MEM_Null;
drhe30f4422007-08-21 16:15:55 +0000259 }
drh7e8b8482008-01-23 03:03:05 +0000260 sqlite3_mutex_leave(mutex);
drhe30f4422007-08-21 16:15:55 +0000261 return rc;
262}
263
264
drh4f26d6c2004-05-26 23:25:30 +0000265/**************************** sqlite3_value_ *******************************
266** The following routines extract information from a Mem or sqlite3_value
267** structure.
268*/
269const void *sqlite3_value_blob(sqlite3_value *pVal){
270 Mem *p = (Mem*)pVal;
271 if( p->flags & (MEM_Blob|MEM_Str) ){
drhb21c8cd2007-08-21 19:33:56 +0000272 sqlite3VdbeMemExpandBlob(p);
drh1f0feef2007-05-15 13:27:07 +0000273 p->flags &= ~MEM_Str;
274 p->flags |= MEM_Blob;
drh4f26d6c2004-05-26 23:25:30 +0000275 return p->z;
276 }else{
277 return sqlite3_value_text(pVal);
278 }
279}
280int sqlite3_value_bytes(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000281 return sqlite3ValueBytes(pVal, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +0000282}
283int sqlite3_value_bytes16(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000284 return sqlite3ValueBytes(pVal, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +0000285}
286double sqlite3_value_double(sqlite3_value *pVal){
drh6a6124e2004-06-27 01:56:33 +0000287 return sqlite3VdbeRealValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000288}
289int sqlite3_value_int(sqlite3_value *pVal){
drhb27b7f52008-12-10 18:03:45 +0000290 return (int)sqlite3VdbeIntValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000291}
drhefad9992004-06-22 12:13:55 +0000292sqlite_int64 sqlite3_value_int64(sqlite3_value *pVal){
drh6a6124e2004-06-27 01:56:33 +0000293 return sqlite3VdbeIntValue((Mem*)pVal);
drh4f26d6c2004-05-26 23:25:30 +0000294}
295const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000296 return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +0000297}
drh6c626082004-11-14 21:56:29 +0000298#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000299const void *sqlite3_value_text16(sqlite3_value* pVal){
drhb21c8cd2007-08-21 19:33:56 +0000300 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +0000301}
danielk1977d8123362004-06-12 09:25:12 +0000302const void *sqlite3_value_text16be(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000303 return sqlite3ValueText(pVal, SQLITE_UTF16BE);
danielk1977d8123362004-06-12 09:25:12 +0000304}
305const void *sqlite3_value_text16le(sqlite3_value *pVal){
drhb21c8cd2007-08-21 19:33:56 +0000306 return sqlite3ValueText(pVal, SQLITE_UTF16LE);
danielk1977d8123362004-06-12 09:25:12 +0000307}
drh6c626082004-11-14 21:56:29 +0000308#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000309int sqlite3_value_type(sqlite3_value* pVal){
drhf4479502004-05-27 03:12:53 +0000310 return pVal->type;
drh4f26d6c2004-05-26 23:25:30 +0000311}
312
313/**************************** sqlite3_result_ *******************************
314** The following routines are used by user-defined functions to specify
315** the function result.
316*/
317void sqlite3_result_blob(
318 sqlite3_context *pCtx,
319 const void *z,
320 int n,
danielk1977d8123362004-06-12 09:25:12 +0000321 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000322){
drh5708d2d2005-06-22 10:53:59 +0000323 assert( n>=0 );
drh32bc3f62007-08-21 20:25:39 +0000324 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000325 sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000326}
327void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
drh32bc3f62007-08-21 20:25:39 +0000328 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000329 sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
330}
331void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
drh32bc3f62007-08-21 20:25:39 +0000332 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh69544ec2008-02-06 14:11:34 +0000333 pCtx->isError = SQLITE_ERROR;
drhb21c8cd2007-08-21 19:33:56 +0000334 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +0000335}
danielk1977a1686c92006-01-23 07:52:37 +0000336#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000337void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
drh32bc3f62007-08-21 20:25:39 +0000338 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh69544ec2008-02-06 14:11:34 +0000339 pCtx->isError = SQLITE_ERROR;
drhb21c8cd2007-08-21 19:33:56 +0000340 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +0000341}
danielk1977a1686c92006-01-23 07:52:37 +0000342#endif
drhf4479502004-05-27 03:12:53 +0000343void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
drh32bc3f62007-08-21 20:25:39 +0000344 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000345 sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
346}
347void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
drh32bc3f62007-08-21 20:25:39 +0000348 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drh4f26d6c2004-05-26 23:25:30 +0000349 sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
350}
351void sqlite3_result_null(sqlite3_context *pCtx){
drh32bc3f62007-08-21 20:25:39 +0000352 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhf4479502004-05-27 03:12:53 +0000353 sqlite3VdbeMemSetNull(&pCtx->s);
drh4f26d6c2004-05-26 23:25:30 +0000354}
355void sqlite3_result_text(
356 sqlite3_context *pCtx,
357 const char *z,
358 int n,
danielk1977d8123362004-06-12 09:25:12 +0000359 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000360){
drh32bc3f62007-08-21 20:25:39 +0000361 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000362 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000363}
drh6c626082004-11-14 21:56:29 +0000364#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000365void sqlite3_result_text16(
366 sqlite3_context *pCtx,
367 const void *z,
368 int n,
danielk1977d8123362004-06-12 09:25:12 +0000369 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000370){
drh32bc3f62007-08-21 20:25:39 +0000371 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000372 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
danielk1977d8123362004-06-12 09:25:12 +0000373}
374void sqlite3_result_text16be(
375 sqlite3_context *pCtx,
376 const void *z,
377 int n,
378 void (*xDel)(void *)
379){
drh32bc3f62007-08-21 20:25:39 +0000380 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000381 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);
danielk1977d8123362004-06-12 09:25:12 +0000382}
383void sqlite3_result_text16le(
384 sqlite3_context *pCtx,
385 const void *z,
386 int n,
387 void (*xDel)(void *)
388){
drh32bc3f62007-08-21 20:25:39 +0000389 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000390 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000391}
drh6c626082004-11-14 21:56:29 +0000392#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000393void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
drh32bc3f62007-08-21 20:25:39 +0000394 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb21c8cd2007-08-21 19:33:56 +0000395 sqlite3VdbeMemCopy(&pCtx->s, pValue);
drh4f26d6c2004-05-26 23:25:30 +0000396}
drhb026e052007-05-02 01:34:31 +0000397void sqlite3_result_zeroblob(sqlite3_context *pCtx, int n){
drh32bc3f62007-08-21 20:25:39 +0000398 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhb026e052007-05-02 01:34:31 +0000399 sqlite3VdbeMemSetZeroBlob(&pCtx->s, n);
400}
drh69544ec2008-02-06 14:11:34 +0000401void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
402 pCtx->isError = errCode;
403}
drh4f26d6c2004-05-26 23:25:30 +0000404
drha0206bc2007-05-08 15:15:02 +0000405/* Force an SQLITE_TOOBIG error. */
406void sqlite3_result_error_toobig(sqlite3_context *pCtx){
drh32bc3f62007-08-21 20:25:39 +0000407 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhbb4957f2008-03-20 14:03:29 +0000408 pCtx->isError = SQLITE_TOOBIG;
409 sqlite3VdbeMemSetStr(&pCtx->s, "string or blob too big", -1,
410 SQLITE_UTF8, SQLITE_STATIC);
drha0206bc2007-05-08 15:15:02 +0000411}
412
danielk1977a1644fd2007-08-29 12:31:25 +0000413/* An SQLITE_NOMEM error. */
414void sqlite3_result_error_nomem(sqlite3_context *pCtx){
415 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
416 sqlite3VdbeMemSetNull(&pCtx->s);
drh69544ec2008-02-06 14:11:34 +0000417 pCtx->isError = SQLITE_NOMEM;
danielk1977a1644fd2007-08-29 12:31:25 +0000418 pCtx->s.db->mallocFailed = 1;
419}
drh4f26d6c2004-05-26 23:25:30 +0000420
421/*
422** Execute the statement pStmt, either until a row of data is ready, the
423** statement is completely executed or an error occurs.
drhb900aaf2006-11-09 00:24:53 +0000424**
425** This routine implements the bulk of the logic behind the sqlite_step()
426** API. The only thing omitted is the automatic recompile if a
427** schema change has occurred. That detail is handled by the
428** outer sqlite3_step() wrapper procedure.
drh4f26d6c2004-05-26 23:25:30 +0000429*/
drhb900aaf2006-11-09 00:24:53 +0000430static int sqlite3Step(Vdbe *p){
drh9bb575f2004-09-06 17:24:11 +0000431 sqlite3 *db;
drh4f26d6c2004-05-26 23:25:30 +0000432 int rc;
433
danielk1977a185ddb2007-11-15 16:04:15 +0000434 assert(p);
435 if( p->magic!=VDBE_MAGIC_RUN ){
drhf1bfe9a2007-10-17 01:44:20 +0000436 return SQLITE_MISUSE;
437 }
438
danielk1977efaaf572006-01-16 11:29:19 +0000439 /* Assert that malloc() has not failed */
drh17435752007-08-16 04:30:38 +0000440 db = p->db;
drhc456e572008-08-11 18:44:58 +0000441 if( db->mallocFailed ){
442 return SQLITE_NOMEM;
443 }
danielk1977261919c2005-12-06 12:52:59 +0000444
danielk1977a21c6b62005-01-24 10:25:59 +0000445 if( p->pc<=0 && p->expired ){
446 if( p->rc==SQLITE_OK ){
447 p->rc = SQLITE_SCHEMA;
448 }
drhb900aaf2006-11-09 00:24:53 +0000449 rc = SQLITE_ERROR;
450 goto end_of_step;
danielk1977a21c6b62005-01-24 10:25:59 +0000451 }
drh4f26d6c2004-05-26 23:25:30 +0000452 if( sqlite3SafetyOn(db) ){
453 p->rc = SQLITE_MISUSE;
454 return SQLITE_MISUSE;
455 }
danielk19771d850a72004-05-31 08:26:49 +0000456 if( p->pc<0 ){
drh15ca1df2006-07-26 13:43:30 +0000457 /* If there are no other statements currently running, then
458 ** reset the interrupt flag. This prevents a call to sqlite3_interrupt
459 ** from interrupting a statement that has not yet started.
460 */
461 if( db->activeVdbeCnt==0 ){
462 db->u1.isInterrupted = 0;
463 }
464
drh19e2d372005-08-29 23:00:03 +0000465#ifndef SQLITE_OMIT_TRACE
drh19e2d372005-08-29 23:00:03 +0000466 if( db->xProfile && !db->init.busy ){
467 double rNow;
danielk1977b4b47412007-08-17 15:53:36 +0000468 sqlite3OsCurrentTime(db->pVfs, &rNow);
drhb27b7f52008-12-10 18:03:45 +0000469 p->startTime = (u64)((rNow - (int)rNow)*3600.0*24.0*1000000000.0);
drh19e2d372005-08-29 23:00:03 +0000470 }
471#endif
drhc16a03b2004-09-15 13:38:10 +0000472
danielk19771d850a72004-05-31 08:26:49 +0000473 db->activeVdbeCnt++;
drhad4a4b82008-11-05 16:37:34 +0000474 if( p->readOnly==0 ) db->writeVdbeCnt++;
danielk19771d850a72004-05-31 08:26:49 +0000475 p->pc = 0;
danielk1977dfb316d2008-03-26 18:34:43 +0000476 stmtLruRemove(p);
danielk19771d850a72004-05-31 08:26:49 +0000477 }
drhb7f91642004-10-31 02:22:47 +0000478#ifndef SQLITE_OMIT_EXPLAIN
drh4f26d6c2004-05-26 23:25:30 +0000479 if( p->explain ){
480 rc = sqlite3VdbeList(p);
drhb7f91642004-10-31 02:22:47 +0000481 }else
482#endif /* SQLITE_OMIT_EXPLAIN */
483 {
drh4f26d6c2004-05-26 23:25:30 +0000484 rc = sqlite3VdbeExec(p);
485 }
486
487 if( sqlite3SafetyOff(db) ){
488 rc = SQLITE_MISUSE;
489 }
490
drh19e2d372005-08-29 23:00:03 +0000491#ifndef SQLITE_OMIT_TRACE
492 /* Invoke the profile callback if there is one
493 */
danielk19776ab3a2e2009-02-19 14:39:25 +0000494 if( rc!=SQLITE_ROW && db->xProfile && !db->init.busy && p->zSql ){
drh19e2d372005-08-29 23:00:03 +0000495 double rNow;
496 u64 elapseTime;
497
danielk1977b4b47412007-08-17 15:53:36 +0000498 sqlite3OsCurrentTime(db->pVfs, &rNow);
drhb27b7f52008-12-10 18:03:45 +0000499 elapseTime = (u64)((rNow - (int)rNow)*3600.0*24.0*1000000000.0);
500 elapseTime -= p->startTime;
danielk19776ab3a2e2009-02-19 14:39:25 +0000501 db->xProfile(db->pProfileArg, p->zSql, elapseTime);
drh19e2d372005-08-29 23:00:03 +0000502 }
503#endif
504
drh80cc85b2008-07-23 21:07:25 +0000505 db->errCode = rc;
506 /*sqlite3Error(p->db, rc, 0);*/
danielk197776e8d1a2006-01-18 18:22:43 +0000507 p->rc = sqlite3ApiExit(p->db, p->rc);
drhb900aaf2006-11-09 00:24:53 +0000508end_of_step:
drh4ac285a2006-09-15 07:28:50 +0000509 assert( (rc&0xff)==rc );
danielk19776ab3a2e2009-02-19 14:39:25 +0000510 if( p->isPrepareV2 && (rc&0xff)<SQLITE_ROW ){
drhb900aaf2006-11-09 00:24:53 +0000511 /* This behavior occurs if sqlite3_prepare_v2() was used to build
512 ** the prepared statement. Return error codes directly */
drh80cc85b2008-07-23 21:07:25 +0000513 p->db->errCode = p->rc;
514 /* sqlite3Error(p->db, p->rc, 0); */
drhb900aaf2006-11-09 00:24:53 +0000515 return p->rc;
516 }else{
517 /* This is for legacy sqlite3_prepare() builds and when the code
518 ** is SQLITE_ROW or SQLITE_DONE */
519 return rc;
520 }
521}
522
523/*
524** This is the top-level implementation of sqlite3_step(). Call
525** sqlite3Step() to do most of the work. If a schema error occurs,
526** call sqlite3Reprepare() and try again.
527*/
528#ifdef SQLITE_OMIT_PARSER
529int sqlite3_step(sqlite3_stmt *pStmt){
danielk1977a185ddb2007-11-15 16:04:15 +0000530 int rc = SQLITE_MISUSE;
531 if( pStmt ){
532 Vdbe *v;
533 v = (Vdbe*)pStmt;
534 sqlite3_mutex_enter(v->db->mutex);
535 rc = sqlite3Step(v);
536 sqlite3_mutex_leave(v->db->mutex);
537 }
drhb21c8cd2007-08-21 19:33:56 +0000538 return rc;
drhb900aaf2006-11-09 00:24:53 +0000539}
540#else
541int sqlite3_step(sqlite3_stmt *pStmt){
danielk1977a185ddb2007-11-15 16:04:15 +0000542 int rc = SQLITE_MISUSE;
543 if( pStmt ){
544 int cnt = 0;
545 Vdbe *v = (Vdbe*)pStmt;
546 sqlite3 *db = v->db;
547 sqlite3_mutex_enter(db->mutex);
548 while( (rc = sqlite3Step(v))==SQLITE_SCHEMA
549 && cnt++ < 5
danielk197765a2ea12009-03-19 07:58:31 +0000550 && (rc = vdbeReprepare(v))==SQLITE_OK ){
danielk1977a185ddb2007-11-15 16:04:15 +0000551 sqlite3_reset(pStmt);
552 v->expired = 0;
danielk19778e556522007-11-13 10:30:24 +0000553 }
danielk19776ab3a2e2009-02-19 14:39:25 +0000554 if( rc==SQLITE_SCHEMA && v->isPrepareV2 && db->pErr ){
danielk1977a185ddb2007-11-15 16:04:15 +0000555 /* This case occurs after failing to recompile an sql statement.
556 ** The error message from the SQL compiler has already been loaded
557 ** into the database handle. This block copies the error message
558 ** from the database handle into the statement and sets the statement
559 ** program counter to 0 to ensure that when the statement is
560 ** finalized or reset the parser error message is available via
561 ** sqlite3_errmsg() and sqlite3_errcode().
562 */
563 const char *zErr = (const char *)sqlite3_value_text(db->pErr);
drh633e6d52008-07-28 19:34:53 +0000564 sqlite3DbFree(db, v->zErrMsg);
danielk1977a185ddb2007-11-15 16:04:15 +0000565 if( !db->mallocFailed ){
566 v->zErrMsg = sqlite3DbStrDup(db, zErr);
567 } else {
568 v->zErrMsg = 0;
569 v->rc = SQLITE_NOMEM;
570 }
571 }
572 rc = sqlite3ApiExit(db, rc);
573 sqlite3_mutex_leave(db->mutex);
danielk19778e556522007-11-13 10:30:24 +0000574 }
danielk197776e8d1a2006-01-18 18:22:43 +0000575 return rc;
drh4f26d6c2004-05-26 23:25:30 +0000576}
drhb900aaf2006-11-09 00:24:53 +0000577#endif
drh4f26d6c2004-05-26 23:25:30 +0000578
579/*
drheb2e1762004-05-27 01:53:56 +0000580** Extract the user data from a sqlite3_context structure and return a
581** pointer to it.
582*/
583void *sqlite3_user_data(sqlite3_context *p){
584 assert( p && p->pFunc );
585 return p->pFunc->pUserData;
586}
587
588/*
drhfa4a4b92008-03-19 21:45:51 +0000589** Extract the user data from a sqlite3_context structure and return a
590** pointer to it.
591*/
592sqlite3 *sqlite3_context_db_handle(sqlite3_context *p){
593 assert( p && p->pFunc );
594 return p->s.db;
595}
596
597/*
drhb7481e72006-09-16 21:45:14 +0000598** The following is the implementation of an SQL function that always
599** fails with an error message stating that the function is used in the
600** wrong context. The sqlite3_overload_function() API might construct
601** SQL function that use this routine so that the functions will exist
602** for name resolution but are actually overloaded by the xFindFunction
603** method of virtual tables.
604*/
605void sqlite3InvalidFunction(
606 sqlite3_context *context, /* The function calling context */
danielk197762c14b32008-11-19 09:05:26 +0000607 int NotUsed, /* Number of arguments to the function */
608 sqlite3_value **NotUsed2 /* Value of each argument */
drhb7481e72006-09-16 21:45:14 +0000609){
610 const char *zName = context->pFunc->zName;
611 char *zErr;
danielk197762c14b32008-11-19 09:05:26 +0000612 UNUSED_PARAMETER2(NotUsed, NotUsed2);
danielk19771e536952007-08-16 10:09:01 +0000613 zErr = sqlite3MPrintf(0,
drhb7481e72006-09-16 21:45:14 +0000614 "unable to use function %s in the requested context", zName);
615 sqlite3_result_error(context, zErr, -1);
danielk19771e536952007-08-16 10:09:01 +0000616 sqlite3_free(zErr);
drhb7481e72006-09-16 21:45:14 +0000617}
618
619/*
drheb2e1762004-05-27 01:53:56 +0000620** Allocate or return the aggregate context for a user function. A new
621** context is allocated on the first call. Subsequent calls return the
622** same context that was returned on prior calls.
drheb2e1762004-05-27 01:53:56 +0000623*/
624void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
drhb21c8cd2007-08-21 19:33:56 +0000625 Mem *pMem;
drh825c6622005-09-08 19:01:05 +0000626 assert( p && p->pFunc && p->pFunc->xStep );
drhb21c8cd2007-08-21 19:33:56 +0000627 assert( sqlite3_mutex_held(p->s.db->mutex) );
628 pMem = p->pMem;
drha10a34b2005-09-07 22:09:48 +0000629 if( (pMem->flags & MEM_Agg)==0 ){
630 if( nByte==0 ){
danielk19775f096132008-03-28 15:44:09 +0000631 sqlite3VdbeMemReleaseExternal(pMem);
632 pMem->flags = MEM_Null;
drha10a34b2005-09-07 22:09:48 +0000633 pMem->z = 0;
drheb2e1762004-05-27 01:53:56 +0000634 }else{
danielk19775f096132008-03-28 15:44:09 +0000635 sqlite3VdbeMemGrow(pMem, nByte, 0);
drha10a34b2005-09-07 22:09:48 +0000636 pMem->flags = MEM_Agg;
drh3c024d62007-03-30 11:23:45 +0000637 pMem->u.pDef = p->pFunc;
danielk19775f096132008-03-28 15:44:09 +0000638 if( pMem->z ){
639 memset(pMem->z, 0, nByte);
640 }
drheb2e1762004-05-27 01:53:56 +0000641 }
642 }
drhabfcea22005-09-06 20:36:48 +0000643 return (void*)pMem->z;
drheb2e1762004-05-27 01:53:56 +0000644}
645
646/*
danielk1977682f68b2004-06-05 10:22:17 +0000647** Return the auxilary data pointer, if any, for the iArg'th argument to
648** the user-function defined by pCtx.
649*/
650void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
drhb21c8cd2007-08-21 19:33:56 +0000651 VdbeFunc *pVdbeFunc;
652
653 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
654 pVdbeFunc = pCtx->pVdbeFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000655 if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
656 return 0;
657 }
drhf92c7ff2004-06-19 15:40:23 +0000658 return pVdbeFunc->apAux[iArg].pAux;
danielk1977682f68b2004-06-05 10:22:17 +0000659}
660
661/*
662** Set the auxilary data pointer and delete function, for the iArg'th
663** argument to the user-function defined by pCtx. Any previous value is
664** deleted by calling the delete function specified when it was set.
665*/
666void sqlite3_set_auxdata(
667 sqlite3_context *pCtx,
668 int iArg,
669 void *pAux,
670 void (*xDelete)(void*)
671){
672 struct AuxData *pAuxData;
drhf92c7ff2004-06-19 15:40:23 +0000673 VdbeFunc *pVdbeFunc;
danielk1977e0fc5262007-07-26 06:50:05 +0000674 if( iArg<0 ) goto failed;
danielk1977682f68b2004-06-05 10:22:17 +0000675
drhb21c8cd2007-08-21 19:33:56 +0000676 assert( sqlite3_mutex_held(pCtx->s.db->mutex) );
drhf92c7ff2004-06-19 15:40:23 +0000677 pVdbeFunc = pCtx->pVdbeFunc;
678 if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
danielk197731dad9d2007-08-16 11:36:15 +0000679 int nAux = (pVdbeFunc ? pVdbeFunc->nAux : 0);
drhf92c7ff2004-06-19 15:40:23 +0000680 int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
danielk197726783a52007-08-29 14:06:22 +0000681 pVdbeFunc = sqlite3DbRealloc(pCtx->s.db, pVdbeFunc, nMalloc);
drh17435752007-08-16 04:30:38 +0000682 if( !pVdbeFunc ){
drh17435752007-08-16 04:30:38 +0000683 goto failed;
684 }
drh53f733c2005-09-16 02:38:09 +0000685 pCtx->pVdbeFunc = pVdbeFunc;
danielk197731dad9d2007-08-16 11:36:15 +0000686 memset(&pVdbeFunc->apAux[nAux], 0, sizeof(struct AuxData)*(iArg+1-nAux));
drh998da3a2004-06-19 15:22:56 +0000687 pVdbeFunc->nAux = iArg+1;
688 pVdbeFunc->pFunc = pCtx->pFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000689 }
690
drhf92c7ff2004-06-19 15:40:23 +0000691 pAuxData = &pVdbeFunc->apAux[iArg];
danielk1977682f68b2004-06-05 10:22:17 +0000692 if( pAuxData->pAux && pAuxData->xDelete ){
693 pAuxData->xDelete(pAuxData->pAux);
694 }
695 pAuxData->pAux = pAux;
696 pAuxData->xDelete = xDelete;
danielk1977e0fc5262007-07-26 06:50:05 +0000697 return;
698
699failed:
700 if( xDelete ){
701 xDelete(pAux);
702 }
danielk1977682f68b2004-06-05 10:22:17 +0000703}
704
shaneeec556d2008-10-12 00:27:53 +0000705#ifndef SQLITE_OMIT_DEPRECATED
danielk1977682f68b2004-06-05 10:22:17 +0000706/*
drheb2e1762004-05-27 01:53:56 +0000707** Return the number of times the Step function of a aggregate has been
708** called.
709**
drhcf85a512006-02-09 18:35:29 +0000710** This function is deprecated. Do not use it for new code. It is
711** provide only to avoid breaking legacy code. New aggregate function
712** implementations should keep their own counts within their aggregate
713** context.
drheb2e1762004-05-27 01:53:56 +0000714*/
715int sqlite3_aggregate_count(sqlite3_context *p){
shanee34c6472009-03-05 04:23:47 +0000716 assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
drhabfcea22005-09-06 20:36:48 +0000717 return p->pMem->n;
drheb2e1762004-05-27 01:53:56 +0000718}
shaneeec556d2008-10-12 00:27:53 +0000719#endif
drheb2e1762004-05-27 01:53:56 +0000720
721/*
drh4f26d6c2004-05-26 23:25:30 +0000722** Return the number of columns in the result set for the statement pStmt.
723*/
724int sqlite3_column_count(sqlite3_stmt *pStmt){
725 Vdbe *pVm = (Vdbe *)pStmt;
drh1bcdb0c2004-08-28 14:49:46 +0000726 return pVm ? pVm->nResColumn : 0;
drh4f26d6c2004-05-26 23:25:30 +0000727}
728
729/*
730** Return the number of values available from the current row of the
731** currently executing statement pStmt.
732*/
733int sqlite3_data_count(sqlite3_stmt *pStmt){
734 Vdbe *pVm = (Vdbe *)pStmt;
drhd4e70eb2008-01-02 00:34:36 +0000735 if( pVm==0 || pVm->pResultSet==0 ) return 0;
drh4f26d6c2004-05-26 23:25:30 +0000736 return pVm->nResColumn;
737}
738
739
740/*
741** Check to see if column iCol of the given statement is valid. If
742** it is, return a pointer to the Mem for the value of that column.
743** If iCol is not valid, return a pointer to a Mem which has a value
744** of NULL.
745*/
746static Mem *columnMem(sqlite3_stmt *pStmt, int i){
drh32bc3f62007-08-21 20:25:39 +0000747 Vdbe *pVm;
748 int vals;
749 Mem *pOut;
750
751 pVm = (Vdbe *)pStmt;
drhd4e70eb2008-01-02 00:34:36 +0000752 if( pVm && pVm->pResultSet!=0 && i<pVm->nResColumn && i>=0 ){
drh32bc3f62007-08-21 20:25:39 +0000753 sqlite3_mutex_enter(pVm->db->mutex);
754 vals = sqlite3_data_count(pStmt);
drhd4e70eb2008-01-02 00:34:36 +0000755 pOut = &pVm->pResultSet[i];
drh32bc3f62007-08-21 20:25:39 +0000756 }else{
shanefbd60f82009-02-04 03:59:25 +0000757 /* ((double)0) In case of SQLITE_OMIT_FLOATING_POINT... */
758 static const Mem nullMem = {{0}, (double)0, 0, "", 0, MEM_Null, SQLITE_NULL, 0, 0, 0 };
shanee34c6472009-03-05 04:23:47 +0000759 if( pVm && pVm->db ){
drh27641702007-08-22 02:56:42 +0000760 sqlite3_mutex_enter(pVm->db->mutex);
761 sqlite3Error(pVm->db, SQLITE_RANGE, 0);
762 }
drh32bc3f62007-08-21 20:25:39 +0000763 pOut = (Mem*)&nullMem;
drh4f26d6c2004-05-26 23:25:30 +0000764 }
drh32bc3f62007-08-21 20:25:39 +0000765 return pOut;
drh4f26d6c2004-05-26 23:25:30 +0000766}
767
danielk19772e588c72005-12-09 14:25:08 +0000768/*
769** This function is called after invoking an sqlite3_value_XXX function on a
770** column value (i.e. a value returned by evaluating an SQL expression in the
771** select list of a SELECT statement) that may cause a malloc() failure. If
772** malloc() has failed, the threads mallocFailed flag is cleared and the result
773** code of statement pStmt set to SQLITE_NOMEM.
774**
drh32bc3f62007-08-21 20:25:39 +0000775** Specifically, this is called from within:
danielk19772e588c72005-12-09 14:25:08 +0000776**
777** sqlite3_column_int()
778** sqlite3_column_int64()
779** sqlite3_column_text()
780** sqlite3_column_text16()
781** sqlite3_column_real()
782** sqlite3_column_bytes()
783** sqlite3_column_bytes16()
784**
785** But not for sqlite3_column_blob(), which never calls malloc().
786*/
787static void columnMallocFailure(sqlite3_stmt *pStmt)
788{
789 /* If malloc() failed during an encoding conversion within an
790 ** sqlite3_column_XXX API, then set the return code of the statement to
791 ** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
792 ** and _finalize() will return NOMEM.
793 */
danielk197754f01982006-01-18 15:25:17 +0000794 Vdbe *p = (Vdbe *)pStmt;
drh32bc3f62007-08-21 20:25:39 +0000795 if( p ){
796 p->rc = sqlite3ApiExit(p->db, p->rc);
797 sqlite3_mutex_leave(p->db->mutex);
798 }
danielk19772e588c72005-12-09 14:25:08 +0000799}
800
drh4f26d6c2004-05-26 23:25:30 +0000801/**************************** sqlite3_column_ *******************************
802** The following routines are used to access elements of the current row
803** in the result set.
804*/
danielk1977c572ef72004-05-27 09:28:41 +0000805const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000806 const void *val;
danielk19772e588c72005-12-09 14:25:08 +0000807 val = sqlite3_value_blob( columnMem(pStmt,i) );
danielk1977c9cf9012007-05-30 10:36:47 +0000808 /* Even though there is no encoding conversion, value_blob() might
809 ** need to call malloc() to expand the result of a zeroblob()
810 ** expression.
811 */
812 columnMallocFailure(pStmt);
danielk19772e588c72005-12-09 14:25:08 +0000813 return val;
danielk1977c572ef72004-05-27 09:28:41 +0000814}
drh4f26d6c2004-05-26 23:25:30 +0000815int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000816 int val = sqlite3_value_bytes( columnMem(pStmt,i) );
817 columnMallocFailure(pStmt);
818 return val;
drh4f26d6c2004-05-26 23:25:30 +0000819}
820int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000821 int val = sqlite3_value_bytes16( columnMem(pStmt,i) );
822 columnMallocFailure(pStmt);
823 return val;
drh4f26d6c2004-05-26 23:25:30 +0000824}
825double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000826 double val = sqlite3_value_double( columnMem(pStmt,i) );
827 columnMallocFailure(pStmt);
828 return val;
drh4f26d6c2004-05-26 23:25:30 +0000829}
830int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000831 int val = sqlite3_value_int( columnMem(pStmt,i) );
832 columnMallocFailure(pStmt);
833 return val;
drh4f26d6c2004-05-26 23:25:30 +0000834}
drhefad9992004-06-22 12:13:55 +0000835sqlite_int64 sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000836 sqlite_int64 val = sqlite3_value_int64( columnMem(pStmt,i) );
837 columnMallocFailure(pStmt);
838 return val;
drh4f26d6c2004-05-26 23:25:30 +0000839}
840const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000841 const unsigned char *val = sqlite3_value_text( columnMem(pStmt,i) );
842 columnMallocFailure(pStmt);
843 return val;
drh4f26d6c2004-05-26 23:25:30 +0000844}
drhd1e47332005-06-26 17:55:33 +0000845sqlite3_value *sqlite3_column_value(sqlite3_stmt *pStmt, int i){
danielk1977d0ffa1e2008-10-13 10:37:49 +0000846 Mem *pOut = columnMem(pStmt, i);
847 if( pOut->flags&MEM_Static ){
848 pOut->flags &= ~MEM_Static;
849 pOut->flags |= MEM_Ephem;
850 }
drh32bc3f62007-08-21 20:25:39 +0000851 columnMallocFailure(pStmt);
danielk1977d0ffa1e2008-10-13 10:37:49 +0000852 return (sqlite3_value *)pOut;
drhd1e47332005-06-26 17:55:33 +0000853}
drh6c626082004-11-14 21:56:29 +0000854#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +0000855const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
danielk19772e588c72005-12-09 14:25:08 +0000856 const void *val = sqlite3_value_text16( columnMem(pStmt,i) );
857 columnMallocFailure(pStmt);
858 return val;
drh4f26d6c2004-05-26 23:25:30 +0000859}
drh6c626082004-11-14 21:56:29 +0000860#endif /* SQLITE_OMIT_UTF16 */
drh4f26d6c2004-05-26 23:25:30 +0000861int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
drh32bc3f62007-08-21 20:25:39 +0000862 int iType = sqlite3_value_type( columnMem(pStmt,i) );
863 columnMallocFailure(pStmt);
864 return iType;
drh4f26d6c2004-05-26 23:25:30 +0000865}
866
drh29d72102006-02-09 22:13:41 +0000867/* The following function is experimental and subject to change or
868** removal */
869/*int sqlite3_column_numeric_type(sqlite3_stmt *pStmt, int i){
870** return sqlite3_value_numeric_type( columnMem(pStmt,i) );
871**}
872*/
873
drh5e2517e2004-09-24 23:59:12 +0000874/*
875** Convert the N-th element of pStmt->pColName[] into a string using
876** xFunc() then return that string. If N is out of range, return 0.
drhe590fbd2005-05-20 19:36:01 +0000877**
878** There are up to 5 names for each column. useType determines which
879** name is returned. Here are the names:
880**
881** 0 The column name as it should be displayed for output
882** 1 The datatype name for the column
883** 2 The name of the database that the column derives from
884** 3 The name of the table that the column derives from
885** 4 The name of the table column that the result column derives from
886**
887** If the result is not a simple column reference (if it is an expression
888** or a constant) then useTypes 2, 3, and 4 return NULL.
drh5e2517e2004-09-24 23:59:12 +0000889*/
890static const void *columnName(
891 sqlite3_stmt *pStmt,
892 int N,
893 const void *(*xFunc)(Mem*),
894 int useType
895){
drh32bc3f62007-08-21 20:25:39 +0000896 const void *ret = 0;
drh5e2517e2004-09-24 23:59:12 +0000897 Vdbe *p = (Vdbe *)pStmt;
drh32bc3f62007-08-21 20:25:39 +0000898 int n;
899
drh5e2517e2004-09-24 23:59:12 +0000900
drh32bc3f62007-08-21 20:25:39 +0000901 if( p!=0 ){
902 n = sqlite3_column_count(pStmt);
903 if( N<n && N>=0 ){
904 N += useType*n;
drh153c62c2007-08-24 03:51:33 +0000905 sqlite3_mutex_enter(p->db->mutex);
drh32bc3f62007-08-21 20:25:39 +0000906 ret = xFunc(&p->aColName[N]);
907
drh32bc3f62007-08-21 20:25:39 +0000908 /* A malloc may have failed inside of the xFunc() call. If this
909 ** is the case, clear the mallocFailed flag and return NULL.
910 */
911 if( p->db && p->db->mallocFailed ){
912 p->db->mallocFailed = 0;
913 ret = 0;
914 }
drh153c62c2007-08-24 03:51:33 +0000915 sqlite3_mutex_leave(p->db->mutex);
drh32bc3f62007-08-21 20:25:39 +0000916 }
drh5e2517e2004-09-24 23:59:12 +0000917 }
danielk197700fd9572005-12-07 06:27:43 +0000918 return ret;
drh5e2517e2004-09-24 23:59:12 +0000919}
920
drh4f26d6c2004-05-26 23:25:30 +0000921/*
922** Return the name of the Nth column of the result set returned by SQL
923** statement pStmt.
924*/
925const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000926 return columnName(
927 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_NAME);
drh4f26d6c2004-05-26 23:25:30 +0000928}
drhe590fbd2005-05-20 19:36:01 +0000929#ifndef SQLITE_OMIT_UTF16
930const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000931 return columnName(
932 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_NAME);
drhe590fbd2005-05-20 19:36:01 +0000933}
934#endif
drh4f26d6c2004-05-26 23:25:30 +0000935
936/*
drh3f913572008-03-22 01:07:17 +0000937** Constraint: If you have ENABLE_COLUMN_METADATA then you must
938** not define OMIT_DECLTYPE.
939*/
940#if defined(SQLITE_OMIT_DECLTYPE) && defined(SQLITE_ENABLE_COLUMN_METADATA)
941# error "Must not define both SQLITE_OMIT_DECLTYPE \
942 and SQLITE_ENABLE_COLUMN_METADATA"
943#endif
944
945#ifndef SQLITE_OMIT_DECLTYPE
946/*
drh6c626082004-11-14 21:56:29 +0000947** Return the column declaration type (if applicable) of the 'i'th column
drhe590fbd2005-05-20 19:36:01 +0000948** of the result set of SQL statement pStmt.
drh6c626082004-11-14 21:56:29 +0000949*/
950const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000951 return columnName(
952 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DECLTYPE);
drh6c626082004-11-14 21:56:29 +0000953}
drh6c626082004-11-14 21:56:29 +0000954#ifndef SQLITE_OMIT_UTF16
danielk197776d505b2004-05-28 13:13:02 +0000955const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000956 return columnName(
957 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DECLTYPE);
drh4f26d6c2004-05-26 23:25:30 +0000958}
drh6c626082004-11-14 21:56:29 +0000959#endif /* SQLITE_OMIT_UTF16 */
drh3f913572008-03-22 01:07:17 +0000960#endif /* SQLITE_OMIT_DECLTYPE */
drh4f26d6c2004-05-26 23:25:30 +0000961
danielk19774b1ae992006-02-10 03:06:10 +0000962#ifdef SQLITE_ENABLE_COLUMN_METADATA
drhe590fbd2005-05-20 19:36:01 +0000963/*
964** Return the name of the database from which a result column derives.
965** NULL is returned if the result column is an expression or constant or
966** anything else which is not an unabiguous reference to a database column.
967*/
968const char *sqlite3_column_database_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000969 return columnName(
970 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_DATABASE);
drhe590fbd2005-05-20 19:36:01 +0000971}
972#ifndef SQLITE_OMIT_UTF16
973const void *sqlite3_column_database_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000974 return columnName(
975 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_DATABASE);
drhe590fbd2005-05-20 19:36:01 +0000976}
977#endif /* SQLITE_OMIT_UTF16 */
978
979/*
980** Return the name of the table from which a result column derives.
981** NULL is returned if the result column is an expression or constant or
982** anything else which is not an unabiguous reference to a database column.
983*/
984const char *sqlite3_column_table_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000985 return columnName(
986 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_TABLE);
drhe590fbd2005-05-20 19:36:01 +0000987}
988#ifndef SQLITE_OMIT_UTF16
989const void *sqlite3_column_table_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +0000990 return columnName(
991 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_TABLE);
drhe590fbd2005-05-20 19:36:01 +0000992}
993#endif /* SQLITE_OMIT_UTF16 */
994
995/*
996** Return the name of the table column from which a result column derives.
997** NULL is returned if the result column is an expression or constant or
998** anything else which is not an unabiguous reference to a database column.
999*/
1000const char *sqlite3_column_origin_name(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +00001001 return columnName(
1002 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text, COLNAME_COLUMN);
drhe590fbd2005-05-20 19:36:01 +00001003}
1004#ifndef SQLITE_OMIT_UTF16
1005const void *sqlite3_column_origin_name16(sqlite3_stmt *pStmt, int N){
danielk1977955de522006-02-10 02:27:42 +00001006 return columnName(
1007 pStmt, N, (const void*(*)(Mem*))sqlite3_value_text16, COLNAME_COLUMN);
drhe590fbd2005-05-20 19:36:01 +00001008}
1009#endif /* SQLITE_OMIT_UTF16 */
danielk19774b1ae992006-02-10 03:06:10 +00001010#endif /* SQLITE_ENABLE_COLUMN_METADATA */
drhe590fbd2005-05-20 19:36:01 +00001011
1012
drh4f26d6c2004-05-26 23:25:30 +00001013/******************************* sqlite3_bind_ ***************************
1014**
1015** Routines used to attach values to wildcards in a compiled SQL statement.
1016*/
1017/*
1018** Unbind the value bound to variable i in virtual machine p. This is the
1019** the same as binding a NULL value to the column. If the "i" parameter is
1020** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
1021**
drh488e7b62008-10-06 12:46:43 +00001022** A successful evaluation of this routine acquires the mutex on p.
1023** the mutex is released if any kind of error occurs.
1024**
drh4f26d6c2004-05-26 23:25:30 +00001025** The error code stored in database p->db is overwritten with the return
1026** value in any case.
1027*/
1028static int vdbeUnbind(Vdbe *p, int i){
1029 Mem *pVar;
drh488e7b62008-10-06 12:46:43 +00001030 if( p==0 ) return SQLITE_MISUSE;
1031 sqlite3_mutex_enter(p->db->mutex);
1032 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
1033 sqlite3Error(p->db, SQLITE_MISUSE, 0);
1034 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +00001035 return SQLITE_MISUSE;
1036 }
1037 if( i<1 || i>p->nVar ){
1038 sqlite3Error(p->db, SQLITE_RANGE, 0);
drh488e7b62008-10-06 12:46:43 +00001039 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +00001040 return SQLITE_RANGE;
1041 }
1042 i--;
drh290c1942004-08-21 17:54:45 +00001043 pVar = &p->aVar[i];
danielk1977d8123362004-06-12 09:25:12 +00001044 sqlite3VdbeMemRelease(pVar);
drh4f26d6c2004-05-26 23:25:30 +00001045 pVar->flags = MEM_Null;
1046 sqlite3Error(p->db, SQLITE_OK, 0);
1047 return SQLITE_OK;
1048}
1049
1050/*
drh5e2517e2004-09-24 23:59:12 +00001051** Bind a text or BLOB value.
drh4f26d6c2004-05-26 23:25:30 +00001052*/
drh5e2517e2004-09-24 23:59:12 +00001053static int bindText(
drh605264d2007-08-21 15:13:19 +00001054 sqlite3_stmt *pStmt, /* The statement to bind against */
1055 int i, /* Index of the parameter to bind */
1056 const void *zData, /* Pointer to the data to be bound */
1057 int nData, /* Number of bytes of data to be bound */
1058 void (*xDel)(void*), /* Destructor for the data */
drhb27b7f52008-12-10 18:03:45 +00001059 u8 encoding /* Encoding for the data */
drh4f26d6c2004-05-26 23:25:30 +00001060){
1061 Vdbe *p = (Vdbe *)pStmt;
1062 Mem *pVar;
1063 int rc;
1064
1065 rc = vdbeUnbind(p, i);
drh488e7b62008-10-06 12:46:43 +00001066 if( rc==SQLITE_OK ){
1067 if( zData!=0 ){
1068 pVar = &p->aVar[i-1];
1069 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, encoding, xDel);
1070 if( rc==SQLITE_OK && encoding!=0 ){
1071 rc = sqlite3VdbeChangeEncoding(pVar, ENC(p->db));
1072 }
1073 sqlite3Error(p->db, rc, 0);
1074 rc = sqlite3ApiExit(p->db, rc);
drh27641702007-08-22 02:56:42 +00001075 }
drh488e7b62008-10-06 12:46:43 +00001076 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +00001077 }
drh605264d2007-08-21 15:13:19 +00001078 return rc;
drh4f26d6c2004-05-26 23:25:30 +00001079}
drh5e2517e2004-09-24 23:59:12 +00001080
1081
1082/*
1083** Bind a blob value to an SQL statement variable.
1084*/
1085int sqlite3_bind_blob(
1086 sqlite3_stmt *pStmt,
1087 int i,
1088 const void *zData,
1089 int nData,
1090 void (*xDel)(void*)
1091){
1092 return bindText(pStmt, i, zData, nData, xDel, 0);
1093}
drh4f26d6c2004-05-26 23:25:30 +00001094int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
1095 int rc;
1096 Vdbe *p = (Vdbe *)pStmt;
drh4f26d6c2004-05-26 23:25:30 +00001097 rc = vdbeUnbind(p, i);
1098 if( rc==SQLITE_OK ){
drh290c1942004-08-21 17:54:45 +00001099 sqlite3VdbeMemSetDouble(&p->aVar[i-1], rValue);
drh488e7b62008-10-06 12:46:43 +00001100 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +00001101 }
danielk1977f4618892004-06-28 13:09:11 +00001102 return rc;
drh4f26d6c2004-05-26 23:25:30 +00001103}
1104int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
drhefad9992004-06-22 12:13:55 +00001105 return sqlite3_bind_int64(p, i, (i64)iValue);
drh4f26d6c2004-05-26 23:25:30 +00001106}
drhefad9992004-06-22 12:13:55 +00001107int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, sqlite_int64 iValue){
drh4f26d6c2004-05-26 23:25:30 +00001108 int rc;
1109 Vdbe *p = (Vdbe *)pStmt;
1110 rc = vdbeUnbind(p, i);
1111 if( rc==SQLITE_OK ){
drh290c1942004-08-21 17:54:45 +00001112 sqlite3VdbeMemSetInt64(&p->aVar[i-1], iValue);
drh488e7b62008-10-06 12:46:43 +00001113 sqlite3_mutex_leave(p->db->mutex);
drh4f26d6c2004-05-26 23:25:30 +00001114 }
1115 return rc;
1116}
drh605264d2007-08-21 15:13:19 +00001117int sqlite3_bind_null(sqlite3_stmt *pStmt, int i){
1118 int rc;
1119 Vdbe *p = (Vdbe*)pStmt;
drh605264d2007-08-21 15:13:19 +00001120 rc = vdbeUnbind(p, i);
drh488e7b62008-10-06 12:46:43 +00001121 if( rc==SQLITE_OK ){
1122 sqlite3_mutex_leave(p->db->mutex);
1123 }
drh605264d2007-08-21 15:13:19 +00001124 return rc;
drh4f26d6c2004-05-26 23:25:30 +00001125}
1126int sqlite3_bind_text(
1127 sqlite3_stmt *pStmt,
1128 int i,
1129 const char *zData,
1130 int nData,
danielk1977d8123362004-06-12 09:25:12 +00001131 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +00001132){
drh5e2517e2004-09-24 23:59:12 +00001133 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +00001134}
drh6c626082004-11-14 21:56:29 +00001135#ifndef SQLITE_OMIT_UTF16
drh4f26d6c2004-05-26 23:25:30 +00001136int sqlite3_bind_text16(
1137 sqlite3_stmt *pStmt,
1138 int i,
1139 const void *zData,
1140 int nData,
danielk1977d8123362004-06-12 09:25:12 +00001141 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +00001142){
drh5e2517e2004-09-24 23:59:12 +00001143 return bindText(pStmt, i, zData, nData, xDel, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +00001144}
drh6c626082004-11-14 21:56:29 +00001145#endif /* SQLITE_OMIT_UTF16 */
danielk197726e41442006-06-14 15:16:35 +00001146int sqlite3_bind_value(sqlite3_stmt *pStmt, int i, const sqlite3_value *pValue){
1147 int rc;
1148 Vdbe *p = (Vdbe *)pStmt;
1149 rc = vdbeUnbind(p, i);
1150 if( rc==SQLITE_OK ){
drhb21c8cd2007-08-21 19:33:56 +00001151 rc = sqlite3VdbeMemCopy(&p->aVar[i-1], pValue);
danielk19771e740c62008-05-16 15:24:58 +00001152 if( rc==SQLITE_OK ){
1153 rc = sqlite3VdbeChangeEncoding(&p->aVar[i-1], ENC(p->db));
1154 }
drh488e7b62008-10-06 12:46:43 +00001155 sqlite3_mutex_leave(p->db->mutex);
danielk197726e41442006-06-14 15:16:35 +00001156 }
danielk19770bfbaa82008-10-07 14:06:11 +00001157 rc = sqlite3ApiExit(p->db, rc);
danielk197726e41442006-06-14 15:16:35 +00001158 return rc;
1159}
drhb026e052007-05-02 01:34:31 +00001160int sqlite3_bind_zeroblob(sqlite3_stmt *pStmt, int i, int n){
1161 int rc;
1162 Vdbe *p = (Vdbe *)pStmt;
1163 rc = vdbeUnbind(p, i);
1164 if( rc==SQLITE_OK ){
1165 sqlite3VdbeMemSetZeroBlob(&p->aVar[i-1], n);
drh488e7b62008-10-06 12:46:43 +00001166 sqlite3_mutex_leave(p->db->mutex);
drhb026e052007-05-02 01:34:31 +00001167 }
1168 return rc;
1169}
drh75f6a032004-07-15 14:15:00 +00001170
1171/*
1172** Return the number of wildcards that can be potentially bound to.
1173** This routine is added to support DBD::SQLite.
drh75f6a032004-07-15 14:15:00 +00001174*/
1175int sqlite3_bind_parameter_count(sqlite3_stmt *pStmt){
drh92febd92004-08-20 18:34:20 +00001176 Vdbe *p = (Vdbe*)pStmt;
1177 return p ? p->nVar : 0;
drh75f6a032004-07-15 14:15:00 +00001178}
drh895d7472004-08-20 16:02:39 +00001179
1180/*
drhfa6bc002004-09-07 16:19:52 +00001181** Create a mapping from variable numbers to variable names
1182** in the Vdbe.azVar[] array, if such a mapping does not already
1183** exist.
drh895d7472004-08-20 16:02:39 +00001184*/
drhfa6bc002004-09-07 16:19:52 +00001185static void createVarMap(Vdbe *p){
drh895d7472004-08-20 16:02:39 +00001186 if( !p->okVar ){
drh605264d2007-08-21 15:13:19 +00001187 sqlite3_mutex_enter(p->db->mutex);
1188 if( !p->okVar ){
1189 int j;
1190 Op *pOp;
1191 for(j=0, pOp=p->aOp; j<p->nOp; j++, pOp++){
1192 if( pOp->opcode==OP_Variable ){
1193 assert( pOp->p1>0 && pOp->p1<=p->nVar );
danielk19772dca4ac2008-01-03 11:50:29 +00001194 p->azVar[pOp->p1-1] = pOp->p4.z;
drh605264d2007-08-21 15:13:19 +00001195 }
drh895d7472004-08-20 16:02:39 +00001196 }
drh605264d2007-08-21 15:13:19 +00001197 p->okVar = 1;
drh895d7472004-08-20 16:02:39 +00001198 }
drh605264d2007-08-21 15:13:19 +00001199 sqlite3_mutex_leave(p->db->mutex);
drh895d7472004-08-20 16:02:39 +00001200 }
drhfa6bc002004-09-07 16:19:52 +00001201}
1202
1203/*
1204** Return the name of a wildcard parameter. Return NULL if the index
1205** is out of range or if the wildcard is unnamed.
1206**
1207** The result is always UTF-8.
1208*/
1209const char *sqlite3_bind_parameter_name(sqlite3_stmt *pStmt, int i){
1210 Vdbe *p = (Vdbe*)pStmt;
1211 if( p==0 || i<1 || i>p->nVar ){
1212 return 0;
1213 }
1214 createVarMap(p);
drh895d7472004-08-20 16:02:39 +00001215 return p->azVar[i-1];
1216}
drhfa6bc002004-09-07 16:19:52 +00001217
1218/*
1219** Given a wildcard parameter name, return the index of the variable
1220** with that name. If there is no variable with the given name,
1221** return 0.
1222*/
1223int sqlite3_bind_parameter_index(sqlite3_stmt *pStmt, const char *zName){
1224 Vdbe *p = (Vdbe*)pStmt;
1225 int i;
1226 if( p==0 ){
1227 return 0;
1228 }
1229 createVarMap(p);
drh6a8903c2004-12-10 18:00:04 +00001230 if( zName ){
1231 for(i=0; i<p->nVar; i++){
1232 const char *z = p->azVar[i];
1233 if( z && strcmp(z,zName)==0 ){
1234 return i+1;
1235 }
drhfa6bc002004-09-07 16:19:52 +00001236 }
1237 }
1238 return 0;
1239}
drhf8db1bc2005-04-22 02:38:37 +00001240
drh51942bc2005-06-12 22:01:42 +00001241/*
drhf8db1bc2005-04-22 02:38:37 +00001242** Transfer all bindings from the first statement over to the second.
1243** If the two statements contain a different number of bindings, then
1244** an SQLITE_ERROR is returned.
1245*/
shane145834a2008-09-04 12:03:42 +00001246int sqlite3TransferBindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
drhf8db1bc2005-04-22 02:38:37 +00001247 Vdbe *pFrom = (Vdbe*)pFromStmt;
1248 Vdbe *pTo = (Vdbe*)pToStmt;
1249 int i, rc = SQLITE_OK;
1250 if( (pFrom->magic!=VDBE_MAGIC_RUN && pFrom->magic!=VDBE_MAGIC_HALT)
drh27641702007-08-22 02:56:42 +00001251 || (pTo->magic!=VDBE_MAGIC_RUN && pTo->magic!=VDBE_MAGIC_HALT)
1252 || pTo->db!=pFrom->db ){
drhf8db1bc2005-04-22 02:38:37 +00001253 return SQLITE_MISUSE;
1254 }
1255 if( pFrom->nVar!=pTo->nVar ){
1256 return SQLITE_ERROR;
1257 }
drh27641702007-08-22 02:56:42 +00001258 sqlite3_mutex_enter(pTo->db->mutex);
drhf8db1bc2005-04-22 02:38:37 +00001259 for(i=0; rc==SQLITE_OK && i<pFrom->nVar; i++){
drh643167f2008-01-22 21:30:53 +00001260 sqlite3VdbeMemMove(&pTo->aVar[i], &pFrom->aVar[i]);
drhf8db1bc2005-04-22 02:38:37 +00001261 }
drh27641702007-08-22 02:56:42 +00001262 sqlite3_mutex_leave(pTo->db->mutex);
drh4ac285a2006-09-15 07:28:50 +00001263 assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
drhf8db1bc2005-04-22 02:38:37 +00001264 return rc;
1265}
drh51942bc2005-06-12 22:01:42 +00001266
shaneeec556d2008-10-12 00:27:53 +00001267#ifndef SQLITE_OMIT_DEPRECATED
drh51942bc2005-06-12 22:01:42 +00001268/*
shane145834a2008-09-04 12:03:42 +00001269** Deprecated external interface. Internal/core SQLite code
1270** should call sqlite3TransferBindings.
1271*/
1272int sqlite3_transfer_bindings(sqlite3_stmt *pFromStmt, sqlite3_stmt *pToStmt){
1273 return sqlite3TransferBindings(pFromStmt, pToStmt);
1274}
shaneeec556d2008-10-12 00:27:53 +00001275#endif
shane145834a2008-09-04 12:03:42 +00001276
1277/*
drh51942bc2005-06-12 22:01:42 +00001278** Return the sqlite3* database handle to which the prepared statement given
1279** in the argument belongs. This is the same database handle that was
1280** the first argument to the sqlite3_prepare() that was used to create
1281** the statement in the first place.
1282*/
1283sqlite3 *sqlite3_db_handle(sqlite3_stmt *pStmt){
1284 return pStmt ? ((Vdbe*)pStmt)->db : 0;
1285}
drhbb5a9c32008-06-19 02:52:25 +00001286
1287/*
1288** Return a pointer to the next prepared statement after pStmt associated
1289** with database connection pDb. If pStmt is NULL, return the first
1290** prepared statement for the database connection. Return NULL if there
1291** are no more.
1292*/
1293sqlite3_stmt *sqlite3_next_stmt(sqlite3 *pDb, sqlite3_stmt *pStmt){
1294 sqlite3_stmt *pNext;
1295 sqlite3_mutex_enter(pDb->mutex);
1296 if( pStmt==0 ){
1297 pNext = (sqlite3_stmt*)pDb->pVdbe;
1298 }else{
1299 pNext = (sqlite3_stmt*)((Vdbe*)pStmt)->pNext;
1300 }
1301 sqlite3_mutex_leave(pDb->mutex);
1302 return pNext;
1303}
drhd1d38482008-10-07 23:46:38 +00001304
1305/*
1306** Return the value of a status counter for a prepared statement
1307*/
1308int sqlite3_stmt_status(sqlite3_stmt *pStmt, int op, int resetFlag){
1309 Vdbe *pVdbe = (Vdbe*)pStmt;
1310 int v = pVdbe->aCounter[op-1];
1311 if( resetFlag ) pVdbe->aCounter[op-1] = 0;
1312 return v;
1313}