monotone

monotone Mtn Source Tree

Root/sqlite/vdbeapi.c

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

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status