Annotation of embedaddon/php/ext/sqlite/libsqlite/src/vdbeaux.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2003 September 6
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: ** This file contains code used for creating, destroying, and populating
13: ** a VDBE (or an "sqlite_vm" as it is known to the outside world.) Prior
14: ** to version 2.8.7, all this code was combined into the vdbe.c source file.
15: ** But that file was getting too big so this subroutines were split out.
16: */
17: #include "sqliteInt.h"
18: #include "os.h"
19: #include <ctype.h>
20: #include "vdbeInt.h"
21:
22:
23: /*
24: ** When debugging the code generator in a symbolic debugger, one can
25: ** set the sqlite_vdbe_addop_trace to 1 and all opcodes will be printed
26: ** as they are added to the instruction stream.
27: */
28: #ifndef NDEBUG
29: int sqlite_vdbe_addop_trace = 0;
30: #endif
31:
32:
33: /*
34: ** Create a new virtual database engine.
35: */
36: Vdbe *sqliteVdbeCreate(sqlite *db){
37: Vdbe *p;
38: p = sqliteMalloc( sizeof(Vdbe) );
39: if( p==0 ) return 0;
40: p->db = db;
41: if( db->pVdbe ){
42: db->pVdbe->pPrev = p;
43: }
44: p->pNext = db->pVdbe;
45: p->pPrev = 0;
46: db->pVdbe = p;
47: p->magic = VDBE_MAGIC_INIT;
48: return p;
49: }
50:
51: /*
52: ** Turn tracing on or off
53: */
54: void sqliteVdbeTrace(Vdbe *p, FILE *trace){
55: p->trace = trace;
56: }
57:
58: /*
59: ** Add a new instruction to the list of instructions current in the
60: ** VDBE. Return the address of the new instruction.
61: **
62: ** Parameters:
63: **
64: ** p Pointer to the VDBE
65: **
66: ** op The opcode for this instruction
67: **
68: ** p1, p2 First two of the three possible operands.
69: **
70: ** Use the sqliteVdbeResolveLabel() function to fix an address and
71: ** the sqliteVdbeChangeP3() function to change the value of the P3
72: ** operand.
73: */
74: int sqliteVdbeAddOp(Vdbe *p, int op, int p1, int p2){
75: int i;
76: VdbeOp *pOp;
77:
78: i = p->nOp;
79: p->nOp++;
80: assert( p->magic==VDBE_MAGIC_INIT );
81: if( i>=p->nOpAlloc ){
82: int oldSize = p->nOpAlloc;
83: Op *aNew;
84: p->nOpAlloc = p->nOpAlloc*2 + 100;
85: aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op));
86: if( aNew==0 ){
87: p->nOpAlloc = oldSize;
88: return 0;
89: }
90: p->aOp = aNew;
91: memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op));
92: }
93: pOp = &p->aOp[i];
94: pOp->opcode = op;
95: pOp->p1 = p1;
96: if( p2<0 && (-1-p2)<p->nLabel && p->aLabel[-1-p2]>=0 ){
97: p2 = p->aLabel[-1-p2];
98: }
99: pOp->p2 = p2;
100: pOp->p3 = 0;
101: pOp->p3type = P3_NOTUSED;
102: #ifndef NDEBUG
103: if( sqlite_vdbe_addop_trace ) sqliteVdbePrintOp(0, i, &p->aOp[i]);
104: #endif
105: return i;
106: }
107:
108: /*
109: ** Add an opcode that includes the p3 value.
110: */
111: int sqliteVdbeOp3(Vdbe *p, int op, int p1, int p2, const char *zP3, int p3type){
112: int addr = sqliteVdbeAddOp(p, op, p1, p2);
113: sqliteVdbeChangeP3(p, addr, zP3, p3type);
114: return addr;
115: }
116:
117: /*
118: ** Add multiple opcodes. The list is terminated by an opcode of 0.
119: */
120: int sqliteVdbeCode(Vdbe *p, ...){
121: int addr;
122: va_list ap;
123: int opcode, p1, p2;
124: va_start(ap, p);
125: addr = p->nOp;
126: while( (opcode = va_arg(ap,int))!=0 ){
127: p1 = va_arg(ap,int);
128: p2 = va_arg(ap,int);
129: sqliteVdbeAddOp(p, opcode, p1, p2);
130: }
131: va_end(ap);
132: return addr;
133: }
134:
135:
136:
137: /*
138: ** Create a new symbolic label for an instruction that has yet to be
139: ** coded. The symbolic label is really just a negative number. The
140: ** label can be used as the P2 value of an operation. Later, when
141: ** the label is resolved to a specific address, the VDBE will scan
142: ** through its operation list and change all values of P2 which match
143: ** the label into the resolved address.
144: **
145: ** The VDBE knows that a P2 value is a label because labels are
146: ** always negative and P2 values are suppose to be non-negative.
147: ** Hence, a negative P2 value is a label that has yet to be resolved.
148: */
149: int sqliteVdbeMakeLabel(Vdbe *p){
150: int i;
151: i = p->nLabel++;
152: assert( p->magic==VDBE_MAGIC_INIT );
153: if( i>=p->nLabelAlloc ){
154: int *aNew;
155: p->nLabelAlloc = p->nLabelAlloc*2 + 10;
156: aNew = sqliteRealloc( p->aLabel, p->nLabelAlloc*sizeof(p->aLabel[0]));
157: if( aNew==0 ){
158: sqliteFree(p->aLabel);
159: }
160: p->aLabel = aNew;
161: }
162: if( p->aLabel==0 ){
163: p->nLabel = 0;
164: p->nLabelAlloc = 0;
165: return 0;
166: }
167: p->aLabel[i] = -1;
168: return -1-i;
169: }
170:
171: /*
172: ** Resolve label "x" to be the address of the next instruction to
173: ** be inserted. The parameter "x" must have been obtained from
174: ** a prior call to sqliteVdbeMakeLabel().
175: */
176: void sqliteVdbeResolveLabel(Vdbe *p, int x){
177: int j;
178: assert( p->magic==VDBE_MAGIC_INIT );
179: if( x<0 && (-x)<=p->nLabel && p->aOp ){
180: if( p->aLabel[-1-x]==p->nOp ) return;
181: assert( p->aLabel[-1-x]<0 );
182: p->aLabel[-1-x] = p->nOp;
183: for(j=0; j<p->nOp; j++){
184: if( p->aOp[j].p2==x ) p->aOp[j].p2 = p->nOp;
185: }
186: }
187: }
188:
189: /*
190: ** Return the address of the next instruction to be inserted.
191: */
192: int sqliteVdbeCurrentAddr(Vdbe *p){
193: assert( p->magic==VDBE_MAGIC_INIT );
194: return p->nOp;
195: }
196:
197: /*
198: ** Add a whole list of operations to the operation stack. Return the
199: ** address of the first operation added.
200: */
201: int sqliteVdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp){
202: int addr;
203: assert( p->magic==VDBE_MAGIC_INIT );
204: if( p->nOp + nOp >= p->nOpAlloc ){
205: int oldSize = p->nOpAlloc;
206: Op *aNew;
207: p->nOpAlloc = p->nOpAlloc*2 + nOp + 10;
208: aNew = sqliteRealloc(p->aOp, p->nOpAlloc*sizeof(Op));
209: if( aNew==0 ){
210: p->nOpAlloc = oldSize;
211: return 0;
212: }
213: p->aOp = aNew;
214: memset(&p->aOp[oldSize], 0, (p->nOpAlloc-oldSize)*sizeof(Op));
215: }
216: addr = p->nOp;
217: if( nOp>0 ){
218: int i;
219: VdbeOpList const *pIn = aOp;
220: for(i=0; i<nOp; i++, pIn++){
221: int p2 = pIn->p2;
222: VdbeOp *pOut = &p->aOp[i+addr];
223: pOut->opcode = pIn->opcode;
224: pOut->p1 = pIn->p1;
225: pOut->p2 = p2<0 ? addr + ADDR(p2) : p2;
226: pOut->p3 = pIn->p3;
227: pOut->p3type = pIn->p3 ? P3_STATIC : P3_NOTUSED;
228: #ifndef NDEBUG
229: if( sqlite_vdbe_addop_trace ){
230: sqliteVdbePrintOp(0, i+addr, &p->aOp[i+addr]);
231: }
232: #endif
233: }
234: p->nOp += nOp;
235: }
236: return addr;
237: }
238:
239: /*
240: ** Change the value of the P1 operand for a specific instruction.
241: ** This routine is useful when a large program is loaded from a
242: ** static array using sqliteVdbeAddOpList but we want to make a
243: ** few minor changes to the program.
244: */
245: void sqliteVdbeChangeP1(Vdbe *p, int addr, int val){
246: assert( p->magic==VDBE_MAGIC_INIT );
247: if( p && addr>=0 && p->nOp>addr && p->aOp ){
248: p->aOp[addr].p1 = val;
249: }
250: }
251:
252: /*
253: ** Change the value of the P2 operand for a specific instruction.
254: ** This routine is useful for setting a jump destination.
255: */
256: void sqliteVdbeChangeP2(Vdbe *p, int addr, int val){
257: assert( val>=0 );
258: assert( p->magic==VDBE_MAGIC_INIT );
259: if( p && addr>=0 && p->nOp>addr && p->aOp ){
260: p->aOp[addr].p2 = val;
261: }
262: }
263:
264: /*
265: ** Change the value of the P3 operand for a specific instruction.
266: ** This routine is useful when a large program is loaded from a
267: ** static array using sqliteVdbeAddOpList but we want to make a
268: ** few minor changes to the program.
269: **
270: ** If n>=0 then the P3 operand is dynamic, meaning that a copy of
271: ** the string is made into memory obtained from sqliteMalloc().
272: ** A value of n==0 means copy bytes of zP3 up to and including the
273: ** first null byte. If n>0 then copy n+1 bytes of zP3.
274: **
275: ** If n==P3_STATIC it means that zP3 is a pointer to a constant static
276: ** string and we can just copy the pointer. n==P3_POINTER means zP3 is
277: ** a pointer to some object other than a string.
278: **
279: ** If addr<0 then change P3 on the most recently inserted instruction.
280: */
281: void sqliteVdbeChangeP3(Vdbe *p, int addr, const char *zP3, int n){
282: Op *pOp;
283: assert( p->magic==VDBE_MAGIC_INIT );
284: if( p==0 || p->aOp==0 ) return;
285: if( addr<0 || addr>=p->nOp ){
286: addr = p->nOp - 1;
287: if( addr<0 ) return;
288: }
289: pOp = &p->aOp[addr];
290: if( pOp->p3 && pOp->p3type==P3_DYNAMIC ){
291: sqliteFree(pOp->p3);
292: pOp->p3 = 0;
293: }
294: if( zP3==0 ){
295: pOp->p3 = 0;
296: pOp->p3type = P3_NOTUSED;
297: }else if( n<0 ){
298: pOp->p3 = (char*)zP3;
299: pOp->p3type = n;
300: }else{
301: sqliteSetNString(&pOp->p3, zP3, n, 0);
302: pOp->p3type = P3_DYNAMIC;
303: }
304: }
305:
306: /*
307: ** If the P3 operand to the specified instruction appears
308: ** to be a quoted string token, then this procedure removes
309: ** the quotes.
310: **
311: ** The quoting operator can be either a grave ascent (ASCII 0x27)
312: ** or a double quote character (ASCII 0x22). Two quotes in a row
313: ** resolve to be a single actual quote character within the string.
314: */
315: void sqliteVdbeDequoteP3(Vdbe *p, int addr){
316: Op *pOp;
317: assert( p->magic==VDBE_MAGIC_INIT );
318: if( p->aOp==0 ) return;
319: if( addr<0 || addr>=p->nOp ){
320: addr = p->nOp - 1;
321: if( addr<0 ) return;
322: }
323: pOp = &p->aOp[addr];
324: if( pOp->p3==0 || pOp->p3[0]==0 ) return;
325: if( pOp->p3type==P3_POINTER ) return;
326: if( pOp->p3type!=P3_DYNAMIC ){
327: pOp->p3 = sqliteStrDup(pOp->p3);
328: pOp->p3type = P3_DYNAMIC;
329: }
330: sqliteDequote(pOp->p3);
331: }
332:
333: /*
334: ** On the P3 argument of the given instruction, change all
335: ** strings of whitespace characters into a single space and
336: ** delete leading and trailing whitespace.
337: */
338: void sqliteVdbeCompressSpace(Vdbe *p, int addr){
339: unsigned char *z;
340: int i, j;
341: Op *pOp;
342: assert( p->magic==VDBE_MAGIC_INIT );
343: if( p->aOp==0 || addr<0 || addr>=p->nOp ) return;
344: pOp = &p->aOp[addr];
345: if( pOp->p3type==P3_POINTER ){
346: return;
347: }
348: if( pOp->p3type!=P3_DYNAMIC ){
349: pOp->p3 = sqliteStrDup(pOp->p3);
350: pOp->p3type = P3_DYNAMIC;
351: }
352: z = (unsigned char*)pOp->p3;
353: if( z==0 ) return;
354: i = j = 0;
355: while( isspace(z[i]) ){ i++; }
356: while( z[i] ){
357: if( isspace(z[i]) ){
358: z[j++] = ' ';
359: while( isspace(z[++i]) ){}
360: }else{
361: z[j++] = z[i++];
362: }
363: }
364: while( j>0 && isspace(z[j-1]) ){ j--; }
365: z[j] = 0;
366: }
367:
368: /*
369: ** Search for the current program for the given opcode and P2
370: ** value. Return the address plus 1 if found and 0 if not found.
371: */
372: int sqliteVdbeFindOp(Vdbe *p, int op, int p2){
373: int i;
374: assert( p->magic==VDBE_MAGIC_INIT );
375: for(i=0; i<p->nOp; i++){
376: if( p->aOp[i].opcode==op && p->aOp[i].p2==p2 ) return i+1;
377: }
378: return 0;
379: }
380:
381: /*
382: ** Return the opcode for a given address.
383: */
384: VdbeOp *sqliteVdbeGetOp(Vdbe *p, int addr){
385: assert( p->magic==VDBE_MAGIC_INIT );
386: assert( addr>=0 && addr<p->nOp );
387: return &p->aOp[addr];
388: }
389:
390: /*
391: ** The following group or routines are employed by installable functions
392: ** to return their results.
393: **
394: ** The sqlite_set_result_string() routine can be used to return a string
395: ** value or to return a NULL. To return a NULL, pass in NULL for zResult.
396: ** A copy is made of the string before this routine returns so it is safe
397: ** to pass in an ephemeral string.
398: **
399: ** sqlite_set_result_error() works like sqlite_set_result_string() except
400: ** that it signals a fatal error. The string argument, if any, is the
401: ** error message. If the argument is NULL a generic substitute error message
402: ** is used.
403: **
404: ** The sqlite_set_result_int() and sqlite_set_result_double() set the return
405: ** value of the user function to an integer or a double.
406: **
407: ** These routines are defined here in vdbe.c because they depend on knowing
408: ** the internals of the sqlite_func structure which is only defined in
409: ** this source file.
410: */
411: char *sqlite_set_result_string(sqlite_func *p, const char *zResult, int n){
412: assert( !p->isStep );
413: if( p->s.flags & MEM_Dyn ){
414: sqliteFree(p->s.z);
415: }
416: if( zResult==0 ){
417: p->s.flags = MEM_Null;
418: n = 0;
419: p->s.z = 0;
420: p->s.n = 0;
421: }else{
422: if( n<0 ) n = strlen(zResult);
423: if( n<NBFS-1 ){
424: memcpy(p->s.zShort, zResult, n);
425: p->s.zShort[n] = 0;
426: p->s.flags = MEM_Str | MEM_Short;
427: p->s.z = p->s.zShort;
428: }else{
429: p->s.z = sqliteMallocRaw( n+1 );
430: if( p->s.z ){
431: memcpy(p->s.z, zResult, n);
432: p->s.z[n] = 0;
433: }
434: p->s.flags = MEM_Str | MEM_Dyn;
435: }
436: p->s.n = n+1;
437: }
438: return p->s.z;
439: }
440: void sqlite_set_result_int(sqlite_func *p, int iResult){
441: assert( !p->isStep );
442: if( p->s.flags & MEM_Dyn ){
443: sqliteFree(p->s.z);
444: }
445: p->s.i = iResult;
446: p->s.flags = MEM_Int;
447: }
448: void sqlite_set_result_double(sqlite_func *p, double rResult){
449: assert( !p->isStep );
450: if( p->s.flags & MEM_Dyn ){
451: sqliteFree(p->s.z);
452: }
453: p->s.r = rResult;
454: p->s.flags = MEM_Real;
455: }
456: void sqlite_set_result_error(sqlite_func *p, const char *zMsg, int n){
457: assert( !p->isStep );
458: sqlite_set_result_string(p, zMsg, n);
459: p->isError = 1;
460: }
461:
462: /*
463: ** Extract the user data from a sqlite_func structure and return a
464: ** pointer to it.
465: */
466: void *sqlite_user_data(sqlite_func *p){
467: assert( p && p->pFunc );
468: return p->pFunc->pUserData;
469: }
470:
471: /*
472: ** Allocate or return the aggregate context for a user function. A new
473: ** context is allocated on the first call. Subsequent calls return the
474: ** same context that was returned on prior calls.
475: **
476: ** This routine is defined here in vdbe.c because it depends on knowing
477: ** the internals of the sqlite_func structure which is only defined in
478: ** this source file.
479: */
480: void *sqlite_aggregate_context(sqlite_func *p, int nByte){
481: assert( p && p->pFunc && p->pFunc->xStep );
482: if( p->pAgg==0 ){
483: if( nByte<=NBFS ){
484: p->pAgg = (void*)p->s.z;
485: memset(p->pAgg, 0, nByte);
486: }else{
487: p->pAgg = sqliteMalloc( nByte );
488: }
489: }
490: return p->pAgg;
491: }
492:
493: /*
494: ** Return the number of times the Step function of a aggregate has been
495: ** called.
496: **
497: ** This routine is defined here in vdbe.c because it depends on knowing
498: ** the internals of the sqlite_func structure which is only defined in
499: ** this source file.
500: */
501: int sqlite_aggregate_count(sqlite_func *p){
502: assert( p && p->pFunc && p->pFunc->xStep );
503: return p->cnt;
504: }
505:
506: #if !defined(NDEBUG) || defined(VDBE_PROFILE)
507: /*
508: ** Print a single opcode. This routine is used for debugging only.
509: */
510: void sqliteVdbePrintOp(FILE *pOut, int pc, Op *pOp){
511: char *zP3;
512: char zPtr[40];
513: if( pOp->p3type==P3_POINTER ){
514: sprintf(zPtr, "ptr(%#lx)", (long)pOp->p3);
515: zP3 = zPtr;
516: }else{
517: zP3 = pOp->p3;
518: }
519: if( pOut==0 ) pOut = stdout;
520: fprintf(pOut,"%4d %-12s %4d %4d %s\n",
521: pc, sqliteOpcodeNames[pOp->opcode], pOp->p1, pOp->p2, zP3 ? zP3 : "");
522: fflush(pOut);
523: }
524: #endif
525:
526: /*
527: ** Give a listing of the program in the virtual machine.
528: **
529: ** The interface is the same as sqliteVdbeExec(). But instead of
530: ** running the code, it invokes the callback once for each instruction.
531: ** This feature is used to implement "EXPLAIN".
532: */
533: int sqliteVdbeList(
534: Vdbe *p /* The VDBE */
535: ){
536: sqlite *db = p->db;
537: int i;
538: int rc = SQLITE_OK;
539: static char *azColumnNames[] = {
540: "addr", "opcode", "p1", "p2", "p3",
541: "int", "text", "int", "int", "text",
542: 0
543: };
544:
545: assert( p->popStack==0 );
546: assert( p->explain );
547: p->azColName = azColumnNames;
548: p->azResColumn = p->zArgv;
549: for(i=0; i<5; i++) p->zArgv[i] = p->aStack[i].zShort;
550: i = p->pc;
551: if( i>=p->nOp ){
552: p->rc = SQLITE_OK;
553: rc = SQLITE_DONE;
554: }else if( db->flags & SQLITE_Interrupt ){
555: db->flags &= ~SQLITE_Interrupt;
556: if( db->magic!=SQLITE_MAGIC_BUSY ){
557: p->rc = SQLITE_MISUSE;
558: }else{
559: p->rc = SQLITE_INTERRUPT;
560: }
561: rc = SQLITE_ERROR;
562: sqliteSetString(&p->zErrMsg, sqlite_error_string(p->rc), (char*)0);
563: }else{
564: sprintf(p->zArgv[0],"%d",i);
565: sprintf(p->zArgv[2],"%d", p->aOp[i].p1);
566: sprintf(p->zArgv[3],"%d", p->aOp[i].p2);
567: if( p->aOp[i].p3type==P3_POINTER ){
568: sprintf(p->aStack[4].zShort, "ptr(%#lx)", (long)p->aOp[i].p3);
569: p->zArgv[4] = p->aStack[4].zShort;
570: }else{
571: p->zArgv[4] = p->aOp[i].p3;
572: }
573: p->zArgv[1] = sqliteOpcodeNames[p->aOp[i].opcode];
574: p->pc = i+1;
575: p->azResColumn = p->zArgv;
576: p->nResColumn = 5;
577: p->rc = SQLITE_OK;
578: rc = SQLITE_ROW;
579: }
580: return rc;
581: }
582:
583: /*
584: ** Prepare a virtual machine for execution. This involves things such
585: ** as allocating stack space and initializing the program counter.
586: ** After the VDBE has be prepped, it can be executed by one or more
587: ** calls to sqliteVdbeExec().
588: */
589: void sqliteVdbeMakeReady(
590: Vdbe *p, /* The VDBE */
591: int nVar, /* Number of '?' see in the SQL statement */
592: int isExplain /* True if the EXPLAIN keywords is present */
593: ){
594: int n;
595:
596: assert( p!=0 );
597: assert( p->magic==VDBE_MAGIC_INIT );
598:
599: /* Add a HALT instruction to the very end of the program.
600: */
601: if( p->nOp==0 || (p->aOp && p->aOp[p->nOp-1].opcode!=OP_Halt) ){
602: sqliteVdbeAddOp(p, OP_Halt, 0, 0);
603: }
604:
605: /* No instruction ever pushes more than a single element onto the
606: ** stack. And the stack never grows on successive executions of the
607: ** same loop. So the total number of instructions is an upper bound
608: ** on the maximum stack depth required.
609: **
610: ** Allocation all the stack space we will ever need.
611: */
612: if( p->aStack==0 ){
613: p->nVar = nVar;
614: assert( nVar>=0 );
615: n = isExplain ? 10 : p->nOp;
616: p->aStack = sqliteMalloc(
617: n*(sizeof(p->aStack[0]) + 2*sizeof(char*)) /* aStack and zArgv */
618: + p->nVar*(sizeof(char*)+sizeof(int)+1) /* azVar, anVar, abVar */
619: );
620: p->zArgv = (char**)&p->aStack[n];
621: p->azColName = (char**)&p->zArgv[n];
622: p->azVar = (char**)&p->azColName[n];
623: p->anVar = (int*)&p->azVar[p->nVar];
624: p->abVar = (u8*)&p->anVar[p->nVar];
625: }
626:
627: sqliteHashInit(&p->agg.hash, SQLITE_HASH_BINARY, 0);
628: p->agg.pSearch = 0;
629: #ifdef MEMORY_DEBUG
630: if( sqliteOsFileExists("vdbe_trace") ){
631: p->trace = stdout;
632: }
633: #endif
634: p->pTos = &p->aStack[-1];
635: p->pc = 0;
636: p->rc = SQLITE_OK;
637: p->uniqueCnt = 0;
638: p->returnDepth = 0;
639: p->errorAction = OE_Abort;
640: p->undoTransOnError = 0;
641: p->popStack = 0;
642: p->explain |= isExplain;
643: p->magic = VDBE_MAGIC_RUN;
644: #ifdef VDBE_PROFILE
645: {
646: int i;
647: for(i=0; i<p->nOp; i++){
648: p->aOp[i].cnt = 0;
649: p->aOp[i].cycles = 0;
650: }
651: }
652: #endif
653: }
654:
655:
656: /*
657: ** Remove any elements that remain on the sorter for the VDBE given.
658: */
659: void sqliteVdbeSorterReset(Vdbe *p){
660: while( p->pSort ){
661: Sorter *pSorter = p->pSort;
662: p->pSort = pSorter->pNext;
663: sqliteFree(pSorter->zKey);
664: sqliteFree(pSorter->pData);
665: sqliteFree(pSorter);
666: }
667: }
668:
669: /*
670: ** Reset an Agg structure. Delete all its contents.
671: **
672: ** For installable aggregate functions, if the step function has been
673: ** called, make sure the finalizer function has also been called. The
674: ** finalizer might need to free memory that was allocated as part of its
675: ** private context. If the finalizer has not been called yet, call it
676: ** now.
677: */
678: void sqliteVdbeAggReset(Agg *pAgg){
679: int i;
680: HashElem *p;
681: for(p = sqliteHashFirst(&pAgg->hash); p; p = sqliteHashNext(p)){
682: AggElem *pElem = sqliteHashData(p);
683: assert( pAgg->apFunc!=0 );
684: for(i=0; i<pAgg->nMem; i++){
685: Mem *pMem = &pElem->aMem[i];
686: if( pAgg->apFunc[i] && (pMem->flags & MEM_AggCtx)!=0 ){
687: sqlite_func ctx;
688: ctx.pFunc = pAgg->apFunc[i];
689: ctx.s.flags = MEM_Null;
690: ctx.pAgg = pMem->z;
691: ctx.cnt = pMem->i;
692: ctx.isStep = 0;
693: ctx.isError = 0;
694: (*pAgg->apFunc[i]->xFinalize)(&ctx);
695: if( pMem->z!=0 && pMem->z!=pMem->zShort ){
696: sqliteFree(pMem->z);
697: }
698: if( ctx.s.flags & MEM_Dyn ){
699: sqliteFree(ctx.s.z);
700: }
701: }else if( pMem->flags & MEM_Dyn ){
702: sqliteFree(pMem->z);
703: }
704: }
705: sqliteFree(pElem);
706: }
707: sqliteHashClear(&pAgg->hash);
708: sqliteFree(pAgg->apFunc);
709: pAgg->apFunc = 0;
710: pAgg->pCurrent = 0;
711: pAgg->pSearch = 0;
712: pAgg->nMem = 0;
713: }
714:
715: /*
716: ** Delete a keylist
717: */
718: void sqliteVdbeKeylistFree(Keylist *p){
719: while( p ){
720: Keylist *pNext = p->pNext;
721: sqliteFree(p);
722: p = pNext;
723: }
724: }
725:
726: /*
727: ** Close a cursor and release all the resources that cursor happens
728: ** to hold.
729: */
730: void sqliteVdbeCleanupCursor(Cursor *pCx){
731: if( pCx->pCursor ){
732: sqliteBtreeCloseCursor(pCx->pCursor);
733: }
734: if( pCx->pBt ){
735: sqliteBtreeClose(pCx->pBt);
736: }
737: sqliteFree(pCx->pData);
738: memset(pCx, 0, sizeof(Cursor));
739: }
740:
741: /*
742: ** Close all cursors
743: */
744: static void closeAllCursors(Vdbe *p){
745: int i;
746: for(i=0; i<p->nCursor; i++){
747: sqliteVdbeCleanupCursor(&p->aCsr[i]);
748: }
749: sqliteFree(p->aCsr);
750: p->aCsr = 0;
751: p->nCursor = 0;
752: }
753:
754: /*
755: ** Clean up the VM after execution.
756: **
757: ** This routine will automatically close any cursors, lists, and/or
758: ** sorters that were left open. It also deletes the values of
759: ** variables in the azVariable[] array.
760: */
761: static void Cleanup(Vdbe *p){
762: int i;
763: if( p->aStack ){
764: Mem *pTos = p->pTos;
765: while( pTos>=p->aStack ){
766: if( pTos->flags & MEM_Dyn ){
767: sqliteFree(pTos->z);
768: }
769: pTos--;
770: }
771: p->pTos = pTos;
772: }
773: closeAllCursors(p);
774: if( p->aMem ){
775: for(i=0; i<p->nMem; i++){
776: if( p->aMem[i].flags & MEM_Dyn ){
777: sqliteFree(p->aMem[i].z);
778: }
779: }
780: }
781: sqliteFree(p->aMem);
782: p->aMem = 0;
783: p->nMem = 0;
784: if( p->pList ){
785: sqliteVdbeKeylistFree(p->pList);
786: p->pList = 0;
787: }
788: sqliteVdbeSorterReset(p);
789: if( p->pFile ){
790: if( p->pFile!=stdin ) fclose(p->pFile);
791: p->pFile = 0;
792: }
793: if( p->azField ){
794: sqliteFree(p->azField);
795: p->azField = 0;
796: }
797: p->nField = 0;
798: if( p->zLine ){
799: sqliteFree(p->zLine);
800: p->zLine = 0;
801: }
802: p->nLineAlloc = 0;
803: sqliteVdbeAggReset(&p->agg);
804: if( p->aSet ){
805: for(i=0; i<p->nSet; i++){
806: sqliteHashClear(&p->aSet[i].hash);
807: }
808: }
809: sqliteFree(p->aSet);
810: p->aSet = 0;
811: p->nSet = 0;
812: if( p->keylistStack ){
813: int ii;
814: for(ii = 0; ii < p->keylistStackDepth; ii++){
815: sqliteVdbeKeylistFree(p->keylistStack[ii]);
816: }
817: sqliteFree(p->keylistStack);
818: p->keylistStackDepth = 0;
819: p->keylistStack = 0;
820: }
821: sqliteFree(p->contextStack);
822: p->contextStack = 0;
823: sqliteFree(p->zErrMsg);
824: p->zErrMsg = 0;
825: }
826:
827: /*
828: ** Clean up a VDBE after execution but do not delete the VDBE just yet.
829: ** Write any error messages into *pzErrMsg. Return the result code.
830: **
831: ** After this routine is run, the VDBE should be ready to be executed
832: ** again.
833: */
834: int sqliteVdbeReset(Vdbe *p, char **pzErrMsg){
835: sqlite *db = p->db;
836: int i;
837:
838: if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){
839: sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0);
840: return SQLITE_MISUSE;
841: }
842: if( p->zErrMsg ){
843: if( pzErrMsg && *pzErrMsg==0 ){
844: *pzErrMsg = p->zErrMsg;
845: }else{
846: sqliteFree(p->zErrMsg);
847: }
848: p->zErrMsg = 0;
849: }else if( p->rc ){
850: sqliteSetString(pzErrMsg, sqlite_error_string(p->rc), (char*)0);
851: }
852: Cleanup(p);
853: if( p->rc!=SQLITE_OK ){
854: switch( p->errorAction ){
855: case OE_Abort: {
856: if( !p->undoTransOnError ){
857: for(i=0; i<db->nDb; i++){
858: if( db->aDb[i].pBt ){
859: sqliteBtreeRollbackCkpt(db->aDb[i].pBt);
860: }
861: }
862: break;
863: }
864: /* Fall through to ROLLBACK */
865: }
866: case OE_Rollback: {
867: sqliteRollbackAll(db);
868: db->flags &= ~SQLITE_InTrans;
869: db->onError = OE_Default;
870: break;
871: }
872: default: {
873: if( p->undoTransOnError ){
874: sqliteRollbackAll(db);
875: db->flags &= ~SQLITE_InTrans;
876: db->onError = OE_Default;
877: }
878: break;
879: }
880: }
881: sqliteRollbackInternalChanges(db);
882: }
883: for(i=0; i<db->nDb; i++){
884: if( db->aDb[i].pBt && db->aDb[i].inTrans==2 ){
885: sqliteBtreeCommitCkpt(db->aDb[i].pBt);
886: db->aDb[i].inTrans = 1;
887: }
888: }
889: assert( p->pTos<&p->aStack[p->pc] || sqlite_malloc_failed==1 );
890: #ifdef VDBE_PROFILE
891: {
892: FILE *out = fopen("vdbe_profile.out", "a");
893: if( out ){
894: int i;
895: fprintf(out, "---- ");
896: for(i=0; i<p->nOp; i++){
897: fprintf(out, "%02x", p->aOp[i].opcode);
898: }
899: fprintf(out, "\n");
900: for(i=0; i<p->nOp; i++){
901: fprintf(out, "%6d %10lld %8lld ",
902: p->aOp[i].cnt,
903: p->aOp[i].cycles,
904: p->aOp[i].cnt>0 ? p->aOp[i].cycles/p->aOp[i].cnt : 0
905: );
906: sqliteVdbePrintOp(out, i, &p->aOp[i]);
907: }
908: fclose(out);
909: }
910: }
911: #endif
912: p->magic = VDBE_MAGIC_INIT;
913: return p->rc;
914: }
915:
916: /*
917: ** Clean up and delete a VDBE after execution. Return an integer which is
918: ** the result code. Write any error message text into *pzErrMsg.
919: */
920: int sqliteVdbeFinalize(Vdbe *p, char **pzErrMsg){
921: int rc;
922: sqlite *db;
923:
924: if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){
925: sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), (char*)0);
926: return SQLITE_MISUSE;
927: }
928: db = p->db;
929: rc = sqliteVdbeReset(p, pzErrMsg);
930: sqliteVdbeDelete(p);
931: if( db->want_to_close && db->pVdbe==0 ){
932: sqlite_close(db);
933: }
934: if( rc==SQLITE_SCHEMA ){
935: sqliteResetInternalSchema(db, 0);
936: }
937: return rc;
938: }
939:
940: /*
941: ** Set the values of all variables. Variable $1 in the original SQL will
942: ** be the string azValue[0]. $2 will have the value azValue[1]. And
943: ** so forth. If a value is out of range (for example $3 when nValue==2)
944: ** then its value will be NULL.
945: **
946: ** This routine overrides any prior call.
947: */
948: int sqlite_bind(sqlite_vm *pVm, int i, const char *zVal, int len, int copy){
949: Vdbe *p = (Vdbe*)pVm;
950: if( p->magic!=VDBE_MAGIC_RUN || p->pc!=0 ){
951: return SQLITE_MISUSE;
952: }
953: if( i<1 || i>p->nVar ){
954: return SQLITE_RANGE;
955: }
956: i--;
957: if( p->abVar[i] ){
958: sqliteFree(p->azVar[i]);
959: }
960: if( zVal==0 ){
961: copy = 0;
962: len = 0;
963: }
964: if( len<0 ){
965: len = strlen(zVal)+1;
966: }
967: if( copy ){
968: p->azVar[i] = sqliteMalloc( len );
969: if( p->azVar[i] ) memcpy(p->azVar[i], zVal, len);
970: }else{
971: p->azVar[i] = (char*)zVal;
972: }
973: p->abVar[i] = copy;
974: p->anVar[i] = len;
975: return SQLITE_OK;
976: }
977:
978:
979: /*
980: ** Delete an entire VDBE.
981: */
982: void sqliteVdbeDelete(Vdbe *p){
983: int i;
984: if( p==0 ) return;
985: Cleanup(p);
986: if( p->pPrev ){
987: p->pPrev->pNext = p->pNext;
988: }else{
989: assert( p->db->pVdbe==p );
990: p->db->pVdbe = p->pNext;
991: }
992: if( p->pNext ){
993: p->pNext->pPrev = p->pPrev;
994: }
995: p->pPrev = p->pNext = 0;
996: if( p->nOpAlloc==0 ){
997: p->aOp = 0;
998: p->nOp = 0;
999: }
1000: for(i=0; i<p->nOp; i++){
1001: if( p->aOp[i].p3type==P3_DYNAMIC ){
1002: sqliteFree(p->aOp[i].p3);
1003: }
1004: }
1005: for(i=0; i<p->nVar; i++){
1006: if( p->abVar[i] ) sqliteFree(p->azVar[i]);
1007: }
1008: sqliteFree(p->aOp);
1009: sqliteFree(p->aLabel);
1010: sqliteFree(p->aStack);
1011: p->magic = VDBE_MAGIC_DEAD;
1012: sqliteFree(p);
1013: }
1014:
1015: /*
1016: ** Convert an integer in between the native integer format and
1017: ** the bigEndian format used as the record number for tables.
1018: **
1019: ** The bigEndian format (most significant byte first) is used for
1020: ** record numbers so that records will sort into the correct order
1021: ** even though memcmp() is used to compare the keys. On machines
1022: ** whose native integer format is little endian (ex: i486) the
1023: ** order of bytes is reversed. On native big-endian machines
1024: ** (ex: Alpha, Sparc, Motorola) the byte order is the same.
1025: **
1026: ** This function is its own inverse. In other words
1027: **
1028: ** X == byteSwap(byteSwap(X))
1029: */
1030: int sqliteVdbeByteSwap(int x){
1031: union {
1032: char zBuf[sizeof(int)];
1033: int i;
1034: } ux;
1035: ux.zBuf[3] = x&0xff;
1036: ux.zBuf[2] = (x>>8)&0xff;
1037: ux.zBuf[1] = (x>>16)&0xff;
1038: ux.zBuf[0] = (x>>24)&0xff;
1039: return ux.i;
1040: }
1041:
1042: /*
1043: ** If a MoveTo operation is pending on the given cursor, then do that
1044: ** MoveTo now. Return an error code. If no MoveTo is pending, this
1045: ** routine does nothing and returns SQLITE_OK.
1046: */
1047: int sqliteVdbeCursorMoveto(Cursor *p){
1048: if( p->deferredMoveto ){
1049: int res;
1050: extern int sqlite_search_count;
1051: sqliteBtreeMoveto(p->pCursor, (char*)&p->movetoTarget, sizeof(int), &res);
1052: p->lastRecno = keyToInt(p->movetoTarget);
1053: p->recnoIsValid = res==0;
1054: if( res<0 ){
1055: sqliteBtreeNext(p->pCursor, &res);
1056: }
1057: sqlite_search_count++;
1058: p->deferredMoveto = 0;
1059: }
1060: return SQLITE_OK;
1061: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vdbeaux.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sqlite / libsqlite / src