Annotation of embedaddon/php/ext/sqlite/libsqlite/src/vdbe.c, revision 1.1.1.1
1.1 misho 1: /*
2: ** 2001 September 15
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: ** The code in this file implements execution method of the
13: ** Virtual Database Engine (VDBE). A separate file ("vdbeaux.c")
14: ** handles housekeeping details such as creating and deleting
15: ** VDBE instances. This file is solely interested in executing
16: ** the VDBE program.
17: **
18: ** In the external interface, an "sqlite_vm*" is an opaque pointer
19: ** to a VDBE.
20: **
21: ** The SQL parser generates a program which is then executed by
22: ** the VDBE to do the work of the SQL statement. VDBE programs are
23: ** similar in form to assembly language. The program consists of
24: ** a linear sequence of operations. Each operation has an opcode
25: ** and 3 operands. Operands P1 and P2 are integers. Operand P3
26: ** is a null-terminated string. The P2 operand must be non-negative.
27: ** Opcodes will typically ignore one or more operands. Many opcodes
28: ** ignore all three operands.
29: **
30: ** Computation results are stored on a stack. Each entry on the
31: ** stack is either an integer, a null-terminated string, a floating point
32: ** number, or the SQL "NULL" value. An inplicit conversion from one
33: ** type to the other occurs as necessary.
34: **
35: ** Most of the code in this file is taken up by the sqliteVdbeExec()
36: ** function which does the work of interpreting a VDBE program.
37: ** But other routines are also provided to help in building up
38: ** a program instruction by instruction.
39: **
40: ** Various scripts scan this source file in order to generate HTML
41: ** documentation, headers files, or other derived files. The formatting
42: ** of the code in this file is, therefore, important. See other comments
43: ** in this file for details. If in doubt, do not deviate from existing
44: ** commenting and indentation practices when changing or adding code.
45: **
46: ** $Id: vdbe.c 219681 2006-09-09 10:59:05Z tony2001 $
47: */
48: #include "sqliteInt.h"
49: #include "os.h"
50: #include <ctype.h>
51: #include "vdbeInt.h"
52:
53: /*
54: ** The following global variable is incremented every time a cursor
55: ** moves, either by the OP_MoveTo or the OP_Next opcode. The test
56: ** procedures use this information to make sure that indices are
57: ** working correctly. This variable has no function other than to
58: ** help verify the correct operation of the library.
59: */
60: int sqlite_search_count = 0;
61:
62: /*
63: ** When this global variable is positive, it gets decremented once before
64: ** each instruction in the VDBE. When reaches zero, the SQLITE_Interrupt
65: ** of the db.flags field is set in order to simulate an interrupt.
66: **
67: ** This facility is used for testing purposes only. It does not function
68: ** in an ordinary build.
69: */
70: int sqlite_interrupt_count = 0;
71:
72: /*
73: ** Advance the virtual machine to the next output row.
74: **
75: ** The return vale will be either SQLITE_BUSY, SQLITE_DONE,
76: ** SQLITE_ROW, SQLITE_ERROR, or SQLITE_MISUSE.
77: **
78: ** SQLITE_BUSY means that the virtual machine attempted to open
79: ** a locked database and there is no busy callback registered.
80: ** Call sqlite_step() again to retry the open. *pN is set to 0
81: ** and *pazColName and *pazValue are both set to NULL.
82: **
83: ** SQLITE_DONE means that the virtual machine has finished
84: ** executing. sqlite_step() should not be called again on this
85: ** virtual machine. *pN and *pazColName are set appropriately
86: ** but *pazValue is set to NULL.
87: **
88: ** SQLITE_ROW means that the virtual machine has generated another
89: ** row of the result set. *pN is set to the number of columns in
90: ** the row. *pazColName is set to the names of the columns followed
91: ** by the column datatypes. *pazValue is set to the values of each
92: ** column in the row. The value of the i-th column is (*pazValue)[i].
93: ** The name of the i-th column is (*pazColName)[i] and the datatype
94: ** of the i-th column is (*pazColName)[i+*pN].
95: **
96: ** SQLITE_ERROR means that a run-time error (such as a constraint
97: ** violation) has occurred. The details of the error will be returned
98: ** by the next call to sqlite_finalize(). sqlite_step() should not
99: ** be called again on the VM.
100: **
101: ** SQLITE_MISUSE means that the this routine was called inappropriately.
102: ** Perhaps it was called on a virtual machine that had already been
103: ** finalized or on one that had previously returned SQLITE_ERROR or
104: ** SQLITE_DONE. Or it could be the case the the same database connection
105: ** is being used simulataneously by two or more threads.
106: */
107: int sqlite_step(
108: sqlite_vm *pVm, /* The virtual machine to execute */
109: int *pN, /* OUT: Number of columns in result */
110: const char ***pazValue, /* OUT: Column data */
111: const char ***pazColName /* OUT: Column names and datatypes */
112: ){
113: Vdbe *p = (Vdbe*)pVm;
114: sqlite *db;
115: int rc;
116:
117: if( !p || p->magic!=VDBE_MAGIC_RUN ){
118: return SQLITE_MISUSE;
119: }
120: db = p->db;
121: if( sqliteSafetyOn(db) ){
122: p->rc = SQLITE_MISUSE;
123: return SQLITE_MISUSE;
124: }
125: if( p->explain ){
126: rc = sqliteVdbeList(p);
127: }else{
128: rc = sqliteVdbeExec(p);
129: }
130: if( rc==SQLITE_DONE || rc==SQLITE_ROW ){
131: if( pazColName ) *pazColName = (const char**)p->azColName;
132: if( pN ) *pN = p->nResColumn;
133: }else{
134: if( pazColName) *pazColName = 0;
135: if( pN ) *pN = 0;
136: }
137: if( pazValue ){
138: if( rc==SQLITE_ROW ){
139: *pazValue = (const char**)p->azResColumn;
140: }else{
141: *pazValue = 0;
142: }
143: }
144: if( sqliteSafetyOff(db) ){
145: return SQLITE_MISUSE;
146: }
147: return rc;
148: }
149:
150: /*
151: ** Insert a new aggregate element and make it the element that
152: ** has focus.
153: **
154: ** Return 0 on success and 1 if memory is exhausted.
155: */
156: static int AggInsert(Agg *p, char *zKey, int nKey){
157: AggElem *pElem, *pOld;
158: int i;
159: Mem *pMem;
160: pElem = sqliteMalloc( sizeof(AggElem) + nKey +
161: (p->nMem-1)*sizeof(pElem->aMem[0]) );
162: if( pElem==0 ) return 1;
163: pElem->zKey = (char*)&pElem->aMem[p->nMem];
164: memcpy(pElem->zKey, zKey, nKey);
165: pElem->nKey = nKey;
166: pOld = sqliteHashInsert(&p->hash, pElem->zKey, pElem->nKey, pElem);
167: if( pOld!=0 ){
168: assert( pOld==pElem ); /* Malloc failed on insert */
169: sqliteFree(pOld);
170: return 0;
171: }
172: for(i=0, pMem=pElem->aMem; i<p->nMem; i++, pMem++){
173: pMem->flags = MEM_Null;
174: }
175: p->pCurrent = pElem;
176: return 0;
177: }
178:
179: /*
180: ** Get the AggElem currently in focus
181: */
182: #define AggInFocus(P) ((P).pCurrent ? (P).pCurrent : _AggInFocus(&(P)))
183: static AggElem *_AggInFocus(Agg *p){
184: HashElem *pElem = sqliteHashFirst(&p->hash);
185: if( pElem==0 ){
186: AggInsert(p,"",1);
187: pElem = sqliteHashFirst(&p->hash);
188: }
189: return pElem ? sqliteHashData(pElem) : 0;
190: }
191:
192: /*
193: ** Convert the given stack entity into a string if it isn't one
194: ** already.
195: */
196: #define Stringify(P) if(((P)->flags & MEM_Str)==0){hardStringify(P);}
197: static int hardStringify(Mem *pStack){
198: int fg = pStack->flags;
199: if( fg & MEM_Real ){
200: sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%.15g",pStack->r);
201: }else if( fg & MEM_Int ){
202: sqlite_snprintf(sizeof(pStack->zShort),pStack->zShort,"%d",pStack->i);
203: }else{
204: pStack->zShort[0] = 0;
205: }
206: pStack->z = pStack->zShort;
207: pStack->n = strlen(pStack->zShort)+1;
208: pStack->flags = MEM_Str | MEM_Short;
209: return 0;
210: }
211:
212: /*
213: ** Convert the given stack entity into a string that has been obtained
214: ** from sqliteMalloc(). This is different from Stringify() above in that
215: ** Stringify() will use the NBFS bytes of static string space if the string
216: ** will fit but this routine always mallocs for space.
217: ** Return non-zero if we run out of memory.
218: */
219: #define Dynamicify(P) (((P)->flags & MEM_Dyn)==0 ? hardDynamicify(P):0)
220: static int hardDynamicify(Mem *pStack){
221: int fg = pStack->flags;
222: char *z;
223: if( (fg & MEM_Str)==0 ){
224: hardStringify(pStack);
225: }
226: assert( (fg & MEM_Dyn)==0 );
227: z = sqliteMallocRaw( pStack->n );
228: if( z==0 ) return 1;
229: memcpy(z, pStack->z, pStack->n);
230: pStack->z = z;
231: pStack->flags |= MEM_Dyn;
232: return 0;
233: }
234:
235: /*
236: ** An ephemeral string value (signified by the MEM_Ephem flag) contains
237: ** a pointer to a dynamically allocated string where some other entity
238: ** is responsible for deallocating that string. Because the stack entry
239: ** does not control the string, it might be deleted without the stack
240: ** entry knowing it.
241: **
242: ** This routine converts an ephemeral string into a dynamically allocated
243: ** string that the stack entry itself controls. In other words, it
244: ** converts an MEM_Ephem string into an MEM_Dyn string.
245: */
246: #define Deephemeralize(P) \
247: if( ((P)->flags&MEM_Ephem)!=0 && hardDeephem(P) ){ goto no_mem;}
248: static int hardDeephem(Mem *pStack){
249: char *z;
250: assert( (pStack->flags & MEM_Ephem)!=0 );
251: z = sqliteMallocRaw( pStack->n );
252: if( z==0 ) return 1;
253: memcpy(z, pStack->z, pStack->n);
254: pStack->z = z;
255: pStack->flags &= ~MEM_Ephem;
256: pStack->flags |= MEM_Dyn;
257: return 0;
258: }
259:
260: /*
261: ** Release the memory associated with the given stack level. This
262: ** leaves the Mem.flags field in an inconsistent state.
263: */
264: #define Release(P) if((P)->flags&MEM_Dyn){ sqliteFree((P)->z); }
265:
266: /*
267: ** Pop the stack N times.
268: */
269: static void popStack(Mem **ppTos, int N){
270: Mem *pTos = *ppTos;
271: while( N>0 ){
272: N--;
273: Release(pTos);
274: pTos--;
275: }
276: *ppTos = pTos;
277: }
278:
279: /*
280: ** Return TRUE if zNum is a 32-bit signed integer and write
281: ** the value of the integer into *pNum. If zNum is not an integer
282: ** or is an integer that is too large to be expressed with just 32
283: ** bits, then return false.
284: **
285: ** Under Linux (RedHat 7.2) this routine is much faster than atoi()
286: ** for converting strings into integers.
287: */
288: static int toInt(const char *zNum, int *pNum){
289: int v = 0;
290: int neg;
291: int i, c;
292: if( *zNum=='-' ){
293: neg = 1;
294: zNum++;
295: }else if( *zNum=='+' ){
296: neg = 0;
297: zNum++;
298: }else{
299: neg = 0;
300: }
301: for(i=0; (c=zNum[i])>='0' && c<='9'; i++){
302: v = v*10 + c - '0';
303: }
304: *pNum = neg ? -v : v;
305: return c==0 && i>0 && (i<10 || (i==10 && memcmp(zNum,"2147483647",10)<=0));
306: }
307:
308: /*
309: ** Convert the given stack entity into a integer if it isn't one
310: ** already.
311: **
312: ** Any prior string or real representation is invalidated.
313: ** NULLs are converted into 0.
314: */
315: #define Integerify(P) if(((P)->flags&MEM_Int)==0){ hardIntegerify(P); }
316: static void hardIntegerify(Mem *pStack){
317: if( pStack->flags & MEM_Real ){
318: pStack->i = (int)pStack->r;
319: Release(pStack);
320: }else if( pStack->flags & MEM_Str ){
321: toInt(pStack->z, &pStack->i);
322: Release(pStack);
323: }else{
324: pStack->i = 0;
325: }
326: pStack->flags = MEM_Int;
327: }
328:
329: /*
330: ** Get a valid Real representation for the given stack element.
331: **
332: ** Any prior string or integer representation is retained.
333: ** NULLs are converted into 0.0.
334: */
335: #define Realify(P) if(((P)->flags&MEM_Real)==0){ hardRealify(P); }
336: static void hardRealify(Mem *pStack){
337: if( pStack->flags & MEM_Str ){
338: pStack->r = sqliteAtoF(pStack->z, 0);
339: }else if( pStack->flags & MEM_Int ){
340: pStack->r = pStack->i;
341: }else{
342: pStack->r = 0.0;
343: }
344: pStack->flags |= MEM_Real;
345: }
346:
347: /*
348: ** The parameters are pointers to the head of two sorted lists
349: ** of Sorter structures. Merge these two lists together and return
350: ** a single sorted list. This routine forms the core of the merge-sort
351: ** algorithm.
352: **
353: ** In the case of a tie, left sorts in front of right.
354: */
355: static Sorter *Merge(Sorter *pLeft, Sorter *pRight){
356: Sorter sHead;
357: Sorter *pTail;
358: pTail = &sHead;
359: pTail->pNext = 0;
360: while( pLeft && pRight ){
361: int c = sqliteSortCompare(pLeft->zKey, pRight->zKey);
362: if( c<=0 ){
363: pTail->pNext = pLeft;
364: pLeft = pLeft->pNext;
365: }else{
366: pTail->pNext = pRight;
367: pRight = pRight->pNext;
368: }
369: pTail = pTail->pNext;
370: }
371: if( pLeft ){
372: pTail->pNext = pLeft;
373: }else if( pRight ){
374: pTail->pNext = pRight;
375: }
376: return sHead.pNext;
377: }
378:
379: /*
380: ** The following routine works like a replacement for the standard
381: ** library routine fgets(). The difference is in how end-of-line (EOL)
382: ** is handled. Standard fgets() uses LF for EOL under unix, CRLF
383: ** under windows, and CR under mac. This routine accepts any of these
384: ** character sequences as an EOL mark. The EOL mark is replaced by
385: ** a single LF character in zBuf.
386: */
387: static char *vdbe_fgets(char *zBuf, int nBuf, FILE *in){
388: int i, c;
389: for(i=0; i<nBuf-1 && (c=getc(in))!=EOF; i++){
390: zBuf[i] = c;
391: if( c=='\r' || c=='\n' ){
392: if( c=='\r' ){
393: zBuf[i] = '\n';
394: c = getc(in);
395: if( c!=EOF && c!='\n' ) ungetc(c, in);
396: }
397: i++;
398: break;
399: }
400: }
401: zBuf[i] = 0;
402: return i>0 ? zBuf : 0;
403: }
404:
405: /*
406: ** Make sure there is space in the Vdbe structure to hold at least
407: ** mxCursor cursors. If there is not currently enough space, then
408: ** allocate more.
409: **
410: ** If a memory allocation error occurs, return 1. Return 0 if
411: ** everything works.
412: */
413: static int expandCursorArraySize(Vdbe *p, int mxCursor){
414: if( mxCursor>=p->nCursor ){
415: Cursor *aCsr = sqliteRealloc( p->aCsr, (mxCursor+1)*sizeof(Cursor) );
416: if( aCsr==0 ) return 1;
417: p->aCsr = aCsr;
418: memset(&p->aCsr[p->nCursor], 0, sizeof(Cursor)*(mxCursor+1-p->nCursor));
419: p->nCursor = mxCursor+1;
420: }
421: return 0;
422: }
423:
424: #ifdef VDBE_PROFILE
425: /*
426: ** The following routine only works on pentium-class processors.
427: ** It uses the RDTSC opcode to read cycle count value out of the
428: ** processor and returns that value. This can be used for high-res
429: ** profiling.
430: */
431: __inline__ unsigned long long int hwtime(void){
432: unsigned long long int x;
433: __asm__("rdtsc\n\t"
434: "mov %%edx, %%ecx\n\t"
435: :"=A" (x));
436: return x;
437: }
438: #endif
439:
440: /*
441: ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
442: ** sqlite_interrupt() routine has been called. If it has been, then
443: ** processing of the VDBE program is interrupted.
444: **
445: ** This macro added to every instruction that does a jump in order to
446: ** implement a loop. This test used to be on every single instruction,
447: ** but that meant we more testing that we needed. By only testing the
448: ** flag on jump instructions, we get a (small) speed improvement.
449: */
450: #define CHECK_FOR_INTERRUPT \
451: if( db->flags & SQLITE_Interrupt ) goto abort_due_to_interrupt;
452:
453:
454: /*
455: ** Execute as much of a VDBE program as we can then return.
456: **
457: ** sqliteVdbeMakeReady() must be called before this routine in order to
458: ** close the program with a final OP_Halt and to set up the callbacks
459: ** and the error message pointer.
460: **
461: ** Whenever a row or result data is available, this routine will either
462: ** invoke the result callback (if there is one) or return with
463: ** SQLITE_ROW.
464: **
465: ** If an attempt is made to open a locked database, then this routine
466: ** will either invoke the busy callback (if there is one) or it will
467: ** return SQLITE_BUSY.
468: **
469: ** If an error occurs, an error message is written to memory obtained
470: ** from sqliteMalloc() and p->zErrMsg is made to point to that memory.
471: ** The error code is stored in p->rc and this routine returns SQLITE_ERROR.
472: **
473: ** If the callback ever returns non-zero, then the program exits
474: ** immediately. There will be no error message but the p->rc field is
475: ** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
476: **
477: ** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
478: ** routine to return SQLITE_ERROR.
479: **
480: ** Other fatal errors return SQLITE_ERROR.
481: **
482: ** After this routine has finished, sqliteVdbeFinalize() should be
483: ** used to clean up the mess that was left behind.
484: */
485: int sqliteVdbeExec(
486: Vdbe *p /* The VDBE */
487: ){
488: int pc; /* The program counter */
489: Op *pOp; /* Current operation */
490: int rc = SQLITE_OK; /* Value to return */
491: sqlite *db = p->db; /* The database */
492: Mem *pTos; /* Top entry in the operand stack */
493: char zBuf[100]; /* Space to sprintf() an integer */
494: #ifdef VDBE_PROFILE
495: unsigned long long start; /* CPU clock count at start of opcode */
496: int origPc; /* Program counter at start of opcode */
497: #endif
498: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
499: int nProgressOps = 0; /* Opcodes executed since progress callback. */
500: #endif
501:
502: if( p->magic!=VDBE_MAGIC_RUN ) return SQLITE_MISUSE;
503: assert( db->magic==SQLITE_MAGIC_BUSY );
504: assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
505: p->rc = SQLITE_OK;
506: assert( p->explain==0 );
507: if( sqlite_malloc_failed ) goto no_mem;
508: pTos = p->pTos;
509: if( p->popStack ){
510: popStack(&pTos, p->popStack);
511: p->popStack = 0;
512: }
513: CHECK_FOR_INTERRUPT;
514: for(pc=p->pc; rc==SQLITE_OK; pc++){
515: assert( pc>=0 && pc<p->nOp );
516: assert( pTos<=&p->aStack[pc] );
517: #ifdef VDBE_PROFILE
518: origPc = pc;
519: start = hwtime();
520: #endif
521: pOp = &p->aOp[pc];
522:
523: /* Only allow tracing if NDEBUG is not defined.
524: */
525: #ifndef NDEBUG
526: if( p->trace ){
527: sqliteVdbePrintOp(p->trace, pc, pOp);
528: }
529: #endif
530:
531: /* Check to see if we need to simulate an interrupt. This only happens
532: ** if we have a special test build.
533: */
534: #ifdef SQLITE_TEST
535: if( sqlite_interrupt_count>0 ){
536: sqlite_interrupt_count--;
537: if( sqlite_interrupt_count==0 ){
538: sqlite_interrupt(db);
539: }
540: }
541: #endif
542:
543: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
544: /* Call the progress callback if it is configured and the required number
545: ** of VDBE ops have been executed (either since this invocation of
546: ** sqliteVdbeExec() or since last time the progress callback was called).
547: ** If the progress callback returns non-zero, exit the virtual machine with
548: ** a return code SQLITE_ABORT.
549: */
550: if( db->xProgress ){
551: if( db->nProgressOps==nProgressOps ){
552: if( db->xProgress(db->pProgressArg)!=0 ){
553: rc = SQLITE_ABORT;
554: continue; /* skip to the next iteration of the for loop */
555: }
556: nProgressOps = 0;
557: }
558: nProgressOps++;
559: }
560: #endif
561:
562: switch( pOp->opcode ){
563:
564: /*****************************************************************************
565: ** What follows is a massive switch statement where each case implements a
566: ** separate instruction in the virtual machine. If we follow the usual
567: ** indentation conventions, each case should be indented by 6 spaces. But
568: ** that is a lot of wasted space on the left margin. So the code within
569: ** the switch statement will break with convention and be flush-left. Another
570: ** big comment (similar to this one) will mark the point in the code where
571: ** we transition back to normal indentation.
572: **
573: ** The formatting of each case is important. The makefile for SQLite
574: ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
575: ** file looking for lines that begin with "case OP_". The opcodes.h files
576: ** will be filled with #defines that give unique integer values to each
577: ** opcode and the opcodes.c file is filled with an array of strings where
578: ** each string is the symbolic name for the corresponding opcode.
579: **
580: ** Documentation about VDBE opcodes is generated by scanning this file
581: ** for lines of that contain "Opcode:". That line and all subsequent
582: ** comment lines are used in the generation of the opcode.html documentation
583: ** file.
584: **
585: ** SUMMARY:
586: **
587: ** Formatting is important to scripts that scan this file.
588: ** Do not deviate from the formatting style currently in use.
589: **
590: *****************************************************************************/
591:
592: /* Opcode: Goto * P2 *
593: **
594: ** An unconditional jump to address P2.
595: ** The next instruction executed will be
596: ** the one at index P2 from the beginning of
597: ** the program.
598: */
599: case OP_Goto: {
600: CHECK_FOR_INTERRUPT;
601: pc = pOp->p2 - 1;
602: break;
603: }
604:
605: /* Opcode: Gosub * P2 *
606: **
607: ** Push the current address plus 1 onto the return address stack
608: ** and then jump to address P2.
609: **
610: ** The return address stack is of limited depth. If too many
611: ** OP_Gosub operations occur without intervening OP_Returns, then
612: ** the return address stack will fill up and processing will abort
613: ** with a fatal error.
614: */
615: case OP_Gosub: {
616: if( p->returnDepth>=sizeof(p->returnStack)/sizeof(p->returnStack[0]) ){
617: sqliteSetString(&p->zErrMsg, "return address stack overflow", (char*)0);
618: p->rc = SQLITE_INTERNAL;
619: return SQLITE_ERROR;
620: }
621: p->returnStack[p->returnDepth++] = pc+1;
622: pc = pOp->p2 - 1;
623: break;
624: }
625:
626: /* Opcode: Return * * *
627: **
628: ** Jump immediately to the next instruction after the last unreturned
629: ** OP_Gosub. If an OP_Return has occurred for all OP_Gosubs, then
630: ** processing aborts with a fatal error.
631: */
632: case OP_Return: {
633: if( p->returnDepth<=0 ){
634: sqliteSetString(&p->zErrMsg, "return address stack underflow", (char*)0);
635: p->rc = SQLITE_INTERNAL;
636: return SQLITE_ERROR;
637: }
638: p->returnDepth--;
639: pc = p->returnStack[p->returnDepth] - 1;
640: break;
641: }
642:
643: /* Opcode: Halt P1 P2 *
644: **
645: ** Exit immediately. All open cursors, Lists, Sorts, etc are closed
646: ** automatically.
647: **
648: ** P1 is the result code returned by sqlite_exec(). For a normal
649: ** halt, this should be SQLITE_OK (0). For errors, it can be some
650: ** other value. If P1!=0 then P2 will determine whether or not to
651: ** rollback the current transaction. Do not rollback if P2==OE_Fail.
652: ** Do the rollback if P2==OE_Rollback. If P2==OE_Abort, then back
653: ** out all changes that have occurred during this execution of the
654: ** VDBE, but do not rollback the transaction.
655: **
656: ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
657: ** every program. So a jump past the last instruction of the program
658: ** is the same as executing Halt.
659: */
660: case OP_Halt: {
661: p->magic = VDBE_MAGIC_HALT;
662: p->pTos = pTos;
663: if( pOp->p1!=SQLITE_OK ){
664: p->rc = pOp->p1;
665: p->errorAction = pOp->p2;
666: if( pOp->p3 ){
667: sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);
668: }
669: return SQLITE_ERROR;
670: }else{
671: p->rc = SQLITE_OK;
672: return SQLITE_DONE;
673: }
674: }
675:
676: /* Opcode: Integer P1 * P3
677: **
678: ** The integer value P1 is pushed onto the stack. If P3 is not zero
679: ** then it is assumed to be a string representation of the same integer.
680: */
681: case OP_Integer: {
682: pTos++;
683: pTos->i = pOp->p1;
684: pTos->flags = MEM_Int;
685: if( pOp->p3 ){
686: pTos->z = pOp->p3;
687: pTos->flags |= MEM_Str | MEM_Static;
688: pTos->n = strlen(pOp->p3)+1;
689: }
690: break;
691: }
692:
693: /* Opcode: String * * P3
694: **
695: ** The string value P3 is pushed onto the stack. If P3==0 then a
696: ** NULL is pushed onto the stack.
697: */
698: case OP_String: {
699: char *z = pOp->p3;
700: pTos++;
701: if( z==0 ){
702: pTos->flags = MEM_Null;
703: }else{
704: pTos->z = z;
705: pTos->n = strlen(z) + 1;
706: pTos->flags = MEM_Str | MEM_Static;
707: }
708: break;
709: }
710:
711: /* Opcode: Variable P1 * *
712: **
713: ** Push the value of variable P1 onto the stack. A variable is
714: ** an unknown in the original SQL string as handed to sqlite_compile().
715: ** Any occurance of the '?' character in the original SQL is considered
716: ** a variable. Variables in the SQL string are number from left to
717: ** right beginning with 1. The values of variables are set using the
718: ** sqlite_bind() API.
719: */
720: case OP_Variable: {
721: int j = pOp->p1 - 1;
722: pTos++;
723: if( j>=0 && j<p->nVar && p->azVar[j]!=0 ){
724: pTos->z = p->azVar[j];
725: pTos->n = p->anVar[j];
726: pTos->flags = MEM_Str | MEM_Static;
727: }else{
728: pTos->flags = MEM_Null;
729: }
730: break;
731: }
732:
733: /* Opcode: Pop P1 * *
734: **
735: ** P1 elements are popped off of the top of stack and discarded.
736: */
737: case OP_Pop: {
738: assert( pOp->p1>=0 );
739: popStack(&pTos, pOp->p1);
740: assert( pTos>=&p->aStack[-1] );
741: break;
742: }
743:
744: /* Opcode: Dup P1 P2 *
745: **
746: ** A copy of the P1-th element of the stack
747: ** is made and pushed onto the top of the stack.
748: ** The top of the stack is element 0. So the
749: ** instruction "Dup 0 0 0" will make a copy of the
750: ** top of the stack.
751: **
752: ** If the content of the P1-th element is a dynamically
753: ** allocated string, then a new copy of that string
754: ** is made if P2==0. If P2!=0, then just a pointer
755: ** to the string is copied.
756: **
757: ** Also see the Pull instruction.
758: */
759: case OP_Dup: {
760: Mem *pFrom = &pTos[-pOp->p1];
761: assert( pFrom<=pTos && pFrom>=p->aStack );
762: pTos++;
763: memcpy(pTos, pFrom, sizeof(*pFrom)-NBFS);
764: if( pTos->flags & MEM_Str ){
765: if( pOp->p2 && (pTos->flags & (MEM_Dyn|MEM_Ephem)) ){
766: pTos->flags &= ~MEM_Dyn;
767: pTos->flags |= MEM_Ephem;
768: }else if( pTos->flags & MEM_Short ){
769: memcpy(pTos->zShort, pFrom->zShort, pTos->n);
770: pTos->z = pTos->zShort;
771: }else if( (pTos->flags & MEM_Static)==0 ){
772: pTos->z = sqliteMallocRaw(pFrom->n);
773: if( sqlite_malloc_failed ) goto no_mem;
774: memcpy(pTos->z, pFrom->z, pFrom->n);
775: pTos->flags &= ~(MEM_Static|MEM_Ephem|MEM_Short);
776: pTos->flags |= MEM_Dyn;
777: }
778: }
779: break;
780: }
781:
782: /* Opcode: Pull P1 * *
783: **
784: ** The P1-th element is removed from its current location on
785: ** the stack and pushed back on top of the stack. The
786: ** top of the stack is element 0, so "Pull 0 0 0" is
787: ** a no-op. "Pull 1 0 0" swaps the top two elements of
788: ** the stack.
789: **
790: ** See also the Dup instruction.
791: */
792: case OP_Pull: {
793: Mem *pFrom = &pTos[-pOp->p1];
794: int i;
795: Mem ts;
796:
797: ts = *pFrom;
798: Deephemeralize(pTos);
799: for(i=0; i<pOp->p1; i++, pFrom++){
800: Deephemeralize(&pFrom[1]);
801: *pFrom = pFrom[1];
802: assert( (pFrom->flags & MEM_Ephem)==0 );
803: if( pFrom->flags & MEM_Short ){
804: assert( pFrom->flags & MEM_Str );
805: assert( pFrom->z==pFrom[1].zShort );
806: pFrom->z = pFrom->zShort;
807: }
808: }
809: *pTos = ts;
810: if( pTos->flags & MEM_Short ){
811: assert( pTos->flags & MEM_Str );
812: assert( pTos->z==pTos[-pOp->p1].zShort );
813: pTos->z = pTos->zShort;
814: }
815: break;
816: }
817:
818: /* Opcode: Push P1 * *
819: **
820: ** Overwrite the value of the P1-th element down on the
821: ** stack (P1==0 is the top of the stack) with the value
822: ** of the top of the stack. Then pop the top of the stack.
823: */
824: case OP_Push: {
825: Mem *pTo = &pTos[-pOp->p1];
826:
827: assert( pTo>=p->aStack );
828: Deephemeralize(pTos);
829: Release(pTo);
830: *pTo = *pTos;
831: if( pTo->flags & MEM_Short ){
832: assert( pTo->z==pTos->zShort );
833: pTo->z = pTo->zShort;
834: }
835: pTos--;
836: break;
837: }
838:
839:
840: /* Opcode: ColumnName P1 P2 P3
841: **
842: ** P3 becomes the P1-th column name (first is 0). An array of pointers
843: ** to all column names is passed as the 4th parameter to the callback.
844: ** If P2==1 then this is the last column in the result set and thus the
845: ** number of columns in the result set will be P1. There must be at least
846: ** one OP_ColumnName with a P2==1 before invoking OP_Callback and the
847: ** number of columns specified in OP_Callback must one more than the P1
848: ** value of the OP_ColumnName that has P2==1.
849: */
850: case OP_ColumnName: {
851: assert( pOp->p1>=0 && pOp->p1<p->nOp );
852: p->azColName[pOp->p1] = pOp->p3;
853: p->nCallback = 0;
854: if( pOp->p2 ) p->nResColumn = pOp->p1+1;
855: break;
856: }
857:
858: /* Opcode: Callback P1 * *
859: **
860: ** Pop P1 values off the stack and form them into an array. Then
861: ** invoke the callback function using the newly formed array as the
862: ** 3rd parameter.
863: */
864: case OP_Callback: {
865: int i;
866: char **azArgv = p->zArgv;
867: Mem *pCol;
868:
869: pCol = &pTos[1-pOp->p1];
870: assert( pCol>=p->aStack );
871: for(i=0; i<pOp->p1; i++, pCol++){
872: if( pCol->flags & MEM_Null ){
873: azArgv[i] = 0;
874: }else{
875: Stringify(pCol);
876: azArgv[i] = pCol->z;
877: }
878: }
879: azArgv[i] = 0;
880: p->nCallback++;
881: p->azResColumn = azArgv;
882: assert( p->nResColumn==pOp->p1 );
883: p->popStack = pOp->p1;
884: p->pc = pc + 1;
885: p->pTos = pTos;
886: return SQLITE_ROW;
887: }
888:
889: /* Opcode: Concat P1 P2 P3
890: **
891: ** Look at the first P1 elements of the stack. Append them all
892: ** together with the lowest element first. Use P3 as a separator.
893: ** Put the result on the top of the stack. The original P1 elements
894: ** are popped from the stack if P2==0 and retained if P2==1. If
895: ** any element of the stack is NULL, then the result is NULL.
896: **
897: ** If P3 is NULL, then use no separator. When P1==1, this routine
898: ** makes a copy of the top stack element into memory obtained
899: ** from sqliteMalloc().
900: */
901: case OP_Concat: {
902: char *zNew;
903: int nByte;
904: int nField;
905: int i, j;
906: char *zSep;
907: int nSep;
908: Mem *pTerm;
909:
910: nField = pOp->p1;
911: zSep = pOp->p3;
912: if( zSep==0 ) zSep = "";
913: nSep = strlen(zSep);
914: assert( &pTos[1-nField] >= p->aStack );
915: nByte = 1 - nSep;
916: pTerm = &pTos[1-nField];
917: for(i=0; i<nField; i++, pTerm++){
918: if( pTerm->flags & MEM_Null ){
919: nByte = -1;
920: break;
921: }else{
922: Stringify(pTerm);
923: nByte += pTerm->n - 1 + nSep;
924: }
925: }
926: if( nByte<0 ){
927: if( pOp->p2==0 ){
928: popStack(&pTos, nField);
929: }
930: pTos++;
931: pTos->flags = MEM_Null;
932: break;
933: }
934: zNew = sqliteMallocRaw( nByte );
935: if( zNew==0 ) goto no_mem;
936: j = 0;
937: pTerm = &pTos[1-nField];
938: for(i=j=0; i<nField; i++, pTerm++){
939: assert( pTerm->flags & MEM_Str );
940: memcpy(&zNew[j], pTerm->z, pTerm->n-1);
941: j += pTerm->n-1;
942: if( nSep>0 && i<nField-1 ){
943: memcpy(&zNew[j], zSep, nSep);
944: j += nSep;
945: }
946: }
947: zNew[j] = 0;
948: if( pOp->p2==0 ){
949: popStack(&pTos, nField);
950: }
951: pTos++;
952: pTos->n = nByte;
953: pTos->flags = MEM_Str|MEM_Dyn;
954: pTos->z = zNew;
955: break;
956: }
957:
958: /* Opcode: Add * * *
959: **
960: ** Pop the top two elements from the stack, add them together,
961: ** and push the result back onto the stack. If either element
962: ** is a string then it is converted to a double using the atof()
963: ** function before the addition.
964: ** If either operand is NULL, the result is NULL.
965: */
966: /* Opcode: Multiply * * *
967: **
968: ** Pop the top two elements from the stack, multiply them together,
969: ** and push the result back onto the stack. If either element
970: ** is a string then it is converted to a double using the atof()
971: ** function before the multiplication.
972: ** If either operand is NULL, the result is NULL.
973: */
974: /* Opcode: Subtract * * *
975: **
976: ** Pop the top two elements from the stack, subtract the
977: ** first (what was on top of the stack) from the second (the
978: ** next on stack)
979: ** and push the result back onto the stack. If either element
980: ** is a string then it is converted to a double using the atof()
981: ** function before the subtraction.
982: ** If either operand is NULL, the result is NULL.
983: */
984: /* Opcode: Divide * * *
985: **
986: ** Pop the top two elements from the stack, divide the
987: ** first (what was on top of the stack) from the second (the
988: ** next on stack)
989: ** and push the result back onto the stack. If either element
990: ** is a string then it is converted to a double using the atof()
991: ** function before the division. Division by zero returns NULL.
992: ** If either operand is NULL, the result is NULL.
993: */
994: /* Opcode: Remainder * * *
995: **
996: ** Pop the top two elements from the stack, divide the
997: ** first (what was on top of the stack) from the second (the
998: ** next on stack)
999: ** and push the remainder after division onto the stack. If either element
1000: ** is a string then it is converted to a double using the atof()
1001: ** function before the division. Division by zero returns NULL.
1002: ** If either operand is NULL, the result is NULL.
1003: */
1004: case OP_Add:
1005: case OP_Subtract:
1006: case OP_Multiply:
1007: case OP_Divide:
1008: case OP_Remainder: {
1009: Mem *pNos = &pTos[-1];
1010: assert( pNos>=p->aStack );
1011: if( ((pTos->flags | pNos->flags) & MEM_Null)!=0 ){
1012: Release(pTos);
1013: pTos--;
1014: Release(pTos);
1015: pTos->flags = MEM_Null;
1016: }else if( (pTos->flags & pNos->flags & MEM_Int)==MEM_Int ){
1017: int a, b;
1018: a = pTos->i;
1019: b = pNos->i;
1020: switch( pOp->opcode ){
1021: case OP_Add: b += a; break;
1022: case OP_Subtract: b -= a; break;
1023: case OP_Multiply: b *= a; break;
1024: case OP_Divide: {
1025: if( a==0 ) goto divide_by_zero;
1026: b /= a;
1027: break;
1028: }
1029: default: {
1030: if( a==0 ) goto divide_by_zero;
1031: b %= a;
1032: break;
1033: }
1034: }
1035: Release(pTos);
1036: pTos--;
1037: Release(pTos);
1038: pTos->i = b;
1039: pTos->flags = MEM_Int;
1040: }else{
1041: double a, b;
1042: Realify(pTos);
1043: Realify(pNos);
1044: a = pTos->r;
1045: b = pNos->r;
1046: switch( pOp->opcode ){
1047: case OP_Add: b += a; break;
1048: case OP_Subtract: b -= a; break;
1049: case OP_Multiply: b *= a; break;
1050: case OP_Divide: {
1051: if( a==0.0 ) goto divide_by_zero;
1052: b /= a;
1053: break;
1054: }
1055: default: {
1056: int ia = (int)a;
1057: int ib = (int)b;
1058: if( ia==0.0 ) goto divide_by_zero;
1059: b = ib % ia;
1060: break;
1061: }
1062: }
1063: Release(pTos);
1064: pTos--;
1065: Release(pTos);
1066: pTos->r = b;
1067: pTos->flags = MEM_Real;
1068: }
1069: break;
1070:
1071: divide_by_zero:
1072: Release(pTos);
1073: pTos--;
1074: Release(pTos);
1075: pTos->flags = MEM_Null;
1076: break;
1077: }
1078:
1079: /* Opcode: Function P1 * P3
1080: **
1081: ** Invoke a user function (P3 is a pointer to a Function structure that
1082: ** defines the function) with P1 string arguments taken from the stack.
1083: ** Pop all arguments from the stack and push back the result.
1084: **
1085: ** See also: AggFunc
1086: */
1087: case OP_Function: {
1088: int n, i;
1089: Mem *pArg;
1090: char **azArgv;
1091: sqlite_func ctx;
1092:
1093: n = pOp->p1;
1094: pArg = &pTos[1-n];
1095: azArgv = p->zArgv;
1096: for(i=0; i<n; i++, pArg++){
1097: if( pArg->flags & MEM_Null ){
1098: azArgv[i] = 0;
1099: }else{
1100: Stringify(pArg);
1101: azArgv[i] = pArg->z;
1102: }
1103: }
1104: ctx.pFunc = (FuncDef*)pOp->p3;
1105: ctx.s.flags = MEM_Null;
1106: ctx.s.z = 0;
1107: ctx.isError = 0;
1108: ctx.isStep = 0;
1109: if( sqliteSafetyOff(db) ) goto abort_due_to_misuse;
1110: (*ctx.pFunc->xFunc)(&ctx, n, (const char**)azArgv);
1111: if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
1112: popStack(&pTos, n);
1113: pTos++;
1114: *pTos = ctx.s;
1115: if( pTos->flags & MEM_Short ){
1116: pTos->z = pTos->zShort;
1117: }
1118: if( ctx.isError ){
1119: sqliteSetString(&p->zErrMsg,
1120: (pTos->flags & MEM_Str)!=0 ? pTos->z : "user function error", (char*)0);
1121: rc = SQLITE_ERROR;
1122: }
1123: break;
1124: }
1125:
1126: /* Opcode: BitAnd * * *
1127: **
1128: ** Pop the top two elements from the stack. Convert both elements
1129: ** to integers. Push back onto the stack the bit-wise AND of the
1130: ** two elements.
1131: ** If either operand is NULL, the result is NULL.
1132: */
1133: /* Opcode: BitOr * * *
1134: **
1135: ** Pop the top two elements from the stack. Convert both elements
1136: ** to integers. Push back onto the stack the bit-wise OR of the
1137: ** two elements.
1138: ** If either operand is NULL, the result is NULL.
1139: */
1140: /* Opcode: ShiftLeft * * *
1141: **
1142: ** Pop the top two elements from the stack. Convert both elements
1143: ** to integers. Push back onto the stack the top element shifted
1144: ** left by N bits where N is the second element on the stack.
1145: ** If either operand is NULL, the result is NULL.
1146: */
1147: /* Opcode: ShiftRight * * *
1148: **
1149: ** Pop the top two elements from the stack. Convert both elements
1150: ** to integers. Push back onto the stack the top element shifted
1151: ** right by N bits where N is the second element on the stack.
1152: ** If either operand is NULL, the result is NULL.
1153: */
1154: case OP_BitAnd:
1155: case OP_BitOr:
1156: case OP_ShiftLeft:
1157: case OP_ShiftRight: {
1158: Mem *pNos = &pTos[-1];
1159: int a, b;
1160:
1161: assert( pNos>=p->aStack );
1162: if( (pTos->flags | pNos->flags) & MEM_Null ){
1163: popStack(&pTos, 2);
1164: pTos++;
1165: pTos->flags = MEM_Null;
1166: break;
1167: }
1168: Integerify(pTos);
1169: Integerify(pNos);
1170: a = pTos->i;
1171: b = pNos->i;
1172: switch( pOp->opcode ){
1173: case OP_BitAnd: a &= b; break;
1174: case OP_BitOr: a |= b; break;
1175: case OP_ShiftLeft: a <<= b; break;
1176: case OP_ShiftRight: a >>= b; break;
1177: default: /* CANT HAPPEN */ break;
1178: }
1179: assert( (pTos->flags & MEM_Dyn)==0 );
1180: assert( (pNos->flags & MEM_Dyn)==0 );
1181: pTos--;
1182: Release(pTos);
1183: pTos->i = a;
1184: pTos->flags = MEM_Int;
1185: break;
1186: }
1187:
1188: /* Opcode: AddImm P1 * *
1189: **
1190: ** Add the value P1 to whatever is on top of the stack. The result
1191: ** is always an integer.
1192: **
1193: ** To force the top of the stack to be an integer, just add 0.
1194: */
1195: case OP_AddImm: {
1196: assert( pTos>=p->aStack );
1197: Integerify(pTos);
1198: pTos->i += pOp->p1;
1199: break;
1200: }
1201:
1202: /* Opcode: ForceInt P1 P2 *
1203: **
1204: ** Convert the top of the stack into an integer. If the current top of
1205: ** the stack is not numeric (meaning that is is a NULL or a string that
1206: ** does not look like an integer or floating point number) then pop the
1207: ** stack and jump to P2. If the top of the stack is numeric then
1208: ** convert it into the least integer that is greater than or equal to its
1209: ** current value if P1==0, or to the least integer that is strictly
1210: ** greater than its current value if P1==1.
1211: */
1212: case OP_ForceInt: {
1213: int v;
1214: assert( pTos>=p->aStack );
1215: if( (pTos->flags & (MEM_Int|MEM_Real))==0
1216: && ((pTos->flags & MEM_Str)==0 || sqliteIsNumber(pTos->z)==0) ){
1217: Release(pTos);
1218: pTos--;
1219: pc = pOp->p2 - 1;
1220: break;
1221: }
1222: if( pTos->flags & MEM_Int ){
1223: v = pTos->i + (pOp->p1!=0);
1224: }else{
1225: Realify(pTos);
1226: v = (int)pTos->r;
1227: if( pTos->r>(double)v ) v++;
1228: if( pOp->p1 && pTos->r==(double)v ) v++;
1229: }
1230: Release(pTos);
1231: pTos->i = v;
1232: pTos->flags = MEM_Int;
1233: break;
1234: }
1235:
1236: /* Opcode: MustBeInt P1 P2 *
1237: **
1238: ** Force the top of the stack to be an integer. If the top of the
1239: ** stack is not an integer and cannot be converted into an integer
1240: ** with out data loss, then jump immediately to P2, or if P2==0
1241: ** raise an SQLITE_MISMATCH exception.
1242: **
1243: ** If the top of the stack is not an integer and P2 is not zero and
1244: ** P1 is 1, then the stack is popped. In all other cases, the depth
1245: ** of the stack is unchanged.
1246: */
1247: case OP_MustBeInt: {
1248: assert( pTos>=p->aStack );
1249: if( pTos->flags & MEM_Int ){
1250: /* Do nothing */
1251: }else if( pTos->flags & MEM_Real ){
1252: int i = (int)pTos->r;
1253: double r = (double)i;
1254: if( r!=pTos->r ){
1255: goto mismatch;
1256: }
1257: pTos->i = i;
1258: }else if( pTos->flags & MEM_Str ){
1259: int v;
1260: if( !toInt(pTos->z, &v) ){
1261: double r;
1262: if( !sqliteIsNumber(pTos->z) ){
1263: goto mismatch;
1264: }
1265: Realify(pTos);
1266: v = (int)pTos->r;
1267: r = (double)v;
1268: if( r!=pTos->r ){
1269: goto mismatch;
1270: }
1271: }
1272: pTos->i = v;
1273: }else{
1274: goto mismatch;
1275: }
1276: Release(pTos);
1277: pTos->flags = MEM_Int;
1278: break;
1279:
1280: mismatch:
1281: if( pOp->p2==0 ){
1282: rc = SQLITE_MISMATCH;
1283: goto abort_due_to_error;
1284: }else{
1285: if( pOp->p1 ) popStack(&pTos, 1);
1286: pc = pOp->p2 - 1;
1287: }
1288: break;
1289: }
1290:
1291: /* Opcode: Eq P1 P2 *
1292: **
1293: ** Pop the top two elements from the stack. If they are equal, then
1294: ** jump to instruction P2. Otherwise, continue to the next instruction.
1295: **
1296: ** If either operand is NULL (and thus if the result is unknown) then
1297: ** take the jump if P1 is true.
1298: **
1299: ** If both values are numeric, they are converted to doubles using atof()
1300: ** and compared for equality that way. Otherwise the strcmp() library
1301: ** routine is used for the comparison. For a pure text comparison
1302: ** use OP_StrEq.
1303: **
1304: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1305: ** stack if the jump would have been taken, or a 0 if not. Push a
1306: ** NULL if either operand was NULL.
1307: */
1308: /* Opcode: Ne P1 P2 *
1309: **
1310: ** Pop the top two elements from the stack. If they are not equal, then
1311: ** jump to instruction P2. Otherwise, continue to the next instruction.
1312: **
1313: ** If either operand is NULL (and thus if the result is unknown) then
1314: ** take the jump if P1 is true.
1315: **
1316: ** If both values are numeric, they are converted to doubles using atof()
1317: ** and compared in that format. Otherwise the strcmp() library
1318: ** routine is used for the comparison. For a pure text comparison
1319: ** use OP_StrNe.
1320: **
1321: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1322: ** stack if the jump would have been taken, or a 0 if not. Push a
1323: ** NULL if either operand was NULL.
1324: */
1325: /* Opcode: Lt P1 P2 *
1326: **
1327: ** Pop the top two elements from the stack. If second element (the
1328: ** next on stack) is less than the first (the top of stack), then
1329: ** jump to instruction P2. Otherwise, continue to the next instruction.
1330: ** In other words, jump if NOS<TOS.
1331: **
1332: ** If either operand is NULL (and thus if the result is unknown) then
1333: ** take the jump if P1 is true.
1334: **
1335: ** If both values are numeric, they are converted to doubles using atof()
1336: ** and compared in that format. Numeric values are always less than
1337: ** non-numeric values. If both operands are non-numeric, the strcmp() library
1338: ** routine is used for the comparison. For a pure text comparison
1339: ** use OP_StrLt.
1340: **
1341: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1342: ** stack if the jump would have been taken, or a 0 if not. Push a
1343: ** NULL if either operand was NULL.
1344: */
1345: /* Opcode: Le P1 P2 *
1346: **
1347: ** Pop the top two elements from the stack. If second element (the
1348: ** next on stack) is less than or equal to the first (the top of stack),
1349: ** then jump to instruction P2. In other words, jump if NOS<=TOS.
1350: **
1351: ** If either operand is NULL (and thus if the result is unknown) then
1352: ** take the jump if P1 is true.
1353: **
1354: ** If both values are numeric, they are converted to doubles using atof()
1355: ** and compared in that format. Numeric values are always less than
1356: ** non-numeric values. If both operands are non-numeric, the strcmp() library
1357: ** routine is used for the comparison. For a pure text comparison
1358: ** use OP_StrLe.
1359: **
1360: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1361: ** stack if the jump would have been taken, or a 0 if not. Push a
1362: ** NULL if either operand was NULL.
1363: */
1364: /* Opcode: Gt P1 P2 *
1365: **
1366: ** Pop the top two elements from the stack. If second element (the
1367: ** next on stack) is greater than the first (the top of stack),
1368: ** then jump to instruction P2. In other words, jump if NOS>TOS.
1369: **
1370: ** If either operand is NULL (and thus if the result is unknown) then
1371: ** take the jump if P1 is true.
1372: **
1373: ** If both values are numeric, they are converted to doubles using atof()
1374: ** and compared in that format. Numeric values are always less than
1375: ** non-numeric values. If both operands are non-numeric, the strcmp() library
1376: ** routine is used for the comparison. For a pure text comparison
1377: ** use OP_StrGt.
1378: **
1379: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1380: ** stack if the jump would have been taken, or a 0 if not. Push a
1381: ** NULL if either operand was NULL.
1382: */
1383: /* Opcode: Ge P1 P2 *
1384: **
1385: ** Pop the top two elements from the stack. If second element (the next
1386: ** on stack) is greater than or equal to the first (the top of stack),
1387: ** then jump to instruction P2. In other words, jump if NOS>=TOS.
1388: **
1389: ** If either operand is NULL (and thus if the result is unknown) then
1390: ** take the jump if P1 is true.
1391: **
1392: ** If both values are numeric, they are converted to doubles using atof()
1393: ** and compared in that format. Numeric values are always less than
1394: ** non-numeric values. If both operands are non-numeric, the strcmp() library
1395: ** routine is used for the comparison. For a pure text comparison
1396: ** use OP_StrGe.
1397: **
1398: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1399: ** stack if the jump would have been taken, or a 0 if not. Push a
1400: ** NULL if either operand was NULL.
1401: */
1402: case OP_Eq:
1403: case OP_Ne:
1404: case OP_Lt:
1405: case OP_Le:
1406: case OP_Gt:
1407: case OP_Ge: {
1408: Mem *pNos = &pTos[-1];
1409: int c, v;
1410: int ft, fn;
1411: assert( pNos>=p->aStack );
1412: ft = pTos->flags;
1413: fn = pNos->flags;
1414: if( (ft | fn) & MEM_Null ){
1415: popStack(&pTos, 2);
1416: if( pOp->p2 ){
1417: if( pOp->p1 ) pc = pOp->p2-1;
1418: }else{
1419: pTos++;
1420: pTos->flags = MEM_Null;
1421: }
1422: break;
1423: }else if( (ft & fn & MEM_Int)==MEM_Int ){
1424: c = pNos->i - pTos->i;
1425: }else if( (ft & MEM_Int)!=0 && (fn & MEM_Str)!=0 && toInt(pNos->z,&v) ){
1426: c = v - pTos->i;
1427: }else if( (fn & MEM_Int)!=0 && (ft & MEM_Str)!=0 && toInt(pTos->z,&v) ){
1428: c = pNos->i - v;
1429: }else{
1430: Stringify(pTos);
1431: Stringify(pNos);
1432: c = sqliteCompare(pNos->z, pTos->z);
1433: }
1434: switch( pOp->opcode ){
1435: case OP_Eq: c = c==0; break;
1436: case OP_Ne: c = c!=0; break;
1437: case OP_Lt: c = c<0; break;
1438: case OP_Le: c = c<=0; break;
1439: case OP_Gt: c = c>0; break;
1440: default: c = c>=0; break;
1441: }
1442: popStack(&pTos, 2);
1443: if( pOp->p2 ){
1444: if( c ) pc = pOp->p2-1;
1445: }else{
1446: pTos++;
1447: pTos->i = c;
1448: pTos->flags = MEM_Int;
1449: }
1450: break;
1451: }
1452: /* INSERT NO CODE HERE!
1453: **
1454: ** The opcode numbers are extracted from this source file by doing
1455: **
1456: ** grep '^case OP_' vdbe.c | ... >opcodes.h
1457: **
1458: ** The opcodes are numbered in the order that they appear in this file.
1459: ** But in order for the expression generating code to work right, the
1460: ** string comparison operators that follow must be numbered exactly 6
1461: ** greater than the numeric comparison opcodes above. So no other
1462: ** cases can appear between the two.
1463: */
1464: /* Opcode: StrEq P1 P2 *
1465: **
1466: ** Pop the top two elements from the stack. If they are equal, then
1467: ** jump to instruction P2. Otherwise, continue to the next instruction.
1468: **
1469: ** If either operand is NULL (and thus if the result is unknown) then
1470: ** take the jump if P1 is true.
1471: **
1472: ** The strcmp() library routine is used for the comparison. For a
1473: ** numeric comparison, use OP_Eq.
1474: **
1475: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1476: ** stack if the jump would have been taken, or a 0 if not. Push a
1477: ** NULL if either operand was NULL.
1478: */
1479: /* Opcode: StrNe P1 P2 *
1480: **
1481: ** Pop the top two elements from the stack. If they are not equal, then
1482: ** jump to instruction P2. Otherwise, continue to the next instruction.
1483: **
1484: ** If either operand is NULL (and thus if the result is unknown) then
1485: ** take the jump if P1 is true.
1486: **
1487: ** The strcmp() library routine is used for the comparison. For a
1488: ** numeric comparison, use OP_Ne.
1489: **
1490: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1491: ** stack if the jump would have been taken, or a 0 if not. Push a
1492: ** NULL if either operand was NULL.
1493: */
1494: /* Opcode: StrLt P1 P2 *
1495: **
1496: ** Pop the top two elements from the stack. If second element (the
1497: ** next on stack) is less than the first (the top of stack), then
1498: ** jump to instruction P2. Otherwise, continue to the next instruction.
1499: ** In other words, jump if NOS<TOS.
1500: **
1501: ** If either operand is NULL (and thus if the result is unknown) then
1502: ** take the jump if P1 is true.
1503: **
1504: ** The strcmp() library routine is used for the comparison. For a
1505: ** numeric comparison, use OP_Lt.
1506: **
1507: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1508: ** stack if the jump would have been taken, or a 0 if not. Push a
1509: ** NULL if either operand was NULL.
1510: */
1511: /* Opcode: StrLe P1 P2 *
1512: **
1513: ** Pop the top two elements from the stack. If second element (the
1514: ** next on stack) is less than or equal to the first (the top of stack),
1515: ** then jump to instruction P2. In other words, jump if NOS<=TOS.
1516: **
1517: ** If either operand is NULL (and thus if the result is unknown) then
1518: ** take the jump if P1 is true.
1519: **
1520: ** The strcmp() library routine is used for the comparison. For a
1521: ** numeric comparison, use OP_Le.
1522: **
1523: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1524: ** stack if the jump would have been taken, or a 0 if not. Push a
1525: ** NULL if either operand was NULL.
1526: */
1527: /* Opcode: StrGt P1 P2 *
1528: **
1529: ** Pop the top two elements from the stack. If second element (the
1530: ** next on stack) is greater than the first (the top of stack),
1531: ** then jump to instruction P2. In other words, jump if NOS>TOS.
1532: **
1533: ** If either operand is NULL (and thus if the result is unknown) then
1534: ** take the jump if P1 is true.
1535: **
1536: ** The strcmp() library routine is used for the comparison. For a
1537: ** numeric comparison, use OP_Gt.
1538: **
1539: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1540: ** stack if the jump would have been taken, or a 0 if not. Push a
1541: ** NULL if either operand was NULL.
1542: */
1543: /* Opcode: StrGe P1 P2 *
1544: **
1545: ** Pop the top two elements from the stack. If second element (the next
1546: ** on stack) is greater than or equal to the first (the top of stack),
1547: ** then jump to instruction P2. In other words, jump if NOS>=TOS.
1548: **
1549: ** If either operand is NULL (and thus if the result is unknown) then
1550: ** take the jump if P1 is true.
1551: **
1552: ** The strcmp() library routine is used for the comparison. For a
1553: ** numeric comparison, use OP_Ge.
1554: **
1555: ** If P2 is zero, do not jump. Instead, push an integer 1 onto the
1556: ** stack if the jump would have been taken, or a 0 if not. Push a
1557: ** NULL if either operand was NULL.
1558: */
1559: case OP_StrEq:
1560: case OP_StrNe:
1561: case OP_StrLt:
1562: case OP_StrLe:
1563: case OP_StrGt:
1564: case OP_StrGe: {
1565: Mem *pNos = &pTos[-1];
1566: int c;
1567: assert( pNos>=p->aStack );
1568: if( (pNos->flags | pTos->flags) & MEM_Null ){
1569: popStack(&pTos, 2);
1570: if( pOp->p2 ){
1571: if( pOp->p1 ) pc = pOp->p2-1;
1572: }else{
1573: pTos++;
1574: pTos->flags = MEM_Null;
1575: }
1576: break;
1577: }else{
1578: Stringify(pTos);
1579: Stringify(pNos);
1580: c = strcmp(pNos->z, pTos->z);
1581: }
1582: /* The asserts on each case of the following switch are there to verify
1583: ** that string comparison opcodes are always exactly 6 greater than the
1584: ** corresponding numeric comparison opcodes. The code generator depends
1585: ** on this fact.
1586: */
1587: switch( pOp->opcode ){
1588: case OP_StrEq: c = c==0; assert( pOp->opcode-6==OP_Eq ); break;
1589: case OP_StrNe: c = c!=0; assert( pOp->opcode-6==OP_Ne ); break;
1590: case OP_StrLt: c = c<0; assert( pOp->opcode-6==OP_Lt ); break;
1591: case OP_StrLe: c = c<=0; assert( pOp->opcode-6==OP_Le ); break;
1592: case OP_StrGt: c = c>0; assert( pOp->opcode-6==OP_Gt ); break;
1593: default: c = c>=0; assert( pOp->opcode-6==OP_Ge ); break;
1594: }
1595: popStack(&pTos, 2);
1596: if( pOp->p2 ){
1597: if( c ) pc = pOp->p2-1;
1598: }else{
1599: pTos++;
1600: pTos->flags = MEM_Int;
1601: pTos->i = c;
1602: }
1603: break;
1604: }
1605:
1606: /* Opcode: And * * *
1607: **
1608: ** Pop two values off the stack. Take the logical AND of the
1609: ** two values and push the resulting boolean value back onto the
1610: ** stack.
1611: */
1612: /* Opcode: Or * * *
1613: **
1614: ** Pop two values off the stack. Take the logical OR of the
1615: ** two values and push the resulting boolean value back onto the
1616: ** stack.
1617: */
1618: case OP_And:
1619: case OP_Or: {
1620: Mem *pNos = &pTos[-1];
1621: int v1, v2; /* 0==TRUE, 1==FALSE, 2==UNKNOWN or NULL */
1622:
1623: assert( pNos>=p->aStack );
1624: if( pTos->flags & MEM_Null ){
1625: v1 = 2;
1626: }else{
1627: Integerify(pTos);
1628: v1 = pTos->i==0;
1629: }
1630: if( pNos->flags & MEM_Null ){
1631: v2 = 2;
1632: }else{
1633: Integerify(pNos);
1634: v2 = pNos->i==0;
1635: }
1636: if( pOp->opcode==OP_And ){
1637: static const unsigned char and_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
1638: v1 = and_logic[v1*3+v2];
1639: }else{
1640: static const unsigned char or_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
1641: v1 = or_logic[v1*3+v2];
1642: }
1643: popStack(&pTos, 2);
1644: pTos++;
1645: if( v1==2 ){
1646: pTos->flags = MEM_Null;
1647: }else{
1648: pTos->i = v1==0;
1649: pTos->flags = MEM_Int;
1650: }
1651: break;
1652: }
1653:
1654: /* Opcode: Negative * * *
1655: **
1656: ** Treat the top of the stack as a numeric quantity. Replace it
1657: ** with its additive inverse. If the top of the stack is NULL
1658: ** its value is unchanged.
1659: */
1660: /* Opcode: AbsValue * * *
1661: **
1662: ** Treat the top of the stack as a numeric quantity. Replace it
1663: ** with its absolute value. If the top of the stack is NULL
1664: ** its value is unchanged.
1665: */
1666: case OP_Negative:
1667: case OP_AbsValue: {
1668: assert( pTos>=p->aStack );
1669: if( pTos->flags & MEM_Real ){
1670: Release(pTos);
1671: if( pOp->opcode==OP_Negative || pTos->r<0.0 ){
1672: pTos->r = -pTos->r;
1673: }
1674: pTos->flags = MEM_Real;
1675: }else if( pTos->flags & MEM_Int ){
1676: Release(pTos);
1677: if( pOp->opcode==OP_Negative || pTos->i<0 ){
1678: pTos->i = -pTos->i;
1679: }
1680: pTos->flags = MEM_Int;
1681: }else if( pTos->flags & MEM_Null ){
1682: /* Do nothing */
1683: }else{
1684: Realify(pTos);
1685: Release(pTos);
1686: if( pOp->opcode==OP_Negative || pTos->r<0.0 ){
1687: pTos->r = -pTos->r;
1688: }
1689: pTos->flags = MEM_Real;
1690: }
1691: break;
1692: }
1693:
1694: /* Opcode: Not * * *
1695: **
1696: ** Interpret the top of the stack as a boolean value. Replace it
1697: ** with its complement. If the top of the stack is NULL its value
1698: ** is unchanged.
1699: */
1700: case OP_Not: {
1701: assert( pTos>=p->aStack );
1702: if( pTos->flags & MEM_Null ) break; /* Do nothing to NULLs */
1703: Integerify(pTos);
1704: Release(pTos);
1705: pTos->i = !pTos->i;
1706: pTos->flags = MEM_Int;
1707: break;
1708: }
1709:
1710: /* Opcode: BitNot * * *
1711: **
1712: ** Interpret the top of the stack as an value. Replace it
1713: ** with its ones-complement. If the top of the stack is NULL its
1714: ** value is unchanged.
1715: */
1716: case OP_BitNot: {
1717: assert( pTos>=p->aStack );
1718: if( pTos->flags & MEM_Null ) break; /* Do nothing to NULLs */
1719: Integerify(pTos);
1720: Release(pTos);
1721: pTos->i = ~pTos->i;
1722: pTos->flags = MEM_Int;
1723: break;
1724: }
1725:
1726: /* Opcode: Noop * * *
1727: **
1728: ** Do nothing. This instruction is often useful as a jump
1729: ** destination.
1730: */
1731: case OP_Noop: {
1732: break;
1733: }
1734:
1735: /* Opcode: If P1 P2 *
1736: **
1737: ** Pop a single boolean from the stack. If the boolean popped is
1738: ** true, then jump to p2. Otherwise continue to the next instruction.
1739: ** An integer is false if zero and true otherwise. A string is
1740: ** false if it has zero length and true otherwise.
1741: **
1742: ** If the value popped of the stack is NULL, then take the jump if P1
1743: ** is true and fall through if P1 is false.
1744: */
1745: /* Opcode: IfNot P1 P2 *
1746: **
1747: ** Pop a single boolean from the stack. If the boolean popped is
1748: ** false, then jump to p2. Otherwise continue to the next instruction.
1749: ** An integer is false if zero and true otherwise. A string is
1750: ** false if it has zero length and true otherwise.
1751: **
1752: ** If the value popped of the stack is NULL, then take the jump if P1
1753: ** is true and fall through if P1 is false.
1754: */
1755: case OP_If:
1756: case OP_IfNot: {
1757: int c;
1758: assert( pTos>=p->aStack );
1759: if( pTos->flags & MEM_Null ){
1760: c = pOp->p1;
1761: }else{
1762: Integerify(pTos);
1763: c = pTos->i;
1764: if( pOp->opcode==OP_IfNot ) c = !c;
1765: }
1766: assert( (pTos->flags & MEM_Dyn)==0 );
1767: pTos--;
1768: if( c ) pc = pOp->p2-1;
1769: break;
1770: }
1771:
1772: /* Opcode: IsNull P1 P2 *
1773: **
1774: ** If any of the top abs(P1) values on the stack are NULL, then jump
1775: ** to P2. Pop the stack P1 times if P1>0. If P1<0 leave the stack
1776: ** unchanged.
1777: */
1778: case OP_IsNull: {
1779: int i, cnt;
1780: Mem *pTerm;
1781: cnt = pOp->p1;
1782: if( cnt<0 ) cnt = -cnt;
1783: pTerm = &pTos[1-cnt];
1784: assert( pTerm>=p->aStack );
1785: for(i=0; i<cnt; i++, pTerm++){
1786: if( pTerm->flags & MEM_Null ){
1787: pc = pOp->p2-1;
1788: break;
1789: }
1790: }
1791: if( pOp->p1>0 ) popStack(&pTos, cnt);
1792: break;
1793: }
1794:
1795: /* Opcode: NotNull P1 P2 *
1796: **
1797: ** Jump to P2 if the top P1 values on the stack are all not NULL. Pop the
1798: ** stack if P1 times if P1 is greater than zero. If P1 is less than
1799: ** zero then leave the stack unchanged.
1800: */
1801: case OP_NotNull: {
1802: int i, cnt;
1803: cnt = pOp->p1;
1804: if( cnt<0 ) cnt = -cnt;
1805: assert( &pTos[1-cnt] >= p->aStack );
1806: for(i=0; i<cnt && (pTos[1+i-cnt].flags & MEM_Null)==0; i++){}
1807: if( i>=cnt ) pc = pOp->p2-1;
1808: if( pOp->p1>0 ) popStack(&pTos, cnt);
1809: break;
1810: }
1811:
1812: /* Opcode: MakeRecord P1 P2 *
1813: **
1814: ** Convert the top P1 entries of the stack into a single entry
1815: ** suitable for use as a data record in a database table. The
1816: ** details of the format are irrelavant as long as the OP_Column
1817: ** opcode can decode the record later. Refer to source code
1818: ** comments for the details of the record format.
1819: **
1820: ** If P2 is true (non-zero) and one or more of the P1 entries
1821: ** that go into building the record is NULL, then add some extra
1822: ** bytes to the record to make it distinct for other entries created
1823: ** during the same run of the VDBE. The extra bytes added are a
1824: ** counter that is reset with each run of the VDBE, so records
1825: ** created this way will not necessarily be distinct across runs.
1826: ** But they should be distinct for transient tables (created using
1827: ** OP_OpenTemp) which is what they are intended for.
1828: **
1829: ** (Later:) The P2==1 option was intended to make NULLs distinct
1830: ** for the UNION operator. But I have since discovered that NULLs
1831: ** are indistinct for UNION. So this option is never used.
1832: */
1833: case OP_MakeRecord: {
1834: char *zNewRecord;
1835: int nByte;
1836: int nField;
1837: int i, j;
1838: int idxWidth;
1839: u32 addr;
1840: Mem *pRec;
1841: int addUnique = 0; /* True to cause bytes to be added to make the
1842: ** generated record distinct */
1843: char zTemp[NBFS]; /* Temp space for small records */
1844:
1845: /* Assuming the record contains N fields, the record format looks
1846: ** like this:
1847: **
1848: ** -------------------------------------------------------------------
1849: ** | idx0 | idx1 | ... | idx(N-1) | idx(N) | data0 | ... | data(N-1) |
1850: ** -------------------------------------------------------------------
1851: **
1852: ** All data fields are converted to strings before being stored and
1853: ** are stored with their null terminators. NULL entries omit the
1854: ** null terminator. Thus an empty string uses 1 byte and a NULL uses
1855: ** zero bytes. Data(0) is taken from the lowest element of the stack
1856: ** and data(N-1) is the top of the stack.
1857: **
1858: ** Each of the idx() entries is either 1, 2, or 3 bytes depending on
1859: ** how big the total record is. Idx(0) contains the offset to the start
1860: ** of data(0). Idx(k) contains the offset to the start of data(k).
1861: ** Idx(N) contains the total number of bytes in the record.
1862: */
1863: nField = pOp->p1;
1864: pRec = &pTos[1-nField];
1865: assert( pRec>=p->aStack );
1866: nByte = 0;
1867: for(i=0; i<nField; i++, pRec++){
1868: if( pRec->flags & MEM_Null ){
1869: addUnique = pOp->p2;
1870: }else{
1871: Stringify(pRec);
1872: nByte += pRec->n;
1873: }
1874: }
1875: if( addUnique ) nByte += sizeof(p->uniqueCnt);
1876: if( nByte + nField + 1 < 256 ){
1877: idxWidth = 1;
1878: }else if( nByte + 2*nField + 2 < 65536 ){
1879: idxWidth = 2;
1880: }else{
1881: idxWidth = 3;
1882: }
1883: nByte += idxWidth*(nField + 1);
1884: if( nByte>MAX_BYTES_PER_ROW ){
1885: rc = SQLITE_TOOBIG;
1886: goto abort_due_to_error;
1887: }
1888: if( nByte<=NBFS ){
1889: zNewRecord = zTemp;
1890: }else{
1891: zNewRecord = sqliteMallocRaw( nByte );
1892: if( zNewRecord==0 ) goto no_mem;
1893: }
1894: j = 0;
1895: addr = idxWidth*(nField+1) + addUnique*sizeof(p->uniqueCnt);
1896: for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){
1897: zNewRecord[j++] = addr & 0xff;
1898: if( idxWidth>1 ){
1899: zNewRecord[j++] = (addr>>8)&0xff;
1900: if( idxWidth>2 ){
1901: zNewRecord[j++] = (addr>>16)&0xff;
1902: }
1903: }
1904: if( (pRec->flags & MEM_Null)==0 ){
1905: addr += pRec->n;
1906: }
1907: }
1908: zNewRecord[j++] = addr & 0xff;
1909: if( idxWidth>1 ){
1910: zNewRecord[j++] = (addr>>8)&0xff;
1911: if( idxWidth>2 ){
1912: zNewRecord[j++] = (addr>>16)&0xff;
1913: }
1914: }
1915: if( addUnique ){
1916: memcpy(&zNewRecord[j], &p->uniqueCnt, sizeof(p->uniqueCnt));
1917: p->uniqueCnt++;
1918: j += sizeof(p->uniqueCnt);
1919: }
1920: for(i=0, pRec=&pTos[1-nField]; i<nField; i++, pRec++){
1921: if( (pRec->flags & MEM_Null)==0 ){
1922: memcpy(&zNewRecord[j], pRec->z, pRec->n);
1923: j += pRec->n;
1924: }
1925: }
1926: popStack(&pTos, nField);
1927: pTos++;
1928: pTos->n = nByte;
1929: if( nByte<=NBFS ){
1930: assert( zNewRecord==zTemp );
1931: memcpy(pTos->zShort, zTemp, nByte);
1932: pTos->z = pTos->zShort;
1933: pTos->flags = MEM_Str | MEM_Short;
1934: }else{
1935: assert( zNewRecord!=zTemp );
1936: pTos->z = zNewRecord;
1937: pTos->flags = MEM_Str | MEM_Dyn;
1938: }
1939: break;
1940: }
1941:
1942: /* Opcode: MakeKey P1 P2 P3
1943: **
1944: ** Convert the top P1 entries of the stack into a single entry suitable
1945: ** for use as the key in an index. The top P1 records are
1946: ** converted to strings and merged. The null-terminators
1947: ** are retained and used as separators.
1948: ** The lowest entry in the stack is the first field and the top of the
1949: ** stack becomes the last.
1950: **
1951: ** If P2 is not zero, then the original entries remain on the stack
1952: ** and the new key is pushed on top. If P2 is zero, the original
1953: ** data is popped off the stack first then the new key is pushed
1954: ** back in its place.
1955: **
1956: ** P3 is a string that is P1 characters long. Each character is either
1957: ** an 'n' or a 't' to indicates if the argument should be intepreted as
1958: ** numeric or text type. The first character of P3 corresponds to the
1959: ** lowest element on the stack. If P3 is NULL then all arguments are
1960: ** assumed to be of the numeric type.
1961: **
1962: ** The type makes a difference in that text-type fields may not be
1963: ** introduced by 'b' (as described in the next paragraph). The
1964: ** first character of a text-type field must be either 'a' (if it is NULL)
1965: ** or 'c'. Numeric fields will be introduced by 'b' if their content
1966: ** looks like a well-formed number. Otherwise the 'a' or 'c' will be
1967: ** used.
1968: **
1969: ** The key is a concatenation of fields. Each field is terminated by
1970: ** a single 0x00 character. A NULL field is introduced by an 'a' and
1971: ** is followed immediately by its 0x00 terminator. A numeric field is
1972: ** introduced by a single character 'b' and is followed by a sequence
1973: ** of characters that represent the number such that a comparison of
1974: ** the character string using memcpy() sorts the numbers in numerical
1975: ** order. The character strings for numbers are generated using the
1976: ** sqliteRealToSortable() function. A text field is introduced by a
1977: ** 'c' character and is followed by the exact text of the field. The
1978: ** use of an 'a', 'b', or 'c' character at the beginning of each field
1979: ** guarantees that NULLs sort before numbers and that numbers sort
1980: ** before text. 0x00 characters do not occur except as separators
1981: ** between fields.
1982: **
1983: ** See also: MakeIdxKey, SortMakeKey
1984: */
1985: /* Opcode: MakeIdxKey P1 P2 P3
1986: **
1987: ** Convert the top P1 entries of the stack into a single entry suitable
1988: ** for use as the key in an index. In addition, take one additional integer
1989: ** off of the stack, treat that integer as a four-byte record number, and
1990: ** append the four bytes to the key. Thus a total of P1+1 entries are
1991: ** popped from the stack for this instruction and a single entry is pushed
1992: ** back. The first P1 entries that are popped are strings and the last
1993: ** entry (the lowest on the stack) is an integer record number.
1994: **
1995: ** The converstion of the first P1 string entries occurs just like in
1996: ** MakeKey. Each entry is separated from the others by a null.
1997: ** The entire concatenation is null-terminated. The lowest entry
1998: ** in the stack is the first field and the top of the stack becomes the
1999: ** last.
2000: **
2001: ** If P2 is not zero and one or more of the P1 entries that go into the
2002: ** generated key is NULL, then jump to P2 after the new key has been
2003: ** pushed on the stack. In other words, jump to P2 if the key is
2004: ** guaranteed to be unique. This jump can be used to skip a subsequent
2005: ** uniqueness test.
2006: **
2007: ** P3 is a string that is P1 characters long. Each character is either
2008: ** an 'n' or a 't' to indicates if the argument should be numeric or
2009: ** text. The first character corresponds to the lowest element on the
2010: ** stack. If P3 is null then all arguments are assumed to be numeric.
2011: **
2012: ** See also: MakeKey, SortMakeKey
2013: */
2014: case OP_MakeIdxKey:
2015: case OP_MakeKey: {
2016: char *zNewKey;
2017: int nByte;
2018: int nField;
2019: int addRowid;
2020: int i, j;
2021: int containsNull = 0;
2022: Mem *pRec;
2023: char zTemp[NBFS];
2024:
2025: addRowid = pOp->opcode==OP_MakeIdxKey;
2026: nField = pOp->p1;
2027: pRec = &pTos[1-nField];
2028: assert( pRec>=p->aStack );
2029: nByte = 0;
2030: for(j=0, i=0; i<nField; i++, j++, pRec++){
2031: int flags = pRec->flags;
2032: int len;
2033: char *z;
2034: if( flags & MEM_Null ){
2035: nByte += 2;
2036: containsNull = 1;
2037: }else if( pOp->p3 && pOp->p3[j]=='t' ){
2038: Stringify(pRec);
2039: pRec->flags &= ~(MEM_Int|MEM_Real);
2040: nByte += pRec->n+1;
2041: }else if( (flags & (MEM_Real|MEM_Int))!=0 || sqliteIsNumber(pRec->z) ){
2042: if( (flags & (MEM_Real|MEM_Int))==MEM_Int ){
2043: pRec->r = pRec->i;
2044: }else if( (flags & (MEM_Real|MEM_Int))==0 ){
2045: pRec->r = sqliteAtoF(pRec->z, 0);
2046: }
2047: Release(pRec);
2048: z = pRec->zShort;
2049: sqliteRealToSortable(pRec->r, z);
2050: len = strlen(z);
2051: pRec->z = 0;
2052: pRec->flags = MEM_Real;
2053: pRec->n = len+1;
2054: nByte += pRec->n+1;
2055: }else{
2056: nByte += pRec->n+1;
2057: }
2058: }
2059: if( nByte+sizeof(u32)>MAX_BYTES_PER_ROW ){
2060: rc = SQLITE_TOOBIG;
2061: goto abort_due_to_error;
2062: }
2063: if( addRowid ) nByte += sizeof(u32);
2064: if( nByte<=NBFS ){
2065: zNewKey = zTemp;
2066: }else{
2067: zNewKey = sqliteMallocRaw( nByte );
2068: if( zNewKey==0 ) goto no_mem;
2069: }
2070: j = 0;
2071: pRec = &pTos[1-nField];
2072: for(i=0; i<nField; i++, pRec++){
2073: if( pRec->flags & MEM_Null ){
2074: zNewKey[j++] = 'a';
2075: zNewKey[j++] = 0;
2076: }else if( pRec->flags==MEM_Real ){
2077: zNewKey[j++] = 'b';
2078: memcpy(&zNewKey[j], pRec->zShort, pRec->n);
2079: j += pRec->n;
2080: }else{
2081: assert( pRec->flags & MEM_Str );
2082: zNewKey[j++] = 'c';
2083: memcpy(&zNewKey[j], pRec->z, pRec->n);
2084: j += pRec->n;
2085: }
2086: }
2087: if( addRowid ){
2088: u32 iKey;
2089: pRec = &pTos[-nField];
2090: assert( pRec>=p->aStack );
2091: Integerify(pRec);
2092: iKey = intToKey(pRec->i);
2093: memcpy(&zNewKey[j], &iKey, sizeof(u32));
2094: popStack(&pTos, nField+1);
2095: if( pOp->p2 && containsNull ) pc = pOp->p2 - 1;
2096: }else{
2097: if( pOp->p2==0 ) popStack(&pTos, nField);
2098: }
2099: pTos++;
2100: pTos->n = nByte;
2101: if( nByte<=NBFS ){
2102: assert( zNewKey==zTemp );
2103: pTos->z = pTos->zShort;
2104: memcpy(pTos->zShort, zTemp, nByte);
2105: pTos->flags = MEM_Str | MEM_Short;
2106: }else{
2107: pTos->z = zNewKey;
2108: pTos->flags = MEM_Str | MEM_Dyn;
2109: }
2110: break;
2111: }
2112:
2113: /* Opcode: IncrKey * * *
2114: **
2115: ** The top of the stack should contain an index key generated by
2116: ** The MakeKey opcode. This routine increases the least significant
2117: ** byte of that key by one. This is used so that the MoveTo opcode
2118: ** will move to the first entry greater than the key rather than to
2119: ** the key itself.
2120: */
2121: case OP_IncrKey: {
2122: assert( pTos>=p->aStack );
2123: /* The IncrKey opcode is only applied to keys generated by
2124: ** MakeKey or MakeIdxKey and the results of those operands
2125: ** are always dynamic strings or zShort[] strings. So we
2126: ** are always free to modify the string in place.
2127: */
2128: assert( pTos->flags & (MEM_Dyn|MEM_Short) );
2129: pTos->z[pTos->n-1]++;
2130: break;
2131: }
2132:
2133: /* Opcode: Checkpoint P1 * *
2134: **
2135: ** Begin a checkpoint. A checkpoint is the beginning of a operation that
2136: ** is part of a larger transaction but which might need to be rolled back
2137: ** itself without effecting the containing transaction. A checkpoint will
2138: ** be automatically committed or rollback when the VDBE halts.
2139: **
2140: ** The checkpoint is begun on the database file with index P1. The main
2141: ** database file has an index of 0 and the file used for temporary tables
2142: ** has an index of 1.
2143: */
2144: case OP_Checkpoint: {
2145: int i = pOp->p1;
2146: if( i>=0 && i<db->nDb && db->aDb[i].pBt && db->aDb[i].inTrans==1 ){
2147: rc = sqliteBtreeBeginCkpt(db->aDb[i].pBt);
2148: if( rc==SQLITE_OK ) db->aDb[i].inTrans = 2;
2149: }
2150: break;
2151: }
2152:
2153: /* Opcode: Transaction P1 * *
2154: **
2155: ** Begin a transaction. The transaction ends when a Commit or Rollback
2156: ** opcode is encountered. Depending on the ON CONFLICT setting, the
2157: ** transaction might also be rolled back if an error is encountered.
2158: **
2159: ** P1 is the index of the database file on which the transaction is
2160: ** started. Index 0 is the main database file and index 1 is the
2161: ** file used for temporary tables.
2162: **
2163: ** A write lock is obtained on the database file when a transaction is
2164: ** started. No other process can read or write the file while the
2165: ** transaction is underway. Starting a transaction also creates a
2166: ** rollback journal. A transaction must be started before any changes
2167: ** can be made to the database.
2168: */
2169: case OP_Transaction: {
2170: int busy = 1;
2171: int i = pOp->p1;
2172: assert( i>=0 && i<db->nDb );
2173: if( db->aDb[i].inTrans ) break;
2174: while( db->aDb[i].pBt!=0 && busy ){
2175: rc = sqliteBtreeBeginTrans(db->aDb[i].pBt);
2176: switch( rc ){
2177: case SQLITE_BUSY: {
2178: if( db->xBusyCallback==0 ){
2179: p->pc = pc;
2180: p->undoTransOnError = 1;
2181: p->rc = SQLITE_BUSY;
2182: p->pTos = pTos;
2183: return SQLITE_BUSY;
2184: }else if( (*db->xBusyCallback)(db->pBusyArg, "", busy++)==0 ){
2185: sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
2186: busy = 0;
2187: }
2188: break;
2189: }
2190: case SQLITE_READONLY: {
2191: rc = SQLITE_OK;
2192: /* Fall thru into the next case */
2193: }
2194: case SQLITE_OK: {
2195: p->inTempTrans = 0;
2196: busy = 0;
2197: break;
2198: }
2199: default: {
2200: goto abort_due_to_error;
2201: }
2202: }
2203: }
2204: db->aDb[i].inTrans = 1;
2205: p->undoTransOnError = 1;
2206: break;
2207: }
2208:
2209: /* Opcode: Commit * * *
2210: **
2211: ** Cause all modifications to the database that have been made since the
2212: ** last Transaction to actually take effect. No additional modifications
2213: ** are allowed until another transaction is started. The Commit instruction
2214: ** deletes the journal file and releases the write lock on the database.
2215: ** A read lock continues to be held if there are still cursors open.
2216: */
2217: case OP_Commit: {
2218: int i;
2219: if( db->xCommitCallback!=0 ){
2220: if( sqliteSafetyOff(db) ) goto abort_due_to_misuse;
2221: if( db->xCommitCallback(db->pCommitArg)!=0 ){
2222: rc = SQLITE_CONSTRAINT;
2223: }
2224: if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
2225: }
2226: for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
2227: if( db->aDb[i].inTrans ){
2228: rc = sqliteBtreeCommit(db->aDb[i].pBt);
2229: db->aDb[i].inTrans = 0;
2230: }
2231: }
2232: if( rc==SQLITE_OK ){
2233: sqliteCommitInternalChanges(db);
2234: }else{
2235: sqliteRollbackAll(db);
2236: }
2237: break;
2238: }
2239:
2240: /* Opcode: Rollback P1 * *
2241: **
2242: ** Cause all modifications to the database that have been made since the
2243: ** last Transaction to be undone. The database is restored to its state
2244: ** before the Transaction opcode was executed. No additional modifications
2245: ** are allowed until another transaction is started.
2246: **
2247: ** P1 is the index of the database file that is committed. An index of 0
2248: ** is used for the main database and an index of 1 is used for the file used
2249: ** to hold temporary tables.
2250: **
2251: ** This instruction automatically closes all cursors and releases both
2252: ** the read and write locks on the indicated database.
2253: */
2254: case OP_Rollback: {
2255: sqliteRollbackAll(db);
2256: break;
2257: }
2258:
2259: /* Opcode: ReadCookie P1 P2 *
2260: **
2261: ** Read cookie number P2 from database P1 and push it onto the stack.
2262: ** P2==0 is the schema version. P2==1 is the database format.
2263: ** P2==2 is the recommended pager cache size, and so forth. P1==0 is
2264: ** the main database file and P1==1 is the database file used to store
2265: ** temporary tables.
2266: **
2267: ** There must be a read-lock on the database (either a transaction
2268: ** must be started or there must be an open cursor) before
2269: ** executing this instruction.
2270: */
2271: case OP_ReadCookie: {
2272: int aMeta[SQLITE_N_BTREE_META];
2273: assert( pOp->p2<SQLITE_N_BTREE_META );
2274: assert( pOp->p1>=0 && pOp->p1<db->nDb );
2275: assert( db->aDb[pOp->p1].pBt!=0 );
2276: rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
2277: pTos++;
2278: pTos->i = aMeta[1+pOp->p2];
2279: pTos->flags = MEM_Int;
2280: break;
2281: }
2282:
2283: /* Opcode: SetCookie P1 P2 *
2284: **
2285: ** Write the top of the stack into cookie number P2 of database P1.
2286: ** P2==0 is the schema version. P2==1 is the database format.
2287: ** P2==2 is the recommended pager cache size, and so forth. P1==0 is
2288: ** the main database file and P1==1 is the database file used to store
2289: ** temporary tables.
2290: **
2291: ** A transaction must be started before executing this opcode.
2292: */
2293: case OP_SetCookie: {
2294: int aMeta[SQLITE_N_BTREE_META];
2295: assert( pOp->p2<SQLITE_N_BTREE_META );
2296: assert( pOp->p1>=0 && pOp->p1<db->nDb );
2297: assert( db->aDb[pOp->p1].pBt!=0 );
2298: assert( pTos>=p->aStack );
2299: Integerify(pTos)
2300: rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
2301: if( rc==SQLITE_OK ){
2302: aMeta[1+pOp->p2] = pTos->i;
2303: rc = sqliteBtreeUpdateMeta(db->aDb[pOp->p1].pBt, aMeta);
2304: }
2305: Release(pTos);
2306: pTos--;
2307: break;
2308: }
2309:
2310: /* Opcode: VerifyCookie P1 P2 *
2311: **
2312: ** Check the value of global database parameter number 0 (the
2313: ** schema version) and make sure it is equal to P2.
2314: ** P1 is the database number which is 0 for the main database file
2315: ** and 1 for the file holding temporary tables and some higher number
2316: ** for auxiliary databases.
2317: **
2318: ** The cookie changes its value whenever the database schema changes.
2319: ** This operation is used to detect when that the cookie has changed
2320: ** and that the current process needs to reread the schema.
2321: **
2322: ** Either a transaction needs to have been started or an OP_Open needs
2323: ** to be executed (to establish a read lock) before this opcode is
2324: ** invoked.
2325: */
2326: case OP_VerifyCookie: {
2327: int aMeta[SQLITE_N_BTREE_META];
2328: assert( pOp->p1>=0 && pOp->p1<db->nDb );
2329: rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
2330: if( rc==SQLITE_OK && aMeta[1]!=pOp->p2 ){
2331: sqliteSetString(&p->zErrMsg, "database schema has changed", (char*)0);
2332: rc = SQLITE_SCHEMA;
2333: }
2334: break;
2335: }
2336:
2337: /* Opcode: OpenRead P1 P2 P3
2338: **
2339: ** Open a read-only cursor for the database table whose root page is
2340: ** P2 in a database file. The database file is determined by an
2341: ** integer from the top of the stack. 0 means the main database and
2342: ** 1 means the database used for temporary tables. Give the new
2343: ** cursor an identifier of P1. The P1 values need not be contiguous
2344: ** but all P1 values should be small integers. It is an error for
2345: ** P1 to be negative.
2346: **
2347: ** If P2==0 then take the root page number from the next of the stack.
2348: **
2349: ** There will be a read lock on the database whenever there is an
2350: ** open cursor. If the database was unlocked prior to this instruction
2351: ** then a read lock is acquired as part of this instruction. A read
2352: ** lock allows other processes to read the database but prohibits
2353: ** any other process from modifying the database. The read lock is
2354: ** released when all cursors are closed. If this instruction attempts
2355: ** to get a read lock but fails, the script terminates with an
2356: ** SQLITE_BUSY error code.
2357: **
2358: ** The P3 value is the name of the table or index being opened.
2359: ** The P3 value is not actually used by this opcode and may be
2360: ** omitted. But the code generator usually inserts the index or
2361: ** table name into P3 to make the code easier to read.
2362: **
2363: ** See also OpenWrite.
2364: */
2365: /* Opcode: OpenWrite P1 P2 P3
2366: **
2367: ** Open a read/write cursor named P1 on the table or index whose root
2368: ** page is P2. If P2==0 then take the root page number from the stack.
2369: **
2370: ** The P3 value is the name of the table or index being opened.
2371: ** The P3 value is not actually used by this opcode and may be
2372: ** omitted. But the code generator usually inserts the index or
2373: ** table name into P3 to make the code easier to read.
2374: **
2375: ** This instruction works just like OpenRead except that it opens the cursor
2376: ** in read/write mode. For a given table, there can be one or more read-only
2377: ** cursors or a single read/write cursor but not both.
2378: **
2379: ** See also OpenRead.
2380: */
2381: case OP_OpenRead:
2382: case OP_OpenWrite: {
2383: int busy = 0;
2384: int i = pOp->p1;
2385: int p2 = pOp->p2;
2386: int wrFlag;
2387: Btree *pX;
2388: int iDb;
2389:
2390: assert( pTos>=p->aStack );
2391: Integerify(pTos);
2392: iDb = pTos->i;
2393: pTos--;
2394: assert( iDb>=0 && iDb<db->nDb );
2395: pX = db->aDb[iDb].pBt;
2396: assert( pX!=0 );
2397: wrFlag = pOp->opcode==OP_OpenWrite;
2398: if( p2<=0 ){
2399: assert( pTos>=p->aStack );
2400: Integerify(pTos);
2401: p2 = pTos->i;
2402: pTos--;
2403: if( p2<2 ){
2404: sqliteSetString(&p->zErrMsg, "root page number less than 2", (char*)0);
2405: rc = SQLITE_INTERNAL;
2406: break;
2407: }
2408: }
2409: assert( i>=0 );
2410: if( expandCursorArraySize(p, i) ) goto no_mem;
2411: sqliteVdbeCleanupCursor(&p->aCsr[i]);
2412: memset(&p->aCsr[i], 0, sizeof(Cursor));
2413: p->aCsr[i].nullRow = 1;
2414: if( pX==0 ) break;
2415: do{
2416: rc = sqliteBtreeCursor(pX, p2, wrFlag, &p->aCsr[i].pCursor);
2417: switch( rc ){
2418: case SQLITE_BUSY: {
2419: if( db->xBusyCallback==0 ){
2420: p->pc = pc;
2421: p->rc = SQLITE_BUSY;
2422: p->pTos = &pTos[1 + (pOp->p2<=0)]; /* Operands must remain on stack */
2423: return SQLITE_BUSY;
2424: }else if( (*db->xBusyCallback)(db->pBusyArg, pOp->p3, ++busy)==0 ){
2425: sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
2426: busy = 0;
2427: }
2428: break;
2429: }
2430: case SQLITE_OK: {
2431: busy = 0;
2432: break;
2433: }
2434: default: {
2435: goto abort_due_to_error;
2436: }
2437: }
2438: }while( busy );
2439: break;
2440: }
2441:
2442: /* Opcode: OpenTemp P1 P2 *
2443: **
2444: ** Open a new cursor to a transient table.
2445: ** The transient cursor is always opened read/write even if
2446: ** the main database is read-only. The transient table is deleted
2447: ** automatically when the cursor is closed.
2448: **
2449: ** The cursor points to a BTree table if P2==0 and to a BTree index
2450: ** if P2==1. A BTree table must have an integer key and can have arbitrary
2451: ** data. A BTree index has no data but can have an arbitrary key.
2452: **
2453: ** This opcode is used for tables that exist for the duration of a single
2454: ** SQL statement only. Tables created using CREATE TEMPORARY TABLE
2455: ** are opened using OP_OpenRead or OP_OpenWrite. "Temporary" in the
2456: ** context of this opcode means for the duration of a single SQL statement
2457: ** whereas "Temporary" in the context of CREATE TABLE means for the duration
2458: ** of the connection to the database. Same word; different meanings.
2459: */
2460: case OP_OpenTemp: {
2461: int i = pOp->p1;
2462: Cursor *pCx;
2463: assert( i>=0 );
2464: if( expandCursorArraySize(p, i) ) goto no_mem;
2465: pCx = &p->aCsr[i];
2466: sqliteVdbeCleanupCursor(pCx);
2467: memset(pCx, 0, sizeof(*pCx));
2468: pCx->nullRow = 1;
2469: rc = sqliteBtreeFactory(db, 0, 1, TEMP_PAGES, &pCx->pBt);
2470:
2471: if( rc==SQLITE_OK ){
2472: rc = sqliteBtreeBeginTrans(pCx->pBt);
2473: }
2474: if( rc==SQLITE_OK ){
2475: if( pOp->p2 ){
2476: int pgno;
2477: rc = sqliteBtreeCreateIndex(pCx->pBt, &pgno);
2478: if( rc==SQLITE_OK ){
2479: rc = sqliteBtreeCursor(pCx->pBt, pgno, 1, &pCx->pCursor);
2480: }
2481: }else{
2482: rc = sqliteBtreeCursor(pCx->pBt, 2, 1, &pCx->pCursor);
2483: }
2484: }
2485: break;
2486: }
2487:
2488: /* Opcode: OpenPseudo P1 * *
2489: **
2490: ** Open a new cursor that points to a fake table that contains a single
2491: ** row of data. Any attempt to write a second row of data causes the
2492: ** first row to be deleted. All data is deleted when the cursor is
2493: ** closed.
2494: **
2495: ** A pseudo-table created by this opcode is useful for holding the
2496: ** NEW or OLD tables in a trigger.
2497: */
2498: case OP_OpenPseudo: {
2499: int i = pOp->p1;
2500: Cursor *pCx;
2501: assert( i>=0 );
2502: if( expandCursorArraySize(p, i) ) goto no_mem;
2503: pCx = &p->aCsr[i];
2504: sqliteVdbeCleanupCursor(pCx);
2505: memset(pCx, 0, sizeof(*pCx));
2506: pCx->nullRow = 1;
2507: pCx->pseudoTable = 1;
2508: break;
2509: }
2510:
2511: /* Opcode: Close P1 * *
2512: **
2513: ** Close a cursor previously opened as P1. If P1 is not
2514: ** currently open, this instruction is a no-op.
2515: */
2516: case OP_Close: {
2517: int i = pOp->p1;
2518: if( i>=0 && i<p->nCursor ){
2519: sqliteVdbeCleanupCursor(&p->aCsr[i]);
2520: }
2521: break;
2522: }
2523:
2524: /* Opcode: MoveTo P1 P2 *
2525: **
2526: ** Pop the top of the stack and use its value as a key. Reposition
2527: ** cursor P1 so that it points to an entry with a matching key. If
2528: ** the table contains no record with a matching key, then the cursor
2529: ** is left pointing at the first record that is greater than the key.
2530: ** If there are no records greater than the key and P2 is not zero,
2531: ** then an immediate jump to P2 is made.
2532: **
2533: ** See also: Found, NotFound, Distinct, MoveLt
2534: */
2535: /* Opcode: MoveLt P1 P2 *
2536: **
2537: ** Pop the top of the stack and use its value as a key. Reposition
2538: ** cursor P1 so that it points to the entry with the largest key that is
2539: ** less than the key popped from the stack.
2540: ** If there are no records less than than the key and P2
2541: ** is not zero then an immediate jump to P2 is made.
2542: **
2543: ** See also: MoveTo
2544: */
2545: case OP_MoveLt:
2546: case OP_MoveTo: {
2547: int i = pOp->p1;
2548: Cursor *pC;
2549:
2550: assert( pTos>=p->aStack );
2551: assert( i>=0 && i<p->nCursor );
2552: pC = &p->aCsr[i];
2553: if( pC->pCursor!=0 ){
2554: int res, oc;
2555: pC->nullRow = 0;
2556: if( pTos->flags & MEM_Int ){
2557: int iKey = intToKey(pTos->i);
2558: if( pOp->p2==0 && pOp->opcode==OP_MoveTo ){
2559: pC->movetoTarget = iKey;
2560: pC->deferredMoveto = 1;
2561: Release(pTos);
2562: pTos--;
2563: break;
2564: }
2565: sqliteBtreeMoveto(pC->pCursor, (char*)&iKey, sizeof(int), &res);
2566: pC->lastRecno = pTos->i;
2567: pC->recnoIsValid = res==0;
2568: }else{
2569: Stringify(pTos);
2570: sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res);
2571: pC->recnoIsValid = 0;
2572: }
2573: pC->deferredMoveto = 0;
2574: sqlite_search_count++;
2575: oc = pOp->opcode;
2576: if( oc==OP_MoveTo && res<0 ){
2577: sqliteBtreeNext(pC->pCursor, &res);
2578: pC->recnoIsValid = 0;
2579: if( res && pOp->p2>0 ){
2580: pc = pOp->p2 - 1;
2581: }
2582: }else if( oc==OP_MoveLt ){
2583: if( res>=0 ){
2584: sqliteBtreePrevious(pC->pCursor, &res);
2585: pC->recnoIsValid = 0;
2586: }else{
2587: /* res might be negative because the table is empty. Check to
2588: ** see if this is the case.
2589: */
2590: int keysize;
2591: res = sqliteBtreeKeySize(pC->pCursor,&keysize)!=0 || keysize==0;
2592: }
2593: if( res && pOp->p2>0 ){
2594: pc = pOp->p2 - 1;
2595: }
2596: }
2597: }
2598: Release(pTos);
2599: pTos--;
2600: break;
2601: }
2602:
2603: /* Opcode: Distinct P1 P2 *
2604: **
2605: ** Use the top of the stack as a string key. If a record with that key does
2606: ** not exist in the table of cursor P1, then jump to P2. If the record
2607: ** does already exist, then fall thru. The cursor is left pointing
2608: ** at the record if it exists. The key is not popped from the stack.
2609: **
2610: ** This operation is similar to NotFound except that this operation
2611: ** does not pop the key from the stack.
2612: **
2613: ** See also: Found, NotFound, MoveTo, IsUnique, NotExists
2614: */
2615: /* Opcode: Found P1 P2 *
2616: **
2617: ** Use the top of the stack as a string key. If a record with that key
2618: ** does exist in table of P1, then jump to P2. If the record
2619: ** does not exist, then fall thru. The cursor is left pointing
2620: ** to the record if it exists. The key is popped from the stack.
2621: **
2622: ** See also: Distinct, NotFound, MoveTo, IsUnique, NotExists
2623: */
2624: /* Opcode: NotFound P1 P2 *
2625: **
2626: ** Use the top of the stack as a string key. If a record with that key
2627: ** does not exist in table of P1, then jump to P2. If the record
2628: ** does exist, then fall thru. The cursor is left pointing to the
2629: ** record if it exists. The key is popped from the stack.
2630: **
2631: ** The difference between this operation and Distinct is that
2632: ** Distinct does not pop the key from the stack.
2633: **
2634: ** See also: Distinct, Found, MoveTo, NotExists, IsUnique
2635: */
2636: case OP_Distinct:
2637: case OP_NotFound:
2638: case OP_Found: {
2639: int i = pOp->p1;
2640: int alreadyExists = 0;
2641: Cursor *pC;
2642: assert( pTos>=p->aStack );
2643: assert( i>=0 && i<p->nCursor );
2644: if( (pC = &p->aCsr[i])->pCursor!=0 ){
2645: int res, rx;
2646: Stringify(pTos);
2647: rx = sqliteBtreeMoveto(pC->pCursor, pTos->z, pTos->n, &res);
2648: alreadyExists = rx==SQLITE_OK && res==0;
2649: pC->deferredMoveto = 0;
2650: }
2651: if( pOp->opcode==OP_Found ){
2652: if( alreadyExists ) pc = pOp->p2 - 1;
2653: }else{
2654: if( !alreadyExists ) pc = pOp->p2 - 1;
2655: }
2656: if( pOp->opcode!=OP_Distinct ){
2657: Release(pTos);
2658: pTos--;
2659: }
2660: break;
2661: }
2662:
2663: /* Opcode: IsUnique P1 P2 *
2664: **
2665: ** The top of the stack is an integer record number. Call this
2666: ** record number R. The next on the stack is an index key created
2667: ** using MakeIdxKey. Call it K. This instruction pops R from the
2668: ** stack but it leaves K unchanged.
2669: **
2670: ** P1 is an index. So all but the last four bytes of K are an
2671: ** index string. The last four bytes of K are a record number.
2672: **
2673: ** This instruction asks if there is an entry in P1 where the
2674: ** index string matches K but the record number is different
2675: ** from R. If there is no such entry, then there is an immediate
2676: ** jump to P2. If any entry does exist where the index string
2677: ** matches K but the record number is not R, then the record
2678: ** number for that entry is pushed onto the stack and control
2679: ** falls through to the next instruction.
2680: **
2681: ** See also: Distinct, NotFound, NotExists, Found
2682: */
2683: case OP_IsUnique: {
2684: int i = pOp->p1;
2685: Mem *pNos = &pTos[-1];
2686: BtCursor *pCrsr;
2687: int R;
2688:
2689: /* Pop the value R off the top of the stack
2690: */
2691: assert( pNos>=p->aStack );
2692: Integerify(pTos);
2693: R = pTos->i;
2694: pTos--;
2695: assert( i>=0 && i<=p->nCursor );
2696: if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
2697: int res, rc;
2698: int v; /* The record number on the P1 entry that matches K */
2699: char *zKey; /* The value of K */
2700: int nKey; /* Number of bytes in K */
2701:
2702: /* Make sure K is a string and make zKey point to K
2703: */
2704: Stringify(pNos);
2705: zKey = pNos->z;
2706: nKey = pNos->n;
2707: assert( nKey >= 4 );
2708:
2709: /* Search for an entry in P1 where all but the last four bytes match K.
2710: ** If there is no such entry, jump immediately to P2.
2711: */
2712: assert( p->aCsr[i].deferredMoveto==0 );
2713: rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res);
2714: if( rc!=SQLITE_OK ) goto abort_due_to_error;
2715: if( res<0 ){
2716: rc = sqliteBtreeNext(pCrsr, &res);
2717: if( res ){
2718: pc = pOp->p2 - 1;
2719: break;
2720: }
2721: }
2722: rc = sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &res);
2723: if( rc!=SQLITE_OK ) goto abort_due_to_error;
2724: if( res>0 ){
2725: pc = pOp->p2 - 1;
2726: break;
2727: }
2728:
2729: /* At this point, pCrsr is pointing to an entry in P1 where all but
2730: ** the last for bytes of the key match K. Check to see if the last
2731: ** four bytes of the key are different from R. If the last four
2732: ** bytes equal R then jump immediately to P2.
2733: */
2734: sqliteBtreeKey(pCrsr, nKey - 4, 4, (char*)&v);
2735: v = keyToInt(v);
2736: if( v==R ){
2737: pc = pOp->p2 - 1;
2738: break;
2739: }
2740:
2741: /* The last four bytes of the key are different from R. Convert the
2742: ** last four bytes of the key into an integer and push it onto the
2743: ** stack. (These bytes are the record number of an entry that
2744: ** violates a UNIQUE constraint.)
2745: */
2746: pTos++;
2747: pTos->i = v;
2748: pTos->flags = MEM_Int;
2749: }
2750: break;
2751: }
2752:
2753: /* Opcode: NotExists P1 P2 *
2754: **
2755: ** Use the top of the stack as a integer key. If a record with that key
2756: ** does not exist in table of P1, then jump to P2. If the record
2757: ** does exist, then fall thru. The cursor is left pointing to the
2758: ** record if it exists. The integer key is popped from the stack.
2759: **
2760: ** The difference between this operation and NotFound is that this
2761: ** operation assumes the key is an integer and NotFound assumes it
2762: ** is a string.
2763: **
2764: ** See also: Distinct, Found, MoveTo, NotFound, IsUnique
2765: */
2766: case OP_NotExists: {
2767: int i = pOp->p1;
2768: BtCursor *pCrsr;
2769: assert( pTos>=p->aStack );
2770: assert( i>=0 && i<p->nCursor );
2771: if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
2772: int res, rx, iKey;
2773: assert( pTos->flags & MEM_Int );
2774: iKey = intToKey(pTos->i);
2775: rx = sqliteBtreeMoveto(pCrsr, (char*)&iKey, sizeof(int), &res);
2776: p->aCsr[i].lastRecno = pTos->i;
2777: p->aCsr[i].recnoIsValid = res==0;
2778: p->aCsr[i].nullRow = 0;
2779: if( rx!=SQLITE_OK || res!=0 ){
2780: pc = pOp->p2 - 1;
2781: p->aCsr[i].recnoIsValid = 0;
2782: }
2783: }
2784: Release(pTos);
2785: pTos--;
2786: break;
2787: }
2788:
2789: /* Opcode: NewRecno P1 * *
2790: **
2791: ** Get a new integer record number used as the key to a table.
2792: ** The record number is not previously used as a key in the database
2793: ** table that cursor P1 points to. The new record number is pushed
2794: ** onto the stack.
2795: */
2796: case OP_NewRecno: {
2797: int i = pOp->p1;
2798: int v = 0;
2799: Cursor *pC;
2800: assert( i>=0 && i<p->nCursor );
2801: if( (pC = &p->aCsr[i])->pCursor==0 ){
2802: v = 0;
2803: }else{
2804: /* The next rowid or record number (different terms for the same
2805: ** thing) is obtained in a two-step algorithm.
2806: **
2807: ** First we attempt to find the largest existing rowid and add one
2808: ** to that. But if the largest existing rowid is already the maximum
2809: ** positive integer, we have to fall through to the second
2810: ** probabilistic algorithm
2811: **
2812: ** The second algorithm is to select a rowid at random and see if
2813: ** it already exists in the table. If it does not exist, we have
2814: ** succeeded. If the random rowid does exist, we select a new one
2815: ** and try again, up to 1000 times.
2816: **
2817: ** For a table with less than 2 billion entries, the probability
2818: ** of not finding a unused rowid is about 1.0e-300. This is a
2819: ** non-zero probability, but it is still vanishingly small and should
2820: ** never cause a problem. You are much, much more likely to have a
2821: ** hardware failure than for this algorithm to fail.
2822: **
2823: ** The analysis in the previous paragraph assumes that you have a good
2824: ** source of random numbers. Is a library function like lrand48()
2825: ** good enough? Maybe. Maybe not. It's hard to know whether there
2826: ** might be subtle bugs is some implementations of lrand48() that
2827: ** could cause problems. To avoid uncertainty, SQLite uses its own
2828: ** random number generator based on the RC4 algorithm.
2829: **
2830: ** To promote locality of reference for repetitive inserts, the
2831: ** first few attempts at chosing a random rowid pick values just a little
2832: ** larger than the previous rowid. This has been shown experimentally
2833: ** to double the speed of the COPY operation.
2834: */
2835: int res, rx, cnt, x;
2836: cnt = 0;
2837: if( !pC->useRandomRowid ){
2838: if( pC->nextRowidValid ){
2839: v = pC->nextRowid;
2840: }else{
2841: rx = sqliteBtreeLast(pC->pCursor, &res);
2842: if( res ){
2843: v = 1;
2844: }else{
2845: sqliteBtreeKey(pC->pCursor, 0, sizeof(v), (void*)&v);
2846: v = keyToInt(v);
2847: if( v==0x7fffffff ){
2848: pC->useRandomRowid = 1;
2849: }else{
2850: v++;
2851: }
2852: }
2853: }
2854: if( v<0x7fffffff ){
2855: pC->nextRowidValid = 1;
2856: pC->nextRowid = v+1;
2857: }else{
2858: pC->nextRowidValid = 0;
2859: }
2860: }
2861: if( pC->useRandomRowid ){
2862: v = db->priorNewRowid;
2863: cnt = 0;
2864: do{
2865: if( v==0 || cnt>2 ){
2866: sqliteRandomness(sizeof(v), &v);
2867: if( cnt<5 ) v &= 0xffffff;
2868: }else{
2869: unsigned char r;
2870: sqliteRandomness(1, &r);
2871: v += r + 1;
2872: }
2873: if( v==0 ) continue;
2874: x = intToKey(v);
2875: rx = sqliteBtreeMoveto(pC->pCursor, &x, sizeof(int), &res);
2876: cnt++;
2877: }while( cnt<1000 && rx==SQLITE_OK && res==0 );
2878: db->priorNewRowid = v;
2879: if( rx==SQLITE_OK && res==0 ){
2880: rc = SQLITE_FULL;
2881: goto abort_due_to_error;
2882: }
2883: }
2884: pC->recnoIsValid = 0;
2885: pC->deferredMoveto = 0;
2886: }
2887: pTos++;
2888: pTos->i = v;
2889: pTos->flags = MEM_Int;
2890: break;
2891: }
2892:
2893: /* Opcode: PutIntKey P1 P2 *
2894: **
2895: ** Write an entry into the table of cursor P1. A new entry is
2896: ** created if it doesn't already exist or the data for an existing
2897: ** entry is overwritten. The data is the value on the top of the
2898: ** stack. The key is the next value down on the stack. The key must
2899: ** be an integer. The stack is popped twice by this instruction.
2900: **
2901: ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
2902: ** incremented (otherwise not). If the OPFLAG_CSCHANGE flag is set,
2903: ** then the current statement change count is incremented (otherwise not).
2904: ** If the OPFLAG_LASTROWID flag of P2 is set, then rowid is
2905: ** stored for subsequent return by the sqlite_last_insert_rowid() function
2906: ** (otherwise it's unmodified).
2907: */
2908: /* Opcode: PutStrKey P1 * *
2909: **
2910: ** Write an entry into the table of cursor P1. A new entry is
2911: ** created if it doesn't already exist or the data for an existing
2912: ** entry is overwritten. The data is the value on the top of the
2913: ** stack. The key is the next value down on the stack. The key must
2914: ** be a string. The stack is popped twice by this instruction.
2915: **
2916: ** P1 may not be a pseudo-table opened using the OpenPseudo opcode.
2917: */
2918: case OP_PutIntKey:
2919: case OP_PutStrKey: {
2920: Mem *pNos = &pTos[-1];
2921: int i = pOp->p1;
2922: Cursor *pC;
2923: assert( pNos>=p->aStack );
2924: assert( i>=0 && i<p->nCursor );
2925: if( ((pC = &p->aCsr[i])->pCursor!=0 || pC->pseudoTable) ){
2926: char *zKey;
2927: int nKey, iKey;
2928: if( pOp->opcode==OP_PutStrKey ){
2929: Stringify(pNos);
2930: nKey = pNos->n;
2931: zKey = pNos->z;
2932: }else{
2933: assert( pNos->flags & MEM_Int );
2934: nKey = sizeof(int);
2935: iKey = intToKey(pNos->i);
2936: zKey = (char*)&iKey;
2937: if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++;
2938: if( pOp->p2 & OPFLAG_LASTROWID ) db->lastRowid = pNos->i;
2939: if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++;
2940: if( pC->nextRowidValid && pTos->i>=pC->nextRowid ){
2941: pC->nextRowidValid = 0;
2942: }
2943: }
2944: if( pTos->flags & MEM_Null ){
2945: pTos->z = 0;
2946: pTos->n = 0;
2947: }else{
2948: assert( pTos->flags & MEM_Str );
2949: }
2950: if( pC->pseudoTable ){
2951: /* PutStrKey does not work for pseudo-tables.
2952: ** The following assert makes sure we are not trying to use
2953: ** PutStrKey on a pseudo-table
2954: */
2955: assert( pOp->opcode==OP_PutIntKey );
2956: sqliteFree(pC->pData);
2957: pC->iKey = iKey;
2958: pC->nData = pTos->n;
2959: if( pTos->flags & MEM_Dyn ){
2960: pC->pData = pTos->z;
2961: pTos->flags = MEM_Null;
2962: }else{
2963: pC->pData = sqliteMallocRaw( pC->nData );
2964: if( pC->pData ){
2965: memcpy(pC->pData, pTos->z, pC->nData);
2966: }
2967: }
2968: pC->nullRow = 0;
2969: }else{
2970: rc = sqliteBtreeInsert(pC->pCursor, zKey, nKey, pTos->z, pTos->n);
2971: }
2972: pC->recnoIsValid = 0;
2973: pC->deferredMoveto = 0;
2974: }
2975: popStack(&pTos, 2);
2976: break;
2977: }
2978:
2979: /* Opcode: Delete P1 P2 *
2980: **
2981: ** Delete the record at which the P1 cursor is currently pointing.
2982: **
2983: ** The cursor will be left pointing at either the next or the previous
2984: ** record in the table. If it is left pointing at the next record, then
2985: ** the next Next instruction will be a no-op. Hence it is OK to delete
2986: ** a record from within an Next loop.
2987: **
2988: ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
2989: ** incremented (otherwise not). If OPFLAG_CSCHANGE flag is set,
2990: ** then the current statement change count is incremented (otherwise not).
2991: **
2992: ** If P1 is a pseudo-table, then this instruction is a no-op.
2993: */
2994: case OP_Delete: {
2995: int i = pOp->p1;
2996: Cursor *pC;
2997: assert( i>=0 && i<p->nCursor );
2998: pC = &p->aCsr[i];
2999: if( pC->pCursor!=0 ){
3000: sqliteVdbeCursorMoveto(pC);
3001: rc = sqliteBtreeDelete(pC->pCursor);
3002: pC->nextRowidValid = 0;
3003: }
3004: if( pOp->p2 & OPFLAG_NCHANGE ) db->nChange++;
3005: if( pOp->p2 & OPFLAG_CSCHANGE ) db->csChange++;
3006: break;
3007: }
3008:
3009: /* Opcode: SetCounts * * *
3010: **
3011: ** Called at end of statement. Updates lsChange (last statement change count)
3012: ** and resets csChange (current statement change count) to 0.
3013: */
3014: case OP_SetCounts: {
3015: db->lsChange=db->csChange;
3016: db->csChange=0;
3017: break;
3018: }
3019:
3020: /* Opcode: KeyAsData P1 P2 *
3021: **
3022: ** Turn the key-as-data mode for cursor P1 either on (if P2==1) or
3023: ** off (if P2==0). In key-as-data mode, the OP_Column opcode pulls
3024: ** data off of the key rather than the data. This is used for
3025: ** processing compound selects.
3026: */
3027: case OP_KeyAsData: {
3028: int i = pOp->p1;
3029: assert( i>=0 && i<p->nCursor );
3030: p->aCsr[i].keyAsData = pOp->p2;
3031: break;
3032: }
3033:
3034: /* Opcode: RowData P1 * *
3035: **
3036: ** Push onto the stack the complete row data for cursor P1.
3037: ** There is no interpretation of the data. It is just copied
3038: ** onto the stack exactly as it is found in the database file.
3039: **
3040: ** If the cursor is not pointing to a valid row, a NULL is pushed
3041: ** onto the stack.
3042: */
3043: /* Opcode: RowKey P1 * *
3044: **
3045: ** Push onto the stack the complete row key for cursor P1.
3046: ** There is no interpretation of the key. It is just copied
3047: ** onto the stack exactly as it is found in the database file.
3048: **
3049: ** If the cursor is not pointing to a valid row, a NULL is pushed
3050: ** onto the stack.
3051: */
3052: case OP_RowKey:
3053: case OP_RowData: {
3054: int i = pOp->p1;
3055: Cursor *pC;
3056: int n;
3057:
3058: pTos++;
3059: assert( i>=0 && i<p->nCursor );
3060: pC = &p->aCsr[i];
3061: if( pC->nullRow ){
3062: pTos->flags = MEM_Null;
3063: }else if( pC->pCursor!=0 ){
3064: BtCursor *pCrsr = pC->pCursor;
3065: sqliteVdbeCursorMoveto(pC);
3066: if( pC->nullRow ){
3067: pTos->flags = MEM_Null;
3068: break;
3069: }else if( pC->keyAsData || pOp->opcode==OP_RowKey ){
3070: sqliteBtreeKeySize(pCrsr, &n);
3071: }else{
3072: sqliteBtreeDataSize(pCrsr, &n);
3073: }
3074: pTos->n = n;
3075: if( n<=NBFS ){
3076: pTos->flags = MEM_Str | MEM_Short;
3077: pTos->z = pTos->zShort;
3078: }else{
3079: char *z = sqliteMallocRaw( n );
3080: if( z==0 ) goto no_mem;
3081: pTos->flags = MEM_Str | MEM_Dyn;
3082: pTos->z = z;
3083: }
3084: if( pC->keyAsData || pOp->opcode==OP_RowKey ){
3085: sqliteBtreeKey(pCrsr, 0, n, pTos->z);
3086: }else{
3087: sqliteBtreeData(pCrsr, 0, n, pTos->z);
3088: }
3089: }else if( pC->pseudoTable ){
3090: pTos->n = pC->nData;
3091: pTos->z = pC->pData;
3092: pTos->flags = MEM_Str|MEM_Ephem;
3093: }else{
3094: pTos->flags = MEM_Null;
3095: }
3096: break;
3097: }
3098:
3099: /* Opcode: Column P1 P2 *
3100: **
3101: ** Interpret the data that cursor P1 points to as
3102: ** a structure built using the MakeRecord instruction.
3103: ** (See the MakeRecord opcode for additional information about
3104: ** the format of the data.)
3105: ** Push onto the stack the value of the P2-th column contained
3106: ** in the data.
3107: **
3108: ** If the KeyAsData opcode has previously executed on this cursor,
3109: ** then the field might be extracted from the key rather than the
3110: ** data.
3111: **
3112: ** If P1 is negative, then the record is stored on the stack rather
3113: ** than in a table. For P1==-1, the top of the stack is used.
3114: ** For P1==-2, the next on the stack is used. And so forth. The
3115: ** value pushed is always just a pointer into the record which is
3116: ** stored further down on the stack. The column value is not copied.
3117: */
3118: case OP_Column: {
3119: int amt, offset, end, payloadSize;
3120: int i = pOp->p1;
3121: int p2 = pOp->p2;
3122: Cursor *pC;
3123: char *zRec;
3124: BtCursor *pCrsr;
3125: int idxWidth;
3126: unsigned char aHdr[10];
3127:
3128: assert( i<p->nCursor );
3129: pTos++;
3130: if( i<0 ){
3131: assert( &pTos[i]>=p->aStack );
3132: assert( pTos[i].flags & MEM_Str );
3133: zRec = pTos[i].z;
3134: payloadSize = pTos[i].n;
3135: }else if( (pC = &p->aCsr[i])->pCursor!=0 ){
3136: sqliteVdbeCursorMoveto(pC);
3137: zRec = 0;
3138: pCrsr = pC->pCursor;
3139: if( pC->nullRow ){
3140: payloadSize = 0;
3141: }else if( pC->keyAsData ){
3142: sqliteBtreeKeySize(pCrsr, &payloadSize);
3143: }else{
3144: sqliteBtreeDataSize(pCrsr, &payloadSize);
3145: }
3146: }else if( pC->pseudoTable ){
3147: payloadSize = pC->nData;
3148: zRec = pC->pData;
3149: assert( payloadSize==0 || zRec!=0 );
3150: }else{
3151: payloadSize = 0;
3152: }
3153:
3154: /* Figure out how many bytes in the column data and where the column
3155: ** data begins.
3156: */
3157: if( payloadSize==0 ){
3158: pTos->flags = MEM_Null;
3159: break;
3160: }else if( payloadSize<256 ){
3161: idxWidth = 1;
3162: }else if( payloadSize<65536 ){
3163: idxWidth = 2;
3164: }else{
3165: idxWidth = 3;
3166: }
3167:
3168: /* Figure out where the requested column is stored and how big it is.
3169: */
3170: if( payloadSize < idxWidth*(p2+1) ){
3171: rc = SQLITE_CORRUPT;
3172: goto abort_due_to_error;
3173: }
3174: if( zRec ){
3175: memcpy(aHdr, &zRec[idxWidth*p2], idxWidth*2);
3176: }else if( pC->keyAsData ){
3177: sqliteBtreeKey(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);
3178: }else{
3179: sqliteBtreeData(pCrsr, idxWidth*p2, idxWidth*2, (char*)aHdr);
3180: }
3181: offset = aHdr[0];
3182: end = aHdr[idxWidth];
3183: if( idxWidth>1 ){
3184: offset |= aHdr[1]<<8;
3185: end |= aHdr[idxWidth+1]<<8;
3186: if( idxWidth>2 ){
3187: offset |= aHdr[2]<<16;
3188: end |= aHdr[idxWidth+2]<<16;
3189: }
3190: }
3191: amt = end - offset;
3192: if( amt<0 || offset<0 || end>payloadSize ){
3193: rc = SQLITE_CORRUPT;
3194: goto abort_due_to_error;
3195: }
3196:
3197: /* amt and offset now hold the offset to the start of data and the
3198: ** amount of data. Go get the data and put it on the stack.
3199: */
3200: pTos->n = amt;
3201: if( amt==0 ){
3202: pTos->flags = MEM_Null;
3203: }else if( zRec ){
3204: pTos->flags = MEM_Str | MEM_Ephem;
3205: pTos->z = &zRec[offset];
3206: }else{
3207: if( amt<=NBFS ){
3208: pTos->flags = MEM_Str | MEM_Short;
3209: pTos->z = pTos->zShort;
3210: }else{
3211: char *z = sqliteMallocRaw( amt );
3212: if( z==0 ) goto no_mem;
3213: pTos->flags = MEM_Str | MEM_Dyn;
3214: pTos->z = z;
3215: }
3216: if( pC->keyAsData ){
3217: sqliteBtreeKey(pCrsr, offset, amt, pTos->z);
3218: }else{
3219: sqliteBtreeData(pCrsr, offset, amt, pTos->z);
3220: }
3221: }
3222: break;
3223: }
3224:
3225: /* Opcode: Recno P1 * *
3226: **
3227: ** Push onto the stack an integer which is the first 4 bytes of the
3228: ** the key to the current entry in a sequential scan of the database
3229: ** file P1. The sequential scan should have been started using the
3230: ** Next opcode.
3231: */
3232: case OP_Recno: {
3233: int i = pOp->p1;
3234: Cursor *pC;
3235: int v;
3236:
3237: assert( i>=0 && i<p->nCursor );
3238: pC = &p->aCsr[i];
3239: sqliteVdbeCursorMoveto(pC);
3240: pTos++;
3241: if( pC->recnoIsValid ){
3242: v = pC->lastRecno;
3243: }else if( pC->pseudoTable ){
3244: v = keyToInt(pC->iKey);
3245: }else if( pC->nullRow || pC->pCursor==0 ){
3246: pTos->flags = MEM_Null;
3247: break;
3248: }else{
3249: assert( pC->pCursor!=0 );
3250: sqliteBtreeKey(pC->pCursor, 0, sizeof(u32), (char*)&v);
3251: v = keyToInt(v);
3252: }
3253: pTos->i = v;
3254: pTos->flags = MEM_Int;
3255: break;
3256: }
3257:
3258: /* Opcode: FullKey P1 * *
3259: **
3260: ** Extract the complete key from the record that cursor P1 is currently
3261: ** pointing to and push the key onto the stack as a string.
3262: **
3263: ** Compare this opcode to Recno. The Recno opcode extracts the first
3264: ** 4 bytes of the key and pushes those bytes onto the stack as an
3265: ** integer. This instruction pushes the entire key as a string.
3266: **
3267: ** This opcode may not be used on a pseudo-table.
3268: */
3269: case OP_FullKey: {
3270: int i = pOp->p1;
3271: BtCursor *pCrsr;
3272:
3273: assert( p->aCsr[i].keyAsData );
3274: assert( !p->aCsr[i].pseudoTable );
3275: assert( i>=0 && i<p->nCursor );
3276: pTos++;
3277: if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
3278: int amt;
3279: char *z;
3280:
3281: sqliteVdbeCursorMoveto(&p->aCsr[i]);
3282: sqliteBtreeKeySize(pCrsr, &amt);
3283: if( amt<=0 ){
3284: rc = SQLITE_CORRUPT;
3285: goto abort_due_to_error;
3286: }
3287: if( amt>NBFS ){
3288: z = sqliteMallocRaw( amt );
3289: if( z==0 ) goto no_mem;
3290: pTos->flags = MEM_Str | MEM_Dyn;
3291: }else{
3292: z = pTos->zShort;
3293: pTos->flags = MEM_Str | MEM_Short;
3294: }
3295: sqliteBtreeKey(pCrsr, 0, amt, z);
3296: pTos->z = z;
3297: pTos->n = amt;
3298: }
3299: break;
3300: }
3301:
3302: /* Opcode: NullRow P1 * *
3303: **
3304: ** Move the cursor P1 to a null row. Any OP_Column operations
3305: ** that occur while the cursor is on the null row will always push
3306: ** a NULL onto the stack.
3307: */
3308: case OP_NullRow: {
3309: int i = pOp->p1;
3310:
3311: assert( i>=0 && i<p->nCursor );
3312: p->aCsr[i].nullRow = 1;
3313: p->aCsr[i].recnoIsValid = 0;
3314: break;
3315: }
3316:
3317: /* Opcode: Last P1 P2 *
3318: **
3319: ** The next use of the Recno or Column or Next instruction for P1
3320: ** will refer to the last entry in the database table or index.
3321: ** If the table or index is empty and P2>0, then jump immediately to P2.
3322: ** If P2 is 0 or if the table or index is not empty, fall through
3323: ** to the following instruction.
3324: */
3325: case OP_Last: {
3326: int i = pOp->p1;
3327: Cursor *pC;
3328: BtCursor *pCrsr;
3329:
3330: assert( i>=0 && i<p->nCursor );
3331: pC = &p->aCsr[i];
3332: if( (pCrsr = pC->pCursor)!=0 ){
3333: int res;
3334: rc = sqliteBtreeLast(pCrsr, &res);
3335: pC->nullRow = res;
3336: pC->deferredMoveto = 0;
3337: if( res && pOp->p2>0 ){
3338: pc = pOp->p2 - 1;
3339: }
3340: }else{
3341: pC->nullRow = 0;
3342: }
3343: break;
3344: }
3345:
3346: /* Opcode: Rewind P1 P2 *
3347: **
3348: ** The next use of the Recno or Column or Next instruction for P1
3349: ** will refer to the first entry in the database table or index.
3350: ** If the table or index is empty and P2>0, then jump immediately to P2.
3351: ** If P2 is 0 or if the table or index is not empty, fall through
3352: ** to the following instruction.
3353: */
3354: case OP_Rewind: {
3355: int i = pOp->p1;
3356: Cursor *pC;
3357: BtCursor *pCrsr;
3358:
3359: assert( i>=0 && i<p->nCursor );
3360: pC = &p->aCsr[i];
3361: if( (pCrsr = pC->pCursor)!=0 ){
3362: int res;
3363: rc = sqliteBtreeFirst(pCrsr, &res);
3364: pC->atFirst = res==0;
3365: pC->nullRow = res;
3366: pC->deferredMoveto = 0;
3367: if( res && pOp->p2>0 ){
3368: pc = pOp->p2 - 1;
3369: }
3370: }else{
3371: pC->nullRow = 0;
3372: }
3373: break;
3374: }
3375:
3376: /* Opcode: Next P1 P2 *
3377: **
3378: ** Advance cursor P1 so that it points to the next key/data pair in its
3379: ** table or index. If there are no more key/value pairs then fall through
3380: ** to the following instruction. But if the cursor advance was successful,
3381: ** jump immediately to P2.
3382: **
3383: ** See also: Prev
3384: */
3385: /* Opcode: Prev P1 P2 *
3386: **
3387: ** Back up cursor P1 so that it points to the previous key/data pair in its
3388: ** table or index. If there is no previous key/value pairs then fall through
3389: ** to the following instruction. But if the cursor backup was successful,
3390: ** jump immediately to P2.
3391: */
3392: case OP_Prev:
3393: case OP_Next: {
3394: Cursor *pC;
3395: BtCursor *pCrsr;
3396:
3397: CHECK_FOR_INTERRUPT;
3398: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3399: pC = &p->aCsr[pOp->p1];
3400: if( (pCrsr = pC->pCursor)!=0 ){
3401: int res;
3402: if( pC->nullRow ){
3403: res = 1;
3404: }else{
3405: assert( pC->deferredMoveto==0 );
3406: rc = pOp->opcode==OP_Next ? sqliteBtreeNext(pCrsr, &res) :
3407: sqliteBtreePrevious(pCrsr, &res);
3408: pC->nullRow = res;
3409: }
3410: if( res==0 ){
3411: pc = pOp->p2 - 1;
3412: sqlite_search_count++;
3413: }
3414: }else{
3415: pC->nullRow = 1;
3416: }
3417: pC->recnoIsValid = 0;
3418: break;
3419: }
3420:
3421: /* Opcode: IdxPut P1 P2 P3
3422: **
3423: ** The top of the stack holds a SQL index key made using the
3424: ** MakeIdxKey instruction. This opcode writes that key into the
3425: ** index P1. Data for the entry is nil.
3426: **
3427: ** If P2==1, then the key must be unique. If the key is not unique,
3428: ** the program aborts with a SQLITE_CONSTRAINT error and the database
3429: ** is rolled back. If P3 is not null, then it becomes part of the
3430: ** error message returned with the SQLITE_CONSTRAINT.
3431: */
3432: case OP_IdxPut: {
3433: int i = pOp->p1;
3434: BtCursor *pCrsr;
3435: assert( pTos>=p->aStack );
3436: assert( i>=0 && i<p->nCursor );
3437: assert( pTos->flags & MEM_Str );
3438: if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
3439: int nKey = pTos->n;
3440: const char *zKey = pTos->z;
3441: if( pOp->p2 ){
3442: int res, n;
3443: assert( nKey >= 4 );
3444: rc = sqliteBtreeMoveto(pCrsr, zKey, nKey-4, &res);
3445: if( rc!=SQLITE_OK ) goto abort_due_to_error;
3446: while( res!=0 ){
3447: int c;
3448: sqliteBtreeKeySize(pCrsr, &n);
3449: if( n==nKey
3450: && sqliteBtreeKeyCompare(pCrsr, zKey, nKey-4, 4, &c)==SQLITE_OK
3451: && c==0
3452: ){
3453: rc = SQLITE_CONSTRAINT;
3454: if( pOp->p3 && pOp->p3[0] ){
3455: sqliteSetString(&p->zErrMsg, pOp->p3, (char*)0);
3456: }
3457: goto abort_due_to_error;
3458: }
3459: if( res<0 ){
3460: sqliteBtreeNext(pCrsr, &res);
3461: res = +1;
3462: }else{
3463: break;
3464: }
3465: }
3466: }
3467: rc = sqliteBtreeInsert(pCrsr, zKey, nKey, "", 0);
3468: assert( p->aCsr[i].deferredMoveto==0 );
3469: }
3470: Release(pTos);
3471: pTos--;
3472: break;
3473: }
3474:
3475: /* Opcode: IdxDelete P1 * *
3476: **
3477: ** The top of the stack is an index key built using the MakeIdxKey opcode.
3478: ** This opcode removes that entry from the index.
3479: */
3480: case OP_IdxDelete: {
3481: int i = pOp->p1;
3482: BtCursor *pCrsr;
3483: assert( pTos>=p->aStack );
3484: assert( pTos->flags & MEM_Str );
3485: assert( i>=0 && i<p->nCursor );
3486: if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
3487: int rx, res;
3488: rx = sqliteBtreeMoveto(pCrsr, pTos->z, pTos->n, &res);
3489: if( rx==SQLITE_OK && res==0 ){
3490: rc = sqliteBtreeDelete(pCrsr);
3491: }
3492: assert( p->aCsr[i].deferredMoveto==0 );
3493: }
3494: Release(pTos);
3495: pTos--;
3496: break;
3497: }
3498:
3499: /* Opcode: IdxRecno P1 * *
3500: **
3501: ** Push onto the stack an integer which is the last 4 bytes of the
3502: ** the key to the current entry in index P1. These 4 bytes should
3503: ** be the record number of the table entry to which this index entry
3504: ** points.
3505: **
3506: ** See also: Recno, MakeIdxKey.
3507: */
3508: case OP_IdxRecno: {
3509: int i = pOp->p1;
3510: BtCursor *pCrsr;
3511:
3512: assert( i>=0 && i<p->nCursor );
3513: pTos++;
3514: if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
3515: int v;
3516: int sz;
3517: assert( p->aCsr[i].deferredMoveto==0 );
3518: sqliteBtreeKeySize(pCrsr, &sz);
3519: if( sz<sizeof(u32) ){
3520: pTos->flags = MEM_Null;
3521: }else{
3522: sqliteBtreeKey(pCrsr, sz - sizeof(u32), sizeof(u32), (char*)&v);
3523: v = keyToInt(v);
3524: pTos->i = v;
3525: pTos->flags = MEM_Int;
3526: }
3527: }else{
3528: pTos->flags = MEM_Null;
3529: }
3530: break;
3531: }
3532:
3533: /* Opcode: IdxGT P1 P2 *
3534: **
3535: ** Compare the top of the stack against the key on the index entry that
3536: ** cursor P1 is currently pointing to. Ignore the last 4 bytes of the
3537: ** index entry. If the index entry is greater than the top of the stack
3538: ** then jump to P2. Otherwise fall through to the next instruction.
3539: ** In either case, the stack is popped once.
3540: */
3541: /* Opcode: IdxGE P1 P2 *
3542: **
3543: ** Compare the top of the stack against the key on the index entry that
3544: ** cursor P1 is currently pointing to. Ignore the last 4 bytes of the
3545: ** index entry. If the index entry is greater than or equal to
3546: ** the top of the stack
3547: ** then jump to P2. Otherwise fall through to the next instruction.
3548: ** In either case, the stack is popped once.
3549: */
3550: /* Opcode: IdxLT P1 P2 *
3551: **
3552: ** Compare the top of the stack against the key on the index entry that
3553: ** cursor P1 is currently pointing to. Ignore the last 4 bytes of the
3554: ** index entry. If the index entry is less than the top of the stack
3555: ** then jump to P2. Otherwise fall through to the next instruction.
3556: ** In either case, the stack is popped once.
3557: */
3558: case OP_IdxLT:
3559: case OP_IdxGT:
3560: case OP_IdxGE: {
3561: int i= pOp->p1;
3562: BtCursor *pCrsr;
3563:
3564: assert( i>=0 && i<p->nCursor );
3565: assert( pTos>=p->aStack );
3566: if( (pCrsr = p->aCsr[i].pCursor)!=0 ){
3567: int res, rc;
3568:
3569: Stringify(pTos);
3570: assert( p->aCsr[i].deferredMoveto==0 );
3571: rc = sqliteBtreeKeyCompare(pCrsr, pTos->z, pTos->n, 4, &res);
3572: if( rc!=SQLITE_OK ){
3573: break;
3574: }
3575: if( pOp->opcode==OP_IdxLT ){
3576: res = -res;
3577: }else if( pOp->opcode==OP_IdxGE ){
3578: res++;
3579: }
3580: if( res>0 ){
3581: pc = pOp->p2 - 1 ;
3582: }
3583: }
3584: Release(pTos);
3585: pTos--;
3586: break;
3587: }
3588:
3589: /* Opcode: IdxIsNull P1 P2 *
3590: **
3591: ** The top of the stack contains an index entry such as might be generated
3592: ** by the MakeIdxKey opcode. This routine looks at the first P1 fields of
3593: ** that key. If any of the first P1 fields are NULL, then a jump is made
3594: ** to address P2. Otherwise we fall straight through.
3595: **
3596: ** The index entry is always popped from the stack.
3597: */
3598: case OP_IdxIsNull: {
3599: int i = pOp->p1;
3600: int k, n;
3601: const char *z;
3602:
3603: assert( pTos>=p->aStack );
3604: assert( pTos->flags & MEM_Str );
3605: z = pTos->z;
3606: n = pTos->n;
3607: for(k=0; k<n && i>0; i--){
3608: if( z[k]=='a' ){
3609: pc = pOp->p2-1;
3610: break;
3611: }
3612: while( k<n && z[k] ){ k++; }
3613: k++;
3614: }
3615: Release(pTos);
3616: pTos--;
3617: break;
3618: }
3619:
3620: /* Opcode: Destroy P1 P2 *
3621: **
3622: ** Delete an entire database table or index whose root page in the database
3623: ** file is given by P1.
3624: **
3625: ** The table being destroyed is in the main database file if P2==0. If
3626: ** P2==1 then the table to be clear is in the auxiliary database file
3627: ** that is used to store tables create using CREATE TEMPORARY TABLE.
3628: **
3629: ** See also: Clear
3630: */
3631: case OP_Destroy: {
3632: rc = sqliteBtreeDropTable(db->aDb[pOp->p2].pBt, pOp->p1);
3633: break;
3634: }
3635:
3636: /* Opcode: Clear P1 P2 *
3637: **
3638: ** Delete all contents of the database table or index whose root page
3639: ** in the database file is given by P1. But, unlike Destroy, do not
3640: ** remove the table or index from the database file.
3641: **
3642: ** The table being clear is in the main database file if P2==0. If
3643: ** P2==1 then the table to be clear is in the auxiliary database file
3644: ** that is used to store tables create using CREATE TEMPORARY TABLE.
3645: **
3646: ** See also: Destroy
3647: */
3648: case OP_Clear: {
3649: rc = sqliteBtreeClearTable(db->aDb[pOp->p2].pBt, pOp->p1);
3650: break;
3651: }
3652:
3653: /* Opcode: CreateTable * P2 P3
3654: **
3655: ** Allocate a new table in the main database file if P2==0 or in the
3656: ** auxiliary database file if P2==1. Push the page number
3657: ** for the root page of the new table onto the stack.
3658: **
3659: ** The root page number is also written to a memory location that P3
3660: ** points to. This is the mechanism is used to write the root page
3661: ** number into the parser's internal data structures that describe the
3662: ** new table.
3663: **
3664: ** The difference between a table and an index is this: A table must
3665: ** have a 4-byte integer key and can have arbitrary data. An index
3666: ** has an arbitrary key but no data.
3667: **
3668: ** See also: CreateIndex
3669: */
3670: /* Opcode: CreateIndex * P2 P3
3671: **
3672: ** Allocate a new index in the main database file if P2==0 or in the
3673: ** auxiliary database file if P2==1. Push the page number of the
3674: ** root page of the new index onto the stack.
3675: **
3676: ** See documentation on OP_CreateTable for additional information.
3677: */
3678: case OP_CreateIndex:
3679: case OP_CreateTable: {
3680: int pgno;
3681: assert( pOp->p3!=0 && pOp->p3type==P3_POINTER );
3682: assert( pOp->p2>=0 && pOp->p2<db->nDb );
3683: assert( db->aDb[pOp->p2].pBt!=0 );
3684: if( pOp->opcode==OP_CreateTable ){
3685: rc = sqliteBtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno);
3686: }else{
3687: rc = sqliteBtreeCreateIndex(db->aDb[pOp->p2].pBt, &pgno);
3688: }
3689: pTos++;
3690: if( rc==SQLITE_OK ){
3691: pTos->i = pgno;
3692: pTos->flags = MEM_Int;
3693: *(u32*)pOp->p3 = pgno;
3694: pOp->p3 = 0;
3695: }else{
3696: pTos->flags = MEM_Null;
3697: }
3698: break;
3699: }
3700:
3701: /* Opcode: IntegrityCk P1 P2 *
3702: **
3703: ** Do an analysis of the currently open database. Push onto the
3704: ** stack the text of an error message describing any problems.
3705: ** If there are no errors, push a "ok" onto the stack.
3706: **
3707: ** P1 is the index of a set that contains the root page numbers
3708: ** for all tables and indices in the main database file. The set
3709: ** is cleared by this opcode. In other words, after this opcode
3710: ** has executed, the set will be empty.
3711: **
3712: ** If P2 is not zero, the check is done on the auxiliary database
3713: ** file, not the main database file.
3714: **
3715: ** This opcode is used for testing purposes only.
3716: */
3717: case OP_IntegrityCk: {
3718: int nRoot;
3719: int *aRoot;
3720: int iSet = pOp->p1;
3721: Set *pSet;
3722: int j;
3723: HashElem *i;
3724: char *z;
3725:
3726: assert( iSet>=0 && iSet<p->nSet );
3727: pTos++;
3728: pSet = &p->aSet[iSet];
3729: nRoot = sqliteHashCount(&pSet->hash);
3730: aRoot = sqliteMallocRaw( sizeof(int)*(nRoot+1) );
3731: if( aRoot==0 ) goto no_mem;
3732: for(j=0, i=sqliteHashFirst(&pSet->hash); i; i=sqliteHashNext(i), j++){
3733: toInt((char*)sqliteHashKey(i), &aRoot[j]);
3734: }
3735: aRoot[j] = 0;
3736: sqliteHashClear(&pSet->hash);
3737: pSet->prev = 0;
3738: z = sqliteBtreeIntegrityCheck(db->aDb[pOp->p2].pBt, aRoot, nRoot);
3739: if( z==0 || z[0]==0 ){
3740: if( z ) sqliteFree(z);
3741: pTos->z = "ok";
3742: pTos->n = 3;
3743: pTos->flags = MEM_Str | MEM_Static;
3744: }else{
3745: pTos->z = z;
3746: pTos->n = strlen(z) + 1;
3747: pTos->flags = MEM_Str | MEM_Dyn;
3748: }
3749: sqliteFree(aRoot);
3750: break;
3751: }
3752:
3753: /* Opcode: ListWrite * * *
3754: **
3755: ** Write the integer on the top of the stack
3756: ** into the temporary storage list.
3757: */
3758: case OP_ListWrite: {
3759: Keylist *pKeylist;
3760: assert( pTos>=p->aStack );
3761: pKeylist = p->pList;
3762: if( pKeylist==0 || pKeylist->nUsed>=pKeylist->nKey ){
3763: pKeylist = sqliteMallocRaw( sizeof(Keylist)+999*sizeof(pKeylist->aKey[0]) );
3764: if( pKeylist==0 ) goto no_mem;
3765: pKeylist->nKey = 1000;
3766: pKeylist->nRead = 0;
3767: pKeylist->nUsed = 0;
3768: pKeylist->pNext = p->pList;
3769: p->pList = pKeylist;
3770: }
3771: Integerify(pTos);
3772: pKeylist->aKey[pKeylist->nUsed++] = pTos->i;
3773: Release(pTos);
3774: pTos--;
3775: break;
3776: }
3777:
3778: /* Opcode: ListRewind * * *
3779: **
3780: ** Rewind the temporary buffer back to the beginning.
3781: */
3782: case OP_ListRewind: {
3783: /* What this opcode codes, really, is reverse the order of the
3784: ** linked list of Keylist structures so that they are read out
3785: ** in the same order that they were read in. */
3786: Keylist *pRev, *pTop;
3787: pRev = 0;
3788: while( p->pList ){
3789: pTop = p->pList;
3790: p->pList = pTop->pNext;
3791: pTop->pNext = pRev;
3792: pRev = pTop;
3793: }
3794: p->pList = pRev;
3795: break;
3796: }
3797:
3798: /* Opcode: ListRead * P2 *
3799: **
3800: ** Attempt to read an integer from the temporary storage buffer
3801: ** and push it onto the stack. If the storage buffer is empty,
3802: ** push nothing but instead jump to P2.
3803: */
3804: case OP_ListRead: {
3805: Keylist *pKeylist;
3806: CHECK_FOR_INTERRUPT;
3807: pKeylist = p->pList;
3808: if( pKeylist!=0 ){
3809: assert( pKeylist->nRead>=0 );
3810: assert( pKeylist->nRead<pKeylist->nUsed );
3811: assert( pKeylist->nRead<pKeylist->nKey );
3812: pTos++;
3813: pTos->i = pKeylist->aKey[pKeylist->nRead++];
3814: pTos->flags = MEM_Int;
3815: if( pKeylist->nRead>=pKeylist->nUsed ){
3816: p->pList = pKeylist->pNext;
3817: sqliteFree(pKeylist);
3818: }
3819: }else{
3820: pc = pOp->p2 - 1;
3821: }
3822: break;
3823: }
3824:
3825: /* Opcode: ListReset * * *
3826: **
3827: ** Reset the temporary storage buffer so that it holds nothing.
3828: */
3829: case OP_ListReset: {
3830: if( p->pList ){
3831: sqliteVdbeKeylistFree(p->pList);
3832: p->pList = 0;
3833: }
3834: break;
3835: }
3836:
3837: /* Opcode: ListPush * * *
3838: **
3839: ** Save the current Vdbe list such that it can be restored by a ListPop
3840: ** opcode. The list is empty after this is executed.
3841: */
3842: case OP_ListPush: {
3843: p->keylistStackDepth++;
3844: assert(p->keylistStackDepth > 0);
3845: p->keylistStack = sqliteRealloc(p->keylistStack,
3846: sizeof(Keylist *) * p->keylistStackDepth);
3847: if( p->keylistStack==0 ) goto no_mem;
3848: p->keylistStack[p->keylistStackDepth - 1] = p->pList;
3849: p->pList = 0;
3850: break;
3851: }
3852:
3853: /* Opcode: ListPop * * *
3854: **
3855: ** Restore the Vdbe list to the state it was in when ListPush was last
3856: ** executed.
3857: */
3858: case OP_ListPop: {
3859: assert(p->keylistStackDepth > 0);
3860: p->keylistStackDepth--;
3861: sqliteVdbeKeylistFree(p->pList);
3862: p->pList = p->keylistStack[p->keylistStackDepth];
3863: p->keylistStack[p->keylistStackDepth] = 0;
3864: if( p->keylistStackDepth == 0 ){
3865: sqliteFree(p->keylistStack);
3866: p->keylistStack = 0;
3867: }
3868: break;
3869: }
3870:
3871: /* Opcode: ContextPush * * *
3872: **
3873: ** Save the current Vdbe context such that it can be restored by a ContextPop
3874: ** opcode. The context stores the last insert row id, the last statement change
3875: ** count, and the current statement change count.
3876: */
3877: case OP_ContextPush: {
3878: p->contextStackDepth++;
3879: assert(p->contextStackDepth > 0);
3880: p->contextStack = sqliteRealloc(p->contextStack,
3881: sizeof(Context) * p->contextStackDepth);
3882: if( p->contextStack==0 ) goto no_mem;
3883: p->contextStack[p->contextStackDepth - 1].lastRowid = p->db->lastRowid;
3884: p->contextStack[p->contextStackDepth - 1].lsChange = p->db->lsChange;
3885: p->contextStack[p->contextStackDepth - 1].csChange = p->db->csChange;
3886: break;
3887: }
3888:
3889: /* Opcode: ContextPop * * *
3890: **
3891: ** Restore the Vdbe context to the state it was in when contextPush was last
3892: ** executed. The context stores the last insert row id, the last statement
3893: ** change count, and the current statement change count.
3894: */
3895: case OP_ContextPop: {
3896: assert(p->contextStackDepth > 0);
3897: p->contextStackDepth--;
3898: p->db->lastRowid = p->contextStack[p->contextStackDepth].lastRowid;
3899: p->db->lsChange = p->contextStack[p->contextStackDepth].lsChange;
3900: p->db->csChange = p->contextStack[p->contextStackDepth].csChange;
3901: if( p->contextStackDepth == 0 ){
3902: sqliteFree(p->contextStack);
3903: p->contextStack = 0;
3904: }
3905: break;
3906: }
3907:
3908: /* Opcode: SortPut * * *
3909: **
3910: ** The TOS is the key and the NOS is the data. Pop both from the stack
3911: ** and put them on the sorter. The key and data should have been
3912: ** made using SortMakeKey and SortMakeRec, respectively.
3913: */
3914: case OP_SortPut: {
3915: Mem *pNos = &pTos[-1];
3916: Sorter *pSorter;
3917: assert( pNos>=p->aStack );
3918: if( Dynamicify(pTos) || Dynamicify(pNos) ) goto no_mem;
3919: pSorter = sqliteMallocRaw( sizeof(Sorter) );
3920: if( pSorter==0 ) goto no_mem;
3921: pSorter->pNext = p->pSort;
3922: p->pSort = pSorter;
3923: assert( pTos->flags & MEM_Dyn );
3924: pSorter->nKey = pTos->n;
3925: pSorter->zKey = pTos->z;
3926: assert( pNos->flags & MEM_Dyn );
3927: pSorter->nData = pNos->n;
3928: pSorter->pData = pNos->z;
3929: pTos -= 2;
3930: break;
3931: }
3932:
3933: /* Opcode: SortMakeRec P1 * *
3934: **
3935: ** The top P1 elements are the arguments to a callback. Form these
3936: ** elements into a single data entry that can be stored on a sorter
3937: ** using SortPut and later fed to a callback using SortCallback.
3938: */
3939: case OP_SortMakeRec: {
3940: char *z;
3941: char **azArg;
3942: int nByte;
3943: int nField;
3944: int i;
3945: Mem *pRec;
3946:
3947: nField = pOp->p1;
3948: pRec = &pTos[1-nField];
3949: assert( pRec>=p->aStack );
3950: nByte = 0;
3951: for(i=0; i<nField; i++, pRec++){
3952: if( (pRec->flags & MEM_Null)==0 ){
3953: Stringify(pRec);
3954: nByte += pRec->n;
3955: }
3956: }
3957: nByte += sizeof(char*)*(nField+1);
3958: azArg = sqliteMallocRaw( nByte );
3959: if( azArg==0 ) goto no_mem;
3960: z = (char*)&azArg[nField+1];
3961: for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){
3962: if( pRec->flags & MEM_Null ){
3963: azArg[i] = 0;
3964: }else{
3965: azArg[i] = z;
3966: memcpy(z, pRec->z, pRec->n);
3967: z += pRec->n;
3968: }
3969: }
3970: popStack(&pTos, nField);
3971: pTos++;
3972: pTos->n = nByte;
3973: pTos->z = (char*)azArg;
3974: pTos->flags = MEM_Str | MEM_Dyn;
3975: break;
3976: }
3977:
3978: /* Opcode: SortMakeKey * * P3
3979: **
3980: ** Convert the top few entries of the stack into a sort key. The
3981: ** number of stack entries consumed is the number of characters in
3982: ** the string P3. One character from P3 is prepended to each entry.
3983: ** The first character of P3 is prepended to the element lowest in
3984: ** the stack and the last character of P3 is prepended to the top of
3985: ** the stack. All stack entries are separated by a \000 character
3986: ** in the result. The whole key is terminated by two \000 characters
3987: ** in a row.
3988: **
3989: ** "N" is substituted in place of the P3 character for NULL values.
3990: **
3991: ** See also the MakeKey and MakeIdxKey opcodes.
3992: */
3993: case OP_SortMakeKey: {
3994: char *zNewKey;
3995: int nByte;
3996: int nField;
3997: int i, j, k;
3998: Mem *pRec;
3999:
4000: nField = strlen(pOp->p3);
4001: pRec = &pTos[1-nField];
4002: nByte = 1;
4003: for(i=0; i<nField; i++, pRec++){
4004: if( pRec->flags & MEM_Null ){
4005: nByte += 2;
4006: }else{
4007: Stringify(pRec);
4008: nByte += pRec->n+2;
4009: }
4010: }
4011: zNewKey = sqliteMallocRaw( nByte );
4012: if( zNewKey==0 ) goto no_mem;
4013: j = 0;
4014: k = 0;
4015: for(pRec=&pTos[1-nField], i=0; i<nField; i++, pRec++){
4016: if( pRec->flags & MEM_Null ){
4017: zNewKey[j++] = 'N';
4018: zNewKey[j++] = 0;
4019: k++;
4020: }else{
4021: zNewKey[j++] = pOp->p3[k++];
4022: memcpy(&zNewKey[j], pRec->z, pRec->n-1);
4023: j += pRec->n-1;
4024: zNewKey[j++] = 0;
4025: }
4026: }
4027: zNewKey[j] = 0;
4028: assert( j<nByte );
4029: popStack(&pTos, nField);
4030: pTos++;
4031: pTos->n = nByte;
4032: pTos->flags = MEM_Str|MEM_Dyn;
4033: pTos->z = zNewKey;
4034: break;
4035: }
4036:
4037: /* Opcode: Sort * * *
4038: **
4039: ** Sort all elements on the sorter. The algorithm is a
4040: ** mergesort.
4041: */
4042: case OP_Sort: {
4043: int i;
4044: Sorter *pElem;
4045: Sorter *apSorter[NSORT];
4046: for(i=0; i<NSORT; i++){
4047: apSorter[i] = 0;
4048: }
4049: while( p->pSort ){
4050: pElem = p->pSort;
4051: p->pSort = pElem->pNext;
4052: pElem->pNext = 0;
4053: for(i=0; i<NSORT-1; i++){
4054: if( apSorter[i]==0 ){
4055: apSorter[i] = pElem;
4056: break;
4057: }else{
4058: pElem = Merge(apSorter[i], pElem);
4059: apSorter[i] = 0;
4060: }
4061: }
4062: if( i>=NSORT-1 ){
4063: apSorter[NSORT-1] = Merge(apSorter[NSORT-1],pElem);
4064: }
4065: }
4066: pElem = 0;
4067: for(i=0; i<NSORT; i++){
4068: pElem = Merge(apSorter[i], pElem);
4069: }
4070: p->pSort = pElem;
4071: break;
4072: }
4073:
4074: /* Opcode: SortNext * P2 *
4075: **
4076: ** Push the data for the topmost element in the sorter onto the
4077: ** stack, then remove the element from the sorter. If the sorter
4078: ** is empty, push nothing on the stack and instead jump immediately
4079: ** to instruction P2.
4080: */
4081: case OP_SortNext: {
4082: Sorter *pSorter = p->pSort;
4083: CHECK_FOR_INTERRUPT;
4084: if( pSorter!=0 ){
4085: p->pSort = pSorter->pNext;
4086: pTos++;
4087: pTos->z = pSorter->pData;
4088: pTos->n = pSorter->nData;
4089: pTos->flags = MEM_Str|MEM_Dyn;
4090: sqliteFree(pSorter->zKey);
4091: sqliteFree(pSorter);
4092: }else{
4093: pc = pOp->p2 - 1;
4094: }
4095: break;
4096: }
4097:
4098: /* Opcode: SortCallback P1 * *
4099: **
4100: ** The top of the stack contains a callback record built using
4101: ** the SortMakeRec operation with the same P1 value as this
4102: ** instruction. Pop this record from the stack and invoke the
4103: ** callback on it.
4104: */
4105: case OP_SortCallback: {
4106: assert( pTos>=p->aStack );
4107: assert( pTos->flags & MEM_Str );
4108: p->nCallback++;
4109: p->pc = pc+1;
4110: p->azResColumn = (char**)pTos->z;
4111: assert( p->nResColumn==pOp->p1 );
4112: p->popStack = 1;
4113: p->pTos = pTos;
4114: return SQLITE_ROW;
4115: }
4116:
4117: /* Opcode: SortReset * * *
4118: **
4119: ** Remove any elements that remain on the sorter.
4120: */
4121: case OP_SortReset: {
4122: sqliteVdbeSorterReset(p);
4123: break;
4124: }
4125:
4126: /* Opcode: FileOpen * * P3
4127: **
4128: ** Open the file named by P3 for reading using the FileRead opcode.
4129: ** If P3 is "stdin" then open standard input for reading.
4130: */
4131: case OP_FileOpen: {
4132: assert( pOp->p3!=0 );
4133: if( p->pFile ){
4134: if( p->pFile!=stdin ) fclose(p->pFile);
4135: p->pFile = 0;
4136: }
4137: if( sqliteStrICmp(pOp->p3,"stdin")==0 ){
4138: p->pFile = stdin;
4139: }else{
4140: p->pFile = fopen(pOp->p3, "r");
4141: }
4142: if( p->pFile==0 ){
4143: sqliteSetString(&p->zErrMsg,"unable to open file: ", pOp->p3, (char*)0);
4144: rc = SQLITE_ERROR;
4145: }
4146: break;
4147: }
4148:
4149: /* Opcode: FileRead P1 P2 P3
4150: **
4151: ** Read a single line of input from the open file (the file opened using
4152: ** FileOpen). If we reach end-of-file, jump immediately to P2. If
4153: ** we are able to get another line, split the line apart using P3 as
4154: ** a delimiter. There should be P1 fields. If the input line contains
4155: ** more than P1 fields, ignore the excess. If the input line contains
4156: ** fewer than P1 fields, assume the remaining fields contain NULLs.
4157: **
4158: ** Input ends if a line consists of just "\.". A field containing only
4159: ** "\N" is a null field. The backslash \ character can be used be used
4160: ** to escape newlines or the delimiter.
4161: */
4162: case OP_FileRead: {
4163: int n, eol, nField, i, c, nDelim;
4164: char *zDelim, *z;
4165: CHECK_FOR_INTERRUPT;
4166: if( p->pFile==0 ) goto fileread_jump;
4167: nField = pOp->p1;
4168: if( nField<=0 ) goto fileread_jump;
4169: if( nField!=p->nField || p->azField==0 ){
4170: char **azField = sqliteRealloc(p->azField, sizeof(char*)*nField+1);
4171: if( azField==0 ){ goto no_mem; }
4172: p->azField = azField;
4173: p->nField = nField;
4174: }
4175: n = 0;
4176: eol = 0;
4177: while( eol==0 ){
4178: if( p->zLine==0 || n+200>p->nLineAlloc ){
4179: char *zLine;
4180: p->nLineAlloc = p->nLineAlloc*2 + 300;
4181: zLine = sqliteRealloc(p->zLine, p->nLineAlloc);
4182: if( zLine==0 ){
4183: p->nLineAlloc = 0;
4184: sqliteFree(p->zLine);
4185: p->zLine = 0;
4186: goto no_mem;
4187: }
4188: p->zLine = zLine;
4189: }
4190: if( vdbe_fgets(&p->zLine[n], p->nLineAlloc-n, p->pFile)==0 ){
4191: eol = 1;
4192: p->zLine[n] = 0;
4193: }else{
4194: int c;
4195: while( (c = p->zLine[n])!=0 ){
4196: if( c=='\\' ){
4197: if( p->zLine[n+1]==0 ) break;
4198: n += 2;
4199: }else if( c=='\n' ){
4200: p->zLine[n] = 0;
4201: eol = 1;
4202: break;
4203: }else{
4204: n++;
4205: }
4206: }
4207: }
4208: }
4209: if( n==0 ) goto fileread_jump;
4210: z = p->zLine;
4211: if( z[0]=='\\' && z[1]=='.' && z[2]==0 ){
4212: goto fileread_jump;
4213: }
4214: zDelim = pOp->p3;
4215: if( zDelim==0 ) zDelim = "\t";
4216: c = zDelim[0];
4217: nDelim = strlen(zDelim);
4218: p->azField[0] = z;
4219: for(i=1; *z!=0 && i<=nField; i++){
4220: int from, to;
4221: from = to = 0;
4222: if( z[0]=='\\' && z[1]=='N'
4223: && (z[2]==0 || strncmp(&z[2],zDelim,nDelim)==0) ){
4224: if( i<=nField ) p->azField[i-1] = 0;
4225: z += 2 + nDelim;
4226: if( i<nField ) p->azField[i] = z;
4227: continue;
4228: }
4229: while( z[from] ){
4230: if( z[from]=='\\' && z[from+1]!=0 ){
4231: int tx = z[from+1];
4232: switch( tx ){
4233: case 'b': tx = '\b'; break;
4234: case 'f': tx = '\f'; break;
4235: case 'n': tx = '\n'; break;
4236: case 'r': tx = '\r'; break;
4237: case 't': tx = '\t'; break;
4238: case 'v': tx = '\v'; break;
4239: default: break;
4240: }
4241: z[to++] = tx;
4242: from += 2;
4243: continue;
4244: }
4245: if( z[from]==c && strncmp(&z[from],zDelim,nDelim)==0 ) break;
4246: z[to++] = z[from++];
4247: }
4248: if( z[from] ){
4249: z[to] = 0;
4250: z += from + nDelim;
4251: if( i<nField ) p->azField[i] = z;
4252: }else{
4253: z[to] = 0;
4254: z = "";
4255: }
4256: }
4257: while( i<nField ){
4258: p->azField[i++] = 0;
4259: }
4260: break;
4261:
4262: /* If we reach end-of-file, or if anything goes wrong, jump here.
4263: ** This code will cause a jump to P2 */
4264: fileread_jump:
4265: pc = pOp->p2 - 1;
4266: break;
4267: }
4268:
4269: /* Opcode: FileColumn P1 * *
4270: **
4271: ** Push onto the stack the P1-th column of the most recently read line
4272: ** from the input file.
4273: */
4274: case OP_FileColumn: {
4275: int i = pOp->p1;
4276: char *z;
4277: assert( i>=0 && i<p->nField );
4278: if( p->azField ){
4279: z = p->azField[i];
4280: }else{
4281: z = 0;
4282: }
4283: pTos++;
4284: if( z ){
4285: pTos->n = strlen(z) + 1;
4286: pTos->z = z;
4287: pTos->flags = MEM_Str | MEM_Ephem;
4288: }else{
4289: pTos->flags = MEM_Null;
4290: }
4291: break;
4292: }
4293:
4294: /* Opcode: MemStore P1 P2 *
4295: **
4296: ** Write the top of the stack into memory location P1.
4297: ** P1 should be a small integer since space is allocated
4298: ** for all memory locations between 0 and P1 inclusive.
4299: **
4300: ** After the data is stored in the memory location, the
4301: ** stack is popped once if P2 is 1. If P2 is zero, then
4302: ** the original data remains on the stack.
4303: */
4304: case OP_MemStore: {
4305: int i = pOp->p1;
4306: Mem *pMem;
4307: assert( pTos>=p->aStack );
4308: if( i>=p->nMem ){
4309: int nOld = p->nMem;
4310: Mem *aMem;
4311: p->nMem = i + 5;
4312: aMem = sqliteRealloc(p->aMem, p->nMem*sizeof(p->aMem[0]));
4313: if( aMem==0 ) goto no_mem;
4314: if( aMem!=p->aMem ){
4315: int j;
4316: for(j=0; j<nOld; j++){
4317: if( aMem[j].flags & MEM_Short ){
4318: aMem[j].z = aMem[j].zShort;
4319: }
4320: }
4321: }
4322: p->aMem = aMem;
4323: if( nOld<p->nMem ){
4324: memset(&p->aMem[nOld], 0, sizeof(p->aMem[0])*(p->nMem-nOld));
4325: }
4326: }
4327: Deephemeralize(pTos);
4328: pMem = &p->aMem[i];
4329: Release(pMem);
4330: *pMem = *pTos;
4331: if( pMem->flags & MEM_Dyn ){
4332: if( pOp->p2 ){
4333: pTos->flags = MEM_Null;
4334: }else{
4335: pMem->z = sqliteMallocRaw( pMem->n );
4336: if( pMem->z==0 ) goto no_mem;
4337: memcpy(pMem->z, pTos->z, pMem->n);
4338: }
4339: }else if( pMem->flags & MEM_Short ){
4340: pMem->z = pMem->zShort;
4341: }
4342: if( pOp->p2 ){
4343: Release(pTos);
4344: pTos--;
4345: }
4346: break;
4347: }
4348:
4349: /* Opcode: MemLoad P1 * *
4350: **
4351: ** Push a copy of the value in memory location P1 onto the stack.
4352: **
4353: ** If the value is a string, then the value pushed is a pointer to
4354: ** the string that is stored in the memory location. If the memory
4355: ** location is subsequently changed (using OP_MemStore) then the
4356: ** value pushed onto the stack will change too.
4357: */
4358: case OP_MemLoad: {
4359: int i = pOp->p1;
4360: assert( i>=0 && i<p->nMem );
4361: pTos++;
4362: memcpy(pTos, &p->aMem[i], sizeof(pTos[0])-NBFS);;
4363: if( pTos->flags & MEM_Str ){
4364: pTos->flags |= MEM_Ephem;
4365: pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short);
4366: }
4367: break;
4368: }
4369:
4370: /* Opcode: MemIncr P1 P2 *
4371: **
4372: ** Increment the integer valued memory cell P1 by 1. If P2 is not zero
4373: ** and the result after the increment is greater than zero, then jump
4374: ** to P2.
4375: **
4376: ** This instruction throws an error if the memory cell is not initially
4377: ** an integer.
4378: */
4379: case OP_MemIncr: {
4380: int i = pOp->p1;
4381: Mem *pMem;
4382: assert( i>=0 && i<p->nMem );
4383: pMem = &p->aMem[i];
4384: assert( pMem->flags==MEM_Int );
4385: pMem->i++;
4386: if( pOp->p2>0 && pMem->i>0 ){
4387: pc = pOp->p2 - 1;
4388: }
4389: break;
4390: }
4391:
4392: /* Opcode: AggReset * P2 *
4393: **
4394: ** Reset the aggregator so that it no longer contains any data.
4395: ** Future aggregator elements will contain P2 values each.
4396: */
4397: case OP_AggReset: {
4398: sqliteVdbeAggReset(&p->agg);
4399: p->agg.nMem = pOp->p2;
4400: p->agg.apFunc = sqliteMalloc( p->agg.nMem*sizeof(p->agg.apFunc[0]) );
4401: if( p->agg.apFunc==0 ) goto no_mem;
4402: break;
4403: }
4404:
4405: /* Opcode: AggInit * P2 P3
4406: **
4407: ** Initialize the function parameters for an aggregate function.
4408: ** The aggregate will operate out of aggregate column P2.
4409: ** P3 is a pointer to the FuncDef structure for the function.
4410: */
4411: case OP_AggInit: {
4412: int i = pOp->p2;
4413: assert( i>=0 && i<p->agg.nMem );
4414: p->agg.apFunc[i] = (FuncDef*)pOp->p3;
4415: break;
4416: }
4417:
4418: /* Opcode: AggFunc * P2 P3
4419: **
4420: ** Execute the step function for an aggregate. The
4421: ** function has P2 arguments. P3 is a pointer to the FuncDef
4422: ** structure that specifies the function.
4423: **
4424: ** The top of the stack must be an integer which is the index of
4425: ** the aggregate column that corresponds to this aggregate function.
4426: ** Ideally, this index would be another parameter, but there are
4427: ** no free parameters left. The integer is popped from the stack.
4428: */
4429: case OP_AggFunc: {
4430: int n = pOp->p2;
4431: int i;
4432: Mem *pMem, *pRec;
4433: char **azArgv = p->zArgv;
4434: sqlite_func ctx;
4435:
4436: assert( n>=0 );
4437: assert( pTos->flags==MEM_Int );
4438: pRec = &pTos[-n];
4439: assert( pRec>=p->aStack );
4440: for(i=0; i<n; i++, pRec++){
4441: if( pRec->flags & MEM_Null ){
4442: azArgv[i] = 0;
4443: }else{
4444: Stringify(pRec);
4445: azArgv[i] = pRec->z;
4446: }
4447: }
4448: i = pTos->i;
4449: assert( i>=0 && i<p->agg.nMem );
4450: ctx.pFunc = (FuncDef*)pOp->p3;
4451: pMem = &p->agg.pCurrent->aMem[i];
4452: ctx.s.z = pMem->zShort; /* Space used for small aggregate contexts */
4453: ctx.pAgg = pMem->z;
4454: ctx.cnt = ++pMem->i;
4455: ctx.isError = 0;
4456: ctx.isStep = 1;
4457: (ctx.pFunc->xStep)(&ctx, n, (const char**)azArgv);
4458: pMem->z = ctx.pAgg;
4459: pMem->flags = MEM_AggCtx;
4460: popStack(&pTos, n+1);
4461: if( ctx.isError ){
4462: rc = SQLITE_ERROR;
4463: }
4464: break;
4465: }
4466:
4467: /* Opcode: AggFocus * P2 *
4468: **
4469: ** Pop the top of the stack and use that as an aggregator key. If
4470: ** an aggregator with that same key already exists, then make the
4471: ** aggregator the current aggregator and jump to P2. If no aggregator
4472: ** with the given key exists, create one and make it current but
4473: ** do not jump.
4474: **
4475: ** The order of aggregator opcodes is important. The order is:
4476: ** AggReset AggFocus AggNext. In other words, you must execute
4477: ** AggReset first, then zero or more AggFocus operations, then
4478: ** zero or more AggNext operations. You must not execute an AggFocus
4479: ** in between an AggNext and an AggReset.
4480: */
4481: case OP_AggFocus: {
4482: AggElem *pElem;
4483: char *zKey;
4484: int nKey;
4485:
4486: assert( pTos>=p->aStack );
4487: Stringify(pTos);
4488: zKey = pTos->z;
4489: nKey = pTos->n;
4490: pElem = sqliteHashFind(&p->agg.hash, zKey, nKey);
4491: if( pElem ){
4492: p->agg.pCurrent = pElem;
4493: pc = pOp->p2 - 1;
4494: }else{
4495: AggInsert(&p->agg, zKey, nKey);
4496: if( sqlite_malloc_failed ) goto no_mem;
4497: }
4498: Release(pTos);
4499: pTos--;
4500: break;
4501: }
4502:
4503: /* Opcode: AggSet * P2 *
4504: **
4505: ** Move the top of the stack into the P2-th field of the current
4506: ** aggregate. String values are duplicated into new memory.
4507: */
4508: case OP_AggSet: {
4509: AggElem *pFocus = AggInFocus(p->agg);
4510: Mem *pMem;
4511: int i = pOp->p2;
4512: assert( pTos>=p->aStack );
4513: if( pFocus==0 ) goto no_mem;
4514: assert( i>=0 && i<p->agg.nMem );
4515: Deephemeralize(pTos);
4516: pMem = &pFocus->aMem[i];
4517: Release(pMem);
4518: *pMem = *pTos;
4519: if( pMem->flags & MEM_Dyn ){
4520: pTos->flags = MEM_Null;
4521: }else if( pMem->flags & MEM_Short ){
4522: pMem->z = pMem->zShort;
4523: }
4524: Release(pTos);
4525: pTos--;
4526: break;
4527: }
4528:
4529: /* Opcode: AggGet * P2 *
4530: **
4531: ** Push a new entry onto the stack which is a copy of the P2-th field
4532: ** of the current aggregate. Strings are not duplicated so
4533: ** string values will be ephemeral.
4534: */
4535: case OP_AggGet: {
4536: AggElem *pFocus = AggInFocus(p->agg);
4537: Mem *pMem;
4538: int i = pOp->p2;
4539: if( pFocus==0 ) goto no_mem;
4540: assert( i>=0 && i<p->agg.nMem );
4541: pTos++;
4542: pMem = &pFocus->aMem[i];
4543: *pTos = *pMem;
4544: if( pTos->flags & MEM_Str ){
4545: pTos->flags &= ~(MEM_Dyn|MEM_Static|MEM_Short);
4546: pTos->flags |= MEM_Ephem;
4547: }
4548: if( pTos->flags & MEM_AggCtx ){
4549: Release(pTos);
4550: pTos->flags = MEM_Null;
4551: }
4552: break;
4553: }
4554:
4555: /* Opcode: AggNext * P2 *
4556: **
4557: ** Make the next aggregate value the current aggregate. The prior
4558: ** aggregate is deleted. If all aggregate values have been consumed,
4559: ** jump to P2.
4560: **
4561: ** The order of aggregator opcodes is important. The order is:
4562: ** AggReset AggFocus AggNext. In other words, you must execute
4563: ** AggReset first, then zero or more AggFocus operations, then
4564: ** zero or more AggNext operations. You must not execute an AggFocus
4565: ** in between an AggNext and an AggReset.
4566: */
4567: case OP_AggNext: {
4568: CHECK_FOR_INTERRUPT;
4569: if( p->agg.pSearch==0 ){
4570: p->agg.pSearch = sqliteHashFirst(&p->agg.hash);
4571: }else{
4572: p->agg.pSearch = sqliteHashNext(p->agg.pSearch);
4573: }
4574: if( p->agg.pSearch==0 ){
4575: pc = pOp->p2 - 1;
4576: } else {
4577: int i;
4578: sqlite_func ctx;
4579: Mem *aMem;
4580: p->agg.pCurrent = sqliteHashData(p->agg.pSearch);
4581: aMem = p->agg.pCurrent->aMem;
4582: for(i=0; i<p->agg.nMem; i++){
4583: int freeCtx;
4584: if( p->agg.apFunc[i]==0 ) continue;
4585: if( p->agg.apFunc[i]->xFinalize==0 ) continue;
4586: ctx.s.flags = MEM_Null;
4587: ctx.s.z = aMem[i].zShort;
4588: ctx.pAgg = (void*)aMem[i].z;
4589: freeCtx = aMem[i].z && aMem[i].z!=aMem[i].zShort;
4590: ctx.cnt = aMem[i].i;
4591: ctx.isStep = 0;
4592: ctx.pFunc = p->agg.apFunc[i];
4593: (*p->agg.apFunc[i]->xFinalize)(&ctx);
4594: if( freeCtx ){
4595: sqliteFree( aMem[i].z );
4596: }
4597: aMem[i] = ctx.s;
4598: if( aMem[i].flags & MEM_Short ){
4599: aMem[i].z = aMem[i].zShort;
4600: }
4601: }
4602: }
4603: break;
4604: }
4605:
4606: /* Opcode: SetInsert P1 * P3
4607: **
4608: ** If Set P1 does not exist then create it. Then insert value
4609: ** P3 into that set. If P3 is NULL, then insert the top of the
4610: ** stack into the set.
4611: */
4612: case OP_SetInsert: {
4613: int i = pOp->p1;
4614: if( p->nSet<=i ){
4615: int k;
4616: Set *aSet = sqliteRealloc(p->aSet, (i+1)*sizeof(p->aSet[0]) );
4617: if( aSet==0 ) goto no_mem;
4618: p->aSet = aSet;
4619: for(k=p->nSet; k<=i; k++){
4620: sqliteHashInit(&p->aSet[k].hash, SQLITE_HASH_BINARY, 1);
4621: }
4622: p->nSet = i+1;
4623: }
4624: if( pOp->p3 ){
4625: sqliteHashInsert(&p->aSet[i].hash, pOp->p3, strlen(pOp->p3)+1, p);
4626: }else{
4627: assert( pTos>=p->aStack );
4628: Stringify(pTos);
4629: sqliteHashInsert(&p->aSet[i].hash, pTos->z, pTos->n, p);
4630: Release(pTos);
4631: pTos--;
4632: }
4633: if( sqlite_malloc_failed ) goto no_mem;
4634: break;
4635: }
4636:
4637: /* Opcode: SetFound P1 P2 *
4638: **
4639: ** Pop the stack once and compare the value popped off with the
4640: ** contents of set P1. If the element popped exists in set P1,
4641: ** then jump to P2. Otherwise fall through.
4642: */
4643: case OP_SetFound: {
4644: int i = pOp->p1;
4645: assert( pTos>=p->aStack );
4646: Stringify(pTos);
4647: if( i>=0 && i<p->nSet && sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)){
4648: pc = pOp->p2 - 1;
4649: }
4650: Release(pTos);
4651: pTos--;
4652: break;
4653: }
4654:
4655: /* Opcode: SetNotFound P1 P2 *
4656: **
4657: ** Pop the stack once and compare the value popped off with the
4658: ** contents of set P1. If the element popped does not exists in
4659: ** set P1, then jump to P2. Otherwise fall through.
4660: */
4661: case OP_SetNotFound: {
4662: int i = pOp->p1;
4663: assert( pTos>=p->aStack );
4664: Stringify(pTos);
4665: if( i<0 || i>=p->nSet ||
4666: sqliteHashFind(&p->aSet[i].hash, pTos->z, pTos->n)==0 ){
4667: pc = pOp->p2 - 1;
4668: }
4669: Release(pTos);
4670: pTos--;
4671: break;
4672: }
4673:
4674: /* Opcode: SetFirst P1 P2 *
4675: **
4676: ** Read the first element from set P1 and push it onto the stack. If the
4677: ** set is empty, push nothing and jump immediately to P2. This opcode is
4678: ** used in combination with OP_SetNext to loop over all elements of a set.
4679: */
4680: /* Opcode: SetNext P1 P2 *
4681: **
4682: ** Read the next element from set P1 and push it onto the stack. If there
4683: ** are no more elements in the set, do not do the push and fall through.
4684: ** Otherwise, jump to P2 after pushing the next set element.
4685: */
4686: case OP_SetFirst:
4687: case OP_SetNext: {
4688: Set *pSet;
4689: CHECK_FOR_INTERRUPT;
4690: if( pOp->p1<0 || pOp->p1>=p->nSet ){
4691: if( pOp->opcode==OP_SetFirst ) pc = pOp->p2 - 1;
4692: break;
4693: }
4694: pSet = &p->aSet[pOp->p1];
4695: if( pOp->opcode==OP_SetFirst ){
4696: pSet->prev = sqliteHashFirst(&pSet->hash);
4697: if( pSet->prev==0 ){
4698: pc = pOp->p2 - 1;
4699: break;
4700: }
4701: }else{
4702: if( pSet->prev ){
4703: pSet->prev = sqliteHashNext(pSet->prev);
4704: }
4705: if( pSet->prev==0 ){
4706: break;
4707: }else{
4708: pc = pOp->p2 - 1;
4709: }
4710: }
4711: pTos++;
4712: pTos->z = sqliteHashKey(pSet->prev);
4713: pTos->n = sqliteHashKeysize(pSet->prev);
4714: pTos->flags = MEM_Str | MEM_Ephem;
4715: break;
4716: }
4717:
4718: /* Opcode: Vacuum * * *
4719: **
4720: ** Vacuum the entire database. This opcode will cause other virtual
4721: ** machines to be created and run. It may not be called from within
4722: ** a transaction.
4723: */
4724: case OP_Vacuum: {
4725: if( sqliteSafetyOff(db) ) goto abort_due_to_misuse;
4726: rc = sqliteRunVacuum(&p->zErrMsg, db);
4727: if( sqliteSafetyOn(db) ) goto abort_due_to_misuse;
4728: break;
4729: }
4730:
4731: /* Opcode: StackDepth * * *
4732: **
4733: ** Push an integer onto the stack which is the depth of the stack prior
4734: ** to that integer being pushed.
4735: */
4736: case OP_StackDepth: {
4737: int depth = (&pTos[1]) - p->aStack;
4738: pTos++;
4739: pTos->i = depth;
4740: pTos->flags = MEM_Int;
4741: break;
4742: }
4743:
4744: /* Opcode: StackReset * * *
4745: **
4746: ** Pop a single integer off of the stack. Then pop the stack
4747: ** as many times as necessary to get the depth of the stack down
4748: ** to the value of the integer that was popped.
4749: */
4750: case OP_StackReset: {
4751: int depth, goal;
4752: assert( pTos>=p->aStack );
4753: Integerify(pTos);
4754: goal = pTos->i;
4755: depth = (&pTos[1]) - p->aStack;
4756: assert( goal<depth );
4757: popStack(&pTos, depth-goal);
4758: break;
4759: }
4760:
4761: /* An other opcode is illegal...
4762: */
4763: default: {
4764: sqlite_snprintf(sizeof(zBuf),zBuf,"%d",pOp->opcode);
4765: sqliteSetString(&p->zErrMsg, "unknown opcode ", zBuf, (char*)0);
4766: rc = SQLITE_INTERNAL;
4767: break;
4768: }
4769:
4770: /*****************************************************************************
4771: ** The cases of the switch statement above this line should all be indented
4772: ** by 6 spaces. But the left-most 6 spaces have been removed to improve the
4773: ** readability. From this point on down, the normal indentation rules are
4774: ** restored.
4775: *****************************************************************************/
4776: }
4777:
4778: #ifdef VDBE_PROFILE
4779: {
4780: long long elapse = hwtime() - start;
4781: pOp->cycles += elapse;
4782: pOp->cnt++;
4783: #if 0
4784: fprintf(stdout, "%10lld ", elapse);
4785: sqliteVdbePrintOp(stdout, origPc, &p->aOp[origPc]);
4786: #endif
4787: }
4788: #endif
4789:
4790: /* The following code adds nothing to the actual functionality
4791: ** of the program. It is only here for testing and debugging.
4792: ** On the other hand, it does burn CPU cycles every time through
4793: ** the evaluator loop. So we can leave it out when NDEBUG is defined.
4794: */
4795: #ifndef NDEBUG
4796: /* Sanity checking on the top element of the stack */
4797: if( pTos>=p->aStack ){
4798: assert( pTos->flags!=0 ); /* Must define some type */
4799: if( pTos->flags & MEM_Str ){
4800: int x = pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short);
4801: assert( x!=0 ); /* Strings must define a string subtype */
4802: assert( (x & (x-1))==0 ); /* Only one string subtype can be defined */
4803: assert( pTos->z!=0 ); /* Strings must have a value */
4804: /* Mem.z points to Mem.zShort iff the subtype is MEM_Short */
4805: assert( (pTos->flags & MEM_Short)==0 || pTos->z==pTos->zShort );
4806: assert( (pTos->flags & MEM_Short)!=0 || pTos->z!=pTos->zShort );
4807: }else{
4808: /* Cannot define a string subtype for non-string objects */
4809: assert( (pTos->flags & (MEM_Static|MEM_Dyn|MEM_Ephem|MEM_Short))==0 );
4810: }
4811: /* MEM_Null excludes all other types */
4812: assert( pTos->flags==MEM_Null || (pTos->flags&MEM_Null)==0 );
4813: }
4814: if( pc<-1 || pc>=p->nOp ){
4815: sqliteSetString(&p->zErrMsg, "jump destination out of range", (char*)0);
4816: rc = SQLITE_INTERNAL;
4817: }
4818: if( p->trace && pTos>=p->aStack ){
4819: int i;
4820: fprintf(p->trace, "Stack:");
4821: for(i=0; i>-5 && &pTos[i]>=p->aStack; i--){
4822: if( pTos[i].flags & MEM_Null ){
4823: fprintf(p->trace, " NULL");
4824: }else if( (pTos[i].flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
4825: fprintf(p->trace, " si:%d", pTos[i].i);
4826: }else if( pTos[i].flags & MEM_Int ){
4827: fprintf(p->trace, " i:%d", pTos[i].i);
4828: }else if( pTos[i].flags & MEM_Real ){
4829: fprintf(p->trace, " r:%g", pTos[i].r);
4830: }else if( pTos[i].flags & MEM_Str ){
4831: int j, k;
4832: char zBuf[100];
4833: zBuf[0] = ' ';
4834: if( pTos[i].flags & MEM_Dyn ){
4835: zBuf[1] = 'z';
4836: assert( (pTos[i].flags & (MEM_Static|MEM_Ephem))==0 );
4837: }else if( pTos[i].flags & MEM_Static ){
4838: zBuf[1] = 't';
4839: assert( (pTos[i].flags & (MEM_Dyn|MEM_Ephem))==0 );
4840: }else if( pTos[i].flags & MEM_Ephem ){
4841: zBuf[1] = 'e';
4842: assert( (pTos[i].flags & (MEM_Static|MEM_Dyn))==0 );
4843: }else{
4844: zBuf[1] = 's';
4845: }
4846: zBuf[2] = '[';
4847: k = 3;
4848: for(j=0; j<20 && j<pTos[i].n; j++){
4849: int c = pTos[i].z[j];
4850: if( c==0 && j==pTos[i].n-1 ) break;
4851: if( isprint(c) && !isspace(c) ){
4852: zBuf[k++] = c;
4853: }else{
4854: zBuf[k++] = '.';
4855: }
4856: }
4857: zBuf[k++] = ']';
4858: zBuf[k++] = 0;
4859: fprintf(p->trace, "%s", zBuf);
4860: }else{
4861: fprintf(p->trace, " ???");
4862: }
4863: }
4864: if( rc!=0 ) fprintf(p->trace," rc=%d",rc);
4865: fprintf(p->trace,"\n");
4866: }
4867: #endif
4868: } /* The end of the for(;;) loop the loops through opcodes */
4869:
4870: /* If we reach this point, it means that execution is finished.
4871: */
4872: vdbe_halt:
4873: CHECK_FOR_INTERRUPT
4874: if( rc ){
4875: p->rc = rc;
4876: rc = SQLITE_ERROR;
4877: }else{
4878: rc = SQLITE_DONE;
4879: }
4880: p->magic = VDBE_MAGIC_HALT;
4881: p->pTos = pTos;
4882: return rc;
4883:
4884: /* Jump to here if a malloc() fails. It's hard to get a malloc()
4885: ** to fail on a modern VM computer, so this code is untested.
4886: */
4887: no_mem:
4888: sqliteSetString(&p->zErrMsg, "out of memory", (char*)0);
4889: rc = SQLITE_NOMEM;
4890: goto vdbe_halt;
4891:
4892: /* Jump to here for an SQLITE_MISUSE error.
4893: */
4894: abort_due_to_misuse:
4895: rc = SQLITE_MISUSE;
4896: /* Fall thru into abort_due_to_error */
4897:
4898: /* Jump to here for any other kind of fatal error. The "rc" variable
4899: ** should hold the error number.
4900: */
4901: abort_due_to_error:
4902: if( p->zErrMsg==0 ){
4903: if( sqlite_malloc_failed ) rc = SQLITE_NOMEM;
4904: sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
4905: }
4906: goto vdbe_halt;
4907:
4908: /* Jump to here if the sqlite_interrupt() API sets the interrupt
4909: ** flag.
4910: */
4911: abort_due_to_interrupt:
4912: assert( db->flags & SQLITE_Interrupt );
4913: db->flags &= ~SQLITE_Interrupt;
4914: if( db->magic!=SQLITE_MAGIC_BUSY ){
4915: rc = SQLITE_MISUSE;
4916: }else{
4917: rc = SQLITE_INTERRUPT;
4918: }
4919: sqliteSetString(&p->zErrMsg, sqlite_error_string(rc), (char*)0);
4920: goto vdbe_halt;
4921: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to vdbe.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