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