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