blob: b34b60fb4dd689bd29b737f79e99d287e8d56e41 [file] [log] [blame]
drh4f26d6c2004-05-26 23:25:30 +00001/*
2** 2004 May 26
3**
4** The author disclaims copyright to this source code. In place of
5** a legal notice, here is a blessing:
6**
7** May you do good and not evil.
8** May you find forgiveness for yourself and forgive others.
9** May you share freely, never taking more than you give.
10**
11*************************************************************************
12**
13** This file contains code use to implement APIs that are part of the
14** VDBE.
15*/
16#include "sqliteInt.h"
17#include "vdbeInt.h"
18
19/**************************** sqlite3_value_ *******************************
20** The following routines extract information from a Mem or sqlite3_value
21** structure.
22*/
23const void *sqlite3_value_blob(sqlite3_value *pVal){
24 Mem *p = (Mem*)pVal;
25 if( p->flags & (MEM_Blob|MEM_Str) ){
26 return p->z;
27 }else{
28 return sqlite3_value_text(pVal);
29 }
30}
31int sqlite3_value_bytes(sqlite3_value *pVal){
32 Mem *p = (Mem*)pVal;
33 if( (p->flags & MEM_Blob)!=0 || sqlite3_value_text(pVal) ){
34 return p->n;
35 }
36 return 0;
37}
38int sqlite3_value_bytes16(sqlite3_value *pVal){
39 Mem *p = (Mem*)pVal;
40 if( (p->flags & MEM_Blob)!=0 || sqlite3_value_text16(pVal) ){
41 return ((Mem *)pVal)->n;
42 }
43 return 0;
44}
45double sqlite3_value_double(sqlite3_value *pVal){
46 Mem *pMem = (Mem *)pVal;
drhf4479502004-05-27 03:12:53 +000047 sqlite3VdbeMemRealify(pMem);
drh4f26d6c2004-05-26 23:25:30 +000048 return pMem->r;
49}
50int sqlite3_value_int(sqlite3_value *pVal){
51 Mem *pMem = (Mem *)pVal;
drhf4479502004-05-27 03:12:53 +000052 sqlite3VdbeMemIntegerify(pMem);
drh4f26d6c2004-05-26 23:25:30 +000053 return (int)pVal->i;
54}
55long long int sqlite3_value_int64(sqlite3_value *pVal){
56 Mem *pMem = (Mem *)pVal;
drhf4479502004-05-27 03:12:53 +000057 sqlite3VdbeMemIntegerify(pMem);
drh4f26d6c2004-05-26 23:25:30 +000058 return pVal->i;
59}
60const unsigned char *sqlite3_value_text(sqlite3_value *pVal){
danielk1977dc8453f2004-06-12 00:42:34 +000061 return (const char *)sqlite3ValueText(pVal, SQLITE_UTF8);
drh4f26d6c2004-05-26 23:25:30 +000062}
63const void *sqlite3_value_text16(sqlite3_value* pVal){
danielk1977dc8453f2004-06-12 00:42:34 +000064 return sqlite3ValueText(pVal, SQLITE_UTF16NATIVE);
drh4f26d6c2004-05-26 23:25:30 +000065}
danielk1977d8123362004-06-12 09:25:12 +000066const void *sqlite3_value_text16be(sqlite3_value *pVal){
67 return sqlite3ValueText(pVal, SQLITE_UTF16BE);
68}
69const void *sqlite3_value_text16le(sqlite3_value *pVal){
70 return sqlite3ValueText(pVal, SQLITE_UTF16LE);
71}
drh4f26d6c2004-05-26 23:25:30 +000072int sqlite3_value_type(sqlite3_value* pVal){
drhf4479502004-05-27 03:12:53 +000073 return pVal->type;
drh4f26d6c2004-05-26 23:25:30 +000074}
75
76/**************************** sqlite3_result_ *******************************
77** The following routines are used by user-defined functions to specify
78** the function result.
79*/
80void sqlite3_result_blob(
81 sqlite3_context *pCtx,
82 const void *z,
83 int n,
danielk1977d8123362004-06-12 09:25:12 +000084 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +000085){
86 assert( n>0 );
danielk1977d8123362004-06-12 09:25:12 +000087 sqlite3VdbeMemSetStr(&pCtx->s, z, n, 0, xDel);
drh4f26d6c2004-05-26 23:25:30 +000088}
89void sqlite3_result_double(sqlite3_context *pCtx, double rVal){
90 sqlite3VdbeMemSetDouble(&pCtx->s, rVal);
91}
92void sqlite3_result_error(sqlite3_context *pCtx, const char *z, int n){
93 pCtx->isError = 1;
danielk1977d8123362004-06-12 09:25:12 +000094 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +000095}
96void sqlite3_result_error16(sqlite3_context *pCtx, const void *z, int n){
97 pCtx->isError = 1;
danielk1977d8123362004-06-12 09:25:12 +000098 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, SQLITE_TRANSIENT);
drh4f26d6c2004-05-26 23:25:30 +000099}
drhf4479502004-05-27 03:12:53 +0000100void sqlite3_result_int(sqlite3_context *pCtx, int iVal){
drh4f26d6c2004-05-26 23:25:30 +0000101 sqlite3VdbeMemSetInt64(&pCtx->s, (i64)iVal);
102}
103void sqlite3_result_int64(sqlite3_context *pCtx, i64 iVal){
104 sqlite3VdbeMemSetInt64(&pCtx->s, iVal);
105}
106void sqlite3_result_null(sqlite3_context *pCtx){
drhf4479502004-05-27 03:12:53 +0000107 sqlite3VdbeMemSetNull(&pCtx->s);
drh4f26d6c2004-05-26 23:25:30 +0000108}
109void sqlite3_result_text(
110 sqlite3_context *pCtx,
111 const char *z,
112 int n,
danielk1977d8123362004-06-12 09:25:12 +0000113 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000114){
danielk1977d8123362004-06-12 09:25:12 +0000115 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF8, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000116}
117void sqlite3_result_text16(
118 sqlite3_context *pCtx,
119 const void *z,
120 int n,
danielk1977d8123362004-06-12 09:25:12 +0000121 void (*xDel)(void *)
drh4f26d6c2004-05-26 23:25:30 +0000122){
danielk1977d8123362004-06-12 09:25:12 +0000123 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16NATIVE, xDel);
124}
125void sqlite3_result_text16be(
126 sqlite3_context *pCtx,
127 const void *z,
128 int n,
129 void (*xDel)(void *)
130){
131 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16BE, xDel);
132}
133void sqlite3_result_text16le(
134 sqlite3_context *pCtx,
135 const void *z,
136 int n,
137 void (*xDel)(void *)
138){
139 sqlite3VdbeMemSetStr(&pCtx->s, z, n, SQLITE_UTF16LE, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000140}
141void sqlite3_result_value(sqlite3_context *pCtx, sqlite3_value *pValue){
142 sqlite3VdbeMemCopy(&pCtx->s, pValue);
143}
144
145
146/*
147** Execute the statement pStmt, either until a row of data is ready, the
148** statement is completely executed or an error occurs.
149*/
150int sqlite3_step(sqlite3_stmt *pStmt){
151 Vdbe *p = (Vdbe*)pStmt;
152 sqlite *db;
153 int rc;
154
155 if( p->magic!=VDBE_MAGIC_RUN ){
156 return SQLITE_MISUSE;
157 }
158 db = p->db;
159 if( sqlite3SafetyOn(db) ){
160 p->rc = SQLITE_MISUSE;
161 return SQLITE_MISUSE;
162 }
danielk19771d850a72004-05-31 08:26:49 +0000163 if( p->pc<0 ){
164 db->activeVdbeCnt++;
165 p->pc = 0;
166 }
drh4f26d6c2004-05-26 23:25:30 +0000167 if( p->explain ){
168 rc = sqlite3VdbeList(p);
169 }else{
170 rc = sqlite3VdbeExec(p);
171 }
172
173 if( sqlite3SafetyOff(db) ){
174 rc = SQLITE_MISUSE;
175 }
176
177 sqlite3Error(p->db, rc, p->zErrMsg);
178 return rc;
179}
180
181/*
drheb2e1762004-05-27 01:53:56 +0000182** Extract the user data from a sqlite3_context structure and return a
183** pointer to it.
184*/
185void *sqlite3_user_data(sqlite3_context *p){
186 assert( p && p->pFunc );
187 return p->pFunc->pUserData;
188}
189
190/*
191** Allocate or return the aggregate context for a user function. A new
192** context is allocated on the first call. Subsequent calls return the
193** same context that was returned on prior calls.
194**
195** This routine is defined here in vdbe.c because it depends on knowing
196** the internals of the sqlite3_context structure which is only defined in
197** this source file.
198*/
199void *sqlite3_aggregate_context(sqlite3_context *p, int nByte){
200 assert( p && p->pFunc && p->pFunc->xStep );
201 if( p->pAgg==0 ){
202 if( nByte<=NBFS ){
203 p->pAgg = (void*)p->s.z;
204 memset(p->pAgg, 0, nByte);
205 }else{
206 p->pAgg = sqliteMalloc( nByte );
207 }
208 }
209 return p->pAgg;
210}
211
212/*
danielk1977682f68b2004-06-05 10:22:17 +0000213** Return the auxilary data pointer, if any, for the iArg'th argument to
214** the user-function defined by pCtx.
215*/
216void *sqlite3_get_auxdata(sqlite3_context *pCtx, int iArg){
217 VdbeFunc *pVdbeFunc = pCtx->pVdbeFunc;
218 if( !pVdbeFunc || iArg>=pVdbeFunc->nAux || iArg<0 ){
219 return 0;
220 }
drhf92c7ff2004-06-19 15:40:23 +0000221 return pVdbeFunc->apAux[iArg].pAux;
danielk1977682f68b2004-06-05 10:22:17 +0000222}
223
224/*
225** Set the auxilary data pointer and delete function, for the iArg'th
226** argument to the user-function defined by pCtx. Any previous value is
227** deleted by calling the delete function specified when it was set.
228*/
229void sqlite3_set_auxdata(
230 sqlite3_context *pCtx,
231 int iArg,
232 void *pAux,
233 void (*xDelete)(void*)
234){
235 struct AuxData *pAuxData;
drhf92c7ff2004-06-19 15:40:23 +0000236 VdbeFunc *pVdbeFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000237 if( iArg<0 ) return;
238
drhf92c7ff2004-06-19 15:40:23 +0000239 pVdbeFunc = pCtx->pVdbeFunc;
240 if( !pVdbeFunc || pVdbeFunc->nAux<=iArg ){
241 int nMalloc = sizeof(VdbeFunc) + sizeof(struct AuxData)*iArg;
242 pCtx->pVdbeFunc = pVdbeFunc = sqliteRealloc(pVdbeFunc, nMalloc);
drh998da3a2004-06-19 15:22:56 +0000243 if( !pVdbeFunc ) return;
244 pVdbeFunc->nAux = iArg+1;
245 pVdbeFunc->pFunc = pCtx->pFunc;
danielk1977682f68b2004-06-05 10:22:17 +0000246 }
247
drhf92c7ff2004-06-19 15:40:23 +0000248 pAuxData = &pVdbeFunc->apAux[iArg];
danielk1977682f68b2004-06-05 10:22:17 +0000249 if( pAuxData->pAux && pAuxData->xDelete ){
250 pAuxData->xDelete(pAuxData->pAux);
251 }
252 pAuxData->pAux = pAux;
253 pAuxData->xDelete = xDelete;
254}
255
256/*
drheb2e1762004-05-27 01:53:56 +0000257** Return the number of times the Step function of a aggregate has been
258** called.
259**
260** This routine is defined here in vdbe.c because it depends on knowing
261** the internals of the sqlite3_context structure which is only defined in
262** this source file.
263*/
264int sqlite3_aggregate_count(sqlite3_context *p){
265 assert( p && p->pFunc && p->pFunc->xStep );
266 return p->cnt;
267}
268
269/*
drh4f26d6c2004-05-26 23:25:30 +0000270** Return the number of columns in the result set for the statement pStmt.
271*/
272int sqlite3_column_count(sqlite3_stmt *pStmt){
273 Vdbe *pVm = (Vdbe *)pStmt;
274 return pVm->nResColumn;
275}
276
277/*
278** Return the number of values available from the current row of the
279** currently executing statement pStmt.
280*/
281int sqlite3_data_count(sqlite3_stmt *pStmt){
282 Vdbe *pVm = (Vdbe *)pStmt;
283 if( !pVm->resOnStack ) return 0;
284 return pVm->nResColumn;
285}
286
287
288/*
289** Check to see if column iCol of the given statement is valid. If
290** it is, return a pointer to the Mem for the value of that column.
291** If iCol is not valid, return a pointer to a Mem which has a value
292** of NULL.
293*/
294static Mem *columnMem(sqlite3_stmt *pStmt, int i){
295 Vdbe *pVm = (Vdbe *)pStmt;
296 int vals = sqlite3_data_count(pStmt);
297 if( i>=vals || i<0 ){
298 static Mem nullMem;
299 if( nullMem.flags==0 ){ nullMem.flags = MEM_Null; }
300 sqlite3Error(pVm->db, SQLITE_RANGE, 0);
301 return &nullMem;
302 }
303 return &pVm->pTos[(1-vals)+i];
304}
305
306/**************************** sqlite3_column_ *******************************
307** The following routines are used to access elements of the current row
308** in the result set.
309*/
danielk1977c572ef72004-05-27 09:28:41 +0000310const void *sqlite3_column_blob(sqlite3_stmt *pStmt, int i){
311 return sqlite3_value_blob( columnMem(pStmt,i) );
312}
drh4f26d6c2004-05-26 23:25:30 +0000313int sqlite3_column_bytes(sqlite3_stmt *pStmt, int i){
314 return sqlite3_value_bytes( columnMem(pStmt,i) );
315}
316int sqlite3_column_bytes16(sqlite3_stmt *pStmt, int i){
317 return sqlite3_value_bytes16( columnMem(pStmt,i) );
318}
319double sqlite3_column_double(sqlite3_stmt *pStmt, int i){
320 return sqlite3_value_double( columnMem(pStmt,i) );
321}
322int sqlite3_column_int(sqlite3_stmt *pStmt, int i){
323 return sqlite3_value_int( columnMem(pStmt,i) );
324}
325long long int sqlite3_column_int64(sqlite3_stmt *pStmt, int i){
326 return sqlite3_value_int64( columnMem(pStmt,i) );
327}
328const unsigned char *sqlite3_column_text(sqlite3_stmt *pStmt, int i){
329 return sqlite3_value_text( columnMem(pStmt,i) );
330}
331const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){
332 return sqlite3_value_text16( columnMem(pStmt,i) );
333}
334int sqlite3_column_type(sqlite3_stmt *pStmt, int i){
335 return sqlite3_value_type( columnMem(pStmt,i) );
336}
337
338
339/*
340** Return the name of the Nth column of the result set returned by SQL
341** statement pStmt.
342*/
343const char *sqlite3_column_name(sqlite3_stmt *pStmt, int N){
344 Vdbe *p = (Vdbe *)pStmt;
345 Mem *pColName;
346
347 if( N>=sqlite3_column_count(pStmt) || N<0 ){
348 sqlite3Error(p->db, SQLITE_RANGE, 0);
349 return 0;
350 }
351
352 pColName = &(p->aColName[N]);
353 return sqlite3_value_text(pColName);
354}
355
356/*
357** Return the name of the 'i'th column of the result set of SQL statement
358** pStmt, encoded as UTF-16.
359*/
360const void *sqlite3_column_name16(sqlite3_stmt *pStmt, int N){
361 Vdbe *p = (Vdbe *)pStmt;
362 Mem *pColName;
363
364 if( N>=sqlite3_column_count(pStmt) || N<0 ){
365 sqlite3Error(p->db, SQLITE_RANGE, 0);
366 return 0;
367 }
368
369 pColName = &(p->aColName[N]);
370 return sqlite3_value_text16(pColName);
371}
372
drh4f26d6c2004-05-26 23:25:30 +0000373/*
374** Return the column declaration type (if applicable) of the 'i'th column
375** of the result set of SQL statement pStmt, encoded as UTF-8.
376*/
danielk197776d505b2004-05-28 13:13:02 +0000377const char *sqlite3_column_decltype(sqlite3_stmt *pStmt, int N){
drh4f26d6c2004-05-26 23:25:30 +0000378 Vdbe *p = (Vdbe *)pStmt;
danielk197776d505b2004-05-28 13:13:02 +0000379 Mem *pColName;
drh4f26d6c2004-05-26 23:25:30 +0000380
danielk197776d505b2004-05-28 13:13:02 +0000381 if( N>=sqlite3_column_count(pStmt) || N<0 ){
drh4f26d6c2004-05-26 23:25:30 +0000382 sqlite3Error(p->db, SQLITE_RANGE, 0);
383 return 0;
384 }
385
danielk197776d505b2004-05-28 13:13:02 +0000386 pColName = &(p->aColName[N+sqlite3_column_count(pStmt)]);
387 return sqlite3_value_text(pColName);
drh4f26d6c2004-05-26 23:25:30 +0000388}
389
390/*
391** Return the column declaration type (if applicable) of the 'i'th column
392** of the result set of SQL statement pStmt, encoded as UTF-16.
393*/
danielk197776d505b2004-05-28 13:13:02 +0000394const void *sqlite3_column_decltype16(sqlite3_stmt *pStmt, int N){
395 Vdbe *p = (Vdbe *)pStmt;
396 Mem *pColName;
397
398 if( N>=sqlite3_column_count(pStmt) || N<0 ){
399 sqlite3Error(p->db, SQLITE_RANGE, 0);
400 return 0;
401 }
402
403 pColName = &(p->aColName[N+sqlite3_column_count(pStmt)]);
404 return sqlite3_value_text16(pColName);
drh4f26d6c2004-05-26 23:25:30 +0000405}
406
407/******************************* sqlite3_bind_ ***************************
408**
409** Routines used to attach values to wildcards in a compiled SQL statement.
410*/
411/*
412** Unbind the value bound to variable i in virtual machine p. This is the
413** the same as binding a NULL value to the column. If the "i" parameter is
414** out of range, then SQLITE_RANGE is returned. Othewise SQLITE_OK.
415**
416** The error code stored in database p->db is overwritten with the return
417** value in any case.
418*/
419static int vdbeUnbind(Vdbe *p, int i){
420 Mem *pVar;
danielk19771d850a72004-05-31 08:26:49 +0000421 if( p->magic!=VDBE_MAGIC_RUN || p->pc>=0 ){
drh4f26d6c2004-05-26 23:25:30 +0000422 sqlite3Error(p->db, SQLITE_MISUSE, 0);
423 return SQLITE_MISUSE;
424 }
425 if( i<1 || i>p->nVar ){
426 sqlite3Error(p->db, SQLITE_RANGE, 0);
427 return SQLITE_RANGE;
428 }
429 i--;
430 pVar = &p->apVar[i];
danielk1977d8123362004-06-12 09:25:12 +0000431 sqlite3VdbeMemRelease(pVar);
drh4f26d6c2004-05-26 23:25:30 +0000432 pVar->flags = MEM_Null;
433 sqlite3Error(p->db, SQLITE_OK, 0);
434 return SQLITE_OK;
435}
436
437/*
438** Bind a blob value to an SQL statement variable.
439*/
440int sqlite3_bind_blob(
drhf4479502004-05-27 03:12:53 +0000441 sqlite3_stmt *pStmt,
drh4f26d6c2004-05-26 23:25:30 +0000442 int i,
443 const void *zData,
444 int nData,
danielk1977d8123362004-06-12 09:25:12 +0000445 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +0000446){
447 Vdbe *p = (Vdbe *)pStmt;
448 Mem *pVar;
449 int rc;
450
451 rc = vdbeUnbind(p, i);
452 if( rc ){
453 return rc;
454 }
455 pVar = &p->apVar[i-1];
danielk1977d8123362004-06-12 09:25:12 +0000456 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, 0, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000457 return rc;
458}
459int sqlite3_bind_double(sqlite3_stmt *pStmt, int i, double rValue){
460 int rc;
461 Vdbe *p = (Vdbe *)pStmt;
drh4f26d6c2004-05-26 23:25:30 +0000462 rc = vdbeUnbind(p, i);
463 if( rc==SQLITE_OK ){
drhf4479502004-05-27 03:12:53 +0000464 sqlite3VdbeMemSetDouble(&p->apVar[i-1], rValue);
drh4f26d6c2004-05-26 23:25:30 +0000465 }
466 return SQLITE_OK;
467}
468int sqlite3_bind_int(sqlite3_stmt *p, int i, int iValue){
469 return sqlite3_bind_int64(p, i, (long long int)iValue);
470}
471int sqlite3_bind_int64(sqlite3_stmt *pStmt, int i, long long int iValue){
472 int rc;
473 Vdbe *p = (Vdbe *)pStmt;
474 rc = vdbeUnbind(p, i);
475 if( rc==SQLITE_OK ){
drhf4479502004-05-27 03:12:53 +0000476 sqlite3VdbeMemSetInt64(&p->apVar[i-1], iValue);
drh4f26d6c2004-05-26 23:25:30 +0000477 }
478 return rc;
479}
480int sqlite3_bind_null(sqlite3_stmt* p, int i){
481 return vdbeUnbind((Vdbe *)p, i);
482}
483int sqlite3_bind_text(
484 sqlite3_stmt *pStmt,
485 int i,
486 const char *zData,
487 int nData,
danielk1977d8123362004-06-12 09:25:12 +0000488 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +0000489){
490 Vdbe *p = (Vdbe *)pStmt;
491 Mem *pVar;
492 int rc;
493
494 rc = vdbeUnbind(p, i);
495 if( rc ){
496 return rc;
497 }
498 pVar = &p->apVar[i-1];
danielk1977d8123362004-06-12 09:25:12 +0000499 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, SQLITE_UTF8, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000500 if( rc ){
501 return rc;
502 }
drhf4479502004-05-27 03:12:53 +0000503 rc = sqlite3VdbeChangeEncoding(pVar, p->db->enc);
drh4f26d6c2004-05-26 23:25:30 +0000504 return rc;
505}
506int sqlite3_bind_text16(
507 sqlite3_stmt *pStmt,
508 int i,
509 const void *zData,
510 int nData,
danielk1977d8123362004-06-12 09:25:12 +0000511 void (*xDel)(void*)
drh4f26d6c2004-05-26 23:25:30 +0000512){
513 Vdbe *p = (Vdbe *)pStmt;
514 Mem *pVar;
danielk19775314c4d2004-06-18 06:02:35 +0000515 int rc;
drh4f26d6c2004-05-26 23:25:30 +0000516
517 rc = vdbeUnbind(p, i);
518 if( rc ){
519 return rc;
520 }
drhf4479502004-05-27 03:12:53 +0000521 pVar = &p->apVar[i-1];
drh4f26d6c2004-05-26 23:25:30 +0000522
danielk1977bfd6cce2004-06-18 04:24:54 +0000523 rc = sqlite3VdbeMemSetStr(pVar, zData, nData, SQLITE_UTF16NATIVE, xDel);
drh4f26d6c2004-05-26 23:25:30 +0000524 if( rc ){
525 return rc;
526 }
drhf4479502004-05-27 03:12:53 +0000527 rc = sqlite3VdbeChangeEncoding(pVar, p->db->enc);
drh4f26d6c2004-05-26 23:25:30 +0000528 return rc;
529}