Annotation of embedaddon/sqlite3/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 "sqlite3_stmt*" 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 5 operands. Operands P1, P2, and P3 are integers. Operand P4
26: ** is a null-terminated string. Operand P5 is an unsigned character.
27: ** Few opcodes use all 5 operands.
28: **
29: ** Computation results are stored on a set of registers numbered beginning
30: ** with 1 and going up to Vdbe.nMem. Each register can store
31: ** either an integer, a null-terminated string, a floating point
32: ** number, or the SQL "NULL" value. An implicit 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 sqlite3VdbeExec()
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: #include "sqliteInt.h"
47: #include "vdbeInt.h"
48:
49: /*
50: ** Invoke this macro on memory cells just prior to changing the
51: ** value of the cell. This macro verifies that shallow copies are
52: ** not misused.
53: */
54: #ifdef SQLITE_DEBUG
55: # define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M)
56: #else
57: # define memAboutToChange(P,M)
58: #endif
59:
60: /*
61: ** The following global variable is incremented every time a cursor
62: ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test
63: ** procedures use this information to make sure that indices are
64: ** working correctly. This variable has no function other than to
65: ** help verify the correct operation of the library.
66: */
67: #ifdef SQLITE_TEST
68: int sqlite3_search_count = 0;
69: #endif
70:
71: /*
72: ** When this global variable is positive, it gets decremented once before
73: ** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted
74: ** field of the sqlite3 structure is set in order to simulate an interrupt.
75: **
76: ** This facility is used for testing purposes only. It does not function
77: ** in an ordinary build.
78: */
79: #ifdef SQLITE_TEST
80: int sqlite3_interrupt_count = 0;
81: #endif
82:
83: /*
84: ** The next global variable is incremented each type the OP_Sort opcode
85: ** is executed. The test procedures use this information to make sure that
86: ** sorting is occurring or not occurring at appropriate times. This variable
87: ** has no function other than to help verify the correct operation of the
88: ** library.
89: */
90: #ifdef SQLITE_TEST
91: int sqlite3_sort_count = 0;
92: #endif
93:
94: /*
95: ** The next global variable records the size of the largest MEM_Blob
96: ** or MEM_Str that has been used by a VDBE opcode. The test procedures
97: ** use this information to make sure that the zero-blob functionality
98: ** is working correctly. This variable has no function other than to
99: ** help verify the correct operation of the library.
100: */
101: #ifdef SQLITE_TEST
102: int sqlite3_max_blobsize = 0;
103: static void updateMaxBlobsize(Mem *p){
104: if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
105: sqlite3_max_blobsize = p->n;
106: }
107: }
108: #endif
109:
110: /*
111: ** The next global variable is incremented each type the OP_Found opcode
112: ** is executed. This is used to test whether or not the foreign key
113: ** operation implemented using OP_FkIsZero is working. This variable
114: ** has no function other than to help verify the correct operation of the
115: ** library.
116: */
117: #ifdef SQLITE_TEST
118: int sqlite3_found_count = 0;
119: #endif
120:
121: /*
122: ** Test a register to see if it exceeds the current maximum blob size.
123: ** If it does, record the new maximum blob size.
124: */
125: #if defined(SQLITE_TEST) && !defined(SQLITE_OMIT_BUILTIN_TEST)
126: # define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P)
127: #else
128: # define UPDATE_MAX_BLOBSIZE(P)
129: #endif
130:
131: /*
132: ** Convert the given register into a string if it isn't one
133: ** already. Return non-zero if a malloc() fails.
134: */
135: #define Stringify(P, enc) \
136: if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc)) \
137: { goto no_mem; }
138:
139: /*
140: ** An ephemeral string value (signified by the MEM_Ephem flag) contains
141: ** a pointer to a dynamically allocated string where some other entity
142: ** is responsible for deallocating that string. Because the register
143: ** does not control the string, it might be deleted without the register
144: ** knowing it.
145: **
146: ** This routine converts an ephemeral string into a dynamically allocated
147: ** string that the register itself controls. In other words, it
148: ** converts an MEM_Ephem string into an MEM_Dyn string.
149: */
150: #define Deephemeralize(P) \
151: if( ((P)->flags&MEM_Ephem)!=0 \
152: && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
153:
154: /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
155: #ifdef SQLITE_OMIT_MERGE_SORT
156: # define isSorter(x) 0
157: #else
158: # define isSorter(x) ((x)->pSorter!=0)
159: #endif
160:
161: /*
162: ** Argument pMem points at a register that will be passed to a
163: ** user-defined function or returned to the user as the result of a query.
164: ** This routine sets the pMem->type variable used by the sqlite3_value_*()
165: ** routines.
166: */
167: void sqlite3VdbeMemStoreType(Mem *pMem){
168: int flags = pMem->flags;
169: if( flags & MEM_Null ){
170: pMem->type = SQLITE_NULL;
171: }
172: else if( flags & MEM_Int ){
173: pMem->type = SQLITE_INTEGER;
174: }
175: else if( flags & MEM_Real ){
176: pMem->type = SQLITE_FLOAT;
177: }
178: else if( flags & MEM_Str ){
179: pMem->type = SQLITE_TEXT;
180: }else{
181: pMem->type = SQLITE_BLOB;
182: }
183: }
184:
185: /*
186: ** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL
187: ** if we run out of memory.
188: */
189: static VdbeCursor *allocateCursor(
190: Vdbe *p, /* The virtual machine */
191: int iCur, /* Index of the new VdbeCursor */
192: int nField, /* Number of fields in the table or index */
193: int iDb, /* Database the cursor belongs to, or -1 */
194: int isBtreeCursor /* True for B-Tree. False for pseudo-table or vtab */
195: ){
196: /* Find the memory cell that will be used to store the blob of memory
197: ** required for this VdbeCursor structure. It is convenient to use a
198: ** vdbe memory cell to manage the memory allocation required for a
199: ** VdbeCursor structure for the following reasons:
200: **
201: ** * Sometimes cursor numbers are used for a couple of different
202: ** purposes in a vdbe program. The different uses might require
203: ** different sized allocations. Memory cells provide growable
204: ** allocations.
205: **
206: ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
207: ** be freed lazily via the sqlite3_release_memory() API. This
208: ** minimizes the number of malloc calls made by the system.
209: **
210: ** Memory cells for cursors are allocated at the top of the address
211: ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for
212: ** cursor 1 is managed by memory cell (p->nMem-1), etc.
213: */
214: Mem *pMem = &p->aMem[p->nMem-iCur];
215:
216: int nByte;
217: VdbeCursor *pCx = 0;
218: nByte =
219: ROUND8(sizeof(VdbeCursor)) +
220: (isBtreeCursor?sqlite3BtreeCursorSize():0) +
221: 2*nField*sizeof(u32);
222:
223: assert( iCur<p->nCursor );
224: if( p->apCsr[iCur] ){
225: sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
226: p->apCsr[iCur] = 0;
227: }
228: if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
229: p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
230: memset(pCx, 0, sizeof(VdbeCursor));
231: pCx->iDb = iDb;
232: pCx->nField = nField;
233: if( nField ){
234: pCx->aType = (u32 *)&pMem->z[ROUND8(sizeof(VdbeCursor))];
235: }
236: if( isBtreeCursor ){
237: pCx->pCursor = (BtCursor*)
238: &pMem->z[ROUND8(sizeof(VdbeCursor))+2*nField*sizeof(u32)];
239: sqlite3BtreeCursorZero(pCx->pCursor);
240: }
241: }
242: return pCx;
243: }
244:
245: /*
246: ** Try to convert a value into a numeric representation if we can
247: ** do so without loss of information. In other words, if the string
248: ** looks like a number, convert it into a number. If it does not
249: ** look like a number, leave it alone.
250: */
251: static void applyNumericAffinity(Mem *pRec){
252: if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){
253: double rValue;
254: i64 iValue;
255: u8 enc = pRec->enc;
256: if( (pRec->flags&MEM_Str)==0 ) return;
257: if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return;
258: if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){
259: pRec->u.i = iValue;
260: pRec->flags |= MEM_Int;
261: }else{
262: pRec->r = rValue;
263: pRec->flags |= MEM_Real;
264: }
265: }
266: }
267:
268: /*
269: ** Processing is determine by the affinity parameter:
270: **
271: ** SQLITE_AFF_INTEGER:
272: ** SQLITE_AFF_REAL:
273: ** SQLITE_AFF_NUMERIC:
274: ** Try to convert pRec to an integer representation or a
275: ** floating-point representation if an integer representation
276: ** is not possible. Note that the integer representation is
277: ** always preferred, even if the affinity is REAL, because
278: ** an integer representation is more space efficient on disk.
279: **
280: ** SQLITE_AFF_TEXT:
281: ** Convert pRec to a text representation.
282: **
283: ** SQLITE_AFF_NONE:
284: ** No-op. pRec is unchanged.
285: */
286: static void applyAffinity(
287: Mem *pRec, /* The value to apply affinity to */
288: char affinity, /* The affinity to be applied */
289: u8 enc /* Use this text encoding */
290: ){
291: if( affinity==SQLITE_AFF_TEXT ){
292: /* Only attempt the conversion to TEXT if there is an integer or real
293: ** representation (blob and NULL do not get converted) but no string
294: ** representation.
295: */
296: if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){
297: sqlite3VdbeMemStringify(pRec, enc);
298: }
299: pRec->flags &= ~(MEM_Real|MEM_Int);
300: }else if( affinity!=SQLITE_AFF_NONE ){
301: assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
302: || affinity==SQLITE_AFF_NUMERIC );
303: applyNumericAffinity(pRec);
304: if( pRec->flags & MEM_Real ){
305: sqlite3VdbeIntegerAffinity(pRec);
306: }
307: }
308: }
309:
310: /*
311: ** Try to convert the type of a function argument or a result column
312: ** into a numeric representation. Use either INTEGER or REAL whichever
313: ** is appropriate. But only do the conversion if it is possible without
314: ** loss of information and return the revised type of the argument.
315: */
316: int sqlite3_value_numeric_type(sqlite3_value *pVal){
317: Mem *pMem = (Mem*)pVal;
318: if( pMem->type==SQLITE_TEXT ){
319: applyNumericAffinity(pMem);
320: sqlite3VdbeMemStoreType(pMem);
321: }
322: return pMem->type;
323: }
324:
325: /*
326: ** Exported version of applyAffinity(). This one works on sqlite3_value*,
327: ** not the internal Mem* type.
328: */
329: void sqlite3ValueApplyAffinity(
330: sqlite3_value *pVal,
331: u8 affinity,
332: u8 enc
333: ){
334: applyAffinity((Mem *)pVal, affinity, enc);
335: }
336:
337: #ifdef SQLITE_DEBUG
338: /*
339: ** Write a nice string representation of the contents of cell pMem
340: ** into buffer zBuf, length nBuf.
341: */
342: void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
343: char *zCsr = zBuf;
344: int f = pMem->flags;
345:
346: static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
347:
348: if( f&MEM_Blob ){
349: int i;
350: char c;
351: if( f & MEM_Dyn ){
352: c = 'z';
353: assert( (f & (MEM_Static|MEM_Ephem))==0 );
354: }else if( f & MEM_Static ){
355: c = 't';
356: assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
357: }else if( f & MEM_Ephem ){
358: c = 'e';
359: assert( (f & (MEM_Static|MEM_Dyn))==0 );
360: }else{
361: c = 's';
362: }
363:
364: sqlite3_snprintf(100, zCsr, "%c", c);
365: zCsr += sqlite3Strlen30(zCsr);
366: sqlite3_snprintf(100, zCsr, "%d[", pMem->n);
367: zCsr += sqlite3Strlen30(zCsr);
368: for(i=0; i<16 && i<pMem->n; i++){
369: sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
370: zCsr += sqlite3Strlen30(zCsr);
371: }
372: for(i=0; i<16 && i<pMem->n; i++){
373: char z = pMem->z[i];
374: if( z<32 || z>126 ) *zCsr++ = '.';
375: else *zCsr++ = z;
376: }
377:
378: sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);
379: zCsr += sqlite3Strlen30(zCsr);
380: if( f & MEM_Zero ){
381: sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero);
382: zCsr += sqlite3Strlen30(zCsr);
383: }
384: *zCsr = '\0';
385: }else if( f & MEM_Str ){
386: int j, k;
387: zBuf[0] = ' ';
388: if( f & MEM_Dyn ){
389: zBuf[1] = 'z';
390: assert( (f & (MEM_Static|MEM_Ephem))==0 );
391: }else if( f & MEM_Static ){
392: zBuf[1] = 't';
393: assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
394: }else if( f & MEM_Ephem ){
395: zBuf[1] = 'e';
396: assert( (f & (MEM_Static|MEM_Dyn))==0 );
397: }else{
398: zBuf[1] = 's';
399: }
400: k = 2;
401: sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n);
402: k += sqlite3Strlen30(&zBuf[k]);
403: zBuf[k++] = '[';
404: for(j=0; j<15 && j<pMem->n; j++){
405: u8 c = pMem->z[j];
406: if( c>=0x20 && c<0x7f ){
407: zBuf[k++] = c;
408: }else{
409: zBuf[k++] = '.';
410: }
411: }
412: zBuf[k++] = ']';
413: sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]);
414: k += sqlite3Strlen30(&zBuf[k]);
415: zBuf[k++] = 0;
416: }
417: }
418: #endif
419:
420: #ifdef SQLITE_DEBUG
421: /*
422: ** Print the value of a register for tracing purposes:
423: */
424: static void memTracePrint(FILE *out, Mem *p){
425: if( p->flags & MEM_Null ){
426: fprintf(out, " NULL");
427: }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
428: fprintf(out, " si:%lld", p->u.i);
429: }else if( p->flags & MEM_Int ){
430: fprintf(out, " i:%lld", p->u.i);
431: #ifndef SQLITE_OMIT_FLOATING_POINT
432: }else if( p->flags & MEM_Real ){
433: fprintf(out, " r:%g", p->r);
434: #endif
435: }else if( p->flags & MEM_RowSet ){
436: fprintf(out, " (rowset)");
437: }else{
438: char zBuf[200];
439: sqlite3VdbeMemPrettyPrint(p, zBuf);
440: fprintf(out, " ");
441: fprintf(out, "%s", zBuf);
442: }
443: }
444: static void registerTrace(FILE *out, int iReg, Mem *p){
445: fprintf(out, "REG[%d] = ", iReg);
446: memTracePrint(out, p);
447: fprintf(out, "\n");
448: }
449: #endif
450:
451: #ifdef SQLITE_DEBUG
452: # define REGISTER_TRACE(R,M) if(p->trace)registerTrace(p->trace,R,M)
453: #else
454: # define REGISTER_TRACE(R,M)
455: #endif
456:
457:
458: #ifdef VDBE_PROFILE
459:
460: /*
461: ** hwtime.h contains inline assembler code for implementing
462: ** high-performance timing routines.
463: */
464: #include "hwtime.h"
465:
466: #endif
467:
468: /*
469: ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
470: ** sqlite3_interrupt() routine has been called. If it has been, then
471: ** processing of the VDBE program is interrupted.
472: **
473: ** This macro added to every instruction that does a jump in order to
474: ** implement a loop. This test used to be on every single instruction,
475: ** but that meant we more testing than we needed. By only testing the
476: ** flag on jump instructions, we get a (small) speed improvement.
477: */
478: #define CHECK_FOR_INTERRUPT \
479: if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
480:
481:
482: #ifndef NDEBUG
483: /*
484: ** This function is only called from within an assert() expression. It
485: ** checks that the sqlite3.nTransaction variable is correctly set to
486: ** the number of non-transaction savepoints currently in the
487: ** linked list starting at sqlite3.pSavepoint.
488: **
489: ** Usage:
490: **
491: ** assert( checkSavepointCount(db) );
492: */
493: static int checkSavepointCount(sqlite3 *db){
494: int n = 0;
495: Savepoint *p;
496: for(p=db->pSavepoint; p; p=p->pNext) n++;
497: assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
498: return 1;
499: }
500: #endif
501:
502: /*
503: ** Transfer error message text from an sqlite3_vtab.zErrMsg (text stored
504: ** in memory obtained from sqlite3_malloc) into a Vdbe.zErrMsg (text stored
505: ** in memory obtained from sqlite3DbMalloc).
506: */
507: static void importVtabErrMsg(Vdbe *p, sqlite3_vtab *pVtab){
508: sqlite3 *db = p->db;
509: sqlite3DbFree(db, p->zErrMsg);
510: p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
511: sqlite3_free(pVtab->zErrMsg);
512: pVtab->zErrMsg = 0;
513: }
514:
515:
516: /*
517: ** Execute as much of a VDBE program as we can then return.
518: **
519: ** sqlite3VdbeMakeReady() must be called before this routine in order to
520: ** close the program with a final OP_Halt and to set up the callbacks
521: ** and the error message pointer.
522: **
523: ** Whenever a row or result data is available, this routine will either
524: ** invoke the result callback (if there is one) or return with
525: ** SQLITE_ROW.
526: **
527: ** If an attempt is made to open a locked database, then this routine
528: ** will either invoke the busy callback (if there is one) or it will
529: ** return SQLITE_BUSY.
530: **
531: ** If an error occurs, an error message is written to memory obtained
532: ** from sqlite3_malloc() and p->zErrMsg is made to point to that memory.
533: ** The error code is stored in p->rc and this routine returns SQLITE_ERROR.
534: **
535: ** If the callback ever returns non-zero, then the program exits
536: ** immediately. There will be no error message but the p->rc field is
537: ** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
538: **
539: ** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
540: ** routine to return SQLITE_ERROR.
541: **
542: ** Other fatal errors return SQLITE_ERROR.
543: **
544: ** After this routine has finished, sqlite3VdbeFinalize() should be
545: ** used to clean up the mess that was left behind.
546: */
547: int sqlite3VdbeExec(
548: Vdbe *p /* The VDBE */
549: ){
550: int pc=0; /* The program counter */
551: Op *aOp = p->aOp; /* Copy of p->aOp */
552: Op *pOp; /* Current operation */
553: int rc = SQLITE_OK; /* Value to return */
554: sqlite3 *db = p->db; /* The database */
555: u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
556: u8 encoding = ENC(db); /* The database encoding */
557: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
558: int checkProgress; /* True if progress callbacks are enabled */
559: int nProgressOps = 0; /* Opcodes executed since progress callback. */
560: #endif
561: Mem *aMem = p->aMem; /* Copy of p->aMem */
562: Mem *pIn1 = 0; /* 1st input operand */
563: Mem *pIn2 = 0; /* 2nd input operand */
564: Mem *pIn3 = 0; /* 3rd input operand */
565: Mem *pOut = 0; /* Output operand */
566: int iCompare = 0; /* Result of last OP_Compare operation */
567: int *aPermute = 0; /* Permutation of columns for OP_Compare */
568: i64 lastRowid = db->lastRowid; /* Saved value of the last insert ROWID */
569: #ifdef VDBE_PROFILE
570: u64 start; /* CPU clock count at start of opcode */
571: int origPc; /* Program counter at start of opcode */
572: #endif
573: /*** INSERT STACK UNION HERE ***/
574:
575: assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */
576: sqlite3VdbeEnter(p);
577: if( p->rc==SQLITE_NOMEM ){
578: /* This happens if a malloc() inside a call to sqlite3_column_text() or
579: ** sqlite3_column_text16() failed. */
580: goto no_mem;
581: }
582: assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
583: p->rc = SQLITE_OK;
584: assert( p->explain==0 );
585: p->pResultSet = 0;
586: db->busyHandler.nBusy = 0;
587: CHECK_FOR_INTERRUPT;
588: sqlite3VdbeIOTraceSql(p);
589: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
590: checkProgress = db->xProgress!=0;
591: #endif
592: #ifdef SQLITE_DEBUG
593: sqlite3BeginBenignMalloc();
594: if( p->pc==0 && (p->db->flags & SQLITE_VdbeListing)!=0 ){
595: int i;
596: printf("VDBE Program Listing:\n");
597: sqlite3VdbePrintSql(p);
598: for(i=0; i<p->nOp; i++){
599: sqlite3VdbePrintOp(stdout, i, &aOp[i]);
600: }
601: }
602: sqlite3EndBenignMalloc();
603: #endif
604: for(pc=p->pc; rc==SQLITE_OK; pc++){
605: assert( pc>=0 && pc<p->nOp );
606: if( db->mallocFailed ) goto no_mem;
607: #ifdef VDBE_PROFILE
608: origPc = pc;
609: start = sqlite3Hwtime();
610: #endif
611: pOp = &aOp[pc];
612:
613: /* Only allow tracing if SQLITE_DEBUG is defined.
614: */
615: #ifdef SQLITE_DEBUG
616: if( p->trace ){
617: if( pc==0 ){
618: printf("VDBE Execution Trace:\n");
619: sqlite3VdbePrintSql(p);
620: }
621: sqlite3VdbePrintOp(p->trace, pc, pOp);
622: }
623: #endif
624:
625:
626: /* Check to see if we need to simulate an interrupt. This only happens
627: ** if we have a special test build.
628: */
629: #ifdef SQLITE_TEST
630: if( sqlite3_interrupt_count>0 ){
631: sqlite3_interrupt_count--;
632: if( sqlite3_interrupt_count==0 ){
633: sqlite3_interrupt(db);
634: }
635: }
636: #endif
637:
638: #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
639: /* Call the progress callback if it is configured and the required number
640: ** of VDBE ops have been executed (either since this invocation of
641: ** sqlite3VdbeExec() or since last time the progress callback was called).
642: ** If the progress callback returns non-zero, exit the virtual machine with
643: ** a return code SQLITE_ABORT.
644: */
645: if( checkProgress ){
646: if( db->nProgressOps==nProgressOps ){
647: int prc;
648: prc = db->xProgress(db->pProgressArg);
649: if( prc!=0 ){
650: rc = SQLITE_INTERRUPT;
651: goto vdbe_error_halt;
652: }
653: nProgressOps = 0;
654: }
655: nProgressOps++;
656: }
657: #endif
658:
659: /* On any opcode with the "out2-prerelase" tag, free any
660: ** external allocations out of mem[p2] and set mem[p2] to be
661: ** an undefined integer. Opcodes will either fill in the integer
662: ** value or convert mem[p2] to a different type.
663: */
664: assert( pOp->opflags==sqlite3OpcodeProperty[pOp->opcode] );
665: if( pOp->opflags & OPFLG_OUT2_PRERELEASE ){
666: assert( pOp->p2>0 );
667: assert( pOp->p2<=p->nMem );
668: pOut = &aMem[pOp->p2];
669: memAboutToChange(p, pOut);
670: VdbeMemRelease(pOut);
671: pOut->flags = MEM_Int;
672: }
673:
674: /* Sanity checking on other operands */
675: #ifdef SQLITE_DEBUG
676: if( (pOp->opflags & OPFLG_IN1)!=0 ){
677: assert( pOp->p1>0 );
678: assert( pOp->p1<=p->nMem );
679: assert( memIsValid(&aMem[pOp->p1]) );
680: REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
681: }
682: if( (pOp->opflags & OPFLG_IN2)!=0 ){
683: assert( pOp->p2>0 );
684: assert( pOp->p2<=p->nMem );
685: assert( memIsValid(&aMem[pOp->p2]) );
686: REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
687: }
688: if( (pOp->opflags & OPFLG_IN3)!=0 ){
689: assert( pOp->p3>0 );
690: assert( pOp->p3<=p->nMem );
691: assert( memIsValid(&aMem[pOp->p3]) );
692: REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
693: }
694: if( (pOp->opflags & OPFLG_OUT2)!=0 ){
695: assert( pOp->p2>0 );
696: assert( pOp->p2<=p->nMem );
697: memAboutToChange(p, &aMem[pOp->p2]);
698: }
699: if( (pOp->opflags & OPFLG_OUT3)!=0 ){
700: assert( pOp->p3>0 );
701: assert( pOp->p3<=p->nMem );
702: memAboutToChange(p, &aMem[pOp->p3]);
703: }
704: #endif
705:
706: switch( pOp->opcode ){
707:
708: /*****************************************************************************
709: ** What follows is a massive switch statement where each case implements a
710: ** separate instruction in the virtual machine. If we follow the usual
711: ** indentation conventions, each case should be indented by 6 spaces. But
712: ** that is a lot of wasted space on the left margin. So the code within
713: ** the switch statement will break with convention and be flush-left. Another
714: ** big comment (similar to this one) will mark the point in the code where
715: ** we transition back to normal indentation.
716: **
717: ** The formatting of each case is important. The makefile for SQLite
718: ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
719: ** file looking for lines that begin with "case OP_". The opcodes.h files
720: ** will be filled with #defines that give unique integer values to each
721: ** opcode and the opcodes.c file is filled with an array of strings where
722: ** each string is the symbolic name for the corresponding opcode. If the
723: ** case statement is followed by a comment of the form "/# same as ... #/"
724: ** that comment is used to determine the particular value of the opcode.
725: **
726: ** Other keywords in the comment that follows each case are used to
727: ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
728: ** Keywords include: in1, in2, in3, out2_prerelease, out2, out3. See
729: ** the mkopcodeh.awk script for additional information.
730: **
731: ** Documentation about VDBE opcodes is generated by scanning this file
732: ** for lines of that contain "Opcode:". That line and all subsequent
733: ** comment lines are used in the generation of the opcode.html documentation
734: ** file.
735: **
736: ** SUMMARY:
737: **
738: ** Formatting is important to scripts that scan this file.
739: ** Do not deviate from the formatting style currently in use.
740: **
741: *****************************************************************************/
742:
743: /* Opcode: Goto * P2 * * *
744: **
745: ** An unconditional jump to address P2.
746: ** The next instruction executed will be
747: ** the one at index P2 from the beginning of
748: ** the program.
749: */
750: case OP_Goto: { /* jump */
751: CHECK_FOR_INTERRUPT;
752: pc = pOp->p2 - 1;
753: break;
754: }
755:
756: /* Opcode: Gosub P1 P2 * * *
757: **
758: ** Write the current address onto register P1
759: ** and then jump to address P2.
760: */
761: case OP_Gosub: { /* jump */
762: assert( pOp->p1>0 && pOp->p1<=p->nMem );
763: pIn1 = &aMem[pOp->p1];
764: assert( (pIn1->flags & MEM_Dyn)==0 );
765: memAboutToChange(p, pIn1);
766: pIn1->flags = MEM_Int;
767: pIn1->u.i = pc;
768: REGISTER_TRACE(pOp->p1, pIn1);
769: pc = pOp->p2 - 1;
770: break;
771: }
772:
773: /* Opcode: Return P1 * * * *
774: **
775: ** Jump to the next instruction after the address in register P1.
776: */
777: case OP_Return: { /* in1 */
778: pIn1 = &aMem[pOp->p1];
779: assert( pIn1->flags & MEM_Int );
780: pc = (int)pIn1->u.i;
781: break;
782: }
783:
784: /* Opcode: Yield P1 * * * *
785: **
786: ** Swap the program counter with the value in register P1.
787: */
788: case OP_Yield: { /* in1 */
789: int pcDest;
790: pIn1 = &aMem[pOp->p1];
791: assert( (pIn1->flags & MEM_Dyn)==0 );
792: pIn1->flags = MEM_Int;
793: pcDest = (int)pIn1->u.i;
794: pIn1->u.i = pc;
795: REGISTER_TRACE(pOp->p1, pIn1);
796: pc = pcDest;
797: break;
798: }
799:
800: /* Opcode: HaltIfNull P1 P2 P3 P4 *
801: **
802: ** Check the value in register P3. If it is NULL then Halt using
803: ** parameter P1, P2, and P4 as if this were a Halt instruction. If the
804: ** value in register P3 is not NULL, then this routine is a no-op.
805: */
806: case OP_HaltIfNull: { /* in3 */
807: pIn3 = &aMem[pOp->p3];
808: if( (pIn3->flags & MEM_Null)==0 ) break;
809: /* Fall through into OP_Halt */
810: }
811:
812: /* Opcode: Halt P1 P2 * P4 *
813: **
814: ** Exit immediately. All open cursors, etc are closed
815: ** automatically.
816: **
817: ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
818: ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0).
819: ** For errors, it can be some other value. If P1!=0 then P2 will determine
820: ** whether or not to rollback the current transaction. Do not rollback
821: ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort,
822: ** then back out all changes that have occurred during this execution of the
823: ** VDBE, but do not rollback the transaction.
824: **
825: ** If P4 is not null then it is an error message string.
826: **
827: ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
828: ** every program. So a jump past the last instruction of the program
829: ** is the same as executing Halt.
830: */
831: case OP_Halt: {
832: if( pOp->p1==SQLITE_OK && p->pFrame ){
833: /* Halt the sub-program. Return control to the parent frame. */
834: VdbeFrame *pFrame = p->pFrame;
835: p->pFrame = pFrame->pParent;
836: p->nFrame--;
837: sqlite3VdbeSetChanges(db, p->nChange);
838: pc = sqlite3VdbeFrameRestore(pFrame);
839: lastRowid = db->lastRowid;
840: if( pOp->p2==OE_Ignore ){
841: /* Instruction pc is the OP_Program that invoked the sub-program
842: ** currently being halted. If the p2 instruction of this OP_Halt
843: ** instruction is set to OE_Ignore, then the sub-program is throwing
844: ** an IGNORE exception. In this case jump to the address specified
845: ** as the p2 of the calling OP_Program. */
846: pc = p->aOp[pc].p2-1;
847: }
848: aOp = p->aOp;
849: aMem = p->aMem;
850: break;
851: }
852:
853: p->rc = pOp->p1;
854: p->errorAction = (u8)pOp->p2;
855: p->pc = pc;
856: if( pOp->p4.z ){
857: assert( p->rc!=SQLITE_OK );
858: sqlite3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);
859: testcase( sqlite3GlobalConfig.xLog!=0 );
860: sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pc, p->zSql, pOp->p4.z);
861: }else if( p->rc ){
862: testcase( sqlite3GlobalConfig.xLog!=0 );
863: sqlite3_log(pOp->p1, "constraint failed at %d in [%s]", pc, p->zSql);
864: }
865: rc = sqlite3VdbeHalt(p);
866: assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
867: if( rc==SQLITE_BUSY ){
868: p->rc = rc = SQLITE_BUSY;
869: }else{
870: assert( rc==SQLITE_OK || p->rc==SQLITE_CONSTRAINT );
871: assert( rc==SQLITE_OK || db->nDeferredCons>0 );
872: rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
873: }
874: goto vdbe_return;
875: }
876:
877: /* Opcode: Integer P1 P2 * * *
878: **
879: ** The 32-bit integer value P1 is written into register P2.
880: */
881: case OP_Integer: { /* out2-prerelease */
882: pOut->u.i = pOp->p1;
883: break;
884: }
885:
886: /* Opcode: Int64 * P2 * P4 *
887: **
888: ** P4 is a pointer to a 64-bit integer value.
889: ** Write that value into register P2.
890: */
891: case OP_Int64: { /* out2-prerelease */
892: assert( pOp->p4.pI64!=0 );
893: pOut->u.i = *pOp->p4.pI64;
894: break;
895: }
896:
897: #ifndef SQLITE_OMIT_FLOATING_POINT
898: /* Opcode: Real * P2 * P4 *
899: **
900: ** P4 is a pointer to a 64-bit floating point value.
901: ** Write that value into register P2.
902: */
903: case OP_Real: { /* same as TK_FLOAT, out2-prerelease */
904: pOut->flags = MEM_Real;
905: assert( !sqlite3IsNaN(*pOp->p4.pReal) );
906: pOut->r = *pOp->p4.pReal;
907: break;
908: }
909: #endif
910:
911: /* Opcode: String8 * P2 * P4 *
912: **
913: ** P4 points to a nul terminated UTF-8 string. This opcode is transformed
914: ** into an OP_String before it is executed for the first time.
915: */
916: case OP_String8: { /* same as TK_STRING, out2-prerelease */
917: assert( pOp->p4.z!=0 );
918: pOp->opcode = OP_String;
919: pOp->p1 = sqlite3Strlen30(pOp->p4.z);
920:
921: #ifndef SQLITE_OMIT_UTF16
922: if( encoding!=SQLITE_UTF8 ){
923: rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
924: if( rc==SQLITE_TOOBIG ) goto too_big;
925: if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
926: assert( pOut->zMalloc==pOut->z );
927: assert( pOut->flags & MEM_Dyn );
928: pOut->zMalloc = 0;
929: pOut->flags |= MEM_Static;
930: pOut->flags &= ~MEM_Dyn;
931: if( pOp->p4type==P4_DYNAMIC ){
932: sqlite3DbFree(db, pOp->p4.z);
933: }
934: pOp->p4type = P4_DYNAMIC;
935: pOp->p4.z = pOut->z;
936: pOp->p1 = pOut->n;
937: }
938: #endif
939: if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
940: goto too_big;
941: }
942: /* Fall through to the next case, OP_String */
943: }
944:
945: /* Opcode: String P1 P2 * P4 *
946: **
947: ** The string value P4 of length P1 (bytes) is stored in register P2.
948: */
949: case OP_String: { /* out2-prerelease */
950: assert( pOp->p4.z!=0 );
951: pOut->flags = MEM_Str|MEM_Static|MEM_Term;
952: pOut->z = pOp->p4.z;
953: pOut->n = pOp->p1;
954: pOut->enc = encoding;
955: UPDATE_MAX_BLOBSIZE(pOut);
956: break;
957: }
958:
959: /* Opcode: Null * P2 P3 * *
960: **
961: ** Write a NULL into registers P2. If P3 greater than P2, then also write
962: ** NULL into register P3 and ever register in between P2 and P3. If P3
963: ** is less than P2 (typically P3 is zero) then only register P2 is
964: ** set to NULL
965: */
966: case OP_Null: { /* out2-prerelease */
967: int cnt;
968: cnt = pOp->p3-pOp->p2;
969: assert( pOp->p3<=p->nMem );
970: pOut->flags = MEM_Null;
971: while( cnt>0 ){
972: pOut++;
973: memAboutToChange(p, pOut);
974: VdbeMemRelease(pOut);
975: pOut->flags = MEM_Null;
976: cnt--;
977: }
978: break;
979: }
980:
981:
982: /* Opcode: Blob P1 P2 * P4
983: **
984: ** P4 points to a blob of data P1 bytes long. Store this
985: ** blob in register P2.
986: */
987: case OP_Blob: { /* out2-prerelease */
988: assert( pOp->p1 <= SQLITE_MAX_LENGTH );
989: sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
990: pOut->enc = encoding;
991: UPDATE_MAX_BLOBSIZE(pOut);
992: break;
993: }
994:
995: /* Opcode: Variable P1 P2 * P4 *
996: **
997: ** Transfer the values of bound parameter P1 into register P2
998: **
999: ** If the parameter is named, then its name appears in P4 and P3==1.
1000: ** The P4 value is used by sqlite3_bind_parameter_name().
1001: */
1002: case OP_Variable: { /* out2-prerelease */
1003: Mem *pVar; /* Value being transferred */
1004:
1005: assert( pOp->p1>0 && pOp->p1<=p->nVar );
1006: assert( pOp->p4.z==0 || pOp->p4.z==p->azVar[pOp->p1-1] );
1007: pVar = &p->aVar[pOp->p1 - 1];
1008: if( sqlite3VdbeMemTooBig(pVar) ){
1009: goto too_big;
1010: }
1011: sqlite3VdbeMemShallowCopy(pOut, pVar, MEM_Static);
1012: UPDATE_MAX_BLOBSIZE(pOut);
1013: break;
1014: }
1015:
1016: /* Opcode: Move P1 P2 P3 * *
1017: **
1018: ** Move the values in register P1..P1+P3-1 over into
1019: ** registers P2..P2+P3-1. Registers P1..P1+P1-1 are
1020: ** left holding a NULL. It is an error for register ranges
1021: ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.
1022: */
1023: case OP_Move: {
1024: char *zMalloc; /* Holding variable for allocated memory */
1025: int n; /* Number of registers left to copy */
1026: int p1; /* Register to copy from */
1027: int p2; /* Register to copy to */
1028:
1029: n = pOp->p3;
1030: p1 = pOp->p1;
1031: p2 = pOp->p2;
1032: assert( n>0 && p1>0 && p2>0 );
1033: assert( p1+n<=p2 || p2+n<=p1 );
1034:
1035: pIn1 = &aMem[p1];
1036: pOut = &aMem[p2];
1037: while( n-- ){
1038: assert( pOut<=&aMem[p->nMem] );
1039: assert( pIn1<=&aMem[p->nMem] );
1040: assert( memIsValid(pIn1) );
1041: memAboutToChange(p, pOut);
1042: zMalloc = pOut->zMalloc;
1043: pOut->zMalloc = 0;
1044: sqlite3VdbeMemMove(pOut, pIn1);
1045: #ifdef SQLITE_DEBUG
1046: if( pOut->pScopyFrom>=&aMem[p1] && pOut->pScopyFrom<&aMem[p1+pOp->p3] ){
1047: pOut->pScopyFrom += p1 - pOp->p2;
1048: }
1049: #endif
1050: pIn1->zMalloc = zMalloc;
1051: REGISTER_TRACE(p2++, pOut);
1052: pIn1++;
1053: pOut++;
1054: }
1055: break;
1056: }
1057:
1058: /* Opcode: Copy P1 P2 * * *
1059: **
1060: ** Make a copy of register P1 into register P2.
1061: **
1062: ** This instruction makes a deep copy of the value. A duplicate
1063: ** is made of any string or blob constant. See also OP_SCopy.
1064: */
1065: case OP_Copy: { /* in1, out2 */
1066: pIn1 = &aMem[pOp->p1];
1067: pOut = &aMem[pOp->p2];
1068: assert( pOut!=pIn1 );
1069: sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
1070: Deephemeralize(pOut);
1071: REGISTER_TRACE(pOp->p2, pOut);
1072: break;
1073: }
1074:
1075: /* Opcode: SCopy P1 P2 * * *
1076: **
1077: ** Make a shallow copy of register P1 into register P2.
1078: **
1079: ** This instruction makes a shallow copy of the value. If the value
1080: ** is a string or blob, then the copy is only a pointer to the
1081: ** original and hence if the original changes so will the copy.
1082: ** Worse, if the original is deallocated, the copy becomes invalid.
1083: ** Thus the program must guarantee that the original will not change
1084: ** during the lifetime of the copy. Use OP_Copy to make a complete
1085: ** copy.
1086: */
1087: case OP_SCopy: { /* in1, out2 */
1088: pIn1 = &aMem[pOp->p1];
1089: pOut = &aMem[pOp->p2];
1090: assert( pOut!=pIn1 );
1091: sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
1092: #ifdef SQLITE_DEBUG
1093: if( pOut->pScopyFrom==0 ) pOut->pScopyFrom = pIn1;
1094: #endif
1095: REGISTER_TRACE(pOp->p2, pOut);
1096: break;
1097: }
1098:
1099: /* Opcode: ResultRow P1 P2 * * *
1100: **
1101: ** The registers P1 through P1+P2-1 contain a single row of
1102: ** results. This opcode causes the sqlite3_step() call to terminate
1103: ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
1104: ** structure to provide access to the top P1 values as the result
1105: ** row.
1106: */
1107: case OP_ResultRow: {
1108: Mem *pMem;
1109: int i;
1110: assert( p->nResColumn==pOp->p2 );
1111: assert( pOp->p1>0 );
1112: assert( pOp->p1+pOp->p2<=p->nMem+1 );
1113:
1114: /* If this statement has violated immediate foreign key constraints, do
1115: ** not return the number of rows modified. And do not RELEASE the statement
1116: ** transaction. It needs to be rolled back. */
1117: if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
1118: assert( db->flags&SQLITE_CountRows );
1119: assert( p->usesStmtJournal );
1120: break;
1121: }
1122:
1123: /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then
1124: ** DML statements invoke this opcode to return the number of rows
1125: ** modified to the user. This is the only way that a VM that
1126: ** opens a statement transaction may invoke this opcode.
1127: **
1128: ** In case this is such a statement, close any statement transaction
1129: ** opened by this VM before returning control to the user. This is to
1130: ** ensure that statement-transactions are always nested, not overlapping.
1131: ** If the open statement-transaction is not closed here, then the user
1132: ** may step another VM that opens its own statement transaction. This
1133: ** may lead to overlapping statement transactions.
1134: **
1135: ** The statement transaction is never a top-level transaction. Hence
1136: ** the RELEASE call below can never fail.
1137: */
1138: assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
1139: rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
1140: if( NEVER(rc!=SQLITE_OK) ){
1141: break;
1142: }
1143:
1144: /* Invalidate all ephemeral cursor row caches */
1145: p->cacheCtr = (p->cacheCtr + 2)|1;
1146:
1147: /* Make sure the results of the current row are \000 terminated
1148: ** and have an assigned type. The results are de-ephemeralized as
1149: ** a side effect.
1150: */
1151: pMem = p->pResultSet = &aMem[pOp->p1];
1152: for(i=0; i<pOp->p2; i++){
1153: assert( memIsValid(&pMem[i]) );
1154: Deephemeralize(&pMem[i]);
1155: assert( (pMem[i].flags & MEM_Ephem)==0
1156: || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 );
1157: sqlite3VdbeMemNulTerminate(&pMem[i]);
1158: sqlite3VdbeMemStoreType(&pMem[i]);
1159: REGISTER_TRACE(pOp->p1+i, &pMem[i]);
1160: }
1161: if( db->mallocFailed ) goto no_mem;
1162:
1163: /* Return SQLITE_ROW
1164: */
1165: p->pc = pc + 1;
1166: rc = SQLITE_ROW;
1167: goto vdbe_return;
1168: }
1169:
1170: /* Opcode: Concat P1 P2 P3 * *
1171: **
1172: ** Add the text in register P1 onto the end of the text in
1173: ** register P2 and store the result in register P3.
1174: ** If either the P1 or P2 text are NULL then store NULL in P3.
1175: **
1176: ** P3 = P2 || P1
1177: **
1178: ** It is illegal for P1 and P3 to be the same register. Sometimes,
1179: ** if P3 is the same register as P2, the implementation is able
1180: ** to avoid a memcpy().
1181: */
1182: case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */
1183: i64 nByte;
1184:
1185: pIn1 = &aMem[pOp->p1];
1186: pIn2 = &aMem[pOp->p2];
1187: pOut = &aMem[pOp->p3];
1188: assert( pIn1!=pOut );
1189: if( (pIn1->flags | pIn2->flags) & MEM_Null ){
1190: sqlite3VdbeMemSetNull(pOut);
1191: break;
1192: }
1193: if( ExpandBlob(pIn1) || ExpandBlob(pIn2) ) goto no_mem;
1194: Stringify(pIn1, encoding);
1195: Stringify(pIn2, encoding);
1196: nByte = pIn1->n + pIn2->n;
1197: if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
1198: goto too_big;
1199: }
1200: MemSetTypeFlag(pOut, MEM_Str);
1201: if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
1202: goto no_mem;
1203: }
1204: if( pOut!=pIn2 ){
1205: memcpy(pOut->z, pIn2->z, pIn2->n);
1206: }
1207: memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
1208: pOut->z[nByte] = 0;
1209: pOut->z[nByte+1] = 0;
1210: pOut->flags |= MEM_Term;
1211: pOut->n = (int)nByte;
1212: pOut->enc = encoding;
1213: UPDATE_MAX_BLOBSIZE(pOut);
1214: break;
1215: }
1216:
1217: /* Opcode: Add P1 P2 P3 * *
1218: **
1219: ** Add the value in register P1 to the value in register P2
1220: ** and store the result in register P3.
1221: ** If either input is NULL, the result is NULL.
1222: */
1223: /* Opcode: Multiply P1 P2 P3 * *
1224: **
1225: **
1226: ** Multiply the value in register P1 by the value in register P2
1227: ** and store the result in register P3.
1228: ** If either input is NULL, the result is NULL.
1229: */
1230: /* Opcode: Subtract P1 P2 P3 * *
1231: **
1232: ** Subtract the value in register P1 from the value in register P2
1233: ** and store the result in register P3.
1234: ** If either input is NULL, the result is NULL.
1235: */
1236: /* Opcode: Divide P1 P2 P3 * *
1237: **
1238: ** Divide the value in register P1 by the value in register P2
1239: ** and store the result in register P3 (P3=P2/P1). If the value in
1240: ** register P1 is zero, then the result is NULL. If either input is
1241: ** NULL, the result is NULL.
1242: */
1243: /* Opcode: Remainder P1 P2 P3 * *
1244: **
1245: ** Compute the remainder after integer division of the value in
1246: ** register P1 by the value in register P2 and store the result in P3.
1247: ** If the value in register P2 is zero the result is NULL.
1248: ** If either operand is NULL, the result is NULL.
1249: */
1250: case OP_Add: /* same as TK_PLUS, in1, in2, out3 */
1251: case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */
1252: case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */
1253: case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */
1254: case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */
1255: int flags; /* Combined MEM_* flags from both inputs */
1256: i64 iA; /* Integer value of left operand */
1257: i64 iB; /* Integer value of right operand */
1258: double rA; /* Real value of left operand */
1259: double rB; /* Real value of right operand */
1260:
1261: pIn1 = &aMem[pOp->p1];
1262: applyNumericAffinity(pIn1);
1263: pIn2 = &aMem[pOp->p2];
1264: applyNumericAffinity(pIn2);
1265: pOut = &aMem[pOp->p3];
1266: flags = pIn1->flags | pIn2->flags;
1267: if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
1268: if( (pIn1->flags & pIn2->flags & MEM_Int)==MEM_Int ){
1269: iA = pIn1->u.i;
1270: iB = pIn2->u.i;
1271: switch( pOp->opcode ){
1272: case OP_Add: if( sqlite3AddInt64(&iB,iA) ) goto fp_math; break;
1273: case OP_Subtract: if( sqlite3SubInt64(&iB,iA) ) goto fp_math; break;
1274: case OP_Multiply: if( sqlite3MulInt64(&iB,iA) ) goto fp_math; break;
1275: case OP_Divide: {
1276: if( iA==0 ) goto arithmetic_result_is_null;
1277: if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math;
1278: iB /= iA;
1279: break;
1280: }
1281: default: {
1282: if( iA==0 ) goto arithmetic_result_is_null;
1283: if( iA==-1 ) iA = 1;
1284: iB %= iA;
1285: break;
1286: }
1287: }
1288: pOut->u.i = iB;
1289: MemSetTypeFlag(pOut, MEM_Int);
1290: }else{
1291: fp_math:
1292: rA = sqlite3VdbeRealValue(pIn1);
1293: rB = sqlite3VdbeRealValue(pIn2);
1294: switch( pOp->opcode ){
1295: case OP_Add: rB += rA; break;
1296: case OP_Subtract: rB -= rA; break;
1297: case OP_Multiply: rB *= rA; break;
1298: case OP_Divide: {
1299: /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
1300: if( rA==(double)0 ) goto arithmetic_result_is_null;
1301: rB /= rA;
1302: break;
1303: }
1304: default: {
1305: iA = (i64)rA;
1306: iB = (i64)rB;
1307: if( iA==0 ) goto arithmetic_result_is_null;
1308: if( iA==-1 ) iA = 1;
1309: rB = (double)(iB % iA);
1310: break;
1311: }
1312: }
1313: #ifdef SQLITE_OMIT_FLOATING_POINT
1314: pOut->u.i = rB;
1315: MemSetTypeFlag(pOut, MEM_Int);
1316: #else
1317: if( sqlite3IsNaN(rB) ){
1318: goto arithmetic_result_is_null;
1319: }
1320: pOut->r = rB;
1321: MemSetTypeFlag(pOut, MEM_Real);
1322: if( (flags & MEM_Real)==0 ){
1323: sqlite3VdbeIntegerAffinity(pOut);
1324: }
1325: #endif
1326: }
1327: break;
1328:
1329: arithmetic_result_is_null:
1330: sqlite3VdbeMemSetNull(pOut);
1331: break;
1332: }
1333:
1334: /* Opcode: CollSeq * * P4
1335: **
1336: ** P4 is a pointer to a CollSeq struct. If the next call to a user function
1337: ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
1338: ** be returned. This is used by the built-in min(), max() and nullif()
1339: ** functions.
1340: **
1341: ** The interface used by the implementation of the aforementioned functions
1342: ** to retrieve the collation sequence set by this opcode is not available
1343: ** publicly, only to user functions defined in func.c.
1344: */
1345: case OP_CollSeq: {
1346: assert( pOp->p4type==P4_COLLSEQ );
1347: break;
1348: }
1349:
1350: /* Opcode: Function P1 P2 P3 P4 P5
1351: **
1352: ** Invoke a user function (P4 is a pointer to a Function structure that
1353: ** defines the function) with P5 arguments taken from register P2 and
1354: ** successors. The result of the function is stored in register P3.
1355: ** Register P3 must not be one of the function inputs.
1356: **
1357: ** P1 is a 32-bit bitmask indicating whether or not each argument to the
1358: ** function was determined to be constant at compile time. If the first
1359: ** argument was constant then bit 0 of P1 is set. This is used to determine
1360: ** whether meta data associated with a user function argument using the
1361: ** sqlite3_set_auxdata() API may be safely retained until the next
1362: ** invocation of this opcode.
1363: **
1364: ** See also: AggStep and AggFinal
1365: */
1366: case OP_Function: {
1367: int i;
1368: Mem *pArg;
1369: sqlite3_context ctx;
1370: sqlite3_value **apVal;
1371: int n;
1372:
1373: n = pOp->p5;
1374: apVal = p->apArg;
1375: assert( apVal || n==0 );
1376: assert( pOp->p3>0 && pOp->p3<=p->nMem );
1377: pOut = &aMem[pOp->p3];
1378: memAboutToChange(p, pOut);
1379:
1380: assert( n==0 || (pOp->p2>0 && pOp->p2+n<=p->nMem+1) );
1381: assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
1382: pArg = &aMem[pOp->p2];
1383: for(i=0; i<n; i++, pArg++){
1384: assert( memIsValid(pArg) );
1385: apVal[i] = pArg;
1386: Deephemeralize(pArg);
1387: sqlite3VdbeMemStoreType(pArg);
1388: REGISTER_TRACE(pOp->p2+i, pArg);
1389: }
1390:
1391: assert( pOp->p4type==P4_FUNCDEF || pOp->p4type==P4_VDBEFUNC );
1392: if( pOp->p4type==P4_FUNCDEF ){
1393: ctx.pFunc = pOp->p4.pFunc;
1394: ctx.pVdbeFunc = 0;
1395: }else{
1396: ctx.pVdbeFunc = (VdbeFunc*)pOp->p4.pVdbeFunc;
1397: ctx.pFunc = ctx.pVdbeFunc->pFunc;
1398: }
1399:
1400: ctx.s.flags = MEM_Null;
1401: ctx.s.db = db;
1402: ctx.s.xDel = 0;
1403: ctx.s.zMalloc = 0;
1404:
1405: /* The output cell may already have a buffer allocated. Move
1406: ** the pointer to ctx.s so in case the user-function can use
1407: ** the already allocated buffer instead of allocating a new one.
1408: */
1409: sqlite3VdbeMemMove(&ctx.s, pOut);
1410: MemSetTypeFlag(&ctx.s, MEM_Null);
1411:
1412: ctx.isError = 0;
1413: if( ctx.pFunc->flags & SQLITE_FUNC_NEEDCOLL ){
1414: assert( pOp>aOp );
1415: assert( pOp[-1].p4type==P4_COLLSEQ );
1416: assert( pOp[-1].opcode==OP_CollSeq );
1417: ctx.pColl = pOp[-1].p4.pColl;
1418: }
1419: db->lastRowid = lastRowid;
1420: (*ctx.pFunc->xFunc)(&ctx, n, apVal); /* IMP: R-24505-23230 */
1421: lastRowid = db->lastRowid;
1422:
1423: /* If any auxiliary data functions have been called by this user function,
1424: ** immediately call the destructor for any non-static values.
1425: */
1426: if( ctx.pVdbeFunc ){
1427: sqlite3VdbeDeleteAuxData(ctx.pVdbeFunc, pOp->p1);
1428: pOp->p4.pVdbeFunc = ctx.pVdbeFunc;
1429: pOp->p4type = P4_VDBEFUNC;
1430: }
1431:
1432: if( db->mallocFailed ){
1433: /* Even though a malloc() has failed, the implementation of the
1434: ** user function may have called an sqlite3_result_XXX() function
1435: ** to return a value. The following call releases any resources
1436: ** associated with such a value.
1437: */
1438: sqlite3VdbeMemRelease(&ctx.s);
1439: goto no_mem;
1440: }
1441:
1442: /* If the function returned an error, throw an exception */
1443: if( ctx.isError ){
1444: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&ctx.s));
1445: rc = ctx.isError;
1446: }
1447:
1448: /* Copy the result of the function into register P3 */
1449: sqlite3VdbeChangeEncoding(&ctx.s, encoding);
1450: sqlite3VdbeMemMove(pOut, &ctx.s);
1451: if( sqlite3VdbeMemTooBig(pOut) ){
1452: goto too_big;
1453: }
1454:
1455: #if 0
1456: /* The app-defined function has done something that as caused this
1457: ** statement to expire. (Perhaps the function called sqlite3_exec()
1458: ** with a CREATE TABLE statement.)
1459: */
1460: if( p->expired ) rc = SQLITE_ABORT;
1461: #endif
1462:
1463: REGISTER_TRACE(pOp->p3, pOut);
1464: UPDATE_MAX_BLOBSIZE(pOut);
1465: break;
1466: }
1467:
1468: /* Opcode: BitAnd P1 P2 P3 * *
1469: **
1470: ** Take the bit-wise AND of the values in register P1 and P2 and
1471: ** store the result in register P3.
1472: ** If either input is NULL, the result is NULL.
1473: */
1474: /* Opcode: BitOr P1 P2 P3 * *
1475: **
1476: ** Take the bit-wise OR of the values in register P1 and P2 and
1477: ** store the result in register P3.
1478: ** If either input is NULL, the result is NULL.
1479: */
1480: /* Opcode: ShiftLeft P1 P2 P3 * *
1481: **
1482: ** Shift the integer value in register P2 to the left by the
1483: ** number of bits specified by the integer in register P1.
1484: ** Store the result in register P3.
1485: ** If either input is NULL, the result is NULL.
1486: */
1487: /* Opcode: ShiftRight P1 P2 P3 * *
1488: **
1489: ** Shift the integer value in register P2 to the right by the
1490: ** number of bits specified by the integer in register P1.
1491: ** Store the result in register P3.
1492: ** If either input is NULL, the result is NULL.
1493: */
1494: case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */
1495: case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */
1496: case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */
1497: case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */
1498: i64 iA;
1499: u64 uA;
1500: i64 iB;
1501: u8 op;
1502:
1503: pIn1 = &aMem[pOp->p1];
1504: pIn2 = &aMem[pOp->p2];
1505: pOut = &aMem[pOp->p3];
1506: if( (pIn1->flags | pIn2->flags) & MEM_Null ){
1507: sqlite3VdbeMemSetNull(pOut);
1508: break;
1509: }
1510: iA = sqlite3VdbeIntValue(pIn2);
1511: iB = sqlite3VdbeIntValue(pIn1);
1512: op = pOp->opcode;
1513: if( op==OP_BitAnd ){
1514: iA &= iB;
1515: }else if( op==OP_BitOr ){
1516: iA |= iB;
1517: }else if( iB!=0 ){
1518: assert( op==OP_ShiftRight || op==OP_ShiftLeft );
1519:
1520: /* If shifting by a negative amount, shift in the other direction */
1521: if( iB<0 ){
1522: assert( OP_ShiftRight==OP_ShiftLeft+1 );
1523: op = 2*OP_ShiftLeft + 1 - op;
1524: iB = iB>(-64) ? -iB : 64;
1525: }
1526:
1527: if( iB>=64 ){
1528: iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
1529: }else{
1530: memcpy(&uA, &iA, sizeof(uA));
1531: if( op==OP_ShiftLeft ){
1532: uA <<= iB;
1533: }else{
1534: uA >>= iB;
1535: /* Sign-extend on a right shift of a negative number */
1536: if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB);
1537: }
1538: memcpy(&iA, &uA, sizeof(iA));
1539: }
1540: }
1541: pOut->u.i = iA;
1542: MemSetTypeFlag(pOut, MEM_Int);
1543: break;
1544: }
1545:
1546: /* Opcode: AddImm P1 P2 * * *
1547: **
1548: ** Add the constant P2 to the value in register P1.
1549: ** The result is always an integer.
1550: **
1551: ** To force any register to be an integer, just add 0.
1552: */
1553: case OP_AddImm: { /* in1 */
1554: pIn1 = &aMem[pOp->p1];
1555: memAboutToChange(p, pIn1);
1556: sqlite3VdbeMemIntegerify(pIn1);
1557: pIn1->u.i += pOp->p2;
1558: break;
1559: }
1560:
1561: /* Opcode: MustBeInt P1 P2 * * *
1562: **
1563: ** Force the value in register P1 to be an integer. If the value
1564: ** in P1 is not an integer and cannot be converted into an integer
1565: ** without data loss, then jump immediately to P2, or if P2==0
1566: ** raise an SQLITE_MISMATCH exception.
1567: */
1568: case OP_MustBeInt: { /* jump, in1 */
1569: pIn1 = &aMem[pOp->p1];
1570: applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
1571: if( (pIn1->flags & MEM_Int)==0 ){
1572: if( pOp->p2==0 ){
1573: rc = SQLITE_MISMATCH;
1574: goto abort_due_to_error;
1575: }else{
1576: pc = pOp->p2 - 1;
1577: }
1578: }else{
1579: MemSetTypeFlag(pIn1, MEM_Int);
1580: }
1581: break;
1582: }
1583:
1584: #ifndef SQLITE_OMIT_FLOATING_POINT
1585: /* Opcode: RealAffinity P1 * * * *
1586: **
1587: ** If register P1 holds an integer convert it to a real value.
1588: **
1589: ** This opcode is used when extracting information from a column that
1590: ** has REAL affinity. Such column values may still be stored as
1591: ** integers, for space efficiency, but after extraction we want them
1592: ** to have only a real value.
1593: */
1594: case OP_RealAffinity: { /* in1 */
1595: pIn1 = &aMem[pOp->p1];
1596: if( pIn1->flags & MEM_Int ){
1597: sqlite3VdbeMemRealify(pIn1);
1598: }
1599: break;
1600: }
1601: #endif
1602:
1603: #ifndef SQLITE_OMIT_CAST
1604: /* Opcode: ToText P1 * * * *
1605: **
1606: ** Force the value in register P1 to be text.
1607: ** If the value is numeric, convert it to a string using the
1608: ** equivalent of printf(). Blob values are unchanged and
1609: ** are afterwards simply interpreted as text.
1610: **
1611: ** A NULL value is not changed by this routine. It remains NULL.
1612: */
1613: case OP_ToText: { /* same as TK_TO_TEXT, in1 */
1614: pIn1 = &aMem[pOp->p1];
1615: memAboutToChange(p, pIn1);
1616: if( pIn1->flags & MEM_Null ) break;
1617: assert( MEM_Str==(MEM_Blob>>3) );
1618: pIn1->flags |= (pIn1->flags&MEM_Blob)>>3;
1619: applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
1620: rc = ExpandBlob(pIn1);
1621: assert( pIn1->flags & MEM_Str || db->mallocFailed );
1622: pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Blob|MEM_Zero);
1623: UPDATE_MAX_BLOBSIZE(pIn1);
1624: break;
1625: }
1626:
1627: /* Opcode: ToBlob P1 * * * *
1628: **
1629: ** Force the value in register P1 to be a BLOB.
1630: ** If the value is numeric, convert it to a string first.
1631: ** Strings are simply reinterpreted as blobs with no change
1632: ** to the underlying data.
1633: **
1634: ** A NULL value is not changed by this routine. It remains NULL.
1635: */
1636: case OP_ToBlob: { /* same as TK_TO_BLOB, in1 */
1637: pIn1 = &aMem[pOp->p1];
1638: if( pIn1->flags & MEM_Null ) break;
1639: if( (pIn1->flags & MEM_Blob)==0 ){
1640: applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
1641: assert( pIn1->flags & MEM_Str || db->mallocFailed );
1642: MemSetTypeFlag(pIn1, MEM_Blob);
1643: }else{
1644: pIn1->flags &= ~(MEM_TypeMask&~MEM_Blob);
1645: }
1646: UPDATE_MAX_BLOBSIZE(pIn1);
1647: break;
1648: }
1649:
1650: /* Opcode: ToNumeric P1 * * * *
1651: **
1652: ** Force the value in register P1 to be numeric (either an
1653: ** integer or a floating-point number.)
1654: ** If the value is text or blob, try to convert it to an using the
1655: ** equivalent of atoi() or atof() and store 0 if no such conversion
1656: ** is possible.
1657: **
1658: ** A NULL value is not changed by this routine. It remains NULL.
1659: */
1660: case OP_ToNumeric: { /* same as TK_TO_NUMERIC, in1 */
1661: pIn1 = &aMem[pOp->p1];
1662: sqlite3VdbeMemNumerify(pIn1);
1663: break;
1664: }
1665: #endif /* SQLITE_OMIT_CAST */
1666:
1667: /* Opcode: ToInt P1 * * * *
1668: **
1669: ** Force the value in register P1 to be an integer. If
1670: ** The value is currently a real number, drop its fractional part.
1671: ** If the value is text or blob, try to convert it to an integer using the
1672: ** equivalent of atoi() and store 0 if no such conversion is possible.
1673: **
1674: ** A NULL value is not changed by this routine. It remains NULL.
1675: */
1676: case OP_ToInt: { /* same as TK_TO_INT, in1 */
1677: pIn1 = &aMem[pOp->p1];
1678: if( (pIn1->flags & MEM_Null)==0 ){
1679: sqlite3VdbeMemIntegerify(pIn1);
1680: }
1681: break;
1682: }
1683:
1684: #if !defined(SQLITE_OMIT_CAST) && !defined(SQLITE_OMIT_FLOATING_POINT)
1685: /* Opcode: ToReal P1 * * * *
1686: **
1687: ** Force the value in register P1 to be a floating point number.
1688: ** If The value is currently an integer, convert it.
1689: ** If the value is text or blob, try to convert it to an integer using the
1690: ** equivalent of atoi() and store 0.0 if no such conversion is possible.
1691: **
1692: ** A NULL value is not changed by this routine. It remains NULL.
1693: */
1694: case OP_ToReal: { /* same as TK_TO_REAL, in1 */
1695: pIn1 = &aMem[pOp->p1];
1696: memAboutToChange(p, pIn1);
1697: if( (pIn1->flags & MEM_Null)==0 ){
1698: sqlite3VdbeMemRealify(pIn1);
1699: }
1700: break;
1701: }
1702: #endif /* !defined(SQLITE_OMIT_CAST) && !defined(SQLITE_OMIT_FLOATING_POINT) */
1703:
1704: /* Opcode: Lt P1 P2 P3 P4 P5
1705: **
1706: ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then
1707: ** jump to address P2.
1708: **
1709: ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
1710: ** reg(P3) is NULL then take the jump. If the SQLITE_JUMPIFNULL
1711: ** bit is clear then fall through if either operand is NULL.
1712: **
1713: ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
1714: ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made
1715: ** to coerce both inputs according to this affinity before the
1716: ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
1717: ** affinity is used. Note that the affinity conversions are stored
1718: ** back into the input registers P1 and P3. So this opcode can cause
1719: ** persistent changes to registers P1 and P3.
1720: **
1721: ** Once any conversions have taken place, and neither value is NULL,
1722: ** the values are compared. If both values are blobs then memcmp() is
1723: ** used to determine the results of the comparison. If both values
1724: ** are text, then the appropriate collating function specified in
1725: ** P4 is used to do the comparison. If P4 is not specified then
1726: ** memcmp() is used to compare text string. If both values are
1727: ** numeric, then a numeric comparison is used. If the two values
1728: ** are of different types, then numbers are considered less than
1729: ** strings and strings are considered less than blobs.
1730: **
1731: ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump. Instead,
1732: ** store a boolean result (either 0, or 1, or NULL) in register P2.
1733: */
1734: /* Opcode: Ne P1 P2 P3 P4 P5
1735: **
1736: ** This works just like the Lt opcode except that the jump is taken if
1737: ** the operands in registers P1 and P3 are not equal. See the Lt opcode for
1738: ** additional information.
1739: **
1740: ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
1741: ** true or false and is never NULL. If both operands are NULL then the result
1742: ** of comparison is false. If either operand is NULL then the result is true.
1743: ** If neither operand is NULL the result is the same as it would be if
1744: ** the SQLITE_NULLEQ flag were omitted from P5.
1745: */
1746: /* Opcode: Eq P1 P2 P3 P4 P5
1747: **
1748: ** This works just like the Lt opcode except that the jump is taken if
1749: ** the operands in registers P1 and P3 are equal.
1750: ** See the Lt opcode for additional information.
1751: **
1752: ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
1753: ** true or false and is never NULL. If both operands are NULL then the result
1754: ** of comparison is true. If either operand is NULL then the result is false.
1755: ** If neither operand is NULL the result is the same as it would be if
1756: ** the SQLITE_NULLEQ flag were omitted from P5.
1757: */
1758: /* Opcode: Le P1 P2 P3 P4 P5
1759: **
1760: ** This works just like the Lt opcode except that the jump is taken if
1761: ** the content of register P3 is less than or equal to the content of
1762: ** register P1. See the Lt opcode for additional information.
1763: */
1764: /* Opcode: Gt P1 P2 P3 P4 P5
1765: **
1766: ** This works just like the Lt opcode except that the jump is taken if
1767: ** the content of register P3 is greater than the content of
1768: ** register P1. See the Lt opcode for additional information.
1769: */
1770: /* Opcode: Ge P1 P2 P3 P4 P5
1771: **
1772: ** This works just like the Lt opcode except that the jump is taken if
1773: ** the content of register P3 is greater than or equal to the content of
1774: ** register P1. See the Lt opcode for additional information.
1775: */
1776: case OP_Eq: /* same as TK_EQ, jump, in1, in3 */
1777: case OP_Ne: /* same as TK_NE, jump, in1, in3 */
1778: case OP_Lt: /* same as TK_LT, jump, in1, in3 */
1779: case OP_Le: /* same as TK_LE, jump, in1, in3 */
1780: case OP_Gt: /* same as TK_GT, jump, in1, in3 */
1781: case OP_Ge: { /* same as TK_GE, jump, in1, in3 */
1782: int res; /* Result of the comparison of pIn1 against pIn3 */
1783: char affinity; /* Affinity to use for comparison */
1784: u16 flags1; /* Copy of initial value of pIn1->flags */
1785: u16 flags3; /* Copy of initial value of pIn3->flags */
1786:
1787: pIn1 = &aMem[pOp->p1];
1788: pIn3 = &aMem[pOp->p3];
1789: flags1 = pIn1->flags;
1790: flags3 = pIn3->flags;
1791: if( (flags1 | flags3)&MEM_Null ){
1792: /* One or both operands are NULL */
1793: if( pOp->p5 & SQLITE_NULLEQ ){
1794: /* If SQLITE_NULLEQ is set (which will only happen if the operator is
1795: ** OP_Eq or OP_Ne) then take the jump or not depending on whether
1796: ** or not both operands are null.
1797: */
1798: assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne );
1799: res = (flags1 & flags3 & MEM_Null)==0;
1800: }else{
1801: /* SQLITE_NULLEQ is clear and at least one operand is NULL,
1802: ** then the result is always NULL.
1803: ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
1804: */
1805: if( pOp->p5 & SQLITE_STOREP2 ){
1806: pOut = &aMem[pOp->p2];
1807: MemSetTypeFlag(pOut, MEM_Null);
1808: REGISTER_TRACE(pOp->p2, pOut);
1809: }else if( pOp->p5 & SQLITE_JUMPIFNULL ){
1810: pc = pOp->p2-1;
1811: }
1812: break;
1813: }
1814: }else{
1815: /* Neither operand is NULL. Do a comparison. */
1816: affinity = pOp->p5 & SQLITE_AFF_MASK;
1817: if( affinity ){
1818: applyAffinity(pIn1, affinity, encoding);
1819: applyAffinity(pIn3, affinity, encoding);
1820: if( db->mallocFailed ) goto no_mem;
1821: }
1822:
1823: assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
1824: ExpandBlob(pIn1);
1825: ExpandBlob(pIn3);
1826: res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
1827: }
1828: switch( pOp->opcode ){
1829: case OP_Eq: res = res==0; break;
1830: case OP_Ne: res = res!=0; break;
1831: case OP_Lt: res = res<0; break;
1832: case OP_Le: res = res<=0; break;
1833: case OP_Gt: res = res>0; break;
1834: default: res = res>=0; break;
1835: }
1836:
1837: if( pOp->p5 & SQLITE_STOREP2 ){
1838: pOut = &aMem[pOp->p2];
1839: memAboutToChange(p, pOut);
1840: MemSetTypeFlag(pOut, MEM_Int);
1841: pOut->u.i = res;
1842: REGISTER_TRACE(pOp->p2, pOut);
1843: }else if( res ){
1844: pc = pOp->p2-1;
1845: }
1846:
1847: /* Undo any changes made by applyAffinity() to the input registers. */
1848: pIn1->flags = (pIn1->flags&~MEM_TypeMask) | (flags1&MEM_TypeMask);
1849: pIn3->flags = (pIn3->flags&~MEM_TypeMask) | (flags3&MEM_TypeMask);
1850: break;
1851: }
1852:
1853: /* Opcode: Permutation * * * P4 *
1854: **
1855: ** Set the permutation used by the OP_Compare operator to be the array
1856: ** of integers in P4.
1857: **
1858: ** The permutation is only valid until the next OP_Permutation, OP_Compare,
1859: ** OP_Halt, or OP_ResultRow. Typically the OP_Permutation should occur
1860: ** immediately prior to the OP_Compare.
1861: */
1862: case OP_Permutation: {
1863: assert( pOp->p4type==P4_INTARRAY );
1864: assert( pOp->p4.ai );
1865: aPermute = pOp->p4.ai;
1866: break;
1867: }
1868:
1869: /* Opcode: Compare P1 P2 P3 P4 *
1870: **
1871: ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
1872: ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of
1873: ** the comparison for use by the next OP_Jump instruct.
1874: **
1875: ** P4 is a KeyInfo structure that defines collating sequences and sort
1876: ** orders for the comparison. The permutation applies to registers
1877: ** only. The KeyInfo elements are used sequentially.
1878: **
1879: ** The comparison is a sort comparison, so NULLs compare equal,
1880: ** NULLs are less than numbers, numbers are less than strings,
1881: ** and strings are less than blobs.
1882: */
1883: case OP_Compare: {
1884: int n;
1885: int i;
1886: int p1;
1887: int p2;
1888: const KeyInfo *pKeyInfo;
1889: int idx;
1890: CollSeq *pColl; /* Collating sequence to use on this term */
1891: int bRev; /* True for DESCENDING sort order */
1892:
1893: n = pOp->p3;
1894: pKeyInfo = pOp->p4.pKeyInfo;
1895: assert( n>0 );
1896: assert( pKeyInfo!=0 );
1897: p1 = pOp->p1;
1898: p2 = pOp->p2;
1899: #if SQLITE_DEBUG
1900: if( aPermute ){
1901: int k, mx = 0;
1902: for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
1903: assert( p1>0 && p1+mx<=p->nMem+1 );
1904: assert( p2>0 && p2+mx<=p->nMem+1 );
1905: }else{
1906: assert( p1>0 && p1+n<=p->nMem+1 );
1907: assert( p2>0 && p2+n<=p->nMem+1 );
1908: }
1909: #endif /* SQLITE_DEBUG */
1910: for(i=0; i<n; i++){
1911: idx = aPermute ? aPermute[i] : i;
1912: assert( memIsValid(&aMem[p1+idx]) );
1913: assert( memIsValid(&aMem[p2+idx]) );
1914: REGISTER_TRACE(p1+idx, &aMem[p1+idx]);
1915: REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
1916: assert( i<pKeyInfo->nField );
1917: pColl = pKeyInfo->aColl[i];
1918: bRev = pKeyInfo->aSortOrder[i];
1919: iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);
1920: if( iCompare ){
1921: if( bRev ) iCompare = -iCompare;
1922: break;
1923: }
1924: }
1925: aPermute = 0;
1926: break;
1927: }
1928:
1929: /* Opcode: Jump P1 P2 P3 * *
1930: **
1931: ** Jump to the instruction at address P1, P2, or P3 depending on whether
1932: ** in the most recent OP_Compare instruction the P1 vector was less than
1933: ** equal to, or greater than the P2 vector, respectively.
1934: */
1935: case OP_Jump: { /* jump */
1936: if( iCompare<0 ){
1937: pc = pOp->p1 - 1;
1938: }else if( iCompare==0 ){
1939: pc = pOp->p2 - 1;
1940: }else{
1941: pc = pOp->p3 - 1;
1942: }
1943: break;
1944: }
1945:
1946: /* Opcode: And P1 P2 P3 * *
1947: **
1948: ** Take the logical AND of the values in registers P1 and P2 and
1949: ** write the result into register P3.
1950: **
1951: ** If either P1 or P2 is 0 (false) then the result is 0 even if
1952: ** the other input is NULL. A NULL and true or two NULLs give
1953: ** a NULL output.
1954: */
1955: /* Opcode: Or P1 P2 P3 * *
1956: **
1957: ** Take the logical OR of the values in register P1 and P2 and
1958: ** store the answer in register P3.
1959: **
1960: ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
1961: ** even if the other input is NULL. A NULL and false or two NULLs
1962: ** give a NULL output.
1963: */
1964: case OP_And: /* same as TK_AND, in1, in2, out3 */
1965: case OP_Or: { /* same as TK_OR, in1, in2, out3 */
1966: int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
1967: int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
1968:
1969: pIn1 = &aMem[pOp->p1];
1970: if( pIn1->flags & MEM_Null ){
1971: v1 = 2;
1972: }else{
1973: v1 = sqlite3VdbeIntValue(pIn1)!=0;
1974: }
1975: pIn2 = &aMem[pOp->p2];
1976: if( pIn2->flags & MEM_Null ){
1977: v2 = 2;
1978: }else{
1979: v2 = sqlite3VdbeIntValue(pIn2)!=0;
1980: }
1981: if( pOp->opcode==OP_And ){
1982: static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
1983: v1 = and_logic[v1*3+v2];
1984: }else{
1985: static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
1986: v1 = or_logic[v1*3+v2];
1987: }
1988: pOut = &aMem[pOp->p3];
1989: if( v1==2 ){
1990: MemSetTypeFlag(pOut, MEM_Null);
1991: }else{
1992: pOut->u.i = v1;
1993: MemSetTypeFlag(pOut, MEM_Int);
1994: }
1995: break;
1996: }
1997:
1998: /* Opcode: Not P1 P2 * * *
1999: **
2000: ** Interpret the value in register P1 as a boolean value. Store the
2001: ** boolean complement in register P2. If the value in register P1 is
2002: ** NULL, then a NULL is stored in P2.
2003: */
2004: case OP_Not: { /* same as TK_NOT, in1, out2 */
2005: pIn1 = &aMem[pOp->p1];
2006: pOut = &aMem[pOp->p2];
2007: if( pIn1->flags & MEM_Null ){
2008: sqlite3VdbeMemSetNull(pOut);
2009: }else{
2010: sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeIntValue(pIn1));
2011: }
2012: break;
2013: }
2014:
2015: /* Opcode: BitNot P1 P2 * * *
2016: **
2017: ** Interpret the content of register P1 as an integer. Store the
2018: ** ones-complement of the P1 value into register P2. If P1 holds
2019: ** a NULL then store a NULL in P2.
2020: */
2021: case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */
2022: pIn1 = &aMem[pOp->p1];
2023: pOut = &aMem[pOp->p2];
2024: if( pIn1->flags & MEM_Null ){
2025: sqlite3VdbeMemSetNull(pOut);
2026: }else{
2027: sqlite3VdbeMemSetInt64(pOut, ~sqlite3VdbeIntValue(pIn1));
2028: }
2029: break;
2030: }
2031:
2032: /* Opcode: Once P1 P2 * * *
2033: **
2034: ** Check if OP_Once flag P1 is set. If so, jump to instruction P2. Otherwise,
2035: ** set the flag and fall through to the next instruction.
2036: **
2037: ** See also: JumpOnce
2038: */
2039: case OP_Once: { /* jump */
2040: assert( pOp->p1<p->nOnceFlag );
2041: if( p->aOnceFlag[pOp->p1] ){
2042: pc = pOp->p2-1;
2043: }else{
2044: p->aOnceFlag[pOp->p1] = 1;
2045: }
2046: break;
2047: }
2048:
2049: /* Opcode: If P1 P2 P3 * *
2050: **
2051: ** Jump to P2 if the value in register P1 is true. The value
2052: ** is considered true if it is numeric and non-zero. If the value
2053: ** in P1 is NULL then take the jump if P3 is non-zero.
2054: */
2055: /* Opcode: IfNot P1 P2 P3 * *
2056: **
2057: ** Jump to P2 if the value in register P1 is False. The value
2058: ** is considered false if it has a numeric value of zero. If the value
2059: ** in P1 is NULL then take the jump if P3 is zero.
2060: */
2061: case OP_If: /* jump, in1 */
2062: case OP_IfNot: { /* jump, in1 */
2063: int c;
2064: pIn1 = &aMem[pOp->p1];
2065: if( pIn1->flags & MEM_Null ){
2066: c = pOp->p3;
2067: }else{
2068: #ifdef SQLITE_OMIT_FLOATING_POINT
2069: c = sqlite3VdbeIntValue(pIn1)!=0;
2070: #else
2071: c = sqlite3VdbeRealValue(pIn1)!=0.0;
2072: #endif
2073: if( pOp->opcode==OP_IfNot ) c = !c;
2074: }
2075: if( c ){
2076: pc = pOp->p2-1;
2077: }
2078: break;
2079: }
2080:
2081: /* Opcode: IsNull P1 P2 * * *
2082: **
2083: ** Jump to P2 if the value in register P1 is NULL.
2084: */
2085: case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */
2086: pIn1 = &aMem[pOp->p1];
2087: if( (pIn1->flags & MEM_Null)!=0 ){
2088: pc = pOp->p2 - 1;
2089: }
2090: break;
2091: }
2092:
2093: /* Opcode: NotNull P1 P2 * * *
2094: **
2095: ** Jump to P2 if the value in register P1 is not NULL.
2096: */
2097: case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */
2098: pIn1 = &aMem[pOp->p1];
2099: if( (pIn1->flags & MEM_Null)==0 ){
2100: pc = pOp->p2 - 1;
2101: }
2102: break;
2103: }
2104:
2105: /* Opcode: Column P1 P2 P3 P4 P5
2106: **
2107: ** Interpret the data that cursor P1 points to as a structure built using
2108: ** the MakeRecord instruction. (See the MakeRecord opcode for additional
2109: ** information about the format of the data.) Extract the P2-th column
2110: ** from this record. If there are less that (P2+1)
2111: ** values in the record, extract a NULL.
2112: **
2113: ** The value extracted is stored in register P3.
2114: **
2115: ** If the column contains fewer than P2 fields, then extract a NULL. Or,
2116: ** if the P4 argument is a P4_MEM use the value of the P4 argument as
2117: ** the result.
2118: **
2119: ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor,
2120: ** then the cache of the cursor is reset prior to extracting the column.
2121: ** The first OP_Column against a pseudo-table after the value of the content
2122: ** register has changed should have this bit set.
2123: */
2124: case OP_Column: {
2125: u32 payloadSize; /* Number of bytes in the record */
2126: i64 payloadSize64; /* Number of bytes in the record */
2127: int p1; /* P1 value of the opcode */
2128: int p2; /* column number to retrieve */
2129: VdbeCursor *pC; /* The VDBE cursor */
2130: char *zRec; /* Pointer to complete record-data */
2131: BtCursor *pCrsr; /* The BTree cursor */
2132: u32 *aType; /* aType[i] holds the numeric type of the i-th column */
2133: u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */
2134: int nField; /* number of fields in the record */
2135: int len; /* The length of the serialized data for the column */
2136: int i; /* Loop counter */
2137: char *zData; /* Part of the record being decoded */
2138: Mem *pDest; /* Where to write the extracted value */
2139: Mem sMem; /* For storing the record being decoded */
2140: u8 *zIdx; /* Index into header */
2141: u8 *zEndHdr; /* Pointer to first byte after the header */
2142: u32 offset; /* Offset into the data */
2143: u32 szField; /* Number of bytes in the content of a field */
2144: int szHdr; /* Size of the header size field at start of record */
2145: int avail; /* Number of bytes of available data */
2146: u32 t; /* A type code from the record header */
2147: Mem *pReg; /* PseudoTable input register */
2148:
2149:
2150: p1 = pOp->p1;
2151: p2 = pOp->p2;
2152: pC = 0;
2153: memset(&sMem, 0, sizeof(sMem));
2154: assert( p1<p->nCursor );
2155: assert( pOp->p3>0 && pOp->p3<=p->nMem );
2156: pDest = &aMem[pOp->p3];
2157: memAboutToChange(p, pDest);
2158: zRec = 0;
2159:
2160: /* This block sets the variable payloadSize to be the total number of
2161: ** bytes in the record.
2162: **
2163: ** zRec is set to be the complete text of the record if it is available.
2164: ** The complete record text is always available for pseudo-tables
2165: ** If the record is stored in a cursor, the complete record text
2166: ** might be available in the pC->aRow cache. Or it might not be.
2167: ** If the data is unavailable, zRec is set to NULL.
2168: **
2169: ** We also compute the number of columns in the record. For cursors,
2170: ** the number of columns is stored in the VdbeCursor.nField element.
2171: */
2172: pC = p->apCsr[p1];
2173: assert( pC!=0 );
2174: #ifndef SQLITE_OMIT_VIRTUALTABLE
2175: assert( pC->pVtabCursor==0 );
2176: #endif
2177: pCrsr = pC->pCursor;
2178: if( pCrsr!=0 ){
2179: /* The record is stored in a B-Tree */
2180: rc = sqlite3VdbeCursorMoveto(pC);
2181: if( rc ) goto abort_due_to_error;
2182: if( pC->nullRow ){
2183: payloadSize = 0;
2184: }else if( pC->cacheStatus==p->cacheCtr ){
2185: payloadSize = pC->payloadSize;
2186: zRec = (char*)pC->aRow;
2187: }else if( pC->isIndex ){
2188: assert( sqlite3BtreeCursorIsValid(pCrsr) );
2189: VVA_ONLY(rc =) sqlite3BtreeKeySize(pCrsr, &payloadSize64);
2190: assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
2191: /* sqlite3BtreeParseCellPtr() uses getVarint32() to extract the
2192: ** payload size, so it is impossible for payloadSize64 to be
2193: ** larger than 32 bits. */
2194: assert( (payloadSize64 & SQLITE_MAX_U32)==(u64)payloadSize64 );
2195: payloadSize = (u32)payloadSize64;
2196: }else{
2197: assert( sqlite3BtreeCursorIsValid(pCrsr) );
2198: VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &payloadSize);
2199: assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
2200: }
2201: }else if( ALWAYS(pC->pseudoTableReg>0) ){
2202: pReg = &aMem[pC->pseudoTableReg];
2203: assert( pReg->flags & MEM_Blob );
2204: assert( memIsValid(pReg) );
2205: payloadSize = pReg->n;
2206: zRec = pReg->z;
2207: pC->cacheStatus = (pOp->p5&OPFLAG_CLEARCACHE) ? CACHE_STALE : p->cacheCtr;
2208: assert( payloadSize==0 || zRec!=0 );
2209: }else{
2210: /* Consider the row to be NULL */
2211: payloadSize = 0;
2212: }
2213:
2214: /* If payloadSize is 0, then just store a NULL. This can happen because of
2215: ** nullRow or because of a corrupt database. */
2216: if( payloadSize==0 ){
2217: MemSetTypeFlag(pDest, MEM_Null);
2218: goto op_column_out;
2219: }
2220: assert( db->aLimit[SQLITE_LIMIT_LENGTH]>=0 );
2221: if( payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
2222: goto too_big;
2223: }
2224:
2225: nField = pC->nField;
2226: assert( p2<nField );
2227:
2228: /* Read and parse the table header. Store the results of the parse
2229: ** into the record header cache fields of the cursor.
2230: */
2231: aType = pC->aType;
2232: if( pC->cacheStatus==p->cacheCtr ){
2233: aOffset = pC->aOffset;
2234: }else{
2235: assert(aType);
2236: avail = 0;
2237: pC->aOffset = aOffset = &aType[nField];
2238: pC->payloadSize = payloadSize;
2239: pC->cacheStatus = p->cacheCtr;
2240:
2241: /* Figure out how many bytes are in the header */
2242: if( zRec ){
2243: zData = zRec;
2244: }else{
2245: if( pC->isIndex ){
2246: zData = (char*)sqlite3BtreeKeyFetch(pCrsr, &avail);
2247: }else{
2248: zData = (char*)sqlite3BtreeDataFetch(pCrsr, &avail);
2249: }
2250: /* If KeyFetch()/DataFetch() managed to get the entire payload,
2251: ** save the payload in the pC->aRow cache. That will save us from
2252: ** having to make additional calls to fetch the content portion of
2253: ** the record.
2254: */
2255: assert( avail>=0 );
2256: if( payloadSize <= (u32)avail ){
2257: zRec = zData;
2258: pC->aRow = (u8*)zData;
2259: }else{
2260: pC->aRow = 0;
2261: }
2262: }
2263: /* The following assert is true in all cases accept when
2264: ** the database file has been corrupted externally.
2265: ** assert( zRec!=0 || avail>=payloadSize || avail>=9 ); */
2266: szHdr = getVarint32((u8*)zData, offset);
2267:
2268: /* Make sure a corrupt database has not given us an oversize header.
2269: ** Do this now to avoid an oversize memory allocation.
2270: **
2271: ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte
2272: ** types use so much data space that there can only be 4096 and 32 of
2273: ** them, respectively. So the maximum header length results from a
2274: ** 3-byte type for each of the maximum of 32768 columns plus three
2275: ** extra bytes for the header length itself. 32768*3 + 3 = 98307.
2276: */
2277: if( offset > 98307 ){
2278: rc = SQLITE_CORRUPT_BKPT;
2279: goto op_column_out;
2280: }
2281:
2282: /* Compute in len the number of bytes of data we need to read in order
2283: ** to get nField type values. offset is an upper bound on this. But
2284: ** nField might be significantly less than the true number of columns
2285: ** in the table, and in that case, 5*nField+3 might be smaller than offset.
2286: ** We want to minimize len in order to limit the size of the memory
2287: ** allocation, especially if a corrupt database file has caused offset
2288: ** to be oversized. Offset is limited to 98307 above. But 98307 might
2289: ** still exceed Robson memory allocation limits on some configurations.
2290: ** On systems that cannot tolerate large memory allocations, nField*5+3
2291: ** will likely be much smaller since nField will likely be less than
2292: ** 20 or so. This insures that Robson memory allocation limits are
2293: ** not exceeded even for corrupt database files.
2294: */
2295: len = nField*5 + 3;
2296: if( len > (int)offset ) len = (int)offset;
2297:
2298: /* The KeyFetch() or DataFetch() above are fast and will get the entire
2299: ** record header in most cases. But they will fail to get the complete
2300: ** record header if the record header does not fit on a single page
2301: ** in the B-Tree. When that happens, use sqlite3VdbeMemFromBtree() to
2302: ** acquire the complete header text.
2303: */
2304: if( !zRec && avail<len ){
2305: sMem.flags = 0;
2306: sMem.db = 0;
2307: rc = sqlite3VdbeMemFromBtree(pCrsr, 0, len, pC->isIndex, &sMem);
2308: if( rc!=SQLITE_OK ){
2309: goto op_column_out;
2310: }
2311: zData = sMem.z;
2312: }
2313: zEndHdr = (u8 *)&zData[len];
2314: zIdx = (u8 *)&zData[szHdr];
2315:
2316: /* Scan the header and use it to fill in the aType[] and aOffset[]
2317: ** arrays. aType[i] will contain the type integer for the i-th
2318: ** column and aOffset[i] will contain the offset from the beginning
2319: ** of the record to the start of the data for the i-th column
2320: */
2321: for(i=0; i<nField; i++){
2322: if( zIdx<zEndHdr ){
2323: aOffset[i] = offset;
2324: if( zIdx[0]<0x80 ){
2325: t = zIdx[0];
2326: zIdx++;
2327: }else{
2328: zIdx += sqlite3GetVarint32(zIdx, &t);
2329: }
2330: aType[i] = t;
2331: szField = sqlite3VdbeSerialTypeLen(t);
2332: offset += szField;
2333: if( offset<szField ){ /* True if offset overflows */
2334: zIdx = &zEndHdr[1]; /* Forces SQLITE_CORRUPT return below */
2335: break;
2336: }
2337: }else{
2338: /* If i is less that nField, then there are less fields in this
2339: ** record than SetNumColumns indicated there are columns in the
2340: ** table. Set the offset for any extra columns not present in
2341: ** the record to 0. This tells code below to store a NULL
2342: ** instead of deserializing a value from the record.
2343: */
2344: aOffset[i] = 0;
2345: }
2346: }
2347: sqlite3VdbeMemRelease(&sMem);
2348: sMem.flags = MEM_Null;
2349:
2350: /* If we have read more header data than was contained in the header,
2351: ** or if the end of the last field appears to be past the end of the
2352: ** record, or if the end of the last field appears to be before the end
2353: ** of the record (when all fields present), then we must be dealing
2354: ** with a corrupt database.
2355: */
2356: if( (zIdx > zEndHdr) || (offset > payloadSize)
2357: || (zIdx==zEndHdr && offset!=payloadSize) ){
2358: rc = SQLITE_CORRUPT_BKPT;
2359: goto op_column_out;
2360: }
2361: }
2362:
2363: /* Get the column information. If aOffset[p2] is non-zero, then
2364: ** deserialize the value from the record. If aOffset[p2] is zero,
2365: ** then there are not enough fields in the record to satisfy the
2366: ** request. In this case, set the value NULL or to P4 if P4 is
2367: ** a pointer to a Mem object.
2368: */
2369: if( aOffset[p2] ){
2370: assert( rc==SQLITE_OK );
2371: if( zRec ){
2372: VdbeMemRelease(pDest);
2373: sqlite3VdbeSerialGet((u8 *)&zRec[aOffset[p2]], aType[p2], pDest);
2374: }else{
2375: len = sqlite3VdbeSerialTypeLen(aType[p2]);
2376: sqlite3VdbeMemMove(&sMem, pDest);
2377: rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, pC->isIndex, &sMem);
2378: if( rc!=SQLITE_OK ){
2379: goto op_column_out;
2380: }
2381: zData = sMem.z;
2382: sqlite3VdbeSerialGet((u8*)zData, aType[p2], pDest);
2383: }
2384: pDest->enc = encoding;
2385: }else{
2386: if( pOp->p4type==P4_MEM ){
2387: sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
2388: }else{
2389: MemSetTypeFlag(pDest, MEM_Null);
2390: }
2391: }
2392:
2393: /* If we dynamically allocated space to hold the data (in the
2394: ** sqlite3VdbeMemFromBtree() call above) then transfer control of that
2395: ** dynamically allocated space over to the pDest structure.
2396: ** This prevents a memory copy.
2397: */
2398: if( sMem.zMalloc ){
2399: assert( sMem.z==sMem.zMalloc );
2400: assert( !(pDest->flags & MEM_Dyn) );
2401: assert( !(pDest->flags & (MEM_Blob|MEM_Str)) || pDest->z==sMem.z );
2402: pDest->flags &= ~(MEM_Ephem|MEM_Static);
2403: pDest->flags |= MEM_Term;
2404: pDest->z = sMem.z;
2405: pDest->zMalloc = sMem.zMalloc;
2406: }
2407:
2408: rc = sqlite3VdbeMemMakeWriteable(pDest);
2409:
2410: op_column_out:
2411: UPDATE_MAX_BLOBSIZE(pDest);
2412: REGISTER_TRACE(pOp->p3, pDest);
2413: break;
2414: }
2415:
2416: /* Opcode: Affinity P1 P2 * P4 *
2417: **
2418: ** Apply affinities to a range of P2 registers starting with P1.
2419: **
2420: ** P4 is a string that is P2 characters long. The nth character of the
2421: ** string indicates the column affinity that should be used for the nth
2422: ** memory cell in the range.
2423: */
2424: case OP_Affinity: {
2425: const char *zAffinity; /* The affinity to be applied */
2426: char cAff; /* A single character of affinity */
2427:
2428: zAffinity = pOp->p4.z;
2429: assert( zAffinity!=0 );
2430: assert( zAffinity[pOp->p2]==0 );
2431: pIn1 = &aMem[pOp->p1];
2432: while( (cAff = *(zAffinity++))!=0 ){
2433: assert( pIn1 <= &p->aMem[p->nMem] );
2434: assert( memIsValid(pIn1) );
2435: ExpandBlob(pIn1);
2436: applyAffinity(pIn1, cAff, encoding);
2437: pIn1++;
2438: }
2439: break;
2440: }
2441:
2442: /* Opcode: MakeRecord P1 P2 P3 P4 *
2443: **
2444: ** Convert P2 registers beginning with P1 into the [record format]
2445: ** use as a data record in a database table or as a key
2446: ** in an index. The OP_Column opcode can decode the record later.
2447: **
2448: ** P4 may be a string that is P2 characters long. The nth character of the
2449: ** string indicates the column affinity that should be used for the nth
2450: ** field of the index key.
2451: **
2452: ** The mapping from character to affinity is given by the SQLITE_AFF_
2453: ** macros defined in sqliteInt.h.
2454: **
2455: ** If P4 is NULL then all index fields have the affinity NONE.
2456: */
2457: case OP_MakeRecord: {
2458: u8 *zNewRecord; /* A buffer to hold the data for the new record */
2459: Mem *pRec; /* The new record */
2460: u64 nData; /* Number of bytes of data space */
2461: int nHdr; /* Number of bytes of header space */
2462: i64 nByte; /* Data space required for this record */
2463: int nZero; /* Number of zero bytes at the end of the record */
2464: int nVarint; /* Number of bytes in a varint */
2465: u32 serial_type; /* Type field */
2466: Mem *pData0; /* First field to be combined into the record */
2467: Mem *pLast; /* Last field of the record */
2468: int nField; /* Number of fields in the record */
2469: char *zAffinity; /* The affinity string for the record */
2470: int file_format; /* File format to use for encoding */
2471: int i; /* Space used in zNewRecord[] */
2472: int len; /* Length of a field */
2473:
2474: /* Assuming the record contains N fields, the record format looks
2475: ** like this:
2476: **
2477: ** ------------------------------------------------------------------------
2478: ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 |
2479: ** ------------------------------------------------------------------------
2480: **
2481: ** Data(0) is taken from register P1. Data(1) comes from register P1+1
2482: ** and so froth.
2483: **
2484: ** Each type field is a varint representing the serial type of the
2485: ** corresponding data element (see sqlite3VdbeSerialType()). The
2486: ** hdr-size field is also a varint which is the offset from the beginning
2487: ** of the record to data0.
2488: */
2489: nData = 0; /* Number of bytes of data space */
2490: nHdr = 0; /* Number of bytes of header space */
2491: nZero = 0; /* Number of zero bytes at the end of the record */
2492: nField = pOp->p1;
2493: zAffinity = pOp->p4.z;
2494: assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=p->nMem+1 );
2495: pData0 = &aMem[nField];
2496: nField = pOp->p2;
2497: pLast = &pData0[nField-1];
2498: file_format = p->minWriteFileFormat;
2499:
2500: /* Identify the output register */
2501: assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
2502: pOut = &aMem[pOp->p3];
2503: memAboutToChange(p, pOut);
2504:
2505: /* Loop through the elements that will make up the record to figure
2506: ** out how much space is required for the new record.
2507: */
2508: for(pRec=pData0; pRec<=pLast; pRec++){
2509: assert( memIsValid(pRec) );
2510: if( zAffinity ){
2511: applyAffinity(pRec, zAffinity[pRec-pData0], encoding);
2512: }
2513: if( pRec->flags&MEM_Zero && pRec->n>0 ){
2514: sqlite3VdbeMemExpandBlob(pRec);
2515: }
2516: serial_type = sqlite3VdbeSerialType(pRec, file_format);
2517: len = sqlite3VdbeSerialTypeLen(serial_type);
2518: nData += len;
2519: nHdr += sqlite3VarintLen(serial_type);
2520: if( pRec->flags & MEM_Zero ){
2521: /* Only pure zero-filled BLOBs can be input to this Opcode.
2522: ** We do not allow blobs with a prefix and a zero-filled tail. */
2523: nZero += pRec->u.nZero;
2524: }else if( len ){
2525: nZero = 0;
2526: }
2527: }
2528:
2529: /* Add the initial header varint and total the size */
2530: nHdr += nVarint = sqlite3VarintLen(nHdr);
2531: if( nVarint<sqlite3VarintLen(nHdr) ){
2532: nHdr++;
2533: }
2534: nByte = nHdr+nData-nZero;
2535: if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
2536: goto too_big;
2537: }
2538:
2539: /* Make sure the output register has a buffer large enough to store
2540: ** the new record. The output register (pOp->p3) is not allowed to
2541: ** be one of the input registers (because the following call to
2542: ** sqlite3VdbeMemGrow() could clobber the value before it is used).
2543: */
2544: if( sqlite3VdbeMemGrow(pOut, (int)nByte, 0) ){
2545: goto no_mem;
2546: }
2547: zNewRecord = (u8 *)pOut->z;
2548:
2549: /* Write the record */
2550: i = putVarint32(zNewRecord, nHdr);
2551: for(pRec=pData0; pRec<=pLast; pRec++){
2552: serial_type = sqlite3VdbeSerialType(pRec, file_format);
2553: i += putVarint32(&zNewRecord[i], serial_type); /* serial type */
2554: }
2555: for(pRec=pData0; pRec<=pLast; pRec++){ /* serial data */
2556: i += sqlite3VdbeSerialPut(&zNewRecord[i], (int)(nByte-i), pRec,file_format);
2557: }
2558: assert( i==nByte );
2559:
2560: assert( pOp->p3>0 && pOp->p3<=p->nMem );
2561: pOut->n = (int)nByte;
2562: pOut->flags = MEM_Blob | MEM_Dyn;
2563: pOut->xDel = 0;
2564: if( nZero ){
2565: pOut->u.nZero = nZero;
2566: pOut->flags |= MEM_Zero;
2567: }
2568: pOut->enc = SQLITE_UTF8; /* In case the blob is ever converted to text */
2569: REGISTER_TRACE(pOp->p3, pOut);
2570: UPDATE_MAX_BLOBSIZE(pOut);
2571: break;
2572: }
2573:
2574: /* Opcode: Count P1 P2 * * *
2575: **
2576: ** Store the number of entries (an integer value) in the table or index
2577: ** opened by cursor P1 in register P2
2578: */
2579: #ifndef SQLITE_OMIT_BTREECOUNT
2580: case OP_Count: { /* out2-prerelease */
2581: i64 nEntry;
2582: BtCursor *pCrsr;
2583:
2584: pCrsr = p->apCsr[pOp->p1]->pCursor;
2585: if( ALWAYS(pCrsr) ){
2586: rc = sqlite3BtreeCount(pCrsr, &nEntry);
2587: }else{
2588: nEntry = 0;
2589: }
2590: pOut->u.i = nEntry;
2591: break;
2592: }
2593: #endif
2594:
2595: /* Opcode: Savepoint P1 * * P4 *
2596: **
2597: ** Open, release or rollback the savepoint named by parameter P4, depending
2598: ** on the value of P1. To open a new savepoint, P1==0. To release (commit) an
2599: ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2.
2600: */
2601: case OP_Savepoint: {
2602: int p1; /* Value of P1 operand */
2603: char *zName; /* Name of savepoint */
2604: int nName;
2605: Savepoint *pNew;
2606: Savepoint *pSavepoint;
2607: Savepoint *pTmp;
2608: int iSavepoint;
2609: int ii;
2610:
2611: p1 = pOp->p1;
2612: zName = pOp->p4.z;
2613:
2614: /* Assert that the p1 parameter is valid. Also that if there is no open
2615: ** transaction, then there cannot be any savepoints.
2616: */
2617: assert( db->pSavepoint==0 || db->autoCommit==0 );
2618: assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
2619: assert( db->pSavepoint || db->isTransactionSavepoint==0 );
2620: assert( checkSavepointCount(db) );
2621:
2622: if( p1==SAVEPOINT_BEGIN ){
2623: if( db->writeVdbeCnt>0 ){
2624: /* A new savepoint cannot be created if there are active write
2625: ** statements (i.e. open read/write incremental blob handles).
2626: */
2627: sqlite3SetString(&p->zErrMsg, db, "cannot open savepoint - "
2628: "SQL statements in progress");
2629: rc = SQLITE_BUSY;
2630: }else{
2631: nName = sqlite3Strlen30(zName);
2632:
2633: #ifndef SQLITE_OMIT_VIRTUALTABLE
2634: /* This call is Ok even if this savepoint is actually a transaction
2635: ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
2636: ** If this is a transaction savepoint being opened, it is guaranteed
2637: ** that the db->aVTrans[] array is empty. */
2638: assert( db->autoCommit==0 || db->nVTrans==0 );
2639: rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,
2640: db->nStatement+db->nSavepoint);
2641: if( rc!=SQLITE_OK ) goto abort_due_to_error;
2642: #endif
2643:
2644: /* Create a new savepoint structure. */
2645: pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+nName+1);
2646: if( pNew ){
2647: pNew->zName = (char *)&pNew[1];
2648: memcpy(pNew->zName, zName, nName+1);
2649:
2650: /* If there is no open transaction, then mark this as a special
2651: ** "transaction savepoint". */
2652: if( db->autoCommit ){
2653: db->autoCommit = 0;
2654: db->isTransactionSavepoint = 1;
2655: }else{
2656: db->nSavepoint++;
2657: }
2658:
2659: /* Link the new savepoint into the database handle's list. */
2660: pNew->pNext = db->pSavepoint;
2661: db->pSavepoint = pNew;
2662: pNew->nDeferredCons = db->nDeferredCons;
2663: }
2664: }
2665: }else{
2666: iSavepoint = 0;
2667:
2668: /* Find the named savepoint. If there is no such savepoint, then an
2669: ** an error is returned to the user. */
2670: for(
2671: pSavepoint = db->pSavepoint;
2672: pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
2673: pSavepoint = pSavepoint->pNext
2674: ){
2675: iSavepoint++;
2676: }
2677: if( !pSavepoint ){
2678: sqlite3SetString(&p->zErrMsg, db, "no such savepoint: %s", zName);
2679: rc = SQLITE_ERROR;
2680: }else if(
2681: db->writeVdbeCnt>0 || (p1==SAVEPOINT_ROLLBACK && db->activeVdbeCnt>1)
2682: ){
2683: /* It is not possible to release (commit) a savepoint if there are
2684: ** active write statements. It is not possible to rollback a savepoint
2685: ** if there are any active statements at all.
2686: */
2687: sqlite3SetString(&p->zErrMsg, db,
2688: "cannot %s savepoint - SQL statements in progress",
2689: (p1==SAVEPOINT_ROLLBACK ? "rollback": "release")
2690: );
2691: rc = SQLITE_BUSY;
2692: }else{
2693:
2694: /* Determine whether or not this is a transaction savepoint. If so,
2695: ** and this is a RELEASE command, then the current transaction
2696: ** is committed.
2697: */
2698: int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
2699: if( isTransaction && p1==SAVEPOINT_RELEASE ){
2700: if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
2701: goto vdbe_return;
2702: }
2703: db->autoCommit = 1;
2704: if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
2705: p->pc = pc;
2706: db->autoCommit = 0;
2707: p->rc = rc = SQLITE_BUSY;
2708: goto vdbe_return;
2709: }
2710: db->isTransactionSavepoint = 0;
2711: rc = p->rc;
2712: }else{
2713: iSavepoint = db->nSavepoint - iSavepoint - 1;
2714: for(ii=0; ii<db->nDb; ii++){
2715: rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
2716: if( rc!=SQLITE_OK ){
2717: goto abort_due_to_error;
2718: }
2719: }
2720: if( p1==SAVEPOINT_ROLLBACK && (db->flags&SQLITE_InternChanges)!=0 ){
2721: sqlite3ExpirePreparedStatements(db);
2722: sqlite3ResetInternalSchema(db, -1);
2723: db->flags = (db->flags | SQLITE_InternChanges);
2724: }
2725: }
2726:
2727: /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all
2728: ** savepoints nested inside of the savepoint being operated on. */
2729: while( db->pSavepoint!=pSavepoint ){
2730: pTmp = db->pSavepoint;
2731: db->pSavepoint = pTmp->pNext;
2732: sqlite3DbFree(db, pTmp);
2733: db->nSavepoint--;
2734: }
2735:
2736: /* If it is a RELEASE, then destroy the savepoint being operated on
2737: ** too. If it is a ROLLBACK TO, then set the number of deferred
2738: ** constraint violations present in the database to the value stored
2739: ** when the savepoint was created. */
2740: if( p1==SAVEPOINT_RELEASE ){
2741: assert( pSavepoint==db->pSavepoint );
2742: db->pSavepoint = pSavepoint->pNext;
2743: sqlite3DbFree(db, pSavepoint);
2744: if( !isTransaction ){
2745: db->nSavepoint--;
2746: }
2747: }else{
2748: db->nDeferredCons = pSavepoint->nDeferredCons;
2749: }
2750:
2751: if( !isTransaction ){
2752: rc = sqlite3VtabSavepoint(db, p1, iSavepoint);
2753: if( rc!=SQLITE_OK ) goto abort_due_to_error;
2754: }
2755: }
2756: }
2757:
2758: break;
2759: }
2760:
2761: /* Opcode: AutoCommit P1 P2 * * *
2762: **
2763: ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
2764: ** back any currently active btree transactions. If there are any active
2765: ** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if
2766: ** there are active writing VMs or active VMs that use shared cache.
2767: **
2768: ** This instruction causes the VM to halt.
2769: */
2770: case OP_AutoCommit: {
2771: int desiredAutoCommit;
2772: int iRollback;
2773: int turnOnAC;
2774:
2775: desiredAutoCommit = pOp->p1;
2776: iRollback = pOp->p2;
2777: turnOnAC = desiredAutoCommit && !db->autoCommit;
2778: assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
2779: assert( desiredAutoCommit==1 || iRollback==0 );
2780: assert( db->activeVdbeCnt>0 ); /* At least this one VM is active */
2781:
2782: if( turnOnAC && iRollback && db->activeVdbeCnt>1 ){
2783: /* If this instruction implements a ROLLBACK and other VMs are
2784: ** still running, and a transaction is active, return an error indicating
2785: ** that the other VMs must complete first.
2786: */
2787: sqlite3SetString(&p->zErrMsg, db, "cannot rollback transaction - "
2788: "SQL statements in progress");
2789: rc = SQLITE_BUSY;
2790: }else if( turnOnAC && !iRollback && db->writeVdbeCnt>0 ){
2791: /* If this instruction implements a COMMIT and other VMs are writing
2792: ** return an error indicating that the other VMs must complete first.
2793: */
2794: sqlite3SetString(&p->zErrMsg, db, "cannot commit transaction - "
2795: "SQL statements in progress");
2796: rc = SQLITE_BUSY;
2797: }else if( desiredAutoCommit!=db->autoCommit ){
2798: if( iRollback ){
2799: assert( desiredAutoCommit==1 );
2800: sqlite3RollbackAll(db);
2801: db->autoCommit = 1;
2802: }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
2803: goto vdbe_return;
2804: }else{
2805: db->autoCommit = (u8)desiredAutoCommit;
2806: if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
2807: p->pc = pc;
2808: db->autoCommit = (u8)(1-desiredAutoCommit);
2809: p->rc = rc = SQLITE_BUSY;
2810: goto vdbe_return;
2811: }
2812: }
2813: assert( db->nStatement==0 );
2814: sqlite3CloseSavepoints(db);
2815: if( p->rc==SQLITE_OK ){
2816: rc = SQLITE_DONE;
2817: }else{
2818: rc = SQLITE_ERROR;
2819: }
2820: goto vdbe_return;
2821: }else{
2822: sqlite3SetString(&p->zErrMsg, db,
2823: (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
2824: (iRollback)?"cannot rollback - no transaction is active":
2825: "cannot commit - no transaction is active"));
2826:
2827: rc = SQLITE_ERROR;
2828: }
2829: break;
2830: }
2831:
2832: /* Opcode: Transaction P1 P2 * * *
2833: **
2834: ** Begin a transaction. The transaction ends when a Commit or Rollback
2835: ** opcode is encountered. Depending on the ON CONFLICT setting, the
2836: ** transaction might also be rolled back if an error is encountered.
2837: **
2838: ** P1 is the index of the database file on which the transaction is
2839: ** started. Index 0 is the main database file and index 1 is the
2840: ** file used for temporary tables. Indices of 2 or more are used for
2841: ** attached databases.
2842: **
2843: ** If P2 is non-zero, then a write-transaction is started. A RESERVED lock is
2844: ** obtained on the database file when a write-transaction is started. No
2845: ** other process can start another write transaction while this transaction is
2846: ** underway. Starting a write transaction also creates a rollback journal. A
2847: ** write transaction must be started before any changes can be made to the
2848: ** database. If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
2849: ** on the file.
2850: **
2851: ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
2852: ** true (this flag is set if the Vdbe may modify more than one row and may
2853: ** throw an ABORT exception), a statement transaction may also be opened.
2854: ** More specifically, a statement transaction is opened iff the database
2855: ** connection is currently not in autocommit mode, or if there are other
2856: ** active statements. A statement transaction allows the affects of this
2857: ** VDBE to be rolled back after an error without having to roll back the
2858: ** entire transaction. If no error is encountered, the statement transaction
2859: ** will automatically commit when the VDBE halts.
2860: **
2861: ** If P2 is zero, then a read-lock is obtained on the database file.
2862: */
2863: case OP_Transaction: {
2864: Btree *pBt;
2865:
2866: assert( pOp->p1>=0 && pOp->p1<db->nDb );
2867: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
2868: pBt = db->aDb[pOp->p1].pBt;
2869:
2870: if( pBt ){
2871: rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);
2872: if( rc==SQLITE_BUSY ){
2873: p->pc = pc;
2874: p->rc = rc = SQLITE_BUSY;
2875: goto vdbe_return;
2876: }
2877: if( rc!=SQLITE_OK ){
2878: goto abort_due_to_error;
2879: }
2880:
2881: if( pOp->p2 && p->usesStmtJournal
2882: && (db->autoCommit==0 || db->activeVdbeCnt>1)
2883: ){
2884: assert( sqlite3BtreeIsInTrans(pBt) );
2885: if( p->iStatement==0 ){
2886: assert( db->nStatement>=0 && db->nSavepoint>=0 );
2887: db->nStatement++;
2888: p->iStatement = db->nSavepoint + db->nStatement;
2889: }
2890:
2891: rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
2892: if( rc==SQLITE_OK ){
2893: rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
2894: }
2895:
2896: /* Store the current value of the database handles deferred constraint
2897: ** counter. If the statement transaction needs to be rolled back,
2898: ** the value of this counter needs to be restored too. */
2899: p->nStmtDefCons = db->nDeferredCons;
2900: }
2901: }
2902: break;
2903: }
2904:
2905: /* Opcode: ReadCookie P1 P2 P3 * *
2906: **
2907: ** Read cookie number P3 from database P1 and write it into register P2.
2908: ** P3==1 is the schema version. P3==2 is the database format.
2909: ** P3==3 is the recommended pager cache size, and so forth. P1==0 is
2910: ** the main database file and P1==1 is the database file used to store
2911: ** temporary tables.
2912: **
2913: ** There must be a read-lock on the database (either a transaction
2914: ** must be started or there must be an open cursor) before
2915: ** executing this instruction.
2916: */
2917: case OP_ReadCookie: { /* out2-prerelease */
2918: int iMeta;
2919: int iDb;
2920: int iCookie;
2921:
2922: iDb = pOp->p1;
2923: iCookie = pOp->p3;
2924: assert( pOp->p3<SQLITE_N_BTREE_META );
2925: assert( iDb>=0 && iDb<db->nDb );
2926: assert( db->aDb[iDb].pBt!=0 );
2927: assert( (p->btreeMask & (((yDbMask)1)<<iDb))!=0 );
2928:
2929: sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
2930: pOut->u.i = iMeta;
2931: break;
2932: }
2933:
2934: /* Opcode: SetCookie P1 P2 P3 * *
2935: **
2936: ** Write the content of register P3 (interpreted as an integer)
2937: ** into cookie number P2 of database P1. P2==1 is the schema version.
2938: ** P2==2 is the database format. P2==3 is the recommended pager cache
2939: ** size, and so forth. P1==0 is the main database file and P1==1 is the
2940: ** database file used to store temporary tables.
2941: **
2942: ** A transaction must be started before executing this opcode.
2943: */
2944: case OP_SetCookie: { /* in3 */
2945: Db *pDb;
2946: assert( pOp->p2<SQLITE_N_BTREE_META );
2947: assert( pOp->p1>=0 && pOp->p1<db->nDb );
2948: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
2949: pDb = &db->aDb[pOp->p1];
2950: assert( pDb->pBt!=0 );
2951: assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
2952: pIn3 = &aMem[pOp->p3];
2953: sqlite3VdbeMemIntegerify(pIn3);
2954: /* See note about index shifting on OP_ReadCookie */
2955: rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, (int)pIn3->u.i);
2956: if( pOp->p2==BTREE_SCHEMA_VERSION ){
2957: /* When the schema cookie changes, record the new cookie internally */
2958: pDb->pSchema->schema_cookie = (int)pIn3->u.i;
2959: db->flags |= SQLITE_InternChanges;
2960: }else if( pOp->p2==BTREE_FILE_FORMAT ){
2961: /* Record changes in the file format */
2962: pDb->pSchema->file_format = (u8)pIn3->u.i;
2963: }
2964: if( pOp->p1==1 ){
2965: /* Invalidate all prepared statements whenever the TEMP database
2966: ** schema is changed. Ticket #1644 */
2967: sqlite3ExpirePreparedStatements(db);
2968: p->expired = 0;
2969: }
2970: break;
2971: }
2972:
2973: /* Opcode: VerifyCookie P1 P2 P3 * *
2974: **
2975: ** Check the value of global database parameter number 0 (the
2976: ** schema version) and make sure it is equal to P2 and that the
2977: ** generation counter on the local schema parse equals P3.
2978: **
2979: ** P1 is the database number which is 0 for the main database file
2980: ** and 1 for the file holding temporary tables and some higher number
2981: ** for auxiliary databases.
2982: **
2983: ** The cookie changes its value whenever the database schema changes.
2984: ** This operation is used to detect when that the cookie has changed
2985: ** and that the current process needs to reread the schema.
2986: **
2987: ** Either a transaction needs to have been started or an OP_Open needs
2988: ** to be executed (to establish a read lock) before this opcode is
2989: ** invoked.
2990: */
2991: case OP_VerifyCookie: {
2992: int iMeta;
2993: int iGen;
2994: Btree *pBt;
2995:
2996: assert( pOp->p1>=0 && pOp->p1<db->nDb );
2997: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
2998: assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
2999: pBt = db->aDb[pOp->p1].pBt;
3000: if( pBt ){
3001: sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
3002: iGen = db->aDb[pOp->p1].pSchema->iGeneration;
3003: }else{
3004: iGen = iMeta = 0;
3005: }
3006: if( iMeta!=pOp->p2 || iGen!=pOp->p3 ){
3007: sqlite3DbFree(db, p->zErrMsg);
3008: p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
3009: /* If the schema-cookie from the database file matches the cookie
3010: ** stored with the in-memory representation of the schema, do
3011: ** not reload the schema from the database file.
3012: **
3013: ** If virtual-tables are in use, this is not just an optimization.
3014: ** Often, v-tables store their data in other SQLite tables, which
3015: ** are queried from within xNext() and other v-table methods using
3016: ** prepared queries. If such a query is out-of-date, we do not want to
3017: ** discard the database schema, as the user code implementing the
3018: ** v-table would have to be ready for the sqlite3_vtab structure itself
3019: ** to be invalidated whenever sqlite3_step() is called from within
3020: ** a v-table method.
3021: */
3022: if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
3023: sqlite3ResetInternalSchema(db, pOp->p1);
3024: }
3025:
3026: p->expired = 1;
3027: rc = SQLITE_SCHEMA;
3028: }
3029: break;
3030: }
3031:
3032: /* Opcode: OpenRead P1 P2 P3 P4 P5
3033: **
3034: ** Open a read-only cursor for the database table whose root page is
3035: ** P2 in a database file. The database file is determined by P3.
3036: ** P3==0 means the main database, P3==1 means the database used for
3037: ** temporary tables, and P3>1 means used the corresponding attached
3038: ** database. Give the new cursor an identifier of P1. The P1
3039: ** values need not be contiguous but all P1 values should be small integers.
3040: ** It is an error for P1 to be negative.
3041: **
3042: ** If P5!=0 then use the content of register P2 as the root page, not
3043: ** the value of P2 itself.
3044: **
3045: ** There will be a read lock on the database whenever there is an
3046: ** open cursor. If the database was unlocked prior to this instruction
3047: ** then a read lock is acquired as part of this instruction. A read
3048: ** lock allows other processes to read the database but prohibits
3049: ** any other process from modifying the database. The read lock is
3050: ** released when all cursors are closed. If this instruction attempts
3051: ** to get a read lock but fails, the script terminates with an
3052: ** SQLITE_BUSY error code.
3053: **
3054: ** The P4 value may be either an integer (P4_INT32) or a pointer to
3055: ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
3056: ** structure, then said structure defines the content and collating
3057: ** sequence of the index being opened. Otherwise, if P4 is an integer
3058: ** value, it is set to the number of columns in the table.
3059: **
3060: ** See also OpenWrite.
3061: */
3062: /* Opcode: OpenWrite P1 P2 P3 P4 P5
3063: **
3064: ** Open a read/write cursor named P1 on the table or index whose root
3065: ** page is P2. Or if P5!=0 use the content of register P2 to find the
3066: ** root page.
3067: **
3068: ** The P4 value may be either an integer (P4_INT32) or a pointer to
3069: ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo
3070: ** structure, then said structure defines the content and collating
3071: ** sequence of the index being opened. Otherwise, if P4 is an integer
3072: ** value, it is set to the number of columns in the table, or to the
3073: ** largest index of any column of the table that is actually used.
3074: **
3075: ** This instruction works just like OpenRead except that it opens the cursor
3076: ** in read/write mode. For a given table, there can be one or more read-only
3077: ** cursors or a single read/write cursor but not both.
3078: **
3079: ** See also OpenRead.
3080: */
3081: case OP_OpenRead:
3082: case OP_OpenWrite: {
3083: int nField;
3084: KeyInfo *pKeyInfo;
3085: int p2;
3086: int iDb;
3087: int wrFlag;
3088: Btree *pX;
3089: VdbeCursor *pCur;
3090: Db *pDb;
3091:
3092: if( p->expired ){
3093: rc = SQLITE_ABORT;
3094: break;
3095: }
3096:
3097: nField = 0;
3098: pKeyInfo = 0;
3099: p2 = pOp->p2;
3100: iDb = pOp->p3;
3101: assert( iDb>=0 && iDb<db->nDb );
3102: assert( (p->btreeMask & (((yDbMask)1)<<iDb))!=0 );
3103: pDb = &db->aDb[iDb];
3104: pX = pDb->pBt;
3105: assert( pX!=0 );
3106: if( pOp->opcode==OP_OpenWrite ){
3107: wrFlag = 1;
3108: assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
3109: if( pDb->pSchema->file_format < p->minWriteFileFormat ){
3110: p->minWriteFileFormat = pDb->pSchema->file_format;
3111: }
3112: }else{
3113: wrFlag = 0;
3114: }
3115: if( pOp->p5 ){
3116: assert( p2>0 );
3117: assert( p2<=p->nMem );
3118: pIn2 = &aMem[p2];
3119: assert( memIsValid(pIn2) );
3120: assert( (pIn2->flags & MEM_Int)!=0 );
3121: sqlite3VdbeMemIntegerify(pIn2);
3122: p2 = (int)pIn2->u.i;
3123: /* The p2 value always comes from a prior OP_CreateTable opcode and
3124: ** that opcode will always set the p2 value to 2 or more or else fail.
3125: ** If there were a failure, the prepared statement would have halted
3126: ** before reaching this instruction. */
3127: if( NEVER(p2<2) ) {
3128: rc = SQLITE_CORRUPT_BKPT;
3129: goto abort_due_to_error;
3130: }
3131: }
3132: if( pOp->p4type==P4_KEYINFO ){
3133: pKeyInfo = pOp->p4.pKeyInfo;
3134: pKeyInfo->enc = ENC(p->db);
3135: nField = pKeyInfo->nField+1;
3136: }else if( pOp->p4type==P4_INT32 ){
3137: nField = pOp->p4.i;
3138: }
3139: assert( pOp->p1>=0 );
3140: pCur = allocateCursor(p, pOp->p1, nField, iDb, 1);
3141: if( pCur==0 ) goto no_mem;
3142: pCur->nullRow = 1;
3143: pCur->isOrdered = 1;
3144: rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->pCursor);
3145: pCur->pKeyInfo = pKeyInfo;
3146:
3147: /* Since it performs no memory allocation or IO, the only value that
3148: ** sqlite3BtreeCursor() may return is SQLITE_OK. */
3149: assert( rc==SQLITE_OK );
3150:
3151: /* Set the VdbeCursor.isTable and isIndex variables. Previous versions of
3152: ** SQLite used to check if the root-page flags were sane at this point
3153: ** and report database corruption if they were not, but this check has
3154: ** since moved into the btree layer. */
3155: pCur->isTable = pOp->p4type!=P4_KEYINFO;
3156: pCur->isIndex = !pCur->isTable;
3157: break;
3158: }
3159:
3160: /* Opcode: OpenEphemeral P1 P2 * P4 P5
3161: **
3162: ** Open a new cursor P1 to a transient table.
3163: ** The cursor is always opened read/write even if
3164: ** the main database is read-only. The ephemeral
3165: ** table is deleted automatically when the cursor is closed.
3166: **
3167: ** P2 is the number of columns in the ephemeral table.
3168: ** The cursor points to a BTree table if P4==0 and to a BTree index
3169: ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure
3170: ** that defines the format of keys in the index.
3171: **
3172: ** This opcode was once called OpenTemp. But that created
3173: ** confusion because the term "temp table", might refer either
3174: ** to a TEMP table at the SQL level, or to a table opened by
3175: ** this opcode. Then this opcode was call OpenVirtual. But
3176: ** that created confusion with the whole virtual-table idea.
3177: **
3178: ** The P5 parameter can be a mask of the BTREE_* flags defined
3179: ** in btree.h. These flags control aspects of the operation of
3180: ** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
3181: ** added automatically.
3182: */
3183: /* Opcode: OpenAutoindex P1 P2 * P4 *
3184: **
3185: ** This opcode works the same as OP_OpenEphemeral. It has a
3186: ** different name to distinguish its use. Tables created using
3187: ** by this opcode will be used for automatically created transient
3188: ** indices in joins.
3189: */
3190: case OP_OpenAutoindex:
3191: case OP_OpenEphemeral: {
3192: VdbeCursor *pCx;
3193: static const int vfsFlags =
3194: SQLITE_OPEN_READWRITE |
3195: SQLITE_OPEN_CREATE |
3196: SQLITE_OPEN_EXCLUSIVE |
3197: SQLITE_OPEN_DELETEONCLOSE |
3198: SQLITE_OPEN_TRANSIENT_DB;
3199:
3200: assert( pOp->p1>=0 );
3201: pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
3202: if( pCx==0 ) goto no_mem;
3203: pCx->nullRow = 1;
3204: rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBt,
3205: BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, vfsFlags);
3206: if( rc==SQLITE_OK ){
3207: rc = sqlite3BtreeBeginTrans(pCx->pBt, 1);
3208: }
3209: if( rc==SQLITE_OK ){
3210: /* If a transient index is required, create it by calling
3211: ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
3212: ** opening it. If a transient table is required, just use the
3213: ** automatically created table with root-page 1 (an BLOB_INTKEY table).
3214: */
3215: if( pOp->p4.pKeyInfo ){
3216: int pgno;
3217: assert( pOp->p4type==P4_KEYINFO );
3218: rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_BLOBKEY | pOp->p5);
3219: if( rc==SQLITE_OK ){
3220: assert( pgno==MASTER_ROOT+1 );
3221: rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1,
3222: (KeyInfo*)pOp->p4.z, pCx->pCursor);
3223: pCx->pKeyInfo = pOp->p4.pKeyInfo;
3224: pCx->pKeyInfo->enc = ENC(p->db);
3225: }
3226: pCx->isTable = 0;
3227: }else{
3228: rc = sqlite3BtreeCursor(pCx->pBt, MASTER_ROOT, 1, 0, pCx->pCursor);
3229: pCx->isTable = 1;
3230: }
3231: }
3232: pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
3233: pCx->isIndex = !pCx->isTable;
3234: break;
3235: }
3236:
3237: /* Opcode: OpenSorter P1 P2 * P4 *
3238: **
3239: ** This opcode works like OP_OpenEphemeral except that it opens
3240: ** a transient index that is specifically designed to sort large
3241: ** tables using an external merge-sort algorithm.
3242: */
3243: case OP_SorterOpen: {
3244: VdbeCursor *pCx;
3245: #ifndef SQLITE_OMIT_MERGE_SORT
3246: pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, 1);
3247: if( pCx==0 ) goto no_mem;
3248: pCx->pKeyInfo = pOp->p4.pKeyInfo;
3249: pCx->pKeyInfo->enc = ENC(p->db);
3250: pCx->isSorter = 1;
3251: rc = sqlite3VdbeSorterInit(db, pCx);
3252: #else
3253: pOp->opcode = OP_OpenEphemeral;
3254: pc--;
3255: #endif
3256: break;
3257: }
3258:
3259: /* Opcode: OpenPseudo P1 P2 P3 * *
3260: **
3261: ** Open a new cursor that points to a fake table that contains a single
3262: ** row of data. The content of that one row in the content of memory
3263: ** register P2. In other words, cursor P1 becomes an alias for the
3264: ** MEM_Blob content contained in register P2.
3265: **
3266: ** A pseudo-table created by this opcode is used to hold a single
3267: ** row output from the sorter so that the row can be decomposed into
3268: ** individual columns using the OP_Column opcode. The OP_Column opcode
3269: ** is the only cursor opcode that works with a pseudo-table.
3270: **
3271: ** P3 is the number of fields in the records that will be stored by
3272: ** the pseudo-table.
3273: */
3274: case OP_OpenPseudo: {
3275: VdbeCursor *pCx;
3276:
3277: assert( pOp->p1>=0 );
3278: pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, 0);
3279: if( pCx==0 ) goto no_mem;
3280: pCx->nullRow = 1;
3281: pCx->pseudoTableReg = pOp->p2;
3282: pCx->isTable = 1;
3283: pCx->isIndex = 0;
3284: break;
3285: }
3286:
3287: /* Opcode: Close P1 * * * *
3288: **
3289: ** Close a cursor previously opened as P1. If P1 is not
3290: ** currently open, this instruction is a no-op.
3291: */
3292: case OP_Close: {
3293: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3294: sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
3295: p->apCsr[pOp->p1] = 0;
3296: break;
3297: }
3298:
3299: /* Opcode: SeekGe P1 P2 P3 P4 *
3300: **
3301: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3302: ** use the value in register P3 as the key. If cursor P1 refers
3303: ** to an SQL index, then P3 is the first in an array of P4 registers
3304: ** that are used as an unpacked index key.
3305: **
3306: ** Reposition cursor P1 so that it points to the smallest entry that
3307: ** is greater than or equal to the key value. If there are no records
3308: ** greater than or equal to the key and P2 is not zero, then jump to P2.
3309: **
3310: ** See also: Found, NotFound, Distinct, SeekLt, SeekGt, SeekLe
3311: */
3312: /* Opcode: SeekGt P1 P2 P3 P4 *
3313: **
3314: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3315: ** use the value in register P3 as a key. If cursor P1 refers
3316: ** to an SQL index, then P3 is the first in an array of P4 registers
3317: ** that are used as an unpacked index key.
3318: **
3319: ** Reposition cursor P1 so that it points to the smallest entry that
3320: ** is greater than the key value. If there are no records greater than
3321: ** the key and P2 is not zero, then jump to P2.
3322: **
3323: ** See also: Found, NotFound, Distinct, SeekLt, SeekGe, SeekLe
3324: */
3325: /* Opcode: SeekLt P1 P2 P3 P4 *
3326: **
3327: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3328: ** use the value in register P3 as a key. If cursor P1 refers
3329: ** to an SQL index, then P3 is the first in an array of P4 registers
3330: ** that are used as an unpacked index key.
3331: **
3332: ** Reposition cursor P1 so that it points to the largest entry that
3333: ** is less than the key value. If there are no records less than
3334: ** the key and P2 is not zero, then jump to P2.
3335: **
3336: ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLe
3337: */
3338: /* Opcode: SeekLe P1 P2 P3 P4 *
3339: **
3340: ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys),
3341: ** use the value in register P3 as a key. If cursor P1 refers
3342: ** to an SQL index, then P3 is the first in an array of P4 registers
3343: ** that are used as an unpacked index key.
3344: **
3345: ** Reposition cursor P1 so that it points to the largest entry that
3346: ** is less than or equal to the key value. If there are no records
3347: ** less than or equal to the key and P2 is not zero, then jump to P2.
3348: **
3349: ** See also: Found, NotFound, Distinct, SeekGt, SeekGe, SeekLt
3350: */
3351: case OP_SeekLt: /* jump, in3 */
3352: case OP_SeekLe: /* jump, in3 */
3353: case OP_SeekGe: /* jump, in3 */
3354: case OP_SeekGt: { /* jump, in3 */
3355: int res;
3356: int oc;
3357: VdbeCursor *pC;
3358: UnpackedRecord r;
3359: int nField;
3360: i64 iKey; /* The rowid we are to seek to */
3361:
3362: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3363: assert( pOp->p2!=0 );
3364: pC = p->apCsr[pOp->p1];
3365: assert( pC!=0 );
3366: assert( pC->pseudoTableReg==0 );
3367: assert( OP_SeekLe == OP_SeekLt+1 );
3368: assert( OP_SeekGe == OP_SeekLt+2 );
3369: assert( OP_SeekGt == OP_SeekLt+3 );
3370: assert( pC->isOrdered );
3371: if( ALWAYS(pC->pCursor!=0) ){
3372: oc = pOp->opcode;
3373: pC->nullRow = 0;
3374: if( pC->isTable ){
3375: /* The input value in P3 might be of any type: integer, real, string,
3376: ** blob, or NULL. But it needs to be an integer before we can do
3377: ** the seek, so covert it. */
3378: pIn3 = &aMem[pOp->p3];
3379: applyNumericAffinity(pIn3);
3380: iKey = sqlite3VdbeIntValue(pIn3);
3381: pC->rowidIsValid = 0;
3382:
3383: /* If the P3 value could not be converted into an integer without
3384: ** loss of information, then special processing is required... */
3385: if( (pIn3->flags & MEM_Int)==0 ){
3386: if( (pIn3->flags & MEM_Real)==0 ){
3387: /* If the P3 value cannot be converted into any kind of a number,
3388: ** then the seek is not possible, so jump to P2 */
3389: pc = pOp->p2 - 1;
3390: break;
3391: }
3392: /* If we reach this point, then the P3 value must be a floating
3393: ** point number. */
3394: assert( (pIn3->flags & MEM_Real)!=0 );
3395:
3396: if( iKey==SMALLEST_INT64 && (pIn3->r<(double)iKey || pIn3->r>0) ){
3397: /* The P3 value is too large in magnitude to be expressed as an
3398: ** integer. */
3399: res = 1;
3400: if( pIn3->r<0 ){
3401: if( oc>=OP_SeekGe ){ assert( oc==OP_SeekGe || oc==OP_SeekGt );
3402: rc = sqlite3BtreeFirst(pC->pCursor, &res);
3403: if( rc!=SQLITE_OK ) goto abort_due_to_error;
3404: }
3405: }else{
3406: if( oc<=OP_SeekLe ){ assert( oc==OP_SeekLt || oc==OP_SeekLe );
3407: rc = sqlite3BtreeLast(pC->pCursor, &res);
3408: if( rc!=SQLITE_OK ) goto abort_due_to_error;
3409: }
3410: }
3411: if( res ){
3412: pc = pOp->p2 - 1;
3413: }
3414: break;
3415: }else if( oc==OP_SeekLt || oc==OP_SeekGe ){
3416: /* Use the ceiling() function to convert real->int */
3417: if( pIn3->r > (double)iKey ) iKey++;
3418: }else{
3419: /* Use the floor() function to convert real->int */
3420: assert( oc==OP_SeekLe || oc==OP_SeekGt );
3421: if( pIn3->r < (double)iKey ) iKey--;
3422: }
3423: }
3424: rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)iKey, 0, &res);
3425: if( rc!=SQLITE_OK ){
3426: goto abort_due_to_error;
3427: }
3428: if( res==0 ){
3429: pC->rowidIsValid = 1;
3430: pC->lastRowid = iKey;
3431: }
3432: }else{
3433: nField = pOp->p4.i;
3434: assert( pOp->p4type==P4_INT32 );
3435: assert( nField>0 );
3436: r.pKeyInfo = pC->pKeyInfo;
3437: r.nField = (u16)nField;
3438:
3439: /* The next line of code computes as follows, only faster:
3440: ** if( oc==OP_SeekGt || oc==OP_SeekLe ){
3441: ** r.flags = UNPACKED_INCRKEY;
3442: ** }else{
3443: ** r.flags = 0;
3444: ** }
3445: */
3446: r.flags = (u16)(UNPACKED_INCRKEY * (1 & (oc - OP_SeekLt)));
3447: assert( oc!=OP_SeekGt || r.flags==UNPACKED_INCRKEY );
3448: assert( oc!=OP_SeekLe || r.flags==UNPACKED_INCRKEY );
3449: assert( oc!=OP_SeekGe || r.flags==0 );
3450: assert( oc!=OP_SeekLt || r.flags==0 );
3451:
3452: r.aMem = &aMem[pOp->p3];
3453: #ifdef SQLITE_DEBUG
3454: { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
3455: #endif
3456: ExpandBlob(r.aMem);
3457: rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, &r, 0, 0, &res);
3458: if( rc!=SQLITE_OK ){
3459: goto abort_due_to_error;
3460: }
3461: pC->rowidIsValid = 0;
3462: }
3463: pC->deferredMoveto = 0;
3464: pC->cacheStatus = CACHE_STALE;
3465: #ifdef SQLITE_TEST
3466: sqlite3_search_count++;
3467: #endif
3468: if( oc>=OP_SeekGe ){ assert( oc==OP_SeekGe || oc==OP_SeekGt );
3469: if( res<0 || (res==0 && oc==OP_SeekGt) ){
3470: rc = sqlite3BtreeNext(pC->pCursor, &res);
3471: if( rc!=SQLITE_OK ) goto abort_due_to_error;
3472: pC->rowidIsValid = 0;
3473: }else{
3474: res = 0;
3475: }
3476: }else{
3477: assert( oc==OP_SeekLt || oc==OP_SeekLe );
3478: if( res>0 || (res==0 && oc==OP_SeekLt) ){
3479: rc = sqlite3BtreePrevious(pC->pCursor, &res);
3480: if( rc!=SQLITE_OK ) goto abort_due_to_error;
3481: pC->rowidIsValid = 0;
3482: }else{
3483: /* res might be negative because the table is empty. Check to
3484: ** see if this is the case.
3485: */
3486: res = sqlite3BtreeEof(pC->pCursor);
3487: }
3488: }
3489: assert( pOp->p2>0 );
3490: if( res ){
3491: pc = pOp->p2 - 1;
3492: }
3493: }else{
3494: /* This happens when attempting to open the sqlite3_master table
3495: ** for read access returns SQLITE_EMPTY. In this case always
3496: ** take the jump (since there are no records in the table).
3497: */
3498: pc = pOp->p2 - 1;
3499: }
3500: break;
3501: }
3502:
3503: /* Opcode: Seek P1 P2 * * *
3504: **
3505: ** P1 is an open table cursor and P2 is a rowid integer. Arrange
3506: ** for P1 to move so that it points to the rowid given by P2.
3507: **
3508: ** This is actually a deferred seek. Nothing actually happens until
3509: ** the cursor is used to read a record. That way, if no reads
3510: ** occur, no unnecessary I/O happens.
3511: */
3512: case OP_Seek: { /* in2 */
3513: VdbeCursor *pC;
3514:
3515: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3516: pC = p->apCsr[pOp->p1];
3517: assert( pC!=0 );
3518: if( ALWAYS(pC->pCursor!=0) ){
3519: assert( pC->isTable );
3520: pC->nullRow = 0;
3521: pIn2 = &aMem[pOp->p2];
3522: pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
3523: pC->rowidIsValid = 0;
3524: pC->deferredMoveto = 1;
3525: }
3526: break;
3527: }
3528:
3529:
3530: /* Opcode: Found P1 P2 P3 P4 *
3531: **
3532: ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
3533: ** P4>0 then register P3 is the first of P4 registers that form an unpacked
3534: ** record.
3535: **
3536: ** Cursor P1 is on an index btree. If the record identified by P3 and P4
3537: ** is a prefix of any entry in P1 then a jump is made to P2 and
3538: ** P1 is left pointing at the matching entry.
3539: */
3540: /* Opcode: NotFound P1 P2 P3 P4 *
3541: **
3542: ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If
3543: ** P4>0 then register P3 is the first of P4 registers that form an unpacked
3544: ** record.
3545: **
3546: ** Cursor P1 is on an index btree. If the record identified by P3 and P4
3547: ** is not the prefix of any entry in P1 then a jump is made to P2. If P1
3548: ** does contain an entry whose prefix matches the P3/P4 record then control
3549: ** falls through to the next instruction and P1 is left pointing at the
3550: ** matching entry.
3551: **
3552: ** See also: Found, NotExists, IsUnique
3553: */
3554: case OP_NotFound: /* jump, in3 */
3555: case OP_Found: { /* jump, in3 */
3556: int alreadyExists;
3557: VdbeCursor *pC;
3558: int res;
3559: char *pFree;
3560: UnpackedRecord *pIdxKey;
3561: UnpackedRecord r;
3562: char aTempRec[ROUND8(sizeof(UnpackedRecord)) + sizeof(Mem)*3 + 7];
3563:
3564: #ifdef SQLITE_TEST
3565: sqlite3_found_count++;
3566: #endif
3567:
3568: alreadyExists = 0;
3569: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3570: assert( pOp->p4type==P4_INT32 );
3571: pC = p->apCsr[pOp->p1];
3572: assert( pC!=0 );
3573: pIn3 = &aMem[pOp->p3];
3574: if( ALWAYS(pC->pCursor!=0) ){
3575:
3576: assert( pC->isTable==0 );
3577: if( pOp->p4.i>0 ){
3578: r.pKeyInfo = pC->pKeyInfo;
3579: r.nField = (u16)pOp->p4.i;
3580: r.aMem = pIn3;
3581: #ifdef SQLITE_DEBUG
3582: { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
3583: #endif
3584: r.flags = UNPACKED_PREFIX_MATCH;
3585: pIdxKey = &r;
3586: }else{
3587: pIdxKey = sqlite3VdbeAllocUnpackedRecord(
3588: pC->pKeyInfo, aTempRec, sizeof(aTempRec), &pFree
3589: );
3590: if( pIdxKey==0 ) goto no_mem;
3591: assert( pIn3->flags & MEM_Blob );
3592: assert( (pIn3->flags & MEM_Zero)==0 ); /* zeroblobs already expanded */
3593: sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
3594: pIdxKey->flags |= UNPACKED_PREFIX_MATCH;
3595: }
3596: rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, pIdxKey, 0, 0, &res);
3597: if( pOp->p4.i==0 ){
3598: sqlite3DbFree(db, pFree);
3599: }
3600: if( rc!=SQLITE_OK ){
3601: break;
3602: }
3603: alreadyExists = (res==0);
3604: pC->deferredMoveto = 0;
3605: pC->cacheStatus = CACHE_STALE;
3606: }
3607: if( pOp->opcode==OP_Found ){
3608: if( alreadyExists ) pc = pOp->p2 - 1;
3609: }else{
3610: if( !alreadyExists ) pc = pOp->p2 - 1;
3611: }
3612: break;
3613: }
3614:
3615: /* Opcode: IsUnique P1 P2 P3 P4 *
3616: **
3617: ** Cursor P1 is open on an index b-tree - that is to say, a btree which
3618: ** no data and where the key are records generated by OP_MakeRecord with
3619: ** the list field being the integer ROWID of the entry that the index
3620: ** entry refers to.
3621: **
3622: ** The P3 register contains an integer record number. Call this record
3623: ** number R. Register P4 is the first in a set of N contiguous registers
3624: ** that make up an unpacked index key that can be used with cursor P1.
3625: ** The value of N can be inferred from the cursor. N includes the rowid
3626: ** value appended to the end of the index record. This rowid value may
3627: ** or may not be the same as R.
3628: **
3629: ** If any of the N registers beginning with register P4 contains a NULL
3630: ** value, jump immediately to P2.
3631: **
3632: ** Otherwise, this instruction checks if cursor P1 contains an entry
3633: ** where the first (N-1) fields match but the rowid value at the end
3634: ** of the index entry is not R. If there is no such entry, control jumps
3635: ** to instruction P2. Otherwise, the rowid of the conflicting index
3636: ** entry is copied to register P3 and control falls through to the next
3637: ** instruction.
3638: **
3639: ** See also: NotFound, NotExists, Found
3640: */
3641: case OP_IsUnique: { /* jump, in3 */
3642: u16 ii;
3643: VdbeCursor *pCx;
3644: BtCursor *pCrsr;
3645: u16 nField;
3646: Mem *aMx;
3647: UnpackedRecord r; /* B-Tree index search key */
3648: i64 R; /* Rowid stored in register P3 */
3649:
3650: pIn3 = &aMem[pOp->p3];
3651: aMx = &aMem[pOp->p4.i];
3652: /* Assert that the values of parameters P1 and P4 are in range. */
3653: assert( pOp->p4type==P4_INT32 );
3654: assert( pOp->p4.i>0 && pOp->p4.i<=p->nMem );
3655: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3656:
3657: /* Find the index cursor. */
3658: pCx = p->apCsr[pOp->p1];
3659: assert( pCx->deferredMoveto==0 );
3660: pCx->seekResult = 0;
3661: pCx->cacheStatus = CACHE_STALE;
3662: pCrsr = pCx->pCursor;
3663:
3664: /* If any of the values are NULL, take the jump. */
3665: nField = pCx->pKeyInfo->nField;
3666: for(ii=0; ii<nField; ii++){
3667: if( aMx[ii].flags & MEM_Null ){
3668: pc = pOp->p2 - 1;
3669: pCrsr = 0;
3670: break;
3671: }
3672: }
3673: assert( (aMx[nField].flags & MEM_Null)==0 );
3674:
3675: if( pCrsr!=0 ){
3676: /* Populate the index search key. */
3677: r.pKeyInfo = pCx->pKeyInfo;
3678: r.nField = nField + 1;
3679: r.flags = UNPACKED_PREFIX_SEARCH;
3680: r.aMem = aMx;
3681: #ifdef SQLITE_DEBUG
3682: { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
3683: #endif
3684:
3685: /* Extract the value of R from register P3. */
3686: sqlite3VdbeMemIntegerify(pIn3);
3687: R = pIn3->u.i;
3688:
3689: /* Search the B-Tree index. If no conflicting record is found, jump
3690: ** to P2. Otherwise, copy the rowid of the conflicting record to
3691: ** register P3 and fall through to the next instruction. */
3692: rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &pCx->seekResult);
3693: if( (r.flags & UNPACKED_PREFIX_SEARCH) || r.rowid==R ){
3694: pc = pOp->p2 - 1;
3695: }else{
3696: pIn3->u.i = r.rowid;
3697: }
3698: }
3699: break;
3700: }
3701:
3702: /* Opcode: NotExists P1 P2 P3 * *
3703: **
3704: ** Use the content of register P3 as an integer key. If a record
3705: ** with that key does not exist in table of P1, then jump to P2.
3706: ** If the record does exist, then fall through. The cursor is left
3707: ** pointing to the record if it exists.
3708: **
3709: ** The difference between this operation and NotFound is that this
3710: ** operation assumes the key is an integer and that P1 is a table whereas
3711: ** NotFound assumes key is a blob constructed from MakeRecord and
3712: ** P1 is an index.
3713: **
3714: ** See also: Found, NotFound, IsUnique
3715: */
3716: case OP_NotExists: { /* jump, in3 */
3717: VdbeCursor *pC;
3718: BtCursor *pCrsr;
3719: int res;
3720: u64 iKey;
3721:
3722: pIn3 = &aMem[pOp->p3];
3723: assert( pIn3->flags & MEM_Int );
3724: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3725: pC = p->apCsr[pOp->p1];
3726: assert( pC!=0 );
3727: assert( pC->isTable );
3728: assert( pC->pseudoTableReg==0 );
3729: pCrsr = pC->pCursor;
3730: if( ALWAYS(pCrsr!=0) ){
3731: res = 0;
3732: iKey = pIn3->u.i;
3733: rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res);
3734: pC->lastRowid = pIn3->u.i;
3735: pC->rowidIsValid = res==0 ?1:0;
3736: pC->nullRow = 0;
3737: pC->cacheStatus = CACHE_STALE;
3738: pC->deferredMoveto = 0;
3739: if( res!=0 ){
3740: pc = pOp->p2 - 1;
3741: assert( pC->rowidIsValid==0 );
3742: }
3743: pC->seekResult = res;
3744: }else{
3745: /* This happens when an attempt to open a read cursor on the
3746: ** sqlite_master table returns SQLITE_EMPTY.
3747: */
3748: pc = pOp->p2 - 1;
3749: assert( pC->rowidIsValid==0 );
3750: pC->seekResult = 0;
3751: }
3752: break;
3753: }
3754:
3755: /* Opcode: Sequence P1 P2 * * *
3756: **
3757: ** Find the next available sequence number for cursor P1.
3758: ** Write the sequence number into register P2.
3759: ** The sequence number on the cursor is incremented after this
3760: ** instruction.
3761: */
3762: case OP_Sequence: { /* out2-prerelease */
3763: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3764: assert( p->apCsr[pOp->p1]!=0 );
3765: pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
3766: break;
3767: }
3768:
3769:
3770: /* Opcode: NewRowid P1 P2 P3 * *
3771: **
3772: ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
3773: ** The record number is not previously used as a key in the database
3774: ** table that cursor P1 points to. The new record number is written
3775: ** written to register P2.
3776: **
3777: ** If P3>0 then P3 is a register in the root frame of this VDBE that holds
3778: ** the largest previously generated record number. No new record numbers are
3779: ** allowed to be less than this value. When this value reaches its maximum,
3780: ** an SQLITE_FULL error is generated. The P3 register is updated with the '
3781: ** generated record number. This P3 mechanism is used to help implement the
3782: ** AUTOINCREMENT feature.
3783: */
3784: case OP_NewRowid: { /* out2-prerelease */
3785: i64 v; /* The new rowid */
3786: VdbeCursor *pC; /* Cursor of table to get the new rowid */
3787: int res; /* Result of an sqlite3BtreeLast() */
3788: int cnt; /* Counter to limit the number of searches */
3789: Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */
3790: VdbeFrame *pFrame; /* Root frame of VDBE */
3791:
3792: v = 0;
3793: res = 0;
3794: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3795: pC = p->apCsr[pOp->p1];
3796: assert( pC!=0 );
3797: if( NEVER(pC->pCursor==0) ){
3798: /* The zero initialization above is all that is needed */
3799: }else{
3800: /* The next rowid or record number (different terms for the same
3801: ** thing) is obtained in a two-step algorithm.
3802: **
3803: ** First we attempt to find the largest existing rowid and add one
3804: ** to that. But if the largest existing rowid is already the maximum
3805: ** positive integer, we have to fall through to the second
3806: ** probabilistic algorithm
3807: **
3808: ** The second algorithm is to select a rowid at random and see if
3809: ** it already exists in the table. If it does not exist, we have
3810: ** succeeded. If the random rowid does exist, we select a new one
3811: ** and try again, up to 100 times.
3812: */
3813: assert( pC->isTable );
3814:
3815: #ifdef SQLITE_32BIT_ROWID
3816: # define MAX_ROWID 0x7fffffff
3817: #else
3818: /* Some compilers complain about constants of the form 0x7fffffffffffffff.
3819: ** Others complain about 0x7ffffffffffffffffLL. The following macro seems
3820: ** to provide the constant while making all compilers happy.
3821: */
3822: # define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
3823: #endif
3824:
3825: if( !pC->useRandomRowid ){
3826: v = sqlite3BtreeGetCachedRowid(pC->pCursor);
3827: if( v==0 ){
3828: rc = sqlite3BtreeLast(pC->pCursor, &res);
3829: if( rc!=SQLITE_OK ){
3830: goto abort_due_to_error;
3831: }
3832: if( res ){
3833: v = 1; /* IMP: R-61914-48074 */
3834: }else{
3835: assert( sqlite3BtreeCursorIsValid(pC->pCursor) );
3836: rc = sqlite3BtreeKeySize(pC->pCursor, &v);
3837: assert( rc==SQLITE_OK ); /* Cannot fail following BtreeLast() */
3838: if( v==MAX_ROWID ){
3839: pC->useRandomRowid = 1;
3840: }else{
3841: v++; /* IMP: R-29538-34987 */
3842: }
3843: }
3844: }
3845:
3846: #ifndef SQLITE_OMIT_AUTOINCREMENT
3847: if( pOp->p3 ){
3848: /* Assert that P3 is a valid memory cell. */
3849: assert( pOp->p3>0 );
3850: if( p->pFrame ){
3851: for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
3852: /* Assert that P3 is a valid memory cell. */
3853: assert( pOp->p3<=pFrame->nMem );
3854: pMem = &pFrame->aMem[pOp->p3];
3855: }else{
3856: /* Assert that P3 is a valid memory cell. */
3857: assert( pOp->p3<=p->nMem );
3858: pMem = &aMem[pOp->p3];
3859: memAboutToChange(p, pMem);
3860: }
3861: assert( memIsValid(pMem) );
3862:
3863: REGISTER_TRACE(pOp->p3, pMem);
3864: sqlite3VdbeMemIntegerify(pMem);
3865: assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */
3866: if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
3867: rc = SQLITE_FULL; /* IMP: R-12275-61338 */
3868: goto abort_due_to_error;
3869: }
3870: if( v<pMem->u.i+1 ){
3871: v = pMem->u.i + 1;
3872: }
3873: pMem->u.i = v;
3874: }
3875: #endif
3876:
3877: sqlite3BtreeSetCachedRowid(pC->pCursor, v<MAX_ROWID ? v+1 : 0);
3878: }
3879: if( pC->useRandomRowid ){
3880: /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
3881: ** largest possible integer (9223372036854775807) then the database
3882: ** engine starts picking positive candidate ROWIDs at random until
3883: ** it finds one that is not previously used. */
3884: assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is
3885: ** an AUTOINCREMENT table. */
3886: /* on the first attempt, simply do one more than previous */
3887: v = lastRowid;
3888: v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
3889: v++; /* ensure non-zero */
3890: cnt = 0;
3891: while( ((rc = sqlite3BtreeMovetoUnpacked(pC->pCursor, 0, (u64)v,
3892: 0, &res))==SQLITE_OK)
3893: && (res==0)
3894: && (++cnt<100)){
3895: /* collision - try another random rowid */
3896: sqlite3_randomness(sizeof(v), &v);
3897: if( cnt<5 ){
3898: /* try "small" random rowids for the initial attempts */
3899: v &= 0xffffff;
3900: }else{
3901: v &= (MAX_ROWID>>1); /* ensure doesn't go negative */
3902: }
3903: v++; /* ensure non-zero */
3904: }
3905: if( rc==SQLITE_OK && res==0 ){
3906: rc = SQLITE_FULL; /* IMP: R-38219-53002 */
3907: goto abort_due_to_error;
3908: }
3909: assert( v>0 ); /* EV: R-40812-03570 */
3910: }
3911: pC->rowidIsValid = 0;
3912: pC->deferredMoveto = 0;
3913: pC->cacheStatus = CACHE_STALE;
3914: }
3915: pOut->u.i = v;
3916: break;
3917: }
3918:
3919: /* Opcode: Insert P1 P2 P3 P4 P5
3920: **
3921: ** Write an entry into the table of cursor P1. A new entry is
3922: ** created if it doesn't already exist or the data for an existing
3923: ** entry is overwritten. The data is the value MEM_Blob stored in register
3924: ** number P2. The key is stored in register P3. The key must
3925: ** be a MEM_Int.
3926: **
3927: ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
3928: ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set,
3929: ** then rowid is stored for subsequent return by the
3930: ** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
3931: **
3932: ** If the OPFLAG_USESEEKRESULT flag of P5 is set and if the result of
3933: ** the last seek operation (OP_NotExists) was a success, then this
3934: ** operation will not attempt to find the appropriate row before doing
3935: ** the insert but will instead overwrite the row that the cursor is
3936: ** currently pointing to. Presumably, the prior OP_NotExists opcode
3937: ** has already positioned the cursor correctly. This is an optimization
3938: ** that boosts performance by avoiding redundant seeks.
3939: **
3940: ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
3941: ** UPDATE operation. Otherwise (if the flag is clear) then this opcode
3942: ** is part of an INSERT operation. The difference is only important to
3943: ** the update hook.
3944: **
3945: ** Parameter P4 may point to a string containing the table-name, or
3946: ** may be NULL. If it is not NULL, then the update-hook
3947: ** (sqlite3.xUpdateCallback) is invoked following a successful insert.
3948: **
3949: ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
3950: ** allocated, then ownership of P2 is transferred to the pseudo-cursor
3951: ** and register P2 becomes ephemeral. If the cursor is changed, the
3952: ** value of register P2 will then change. Make sure this does not
3953: ** cause any problems.)
3954: **
3955: ** This instruction only works on tables. The equivalent instruction
3956: ** for indices is OP_IdxInsert.
3957: */
3958: /* Opcode: InsertInt P1 P2 P3 P4 P5
3959: **
3960: ** This works exactly like OP_Insert except that the key is the
3961: ** integer value P3, not the value of the integer stored in register P3.
3962: */
3963: case OP_Insert:
3964: case OP_InsertInt: {
3965: Mem *pData; /* MEM cell holding data for the record to be inserted */
3966: Mem *pKey; /* MEM cell holding key for the record */
3967: i64 iKey; /* The integer ROWID or key for the record to be inserted */
3968: VdbeCursor *pC; /* Cursor to table into which insert is written */
3969: int nZero; /* Number of zero-bytes to append */
3970: int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */
3971: const char *zDb; /* database name - used by the update hook */
3972: const char *zTbl; /* Table name - used by the opdate hook */
3973: int op; /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
3974:
3975: pData = &aMem[pOp->p2];
3976: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
3977: assert( memIsValid(pData) );
3978: pC = p->apCsr[pOp->p1];
3979: assert( pC!=0 );
3980: assert( pC->pCursor!=0 );
3981: assert( pC->pseudoTableReg==0 );
3982: assert( pC->isTable );
3983: REGISTER_TRACE(pOp->p2, pData);
3984:
3985: if( pOp->opcode==OP_Insert ){
3986: pKey = &aMem[pOp->p3];
3987: assert( pKey->flags & MEM_Int );
3988: assert( memIsValid(pKey) );
3989: REGISTER_TRACE(pOp->p3, pKey);
3990: iKey = pKey->u.i;
3991: }else{
3992: assert( pOp->opcode==OP_InsertInt );
3993: iKey = pOp->p3;
3994: }
3995:
3996: if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
3997: if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = lastRowid = iKey;
3998: if( pData->flags & MEM_Null ){
3999: pData->z = 0;
4000: pData->n = 0;
4001: }else{
4002: assert( pData->flags & (MEM_Blob|MEM_Str) );
4003: }
4004: seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
4005: if( pData->flags & MEM_Zero ){
4006: nZero = pData->u.nZero;
4007: }else{
4008: nZero = 0;
4009: }
4010: sqlite3BtreeSetCachedRowid(pC->pCursor, 0);
4011: rc = sqlite3BtreeInsert(pC->pCursor, 0, iKey,
4012: pData->z, pData->n, nZero,
4013: pOp->p5 & OPFLAG_APPEND, seekResult
4014: );
4015: pC->rowidIsValid = 0;
4016: pC->deferredMoveto = 0;
4017: pC->cacheStatus = CACHE_STALE;
4018:
4019: /* Invoke the update-hook if required. */
4020: if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
4021: zDb = db->aDb[pC->iDb].zName;
4022: zTbl = pOp->p4.z;
4023: op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
4024: assert( pC->isTable );
4025: db->xUpdateCallback(db->pUpdateArg, op, zDb, zTbl, iKey);
4026: assert( pC->iDb>=0 );
4027: }
4028: break;
4029: }
4030:
4031: /* Opcode: Delete P1 P2 * P4 *
4032: **
4033: ** Delete the record at which the P1 cursor is currently pointing.
4034: **
4035: ** The cursor will be left pointing at either the next or the previous
4036: ** record in the table. If it is left pointing at the next record, then
4037: ** the next Next instruction will be a no-op. Hence it is OK to delete
4038: ** a record from within an Next loop.
4039: **
4040: ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
4041: ** incremented (otherwise not).
4042: **
4043: ** P1 must not be pseudo-table. It has to be a real table with
4044: ** multiple rows.
4045: **
4046: ** If P4 is not NULL, then it is the name of the table that P1 is
4047: ** pointing to. The update hook will be invoked, if it exists.
4048: ** If P4 is not NULL then the P1 cursor must have been positioned
4049: ** using OP_NotFound prior to invoking this opcode.
4050: */
4051: case OP_Delete: {
4052: i64 iKey;
4053: VdbeCursor *pC;
4054:
4055: iKey = 0;
4056: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4057: pC = p->apCsr[pOp->p1];
4058: assert( pC!=0 );
4059: assert( pC->pCursor!=0 ); /* Only valid for real tables, no pseudotables */
4060:
4061: /* If the update-hook will be invoked, set iKey to the rowid of the
4062: ** row being deleted.
4063: */
4064: if( db->xUpdateCallback && pOp->p4.z ){
4065: assert( pC->isTable );
4066: assert( pC->rowidIsValid ); /* lastRowid set by previous OP_NotFound */
4067: iKey = pC->lastRowid;
4068: }
4069:
4070: /* The OP_Delete opcode always follows an OP_NotExists or OP_Last or
4071: ** OP_Column on the same table without any intervening operations that
4072: ** might move or invalidate the cursor. Hence cursor pC is always pointing
4073: ** to the row to be deleted and the sqlite3VdbeCursorMoveto() operation
4074: ** below is always a no-op and cannot fail. We will run it anyhow, though,
4075: ** to guard against future changes to the code generator.
4076: **/
4077: assert( pC->deferredMoveto==0 );
4078: rc = sqlite3VdbeCursorMoveto(pC);
4079: if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
4080:
4081: sqlite3BtreeSetCachedRowid(pC->pCursor, 0);
4082: rc = sqlite3BtreeDelete(pC->pCursor);
4083: pC->cacheStatus = CACHE_STALE;
4084:
4085: /* Invoke the update-hook if required. */
4086: if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
4087: const char *zDb = db->aDb[pC->iDb].zName;
4088: const char *zTbl = pOp->p4.z;
4089: db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, zTbl, iKey);
4090: assert( pC->iDb>=0 );
4091: }
4092: if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
4093: break;
4094: }
4095: /* Opcode: ResetCount * * * * *
4096: **
4097: ** The value of the change counter is copied to the database handle
4098: ** change counter (returned by subsequent calls to sqlite3_changes()).
4099: ** Then the VMs internal change counter resets to 0.
4100: ** This is used by trigger programs.
4101: */
4102: case OP_ResetCount: {
4103: sqlite3VdbeSetChanges(db, p->nChange);
4104: p->nChange = 0;
4105: break;
4106: }
4107:
4108: /* Opcode: SorterCompare P1 P2 P3
4109: **
4110: ** P1 is a sorter cursor. This instruction compares the record blob in
4111: ** register P3 with the entry that the sorter cursor currently points to.
4112: ** If, excluding the rowid fields at the end, the two records are a match,
4113: ** fall through to the next instruction. Otherwise, jump to instruction P2.
4114: */
4115: case OP_SorterCompare: {
4116: VdbeCursor *pC;
4117: int res;
4118:
4119: pC = p->apCsr[pOp->p1];
4120: assert( isSorter(pC) );
4121: pIn3 = &aMem[pOp->p3];
4122: rc = sqlite3VdbeSorterCompare(pC, pIn3, &res);
4123: if( res ){
4124: pc = pOp->p2-1;
4125: }
4126: break;
4127: };
4128:
4129: /* Opcode: SorterData P1 P2 * * *
4130: **
4131: ** Write into register P2 the current sorter data for sorter cursor P1.
4132: */
4133: case OP_SorterData: {
4134: VdbeCursor *pC;
4135: #ifndef SQLITE_OMIT_MERGE_SORT
4136: pOut = &aMem[pOp->p2];
4137: pC = p->apCsr[pOp->p1];
4138: assert( pC->isSorter );
4139: rc = sqlite3VdbeSorterRowkey(pC, pOut);
4140: #else
4141: pOp->opcode = OP_RowKey;
4142: pc--;
4143: #endif
4144: break;
4145: }
4146:
4147: /* Opcode: RowData P1 P2 * * *
4148: **
4149: ** Write into register P2 the complete row data for cursor P1.
4150: ** There is no interpretation of the data.
4151: ** It is just copied onto the P2 register exactly as
4152: ** it is found in the database file.
4153: **
4154: ** If the P1 cursor must be pointing to a valid row (not a NULL row)
4155: ** of a real table, not a pseudo-table.
4156: */
4157: /* Opcode: RowKey P1 P2 * * *
4158: **
4159: ** Write into register P2 the complete row key for cursor P1.
4160: ** There is no interpretation of the data.
4161: ** The key is copied onto the P3 register exactly as
4162: ** it is found in the database file.
4163: **
4164: ** If the P1 cursor must be pointing to a valid row (not a NULL row)
4165: ** of a real table, not a pseudo-table.
4166: */
4167: case OP_RowKey:
4168: case OP_RowData: {
4169: VdbeCursor *pC;
4170: BtCursor *pCrsr;
4171: u32 n;
4172: i64 n64;
4173:
4174: pOut = &aMem[pOp->p2];
4175: memAboutToChange(p, pOut);
4176:
4177: /* Note that RowKey and RowData are really exactly the same instruction */
4178: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4179: pC = p->apCsr[pOp->p1];
4180: assert( pC->isSorter==0 );
4181: assert( pC->isTable || pOp->opcode!=OP_RowData );
4182: assert( pC->isIndex || pOp->opcode==OP_RowData );
4183: assert( pC!=0 );
4184: assert( pC->nullRow==0 );
4185: assert( pC->pseudoTableReg==0 );
4186: assert( !pC->isSorter );
4187: assert( pC->pCursor!=0 );
4188: pCrsr = pC->pCursor;
4189: assert( sqlite3BtreeCursorIsValid(pCrsr) );
4190:
4191: /* The OP_RowKey and OP_RowData opcodes always follow OP_NotExists or
4192: ** OP_Rewind/Op_Next with no intervening instructions that might invalidate
4193: ** the cursor. Hence the following sqlite3VdbeCursorMoveto() call is always
4194: ** a no-op and can never fail. But we leave it in place as a safety.
4195: */
4196: assert( pC->deferredMoveto==0 );
4197: rc = sqlite3VdbeCursorMoveto(pC);
4198: if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
4199:
4200: if( pC->isIndex ){
4201: assert( !pC->isTable );
4202: VVA_ONLY(rc =) sqlite3BtreeKeySize(pCrsr, &n64);
4203: assert( rc==SQLITE_OK ); /* True because of CursorMoveto() call above */
4204: if( n64>db->aLimit[SQLITE_LIMIT_LENGTH] ){
4205: goto too_big;
4206: }
4207: n = (u32)n64;
4208: }else{
4209: VVA_ONLY(rc =) sqlite3BtreeDataSize(pCrsr, &n);
4210: assert( rc==SQLITE_OK ); /* DataSize() cannot fail */
4211: if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
4212: goto too_big;
4213: }
4214: }
4215: if( sqlite3VdbeMemGrow(pOut, n, 0) ){
4216: goto no_mem;
4217: }
4218: pOut->n = n;
4219: MemSetTypeFlag(pOut, MEM_Blob);
4220: if( pC->isIndex ){
4221: rc = sqlite3BtreeKey(pCrsr, 0, n, pOut->z);
4222: }else{
4223: rc = sqlite3BtreeData(pCrsr, 0, n, pOut->z);
4224: }
4225: pOut->enc = SQLITE_UTF8; /* In case the blob is ever cast to text */
4226: UPDATE_MAX_BLOBSIZE(pOut);
4227: break;
4228: }
4229:
4230: /* Opcode: Rowid P1 P2 * * *
4231: **
4232: ** Store in register P2 an integer which is the key of the table entry that
4233: ** P1 is currently point to.
4234: **
4235: ** P1 can be either an ordinary table or a virtual table. There used to
4236: ** be a separate OP_VRowid opcode for use with virtual tables, but this
4237: ** one opcode now works for both table types.
4238: */
4239: case OP_Rowid: { /* out2-prerelease */
4240: VdbeCursor *pC;
4241: i64 v;
4242: sqlite3_vtab *pVtab;
4243: const sqlite3_module *pModule;
4244:
4245: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4246: pC = p->apCsr[pOp->p1];
4247: assert( pC!=0 );
4248: assert( pC->pseudoTableReg==0 );
4249: if( pC->nullRow ){
4250: pOut->flags = MEM_Null;
4251: break;
4252: }else if( pC->deferredMoveto ){
4253: v = pC->movetoTarget;
4254: #ifndef SQLITE_OMIT_VIRTUALTABLE
4255: }else if( pC->pVtabCursor ){
4256: pVtab = pC->pVtabCursor->pVtab;
4257: pModule = pVtab->pModule;
4258: assert( pModule->xRowid );
4259: rc = pModule->xRowid(pC->pVtabCursor, &v);
4260: importVtabErrMsg(p, pVtab);
4261: #endif /* SQLITE_OMIT_VIRTUALTABLE */
4262: }else{
4263: assert( pC->pCursor!=0 );
4264: rc = sqlite3VdbeCursorMoveto(pC);
4265: if( rc ) goto abort_due_to_error;
4266: if( pC->rowidIsValid ){
4267: v = pC->lastRowid;
4268: }else{
4269: rc = sqlite3BtreeKeySize(pC->pCursor, &v);
4270: assert( rc==SQLITE_OK ); /* Always so because of CursorMoveto() above */
4271: }
4272: }
4273: pOut->u.i = v;
4274: break;
4275: }
4276:
4277: /* Opcode: NullRow P1 * * * *
4278: **
4279: ** Move the cursor P1 to a null row. Any OP_Column operations
4280: ** that occur while the cursor is on the null row will always
4281: ** write a NULL.
4282: */
4283: case OP_NullRow: {
4284: VdbeCursor *pC;
4285:
4286: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4287: pC = p->apCsr[pOp->p1];
4288: assert( pC!=0 );
4289: pC->nullRow = 1;
4290: pC->rowidIsValid = 0;
4291: assert( pC->pCursor || pC->pVtabCursor );
4292: if( pC->pCursor ){
4293: sqlite3BtreeClearCursor(pC->pCursor);
4294: }
4295: break;
4296: }
4297:
4298: /* Opcode: Last P1 P2 * * *
4299: **
4300: ** The next use of the Rowid or Column or Next instruction for P1
4301: ** will refer to the last entry in the database table or index.
4302: ** If the table or index is empty and P2>0, then jump immediately to P2.
4303: ** If P2 is 0 or if the table or index is not empty, fall through
4304: ** to the following instruction.
4305: */
4306: case OP_Last: { /* jump */
4307: VdbeCursor *pC;
4308: BtCursor *pCrsr;
4309: int res;
4310:
4311: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4312: pC = p->apCsr[pOp->p1];
4313: assert( pC!=0 );
4314: pCrsr = pC->pCursor;
4315: res = 0;
4316: if( ALWAYS(pCrsr!=0) ){
4317: rc = sqlite3BtreeLast(pCrsr, &res);
4318: }
4319: pC->nullRow = (u8)res;
4320: pC->deferredMoveto = 0;
4321: pC->rowidIsValid = 0;
4322: pC->cacheStatus = CACHE_STALE;
4323: if( pOp->p2>0 && res ){
4324: pc = pOp->p2 - 1;
4325: }
4326: break;
4327: }
4328:
4329:
4330: /* Opcode: Sort P1 P2 * * *
4331: **
4332: ** This opcode does exactly the same thing as OP_Rewind except that
4333: ** it increments an undocumented global variable used for testing.
4334: **
4335: ** Sorting is accomplished by writing records into a sorting index,
4336: ** then rewinding that index and playing it back from beginning to
4337: ** end. We use the OP_Sort opcode instead of OP_Rewind to do the
4338: ** rewinding so that the global variable will be incremented and
4339: ** regression tests can determine whether or not the optimizer is
4340: ** correctly optimizing out sorts.
4341: */
4342: case OP_SorterSort: /* jump */
4343: #ifdef SQLITE_OMIT_MERGE_SORT
4344: pOp->opcode = OP_Sort;
4345: #endif
4346: case OP_Sort: { /* jump */
4347: #ifdef SQLITE_TEST
4348: sqlite3_sort_count++;
4349: sqlite3_search_count--;
4350: #endif
4351: p->aCounter[SQLITE_STMTSTATUS_SORT-1]++;
4352: /* Fall through into OP_Rewind */
4353: }
4354: /* Opcode: Rewind P1 P2 * * *
4355: **
4356: ** The next use of the Rowid or Column or Next instruction for P1
4357: ** will refer to the first entry in the database table or index.
4358: ** If the table or index is empty and P2>0, then jump immediately to P2.
4359: ** If P2 is 0 or if the table or index is not empty, fall through
4360: ** to the following instruction.
4361: */
4362: case OP_Rewind: { /* jump */
4363: VdbeCursor *pC;
4364: BtCursor *pCrsr;
4365: int res;
4366:
4367: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4368: pC = p->apCsr[pOp->p1];
4369: assert( pC!=0 );
4370: assert( pC->isSorter==(pOp->opcode==OP_SorterSort) );
4371: res = 1;
4372: if( isSorter(pC) ){
4373: rc = sqlite3VdbeSorterRewind(db, pC, &res);
4374: }else{
4375: pCrsr = pC->pCursor;
4376: assert( pCrsr );
4377: rc = sqlite3BtreeFirst(pCrsr, &res);
4378: pC->atFirst = res==0 ?1:0;
4379: pC->deferredMoveto = 0;
4380: pC->cacheStatus = CACHE_STALE;
4381: pC->rowidIsValid = 0;
4382: }
4383: pC->nullRow = (u8)res;
4384: assert( pOp->p2>0 && pOp->p2<p->nOp );
4385: if( res ){
4386: pc = pOp->p2 - 1;
4387: }
4388: break;
4389: }
4390:
4391: /* Opcode: Next P1 P2 * P4 P5
4392: **
4393: ** Advance cursor P1 so that it points to the next key/data pair in its
4394: ** table or index. If there are no more key/value pairs then fall through
4395: ** to the following instruction. But if the cursor advance was successful,
4396: ** jump immediately to P2.
4397: **
4398: ** The P1 cursor must be for a real table, not a pseudo-table.
4399: **
4400: ** P4 is always of type P4_ADVANCE. The function pointer points to
4401: ** sqlite3BtreeNext().
4402: **
4403: ** If P5 is positive and the jump is taken, then event counter
4404: ** number P5-1 in the prepared statement is incremented.
4405: **
4406: ** See also: Prev
4407: */
4408: /* Opcode: Prev P1 P2 * * P5
4409: **
4410: ** Back up cursor P1 so that it points to the previous key/data pair in its
4411: ** table or index. If there is no previous key/value pairs then fall through
4412: ** to the following instruction. But if the cursor backup was successful,
4413: ** jump immediately to P2.
4414: **
4415: ** The P1 cursor must be for a real table, not a pseudo-table.
4416: **
4417: ** P4 is always of type P4_ADVANCE. The function pointer points to
4418: ** sqlite3BtreePrevious().
4419: **
4420: ** If P5 is positive and the jump is taken, then event counter
4421: ** number P5-1 in the prepared statement is incremented.
4422: */
4423: case OP_SorterNext: /* jump */
4424: #ifdef SQLITE_OMIT_MERGE_SORT
4425: pOp->opcode = OP_Next;
4426: #endif
4427: case OP_Prev: /* jump */
4428: case OP_Next: { /* jump */
4429: VdbeCursor *pC;
4430: int res;
4431:
4432: CHECK_FOR_INTERRUPT;
4433: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4434: assert( pOp->p5<=ArraySize(p->aCounter) );
4435: pC = p->apCsr[pOp->p1];
4436: if( pC==0 ){
4437: break; /* See ticket #2273 */
4438: }
4439: assert( pC->isSorter==(pOp->opcode==OP_SorterNext) );
4440: if( isSorter(pC) ){
4441: assert( pOp->opcode==OP_SorterNext );
4442: rc = sqlite3VdbeSorterNext(db, pC, &res);
4443: }else{
4444: res = 1;
4445: assert( pC->deferredMoveto==0 );
4446: assert( pC->pCursor );
4447: assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
4448: assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
4449: rc = pOp->p4.xAdvance(pC->pCursor, &res);
4450: }
4451: pC->nullRow = (u8)res;
4452: pC->cacheStatus = CACHE_STALE;
4453: if( res==0 ){
4454: pc = pOp->p2 - 1;
4455: if( pOp->p5 ) p->aCounter[pOp->p5-1]++;
4456: #ifdef SQLITE_TEST
4457: sqlite3_search_count++;
4458: #endif
4459: }
4460: pC->rowidIsValid = 0;
4461: break;
4462: }
4463:
4464: /* Opcode: IdxInsert P1 P2 P3 * P5
4465: **
4466: ** Register P2 holds an SQL index key made using the
4467: ** MakeRecord instructions. This opcode writes that key
4468: ** into the index P1. Data for the entry is nil.
4469: **
4470: ** P3 is a flag that provides a hint to the b-tree layer that this
4471: ** insert is likely to be an append.
4472: **
4473: ** This instruction only works for indices. The equivalent instruction
4474: ** for tables is OP_Insert.
4475: */
4476: case OP_SorterInsert: /* in2 */
4477: #ifdef SQLITE_OMIT_MERGE_SORT
4478: pOp->opcode = OP_IdxInsert;
4479: #endif
4480: case OP_IdxInsert: { /* in2 */
4481: VdbeCursor *pC;
4482: BtCursor *pCrsr;
4483: int nKey;
4484: const char *zKey;
4485:
4486: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4487: pC = p->apCsr[pOp->p1];
4488: assert( pC!=0 );
4489: assert( pC->isSorter==(pOp->opcode==OP_SorterInsert) );
4490: pIn2 = &aMem[pOp->p2];
4491: assert( pIn2->flags & MEM_Blob );
4492: pCrsr = pC->pCursor;
4493: if( ALWAYS(pCrsr!=0) ){
4494: assert( pC->isTable==0 );
4495: rc = ExpandBlob(pIn2);
4496: if( rc==SQLITE_OK ){
4497: if( isSorter(pC) ){
4498: rc = sqlite3VdbeSorterWrite(db, pC, pIn2);
4499: }else{
4500: nKey = pIn2->n;
4501: zKey = pIn2->z;
4502: rc = sqlite3BtreeInsert(pCrsr, zKey, nKey, "", 0, 0, pOp->p3,
4503: ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
4504: );
4505: assert( pC->deferredMoveto==0 );
4506: pC->cacheStatus = CACHE_STALE;
4507: }
4508: }
4509: }
4510: break;
4511: }
4512:
4513: /* Opcode: IdxDelete P1 P2 P3 * *
4514: **
4515: ** The content of P3 registers starting at register P2 form
4516: ** an unpacked index key. This opcode removes that entry from the
4517: ** index opened by cursor P1.
4518: */
4519: case OP_IdxDelete: {
4520: VdbeCursor *pC;
4521: BtCursor *pCrsr;
4522: int res;
4523: UnpackedRecord r;
4524:
4525: assert( pOp->p3>0 );
4526: assert( pOp->p2>0 && pOp->p2+pOp->p3<=p->nMem+1 );
4527: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4528: pC = p->apCsr[pOp->p1];
4529: assert( pC!=0 );
4530: pCrsr = pC->pCursor;
4531: if( ALWAYS(pCrsr!=0) ){
4532: r.pKeyInfo = pC->pKeyInfo;
4533: r.nField = (u16)pOp->p3;
4534: r.flags = 0;
4535: r.aMem = &aMem[pOp->p2];
4536: #ifdef SQLITE_DEBUG
4537: { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
4538: #endif
4539: rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res);
4540: if( rc==SQLITE_OK && res==0 ){
4541: rc = sqlite3BtreeDelete(pCrsr);
4542: }
4543: assert( pC->deferredMoveto==0 );
4544: pC->cacheStatus = CACHE_STALE;
4545: }
4546: break;
4547: }
4548:
4549: /* Opcode: IdxRowid P1 P2 * * *
4550: **
4551: ** Write into register P2 an integer which is the last entry in the record at
4552: ** the end of the index key pointed to by cursor P1. This integer should be
4553: ** the rowid of the table entry to which this index entry points.
4554: **
4555: ** See also: Rowid, MakeRecord.
4556: */
4557: case OP_IdxRowid: { /* out2-prerelease */
4558: BtCursor *pCrsr;
4559: VdbeCursor *pC;
4560: i64 rowid;
4561:
4562: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4563: pC = p->apCsr[pOp->p1];
4564: assert( pC!=0 );
4565: pCrsr = pC->pCursor;
4566: pOut->flags = MEM_Null;
4567: if( ALWAYS(pCrsr!=0) ){
4568: rc = sqlite3VdbeCursorMoveto(pC);
4569: if( NEVER(rc) ) goto abort_due_to_error;
4570: assert( pC->deferredMoveto==0 );
4571: assert( pC->isTable==0 );
4572: if( !pC->nullRow ){
4573: rc = sqlite3VdbeIdxRowid(db, pCrsr, &rowid);
4574: if( rc!=SQLITE_OK ){
4575: goto abort_due_to_error;
4576: }
4577: pOut->u.i = rowid;
4578: pOut->flags = MEM_Int;
4579: }
4580: }
4581: break;
4582: }
4583:
4584: /* Opcode: IdxGE P1 P2 P3 P4 P5
4585: **
4586: ** The P4 register values beginning with P3 form an unpacked index
4587: ** key that omits the ROWID. Compare this key value against the index
4588: ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
4589: **
4590: ** If the P1 index entry is greater than or equal to the key value
4591: ** then jump to P2. Otherwise fall through to the next instruction.
4592: **
4593: ** If P5 is non-zero then the key value is increased by an epsilon
4594: ** prior to the comparison. This make the opcode work like IdxGT except
4595: ** that if the key from register P3 is a prefix of the key in the cursor,
4596: ** the result is false whereas it would be true with IdxGT.
4597: */
4598: /* Opcode: IdxLT P1 P2 P3 P4 P5
4599: **
4600: ** The P4 register values beginning with P3 form an unpacked index
4601: ** key that omits the ROWID. Compare this key value against the index
4602: ** that P1 is currently pointing to, ignoring the ROWID on the P1 index.
4603: **
4604: ** If the P1 index entry is less than the key value then jump to P2.
4605: ** Otherwise fall through to the next instruction.
4606: **
4607: ** If P5 is non-zero then the key value is increased by an epsilon prior
4608: ** to the comparison. This makes the opcode work like IdxLE.
4609: */
4610: case OP_IdxLT: /* jump */
4611: case OP_IdxGE: { /* jump */
4612: VdbeCursor *pC;
4613: int res;
4614: UnpackedRecord r;
4615:
4616: assert( pOp->p1>=0 && pOp->p1<p->nCursor );
4617: pC = p->apCsr[pOp->p1];
4618: assert( pC!=0 );
4619: assert( pC->isOrdered );
4620: if( ALWAYS(pC->pCursor!=0) ){
4621: assert( pC->deferredMoveto==0 );
4622: assert( pOp->p5==0 || pOp->p5==1 );
4623: assert( pOp->p4type==P4_INT32 );
4624: r.pKeyInfo = pC->pKeyInfo;
4625: r.nField = (u16)pOp->p4.i;
4626: if( pOp->p5 ){
4627: r.flags = UNPACKED_INCRKEY | UNPACKED_PREFIX_MATCH;
4628: }else{
4629: r.flags = UNPACKED_PREFIX_MATCH;
4630: }
4631: r.aMem = &aMem[pOp->p3];
4632: #ifdef SQLITE_DEBUG
4633: { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
4634: #endif
4635: rc = sqlite3VdbeIdxKeyCompare(pC, &r, &res);
4636: if( pOp->opcode==OP_IdxLT ){
4637: res = -res;
4638: }else{
4639: assert( pOp->opcode==OP_IdxGE );
4640: res++;
4641: }
4642: if( res>0 ){
4643: pc = pOp->p2 - 1 ;
4644: }
4645: }
4646: break;
4647: }
4648:
4649: /* Opcode: Destroy P1 P2 P3 * *
4650: **
4651: ** Delete an entire database table or index whose root page in the database
4652: ** file is given by P1.
4653: **
4654: ** The table being destroyed is in the main database file if P3==0. If
4655: ** P3==1 then the table to be clear is in the auxiliary database file
4656: ** that is used to store tables create using CREATE TEMPORARY TABLE.
4657: **
4658: ** If AUTOVACUUM is enabled then it is possible that another root page
4659: ** might be moved into the newly deleted root page in order to keep all
4660: ** root pages contiguous at the beginning of the database. The former
4661: ** value of the root page that moved - its value before the move occurred -
4662: ** is stored in register P2. If no page
4663: ** movement was required (because the table being dropped was already
4664: ** the last one in the database) then a zero is stored in register P2.
4665: ** If AUTOVACUUM is disabled then a zero is stored in register P2.
4666: **
4667: ** See also: Clear
4668: */
4669: case OP_Destroy: { /* out2-prerelease */
4670: int iMoved;
4671: int iCnt;
4672: Vdbe *pVdbe;
4673: int iDb;
4674: #ifndef SQLITE_OMIT_VIRTUALTABLE
4675: iCnt = 0;
4676: for(pVdbe=db->pVdbe; pVdbe; pVdbe = pVdbe->pNext){
4677: if( pVdbe->magic==VDBE_MAGIC_RUN && pVdbe->inVtabMethod<2 && pVdbe->pc>=0 ){
4678: iCnt++;
4679: }
4680: }
4681: #else
4682: iCnt = db->activeVdbeCnt;
4683: #endif
4684: pOut->flags = MEM_Null;
4685: if( iCnt>1 ){
4686: rc = SQLITE_LOCKED;
4687: p->errorAction = OE_Abort;
4688: }else{
4689: iDb = pOp->p3;
4690: assert( iCnt==1 );
4691: assert( (p->btreeMask & (((yDbMask)1)<<iDb))!=0 );
4692: rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
4693: pOut->flags = MEM_Int;
4694: pOut->u.i = iMoved;
4695: #ifndef SQLITE_OMIT_AUTOVACUUM
4696: if( rc==SQLITE_OK && iMoved!=0 ){
4697: sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
4698: /* All OP_Destroy operations occur on the same btree */
4699: assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
4700: resetSchemaOnFault = iDb+1;
4701: }
4702: #endif
4703: }
4704: break;
4705: }
4706:
4707: /* Opcode: Clear P1 P2 P3
4708: **
4709: ** Delete all contents of the database table or index whose root page
4710: ** in the database file is given by P1. But, unlike Destroy, do not
4711: ** remove the table or index from the database file.
4712: **
4713: ** The table being clear is in the main database file if P2==0. If
4714: ** P2==1 then the table to be clear is in the auxiliary database file
4715: ** that is used to store tables create using CREATE TEMPORARY TABLE.
4716: **
4717: ** If the P3 value is non-zero, then the table referred to must be an
4718: ** intkey table (an SQL table, not an index). In this case the row change
4719: ** count is incremented by the number of rows in the table being cleared.
4720: ** If P3 is greater than zero, then the value stored in register P3 is
4721: ** also incremented by the number of rows in the table being cleared.
4722: **
4723: ** See also: Destroy
4724: */
4725: case OP_Clear: {
4726: int nChange;
4727:
4728: nChange = 0;
4729: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p2))!=0 );
4730: rc = sqlite3BtreeClearTable(
4731: db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0)
4732: );
4733: if( pOp->p3 ){
4734: p->nChange += nChange;
4735: if( pOp->p3>0 ){
4736: assert( memIsValid(&aMem[pOp->p3]) );
4737: memAboutToChange(p, &aMem[pOp->p3]);
4738: aMem[pOp->p3].u.i += nChange;
4739: }
4740: }
4741: break;
4742: }
4743:
4744: /* Opcode: CreateTable P1 P2 * * *
4745: **
4746: ** Allocate a new table in the main database file if P1==0 or in the
4747: ** auxiliary database file if P1==1 or in an attached database if
4748: ** P1>1. Write the root page number of the new table into
4749: ** register P2
4750: **
4751: ** The difference between a table and an index is this: A table must
4752: ** have a 4-byte integer key and can have arbitrary data. An index
4753: ** has an arbitrary key but no data.
4754: **
4755: ** See also: CreateIndex
4756: */
4757: /* Opcode: CreateIndex P1 P2 * * *
4758: **
4759: ** Allocate a new index in the main database file if P1==0 or in the
4760: ** auxiliary database file if P1==1 or in an attached database if
4761: ** P1>1. Write the root page number of the new table into
4762: ** register P2.
4763: **
4764: ** See documentation on OP_CreateTable for additional information.
4765: */
4766: case OP_CreateIndex: /* out2-prerelease */
4767: case OP_CreateTable: { /* out2-prerelease */
4768: int pgno;
4769: int flags;
4770: Db *pDb;
4771:
4772: pgno = 0;
4773: assert( pOp->p1>=0 && pOp->p1<db->nDb );
4774: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
4775: pDb = &db->aDb[pOp->p1];
4776: assert( pDb->pBt!=0 );
4777: if( pOp->opcode==OP_CreateTable ){
4778: /* flags = BTREE_INTKEY; */
4779: flags = BTREE_INTKEY;
4780: }else{
4781: flags = BTREE_BLOBKEY;
4782: }
4783: rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
4784: pOut->u.i = pgno;
4785: break;
4786: }
4787:
4788: /* Opcode: ParseSchema P1 * * P4 *
4789: **
4790: ** Read and parse all entries from the SQLITE_MASTER table of database P1
4791: ** that match the WHERE clause P4.
4792: **
4793: ** This opcode invokes the parser to create a new virtual machine,
4794: ** then runs the new virtual machine. It is thus a re-entrant opcode.
4795: */
4796: case OP_ParseSchema: {
4797: int iDb;
4798: const char *zMaster;
4799: char *zSql;
4800: InitData initData;
4801:
4802: /* Any prepared statement that invokes this opcode will hold mutexes
4803: ** on every btree. This is a prerequisite for invoking
4804: ** sqlite3InitCallback().
4805: */
4806: #ifdef SQLITE_DEBUG
4807: for(iDb=0; iDb<db->nDb; iDb++){
4808: assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
4809: }
4810: #endif
4811:
4812: iDb = pOp->p1;
4813: assert( iDb>=0 && iDb<db->nDb );
4814: assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
4815: /* Used to be a conditional */ {
4816: zMaster = SCHEMA_TABLE(iDb);
4817: initData.db = db;
4818: initData.iDb = pOp->p1;
4819: initData.pzErrMsg = &p->zErrMsg;
4820: zSql = sqlite3MPrintf(db,
4821: "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid",
4822: db->aDb[iDb].zName, zMaster, pOp->p4.z);
4823: if( zSql==0 ){
4824: rc = SQLITE_NOMEM;
4825: }else{
4826: assert( db->init.busy==0 );
4827: db->init.busy = 1;
4828: initData.rc = SQLITE_OK;
4829: assert( !db->mallocFailed );
4830: rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
4831: if( rc==SQLITE_OK ) rc = initData.rc;
4832: sqlite3DbFree(db, zSql);
4833: db->init.busy = 0;
4834: }
4835: }
4836: if( rc==SQLITE_NOMEM ){
4837: goto no_mem;
4838: }
4839: break;
4840: }
4841:
4842: #if !defined(SQLITE_OMIT_ANALYZE)
4843: /* Opcode: LoadAnalysis P1 * * * *
4844: **
4845: ** Read the sqlite_stat1 table for database P1 and load the content
4846: ** of that table into the internal index hash table. This will cause
4847: ** the analysis to be used when preparing all subsequent queries.
4848: */
4849: case OP_LoadAnalysis: {
4850: assert( pOp->p1>=0 && pOp->p1<db->nDb );
4851: rc = sqlite3AnalysisLoad(db, pOp->p1);
4852: break;
4853: }
4854: #endif /* !defined(SQLITE_OMIT_ANALYZE) */
4855:
4856: /* Opcode: DropTable P1 * * P4 *
4857: **
4858: ** Remove the internal (in-memory) data structures that describe
4859: ** the table named P4 in database P1. This is called after a table
4860: ** is dropped in order to keep the internal representation of the
4861: ** schema consistent with what is on disk.
4862: */
4863: case OP_DropTable: {
4864: sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
4865: break;
4866: }
4867:
4868: /* Opcode: DropIndex P1 * * P4 *
4869: **
4870: ** Remove the internal (in-memory) data structures that describe
4871: ** the index named P4 in database P1. This is called after an index
4872: ** is dropped in order to keep the internal representation of the
4873: ** schema consistent with what is on disk.
4874: */
4875: case OP_DropIndex: {
4876: sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
4877: break;
4878: }
4879:
4880: /* Opcode: DropTrigger P1 * * P4 *
4881: **
4882: ** Remove the internal (in-memory) data structures that describe
4883: ** the trigger named P4 in database P1. This is called after a trigger
4884: ** is dropped in order to keep the internal representation of the
4885: ** schema consistent with what is on disk.
4886: */
4887: case OP_DropTrigger: {
4888: sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
4889: break;
4890: }
4891:
4892:
4893: #ifndef SQLITE_OMIT_INTEGRITY_CHECK
4894: /* Opcode: IntegrityCk P1 P2 P3 * P5
4895: **
4896: ** Do an analysis of the currently open database. Store in
4897: ** register P1 the text of an error message describing any problems.
4898: ** If no problems are found, store a NULL in register P1.
4899: **
4900: ** The register P3 contains the maximum number of allowed errors.
4901: ** At most reg(P3) errors will be reported.
4902: ** In other words, the analysis stops as soon as reg(P1) errors are
4903: ** seen. Reg(P1) is updated with the number of errors remaining.
4904: **
4905: ** The root page numbers of all tables in the database are integer
4906: ** stored in reg(P1), reg(P1+1), reg(P1+2), .... There are P2 tables
4907: ** total.
4908: **
4909: ** If P5 is not zero, the check is done on the auxiliary database
4910: ** file, not the main database file.
4911: **
4912: ** This opcode is used to implement the integrity_check pragma.
4913: */
4914: case OP_IntegrityCk: {
4915: int nRoot; /* Number of tables to check. (Number of root pages.) */
4916: int *aRoot; /* Array of rootpage numbers for tables to be checked */
4917: int j; /* Loop counter */
4918: int nErr; /* Number of errors reported */
4919: char *z; /* Text of the error report */
4920: Mem *pnErr; /* Register keeping track of errors remaining */
4921:
4922: nRoot = pOp->p2;
4923: assert( nRoot>0 );
4924: aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(nRoot+1) );
4925: if( aRoot==0 ) goto no_mem;
4926: assert( pOp->p3>0 && pOp->p3<=p->nMem );
4927: pnErr = &aMem[pOp->p3];
4928: assert( (pnErr->flags & MEM_Int)!=0 );
4929: assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
4930: pIn1 = &aMem[pOp->p1];
4931: for(j=0; j<nRoot; j++){
4932: aRoot[j] = (int)sqlite3VdbeIntValue(&pIn1[j]);
4933: }
4934: aRoot[j] = 0;
4935: assert( pOp->p5<db->nDb );
4936: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p5))!=0 );
4937: z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
4938: (int)pnErr->u.i, &nErr);
4939: sqlite3DbFree(db, aRoot);
4940: pnErr->u.i -= nErr;
4941: sqlite3VdbeMemSetNull(pIn1);
4942: if( nErr==0 ){
4943: assert( z==0 );
4944: }else if( z==0 ){
4945: goto no_mem;
4946: }else{
4947: sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
4948: }
4949: UPDATE_MAX_BLOBSIZE(pIn1);
4950: sqlite3VdbeChangeEncoding(pIn1, encoding);
4951: break;
4952: }
4953: #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
4954:
4955: /* Opcode: RowSetAdd P1 P2 * * *
4956: **
4957: ** Insert the integer value held by register P2 into a boolean index
4958: ** held in register P1.
4959: **
4960: ** An assertion fails if P2 is not an integer.
4961: */
4962: case OP_RowSetAdd: { /* in1, in2 */
4963: pIn1 = &aMem[pOp->p1];
4964: pIn2 = &aMem[pOp->p2];
4965: assert( (pIn2->flags & MEM_Int)!=0 );
4966: if( (pIn1->flags & MEM_RowSet)==0 ){
4967: sqlite3VdbeMemSetRowSet(pIn1);
4968: if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
4969: }
4970: sqlite3RowSetInsert(pIn1->u.pRowSet, pIn2->u.i);
4971: break;
4972: }
4973:
4974: /* Opcode: RowSetRead P1 P2 P3 * *
4975: **
4976: ** Extract the smallest value from boolean index P1 and put that value into
4977: ** register P3. Or, if boolean index P1 is initially empty, leave P3
4978: ** unchanged and jump to instruction P2.
4979: */
4980: case OP_RowSetRead: { /* jump, in1, out3 */
4981: i64 val;
4982: CHECK_FOR_INTERRUPT;
4983: pIn1 = &aMem[pOp->p1];
4984: if( (pIn1->flags & MEM_RowSet)==0
4985: || sqlite3RowSetNext(pIn1->u.pRowSet, &val)==0
4986: ){
4987: /* The boolean index is empty */
4988: sqlite3VdbeMemSetNull(pIn1);
4989: pc = pOp->p2 - 1;
4990: }else{
4991: /* A value was pulled from the index */
4992: sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
4993: }
4994: break;
4995: }
4996:
4997: /* Opcode: RowSetTest P1 P2 P3 P4
4998: **
4999: ** Register P3 is assumed to hold a 64-bit integer value. If register P1
5000: ** contains a RowSet object and that RowSet object contains
5001: ** the value held in P3, jump to register P2. Otherwise, insert the
5002: ** integer in P3 into the RowSet and continue on to the
5003: ** next opcode.
5004: **
5005: ** The RowSet object is optimized for the case where successive sets
5006: ** of integers, where each set contains no duplicates. Each set
5007: ** of values is identified by a unique P4 value. The first set
5008: ** must have P4==0, the final set P4=-1. P4 must be either -1 or
5009: ** non-negative. For non-negative values of P4 only the lower 4
5010: ** bits are significant.
5011: **
5012: ** This allows optimizations: (a) when P4==0 there is no need to test
5013: ** the rowset object for P3, as it is guaranteed not to contain it,
5014: ** (b) when P4==-1 there is no need to insert the value, as it will
5015: ** never be tested for, and (c) when a value that is part of set X is
5016: ** inserted, there is no need to search to see if the same value was
5017: ** previously inserted as part of set X (only if it was previously
5018: ** inserted as part of some other set).
5019: */
5020: case OP_RowSetTest: { /* jump, in1, in3 */
5021: int iSet;
5022: int exists;
5023:
5024: pIn1 = &aMem[pOp->p1];
5025: pIn3 = &aMem[pOp->p3];
5026: iSet = pOp->p4.i;
5027: assert( pIn3->flags&MEM_Int );
5028:
5029: /* If there is anything other than a rowset object in memory cell P1,
5030: ** delete it now and initialize P1 with an empty rowset
5031: */
5032: if( (pIn1->flags & MEM_RowSet)==0 ){
5033: sqlite3VdbeMemSetRowSet(pIn1);
5034: if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
5035: }
5036:
5037: assert( pOp->p4type==P4_INT32 );
5038: assert( iSet==-1 || iSet>=0 );
5039: if( iSet ){
5040: exists = sqlite3RowSetTest(pIn1->u.pRowSet,
5041: (u8)(iSet>=0 ? iSet & 0xf : 0xff),
5042: pIn3->u.i);
5043: if( exists ){
5044: pc = pOp->p2 - 1;
5045: break;
5046: }
5047: }
5048: if( iSet>=0 ){
5049: sqlite3RowSetInsert(pIn1->u.pRowSet, pIn3->u.i);
5050: }
5051: break;
5052: }
5053:
5054:
5055: #ifndef SQLITE_OMIT_TRIGGER
5056:
5057: /* Opcode: Program P1 P2 P3 P4 *
5058: **
5059: ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM).
5060: **
5061: ** P1 contains the address of the memory cell that contains the first memory
5062: ** cell in an array of values used as arguments to the sub-program. P2
5063: ** contains the address to jump to if the sub-program throws an IGNORE
5064: ** exception using the RAISE() function. Register P3 contains the address
5065: ** of a memory cell in this (the parent) VM that is used to allocate the
5066: ** memory required by the sub-vdbe at runtime.
5067: **
5068: ** P4 is a pointer to the VM containing the trigger program.
5069: */
5070: case OP_Program: { /* jump */
5071: int nMem; /* Number of memory registers for sub-program */
5072: int nByte; /* Bytes of runtime space required for sub-program */
5073: Mem *pRt; /* Register to allocate runtime space */
5074: Mem *pMem; /* Used to iterate through memory cells */
5075: Mem *pEnd; /* Last memory cell in new array */
5076: VdbeFrame *pFrame; /* New vdbe frame to execute in */
5077: SubProgram *pProgram; /* Sub-program to execute */
5078: void *t; /* Token identifying trigger */
5079:
5080: pProgram = pOp->p4.pProgram;
5081: pRt = &aMem[pOp->p3];
5082: assert( pProgram->nOp>0 );
5083:
5084: /* If the p5 flag is clear, then recursive invocation of triggers is
5085: ** disabled for backwards compatibility (p5 is set if this sub-program
5086: ** is really a trigger, not a foreign key action, and the flag set
5087: ** and cleared by the "PRAGMA recursive_triggers" command is clear).
5088: **
5089: ** It is recursive invocation of triggers, at the SQL level, that is
5090: ** disabled. In some cases a single trigger may generate more than one
5091: ** SubProgram (if the trigger may be executed with more than one different
5092: ** ON CONFLICT algorithm). SubProgram structures associated with a
5093: ** single trigger all have the same value for the SubProgram.token
5094: ** variable. */
5095: if( pOp->p5 ){
5096: t = pProgram->token;
5097: for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
5098: if( pFrame ) break;
5099: }
5100:
5101: if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
5102: rc = SQLITE_ERROR;
5103: sqlite3SetString(&p->zErrMsg, db, "too many levels of trigger recursion");
5104: break;
5105: }
5106:
5107: /* Register pRt is used to store the memory required to save the state
5108: ** of the current program, and the memory required at runtime to execute
5109: ** the trigger program. If this trigger has been fired before, then pRt
5110: ** is already allocated. Otherwise, it must be initialized. */
5111: if( (pRt->flags&MEM_Frame)==0 ){
5112: /* SubProgram.nMem is set to the number of memory cells used by the
5113: ** program stored in SubProgram.aOp. As well as these, one memory
5114: ** cell is required for each cursor used by the program. Set local
5115: ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
5116: */
5117: nMem = pProgram->nMem + pProgram->nCsr;
5118: nByte = ROUND8(sizeof(VdbeFrame))
5119: + nMem * sizeof(Mem)
5120: + pProgram->nCsr * sizeof(VdbeCursor *)
5121: + pProgram->nOnce * sizeof(u8);
5122: pFrame = sqlite3DbMallocZero(db, nByte);
5123: if( !pFrame ){
5124: goto no_mem;
5125: }
5126: sqlite3VdbeMemRelease(pRt);
5127: pRt->flags = MEM_Frame;
5128: pRt->u.pFrame = pFrame;
5129:
5130: pFrame->v = p;
5131: pFrame->nChildMem = nMem;
5132: pFrame->nChildCsr = pProgram->nCsr;
5133: pFrame->pc = pc;
5134: pFrame->aMem = p->aMem;
5135: pFrame->nMem = p->nMem;
5136: pFrame->apCsr = p->apCsr;
5137: pFrame->nCursor = p->nCursor;
5138: pFrame->aOp = p->aOp;
5139: pFrame->nOp = p->nOp;
5140: pFrame->token = pProgram->token;
5141: pFrame->aOnceFlag = p->aOnceFlag;
5142: pFrame->nOnceFlag = p->nOnceFlag;
5143:
5144: pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
5145: for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
5146: pMem->flags = MEM_Invalid;
5147: pMem->db = db;
5148: }
5149: }else{
5150: pFrame = pRt->u.pFrame;
5151: assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem );
5152: assert( pProgram->nCsr==pFrame->nChildCsr );
5153: assert( pc==pFrame->pc );
5154: }
5155:
5156: p->nFrame++;
5157: pFrame->pParent = p->pFrame;
5158: pFrame->lastRowid = lastRowid;
5159: pFrame->nChange = p->nChange;
5160: p->nChange = 0;
5161: p->pFrame = pFrame;
5162: p->aMem = aMem = &VdbeFrameMem(pFrame)[-1];
5163: p->nMem = pFrame->nChildMem;
5164: p->nCursor = (u16)pFrame->nChildCsr;
5165: p->apCsr = (VdbeCursor **)&aMem[p->nMem+1];
5166: p->aOp = aOp = pProgram->aOp;
5167: p->nOp = pProgram->nOp;
5168: p->aOnceFlag = (u8 *)&p->apCsr[p->nCursor];
5169: p->nOnceFlag = pProgram->nOnce;
5170: p->nOp = pProgram->nOp;
5171: pc = -1;
5172: memset(p->aOnceFlag, 0, p->nOnceFlag);
5173:
5174: break;
5175: }
5176:
5177: /* Opcode: Param P1 P2 * * *
5178: **
5179: ** This opcode is only ever present in sub-programs called via the
5180: ** OP_Program instruction. Copy a value currently stored in a memory
5181: ** cell of the calling (parent) frame to cell P2 in the current frames
5182: ** address space. This is used by trigger programs to access the new.*
5183: ** and old.* values.
5184: **
5185: ** The address of the cell in the parent frame is determined by adding
5186: ** the value of the P1 argument to the value of the P1 argument to the
5187: ** calling OP_Program instruction.
5188: */
5189: case OP_Param: { /* out2-prerelease */
5190: VdbeFrame *pFrame;
5191: Mem *pIn;
5192: pFrame = p->pFrame;
5193: pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];
5194: sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
5195: break;
5196: }
5197:
5198: #endif /* #ifndef SQLITE_OMIT_TRIGGER */
5199:
5200: #ifndef SQLITE_OMIT_FOREIGN_KEY
5201: /* Opcode: FkCounter P1 P2 * * *
5202: **
5203: ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
5204: ** If P1 is non-zero, the database constraint counter is incremented
5205: ** (deferred foreign key constraints). Otherwise, if P1 is zero, the
5206: ** statement counter is incremented (immediate foreign key constraints).
5207: */
5208: case OP_FkCounter: {
5209: if( pOp->p1 ){
5210: db->nDeferredCons += pOp->p2;
5211: }else{
5212: p->nFkConstraint += pOp->p2;
5213: }
5214: break;
5215: }
5216:
5217: /* Opcode: FkIfZero P1 P2 * * *
5218: **
5219: ** This opcode tests if a foreign key constraint-counter is currently zero.
5220: ** If so, jump to instruction P2. Otherwise, fall through to the next
5221: ** instruction.
5222: **
5223: ** If P1 is non-zero, then the jump is taken if the database constraint-counter
5224: ** is zero (the one that counts deferred constraint violations). If P1 is
5225: ** zero, the jump is taken if the statement constraint-counter is zero
5226: ** (immediate foreign key constraint violations).
5227: */
5228: case OP_FkIfZero: { /* jump */
5229: if( pOp->p1 ){
5230: if( db->nDeferredCons==0 ) pc = pOp->p2-1;
5231: }else{
5232: if( p->nFkConstraint==0 ) pc = pOp->p2-1;
5233: }
5234: break;
5235: }
5236: #endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */
5237:
5238: #ifndef SQLITE_OMIT_AUTOINCREMENT
5239: /* Opcode: MemMax P1 P2 * * *
5240: **
5241: ** P1 is a register in the root frame of this VM (the root frame is
5242: ** different from the current frame if this instruction is being executed
5243: ** within a sub-program). Set the value of register P1 to the maximum of
5244: ** its current value and the value in register P2.
5245: **
5246: ** This instruction throws an error if the memory cell is not initially
5247: ** an integer.
5248: */
5249: case OP_MemMax: { /* in2 */
5250: Mem *pIn1;
5251: VdbeFrame *pFrame;
5252: if( p->pFrame ){
5253: for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
5254: pIn1 = &pFrame->aMem[pOp->p1];
5255: }else{
5256: pIn1 = &aMem[pOp->p1];
5257: }
5258: assert( memIsValid(pIn1) );
5259: sqlite3VdbeMemIntegerify(pIn1);
5260: pIn2 = &aMem[pOp->p2];
5261: sqlite3VdbeMemIntegerify(pIn2);
5262: if( pIn1->u.i<pIn2->u.i){
5263: pIn1->u.i = pIn2->u.i;
5264: }
5265: break;
5266: }
5267: #endif /* SQLITE_OMIT_AUTOINCREMENT */
5268:
5269: /* Opcode: IfPos P1 P2 * * *
5270: **
5271: ** If the value of register P1 is 1 or greater, jump to P2.
5272: **
5273: ** It is illegal to use this instruction on a register that does
5274: ** not contain an integer. An assertion fault will result if you try.
5275: */
5276: case OP_IfPos: { /* jump, in1 */
5277: pIn1 = &aMem[pOp->p1];
5278: assert( pIn1->flags&MEM_Int );
5279: if( pIn1->u.i>0 ){
5280: pc = pOp->p2 - 1;
5281: }
5282: break;
5283: }
5284:
5285: /* Opcode: IfNeg P1 P2 * * *
5286: **
5287: ** If the value of register P1 is less than zero, jump to P2.
5288: **
5289: ** It is illegal to use this instruction on a register that does
5290: ** not contain an integer. An assertion fault will result if you try.
5291: */
5292: case OP_IfNeg: { /* jump, in1 */
5293: pIn1 = &aMem[pOp->p1];
5294: assert( pIn1->flags&MEM_Int );
5295: if( pIn1->u.i<0 ){
5296: pc = pOp->p2 - 1;
5297: }
5298: break;
5299: }
5300:
5301: /* Opcode: IfZero P1 P2 P3 * *
5302: **
5303: ** The register P1 must contain an integer. Add literal P3 to the
5304: ** value in register P1. If the result is exactly 0, jump to P2.
5305: **
5306: ** It is illegal to use this instruction on a register that does
5307: ** not contain an integer. An assertion fault will result if you try.
5308: */
5309: case OP_IfZero: { /* jump, in1 */
5310: pIn1 = &aMem[pOp->p1];
5311: assert( pIn1->flags&MEM_Int );
5312: pIn1->u.i += pOp->p3;
5313: if( pIn1->u.i==0 ){
5314: pc = pOp->p2 - 1;
5315: }
5316: break;
5317: }
5318:
5319: /* Opcode: AggStep * P2 P3 P4 P5
5320: **
5321: ** Execute the step function for an aggregate. The
5322: ** function has P5 arguments. P4 is a pointer to the FuncDef
5323: ** structure that specifies the function. Use register
5324: ** P3 as the accumulator.
5325: **
5326: ** The P5 arguments are taken from register P2 and its
5327: ** successors.
5328: */
5329: case OP_AggStep: {
5330: int n;
5331: int i;
5332: Mem *pMem;
5333: Mem *pRec;
5334: sqlite3_context ctx;
5335: sqlite3_value **apVal;
5336:
5337: n = pOp->p5;
5338: assert( n>=0 );
5339: pRec = &aMem[pOp->p2];
5340: apVal = p->apArg;
5341: assert( apVal || n==0 );
5342: for(i=0; i<n; i++, pRec++){
5343: assert( memIsValid(pRec) );
5344: apVal[i] = pRec;
5345: memAboutToChange(p, pRec);
5346: sqlite3VdbeMemStoreType(pRec);
5347: }
5348: ctx.pFunc = pOp->p4.pFunc;
5349: assert( pOp->p3>0 && pOp->p3<=p->nMem );
5350: ctx.pMem = pMem = &aMem[pOp->p3];
5351: pMem->n++;
5352: ctx.s.flags = MEM_Null;
5353: ctx.s.z = 0;
5354: ctx.s.zMalloc = 0;
5355: ctx.s.xDel = 0;
5356: ctx.s.db = db;
5357: ctx.isError = 0;
5358: ctx.pColl = 0;
5359: if( ctx.pFunc->flags & SQLITE_FUNC_NEEDCOLL ){
5360: assert( pOp>p->aOp );
5361: assert( pOp[-1].p4type==P4_COLLSEQ );
5362: assert( pOp[-1].opcode==OP_CollSeq );
5363: ctx.pColl = pOp[-1].p4.pColl;
5364: }
5365: (ctx.pFunc->xStep)(&ctx, n, apVal); /* IMP: R-24505-23230 */
5366: if( ctx.isError ){
5367: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&ctx.s));
5368: rc = ctx.isError;
5369: }
5370:
5371: sqlite3VdbeMemRelease(&ctx.s);
5372:
5373: break;
5374: }
5375:
5376: /* Opcode: AggFinal P1 P2 * P4 *
5377: **
5378: ** Execute the finalizer function for an aggregate. P1 is
5379: ** the memory location that is the accumulator for the aggregate.
5380: **
5381: ** P2 is the number of arguments that the step function takes and
5382: ** P4 is a pointer to the FuncDef for this function. The P2
5383: ** argument is not used by this opcode. It is only there to disambiguate
5384: ** functions that can take varying numbers of arguments. The
5385: ** P4 argument is only needed for the degenerate case where
5386: ** the step function was not previously called.
5387: */
5388: case OP_AggFinal: {
5389: Mem *pMem;
5390: assert( pOp->p1>0 && pOp->p1<=p->nMem );
5391: pMem = &aMem[pOp->p1];
5392: assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
5393: rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
5394: if( rc ){
5395: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(pMem));
5396: }
5397: sqlite3VdbeChangeEncoding(pMem, encoding);
5398: UPDATE_MAX_BLOBSIZE(pMem);
5399: if( sqlite3VdbeMemTooBig(pMem) ){
5400: goto too_big;
5401: }
5402: break;
5403: }
5404:
5405: #ifndef SQLITE_OMIT_WAL
5406: /* Opcode: Checkpoint P1 P2 P3 * *
5407: **
5408: ** Checkpoint database P1. This is a no-op if P1 is not currently in
5409: ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL
5410: ** or RESTART. Write 1 or 0 into mem[P3] if the checkpoint returns
5411: ** SQLITE_BUSY or not, respectively. Write the number of pages in the
5412: ** WAL after the checkpoint into mem[P3+1] and the number of pages
5413: ** in the WAL that have been checkpointed after the checkpoint
5414: ** completes into mem[P3+2]. However on an error, mem[P3+1] and
5415: ** mem[P3+2] are initialized to -1.
5416: */
5417: case OP_Checkpoint: {
5418: int i; /* Loop counter */
5419: int aRes[3]; /* Results */
5420: Mem *pMem; /* Write results here */
5421:
5422: aRes[0] = 0;
5423: aRes[1] = aRes[2] = -1;
5424: assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
5425: || pOp->p2==SQLITE_CHECKPOINT_FULL
5426: || pOp->p2==SQLITE_CHECKPOINT_RESTART
5427: );
5428: rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
5429: if( rc==SQLITE_BUSY ){
5430: rc = SQLITE_OK;
5431: aRes[0] = 1;
5432: }
5433: for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
5434: sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]);
5435: }
5436: break;
5437: };
5438: #endif
5439:
5440: #ifndef SQLITE_OMIT_PRAGMA
5441: /* Opcode: JournalMode P1 P2 P3 * P5
5442: **
5443: ** Change the journal mode of database P1 to P3. P3 must be one of the
5444: ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
5445: ** modes (delete, truncate, persist, off and memory), this is a simple
5446: ** operation. No IO is required.
5447: **
5448: ** If changing into or out of WAL mode the procedure is more complicated.
5449: **
5450: ** Write a string containing the final journal-mode to register P2.
5451: */
5452: case OP_JournalMode: { /* out2-prerelease */
5453: Btree *pBt; /* Btree to change journal mode of */
5454: Pager *pPager; /* Pager associated with pBt */
5455: int eNew; /* New journal mode */
5456: int eOld; /* The old journal mode */
5457: const char *zFilename; /* Name of database file for pPager */
5458:
5459: eNew = pOp->p3;
5460: assert( eNew==PAGER_JOURNALMODE_DELETE
5461: || eNew==PAGER_JOURNALMODE_TRUNCATE
5462: || eNew==PAGER_JOURNALMODE_PERSIST
5463: || eNew==PAGER_JOURNALMODE_OFF
5464: || eNew==PAGER_JOURNALMODE_MEMORY
5465: || eNew==PAGER_JOURNALMODE_WAL
5466: || eNew==PAGER_JOURNALMODE_QUERY
5467: );
5468: assert( pOp->p1>=0 && pOp->p1<db->nDb );
5469:
5470: pBt = db->aDb[pOp->p1].pBt;
5471: pPager = sqlite3BtreePager(pBt);
5472: eOld = sqlite3PagerGetJournalMode(pPager);
5473: if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
5474: if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
5475:
5476: #ifndef SQLITE_OMIT_WAL
5477: zFilename = sqlite3PagerFilename(pPager);
5478:
5479: /* Do not allow a transition to journal_mode=WAL for a database
5480: ** in temporary storage or if the VFS does not support shared memory
5481: */
5482: if( eNew==PAGER_JOURNALMODE_WAL
5483: && (sqlite3Strlen30(zFilename)==0 /* Temp file */
5484: || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */
5485: ){
5486: eNew = eOld;
5487: }
5488:
5489: if( (eNew!=eOld)
5490: && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL)
5491: ){
5492: if( !db->autoCommit || db->activeVdbeCnt>1 ){
5493: rc = SQLITE_ERROR;
5494: sqlite3SetString(&p->zErrMsg, db,
5495: "cannot change %s wal mode from within a transaction",
5496: (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
5497: );
5498: break;
5499: }else{
5500:
5501: if( eOld==PAGER_JOURNALMODE_WAL ){
5502: /* If leaving WAL mode, close the log file. If successful, the call
5503: ** to PagerCloseWal() checkpoints and deletes the write-ahead-log
5504: ** file. An EXCLUSIVE lock may still be held on the database file
5505: ** after a successful return.
5506: */
5507: rc = sqlite3PagerCloseWal(pPager);
5508: if( rc==SQLITE_OK ){
5509: sqlite3PagerSetJournalMode(pPager, eNew);
5510: }
5511: }else if( eOld==PAGER_JOURNALMODE_MEMORY ){
5512: /* Cannot transition directly from MEMORY to WAL. Use mode OFF
5513: ** as an intermediate */
5514: sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
5515: }
5516:
5517: /* Open a transaction on the database file. Regardless of the journal
5518: ** mode, this transaction always uses a rollback journal.
5519: */
5520: assert( sqlite3BtreeIsInTrans(pBt)==0 );
5521: if( rc==SQLITE_OK ){
5522: rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
5523: }
5524: }
5525: }
5526: #endif /* ifndef SQLITE_OMIT_WAL */
5527:
5528: if( rc ){
5529: eNew = eOld;
5530: }
5531: eNew = sqlite3PagerSetJournalMode(pPager, eNew);
5532:
5533: pOut = &aMem[pOp->p2];
5534: pOut->flags = MEM_Str|MEM_Static|MEM_Term;
5535: pOut->z = (char *)sqlite3JournalModename(eNew);
5536: pOut->n = sqlite3Strlen30(pOut->z);
5537: pOut->enc = SQLITE_UTF8;
5538: sqlite3VdbeChangeEncoding(pOut, encoding);
5539: break;
5540: };
5541: #endif /* SQLITE_OMIT_PRAGMA */
5542:
5543: #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
5544: /* Opcode: Vacuum * * * * *
5545: **
5546: ** Vacuum the entire database. This opcode will cause other virtual
5547: ** machines to be created and run. It may not be called from within
5548: ** a transaction.
5549: */
5550: case OP_Vacuum: {
5551: rc = sqlite3RunVacuum(&p->zErrMsg, db);
5552: break;
5553: }
5554: #endif
5555:
5556: #if !defined(SQLITE_OMIT_AUTOVACUUM)
5557: /* Opcode: IncrVacuum P1 P2 * * *
5558: **
5559: ** Perform a single step of the incremental vacuum procedure on
5560: ** the P1 database. If the vacuum has finished, jump to instruction
5561: ** P2. Otherwise, fall through to the next instruction.
5562: */
5563: case OP_IncrVacuum: { /* jump */
5564: Btree *pBt;
5565:
5566: assert( pOp->p1>=0 && pOp->p1<db->nDb );
5567: assert( (p->btreeMask & (((yDbMask)1)<<pOp->p1))!=0 );
5568: pBt = db->aDb[pOp->p1].pBt;
5569: rc = sqlite3BtreeIncrVacuum(pBt);
5570: if( rc==SQLITE_DONE ){
5571: pc = pOp->p2 - 1;
5572: rc = SQLITE_OK;
5573: }
5574: break;
5575: }
5576: #endif
5577:
5578: /* Opcode: Expire P1 * * * *
5579: **
5580: ** Cause precompiled statements to become expired. An expired statement
5581: ** fails with an error code of SQLITE_SCHEMA if it is ever executed
5582: ** (via sqlite3_step()).
5583: **
5584: ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
5585: ** then only the currently executing statement is affected.
5586: */
5587: case OP_Expire: {
5588: if( !pOp->p1 ){
5589: sqlite3ExpirePreparedStatements(db);
5590: }else{
5591: p->expired = 1;
5592: }
5593: break;
5594: }
5595:
5596: #ifndef SQLITE_OMIT_SHARED_CACHE
5597: /* Opcode: TableLock P1 P2 P3 P4 *
5598: **
5599: ** Obtain a lock on a particular table. This instruction is only used when
5600: ** the shared-cache feature is enabled.
5601: **
5602: ** P1 is the index of the database in sqlite3.aDb[] of the database
5603: ** on which the lock is acquired. A readlock is obtained if P3==0 or
5604: ** a write lock if P3==1.
5605: **
5606: ** P2 contains the root-page of the table to lock.
5607: **
5608: ** P4 contains a pointer to the name of the table being locked. This is only
5609: ** used to generate an error message if the lock cannot be obtained.
5610: */
5611: case OP_TableLock: {
5612: u8 isWriteLock = (u8)pOp->p3;
5613: if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommitted) ){
5614: int p1 = pOp->p1;
5615: assert( p1>=0 && p1<db->nDb );
5616: assert( (p->btreeMask & (((yDbMask)1)<<p1))!=0 );
5617: assert( isWriteLock==0 || isWriteLock==1 );
5618: rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
5619: if( (rc&0xFF)==SQLITE_LOCKED ){
5620: const char *z = pOp->p4.z;
5621: sqlite3SetString(&p->zErrMsg, db, "database table is locked: %s", z);
5622: }
5623: }
5624: break;
5625: }
5626: #endif /* SQLITE_OMIT_SHARED_CACHE */
5627:
5628: #ifndef SQLITE_OMIT_VIRTUALTABLE
5629: /* Opcode: VBegin * * * P4 *
5630: **
5631: ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the
5632: ** xBegin method for that table.
5633: **
5634: ** Also, whether or not P4 is set, check that this is not being called from
5635: ** within a callback to a virtual table xSync() method. If it is, the error
5636: ** code will be set to SQLITE_LOCKED.
5637: */
5638: case OP_VBegin: {
5639: VTable *pVTab;
5640: pVTab = pOp->p4.pVtab;
5641: rc = sqlite3VtabBegin(db, pVTab);
5642: if( pVTab ) importVtabErrMsg(p, pVTab->pVtab);
5643: break;
5644: }
5645: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5646:
5647: #ifndef SQLITE_OMIT_VIRTUALTABLE
5648: /* Opcode: VCreate P1 * * P4 *
5649: **
5650: ** P4 is the name of a virtual table in database P1. Call the xCreate method
5651: ** for that table.
5652: */
5653: case OP_VCreate: {
5654: rc = sqlite3VtabCallCreate(db, pOp->p1, pOp->p4.z, &p->zErrMsg);
5655: break;
5656: }
5657: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5658:
5659: #ifndef SQLITE_OMIT_VIRTUALTABLE
5660: /* Opcode: VDestroy P1 * * P4 *
5661: **
5662: ** P4 is the name of a virtual table in database P1. Call the xDestroy method
5663: ** of that table.
5664: */
5665: case OP_VDestroy: {
5666: p->inVtabMethod = 2;
5667: rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
5668: p->inVtabMethod = 0;
5669: break;
5670: }
5671: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5672:
5673: #ifndef SQLITE_OMIT_VIRTUALTABLE
5674: /* Opcode: VOpen P1 * * P4 *
5675: **
5676: ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
5677: ** P1 is a cursor number. This opcode opens a cursor to the virtual
5678: ** table and stores that cursor in P1.
5679: */
5680: case OP_VOpen: {
5681: VdbeCursor *pCur;
5682: sqlite3_vtab_cursor *pVtabCursor;
5683: sqlite3_vtab *pVtab;
5684: sqlite3_module *pModule;
5685:
5686: pCur = 0;
5687: pVtabCursor = 0;
5688: pVtab = pOp->p4.pVtab->pVtab;
5689: pModule = (sqlite3_module *)pVtab->pModule;
5690: assert(pVtab && pModule);
5691: rc = pModule->xOpen(pVtab, &pVtabCursor);
5692: importVtabErrMsg(p, pVtab);
5693: if( SQLITE_OK==rc ){
5694: /* Initialize sqlite3_vtab_cursor base class */
5695: pVtabCursor->pVtab = pVtab;
5696:
5697: /* Initialise vdbe cursor object */
5698: pCur = allocateCursor(p, pOp->p1, 0, -1, 0);
5699: if( pCur ){
5700: pCur->pVtabCursor = pVtabCursor;
5701: pCur->pModule = pVtabCursor->pVtab->pModule;
5702: }else{
5703: db->mallocFailed = 1;
5704: pModule->xClose(pVtabCursor);
5705: }
5706: }
5707: break;
5708: }
5709: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5710:
5711: #ifndef SQLITE_OMIT_VIRTUALTABLE
5712: /* Opcode: VFilter P1 P2 P3 P4 *
5713: **
5714: ** P1 is a cursor opened using VOpen. P2 is an address to jump to if
5715: ** the filtered result set is empty.
5716: **
5717: ** P4 is either NULL or a string that was generated by the xBestIndex
5718: ** method of the module. The interpretation of the P4 string is left
5719: ** to the module implementation.
5720: **
5721: ** This opcode invokes the xFilter method on the virtual table specified
5722: ** by P1. The integer query plan parameter to xFilter is stored in register
5723: ** P3. Register P3+1 stores the argc parameter to be passed to the
5724: ** xFilter method. Registers P3+2..P3+1+argc are the argc
5725: ** additional parameters which are passed to
5726: ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
5727: **
5728: ** A jump is made to P2 if the result set after filtering would be empty.
5729: */
5730: case OP_VFilter: { /* jump */
5731: int nArg;
5732: int iQuery;
5733: const sqlite3_module *pModule;
5734: Mem *pQuery;
5735: Mem *pArgc;
5736: sqlite3_vtab_cursor *pVtabCursor;
5737: sqlite3_vtab *pVtab;
5738: VdbeCursor *pCur;
5739: int res;
5740: int i;
5741: Mem **apArg;
5742:
5743: pQuery = &aMem[pOp->p3];
5744: pArgc = &pQuery[1];
5745: pCur = p->apCsr[pOp->p1];
5746: assert( memIsValid(pQuery) );
5747: REGISTER_TRACE(pOp->p3, pQuery);
5748: assert( pCur->pVtabCursor );
5749: pVtabCursor = pCur->pVtabCursor;
5750: pVtab = pVtabCursor->pVtab;
5751: pModule = pVtab->pModule;
5752:
5753: /* Grab the index number and argc parameters */
5754: assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
5755: nArg = (int)pArgc->u.i;
5756: iQuery = (int)pQuery->u.i;
5757:
5758: /* Invoke the xFilter method */
5759: {
5760: res = 0;
5761: apArg = p->apArg;
5762: for(i = 0; i<nArg; i++){
5763: apArg[i] = &pArgc[i+1];
5764: sqlite3VdbeMemStoreType(apArg[i]);
5765: }
5766:
5767: p->inVtabMethod = 1;
5768: rc = pModule->xFilter(pVtabCursor, iQuery, pOp->p4.z, nArg, apArg);
5769: p->inVtabMethod = 0;
5770: importVtabErrMsg(p, pVtab);
5771: if( rc==SQLITE_OK ){
5772: res = pModule->xEof(pVtabCursor);
5773: }
5774:
5775: if( res ){
5776: pc = pOp->p2 - 1;
5777: }
5778: }
5779: pCur->nullRow = 0;
5780:
5781: break;
5782: }
5783: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5784:
5785: #ifndef SQLITE_OMIT_VIRTUALTABLE
5786: /* Opcode: VColumn P1 P2 P3 * *
5787: **
5788: ** Store the value of the P2-th column of
5789: ** the row of the virtual-table that the
5790: ** P1 cursor is pointing to into register P3.
5791: */
5792: case OP_VColumn: {
5793: sqlite3_vtab *pVtab;
5794: const sqlite3_module *pModule;
5795: Mem *pDest;
5796: sqlite3_context sContext;
5797:
5798: VdbeCursor *pCur = p->apCsr[pOp->p1];
5799: assert( pCur->pVtabCursor );
5800: assert( pOp->p3>0 && pOp->p3<=p->nMem );
5801: pDest = &aMem[pOp->p3];
5802: memAboutToChange(p, pDest);
5803: if( pCur->nullRow ){
5804: sqlite3VdbeMemSetNull(pDest);
5805: break;
5806: }
5807: pVtab = pCur->pVtabCursor->pVtab;
5808: pModule = pVtab->pModule;
5809: assert( pModule->xColumn );
5810: memset(&sContext, 0, sizeof(sContext));
5811:
5812: /* The output cell may already have a buffer allocated. Move
5813: ** the current contents to sContext.s so in case the user-function
5814: ** can use the already allocated buffer instead of allocating a
5815: ** new one.
5816: */
5817: sqlite3VdbeMemMove(&sContext.s, pDest);
5818: MemSetTypeFlag(&sContext.s, MEM_Null);
5819:
5820: rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
5821: importVtabErrMsg(p, pVtab);
5822: if( sContext.isError ){
5823: rc = sContext.isError;
5824: }
5825:
5826: /* Copy the result of the function to the P3 register. We
5827: ** do this regardless of whether or not an error occurred to ensure any
5828: ** dynamic allocation in sContext.s (a Mem struct) is released.
5829: */
5830: sqlite3VdbeChangeEncoding(&sContext.s, encoding);
5831: sqlite3VdbeMemMove(pDest, &sContext.s);
5832: REGISTER_TRACE(pOp->p3, pDest);
5833: UPDATE_MAX_BLOBSIZE(pDest);
5834:
5835: if( sqlite3VdbeMemTooBig(pDest) ){
5836: goto too_big;
5837: }
5838: break;
5839: }
5840: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5841:
5842: #ifndef SQLITE_OMIT_VIRTUALTABLE
5843: /* Opcode: VNext P1 P2 * * *
5844: **
5845: ** Advance virtual table P1 to the next row in its result set and
5846: ** jump to instruction P2. Or, if the virtual table has reached
5847: ** the end of its result set, then fall through to the next instruction.
5848: */
5849: case OP_VNext: { /* jump */
5850: sqlite3_vtab *pVtab;
5851: const sqlite3_module *pModule;
5852: int res;
5853: VdbeCursor *pCur;
5854:
5855: res = 0;
5856: pCur = p->apCsr[pOp->p1];
5857: assert( pCur->pVtabCursor );
5858: if( pCur->nullRow ){
5859: break;
5860: }
5861: pVtab = pCur->pVtabCursor->pVtab;
5862: pModule = pVtab->pModule;
5863: assert( pModule->xNext );
5864:
5865: /* Invoke the xNext() method of the module. There is no way for the
5866: ** underlying implementation to return an error if one occurs during
5867: ** xNext(). Instead, if an error occurs, true is returned (indicating that
5868: ** data is available) and the error code returned when xColumn or
5869: ** some other method is next invoked on the save virtual table cursor.
5870: */
5871: p->inVtabMethod = 1;
5872: rc = pModule->xNext(pCur->pVtabCursor);
5873: p->inVtabMethod = 0;
5874: importVtabErrMsg(p, pVtab);
5875: if( rc==SQLITE_OK ){
5876: res = pModule->xEof(pCur->pVtabCursor);
5877: }
5878:
5879: if( !res ){
5880: /* If there is data, jump to P2 */
5881: pc = pOp->p2 - 1;
5882: }
5883: break;
5884: }
5885: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5886:
5887: #ifndef SQLITE_OMIT_VIRTUALTABLE
5888: /* Opcode: VRename P1 * * P4 *
5889: **
5890: ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
5891: ** This opcode invokes the corresponding xRename method. The value
5892: ** in register P1 is passed as the zName argument to the xRename method.
5893: */
5894: case OP_VRename: {
5895: sqlite3_vtab *pVtab;
5896: Mem *pName;
5897:
5898: pVtab = pOp->p4.pVtab->pVtab;
5899: pName = &aMem[pOp->p1];
5900: assert( pVtab->pModule->xRename );
5901: assert( memIsValid(pName) );
5902: REGISTER_TRACE(pOp->p1, pName);
5903: assert( pName->flags & MEM_Str );
5904: testcase( pName->enc==SQLITE_UTF8 );
5905: testcase( pName->enc==SQLITE_UTF16BE );
5906: testcase( pName->enc==SQLITE_UTF16LE );
5907: rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8);
5908: if( rc==SQLITE_OK ){
5909: rc = pVtab->pModule->xRename(pVtab, pName->z);
5910: importVtabErrMsg(p, pVtab);
5911: p->expired = 0;
5912: }
5913: break;
5914: }
5915: #endif
5916:
5917: #ifndef SQLITE_OMIT_VIRTUALTABLE
5918: /* Opcode: VUpdate P1 P2 P3 P4 *
5919: **
5920: ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
5921: ** This opcode invokes the corresponding xUpdate method. P2 values
5922: ** are contiguous memory cells starting at P3 to pass to the xUpdate
5923: ** invocation. The value in register (P3+P2-1) corresponds to the
5924: ** p2th element of the argv array passed to xUpdate.
5925: **
5926: ** The xUpdate method will do a DELETE or an INSERT or both.
5927: ** The argv[0] element (which corresponds to memory cell P3)
5928: ** is the rowid of a row to delete. If argv[0] is NULL then no
5929: ** deletion occurs. The argv[1] element is the rowid of the new
5930: ** row. This can be NULL to have the virtual table select the new
5931: ** rowid for itself. The subsequent elements in the array are
5932: ** the values of columns in the new row.
5933: **
5934: ** If P2==1 then no insert is performed. argv[0] is the rowid of
5935: ** a row to delete.
5936: **
5937: ** P1 is a boolean flag. If it is set to true and the xUpdate call
5938: ** is successful, then the value returned by sqlite3_last_insert_rowid()
5939: ** is set to the value of the rowid for the row just inserted.
5940: */
5941: case OP_VUpdate: {
5942: sqlite3_vtab *pVtab;
5943: sqlite3_module *pModule;
5944: int nArg;
5945: int i;
5946: sqlite_int64 rowid;
5947: Mem **apArg;
5948: Mem *pX;
5949:
5950: assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback
5951: || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
5952: );
5953: pVtab = pOp->p4.pVtab->pVtab;
5954: pModule = (sqlite3_module *)pVtab->pModule;
5955: nArg = pOp->p2;
5956: assert( pOp->p4type==P4_VTAB );
5957: if( ALWAYS(pModule->xUpdate) ){
5958: u8 vtabOnConflict = db->vtabOnConflict;
5959: apArg = p->apArg;
5960: pX = &aMem[pOp->p3];
5961: for(i=0; i<nArg; i++){
5962: assert( memIsValid(pX) );
5963: memAboutToChange(p, pX);
5964: sqlite3VdbeMemStoreType(pX);
5965: apArg[i] = pX;
5966: pX++;
5967: }
5968: db->vtabOnConflict = pOp->p5;
5969: rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
5970: db->vtabOnConflict = vtabOnConflict;
5971: importVtabErrMsg(p, pVtab);
5972: if( rc==SQLITE_OK && pOp->p1 ){
5973: assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
5974: db->lastRowid = lastRowid = rowid;
5975: }
5976: if( rc==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
5977: if( pOp->p5==OE_Ignore ){
5978: rc = SQLITE_OK;
5979: }else{
5980: p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
5981: }
5982: }else{
5983: p->nChange++;
5984: }
5985: }
5986: break;
5987: }
5988: #endif /* SQLITE_OMIT_VIRTUALTABLE */
5989:
5990: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
5991: /* Opcode: Pagecount P1 P2 * * *
5992: **
5993: ** Write the current number of pages in database P1 to memory cell P2.
5994: */
5995: case OP_Pagecount: { /* out2-prerelease */
5996: pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
5997: break;
5998: }
5999: #endif
6000:
6001:
6002: #ifndef SQLITE_OMIT_PAGER_PRAGMAS
6003: /* Opcode: MaxPgcnt P1 P2 P3 * *
6004: **
6005: ** Try to set the maximum page count for database P1 to the value in P3.
6006: ** Do not let the maximum page count fall below the current page count and
6007: ** do not change the maximum page count value if P3==0.
6008: **
6009: ** Store the maximum page count after the change in register P2.
6010: */
6011: case OP_MaxPgcnt: { /* out2-prerelease */
6012: unsigned int newMax;
6013: Btree *pBt;
6014:
6015: pBt = db->aDb[pOp->p1].pBt;
6016: newMax = 0;
6017: if( pOp->p3 ){
6018: newMax = sqlite3BtreeLastPage(pBt);
6019: if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
6020: }
6021: pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
6022: break;
6023: }
6024: #endif
6025:
6026:
6027: #ifndef SQLITE_OMIT_TRACE
6028: /* Opcode: Trace * * * P4 *
6029: **
6030: ** If tracing is enabled (by the sqlite3_trace()) interface, then
6031: ** the UTF-8 string contained in P4 is emitted on the trace callback.
6032: */
6033: case OP_Trace: {
6034: char *zTrace;
6035: char *z;
6036:
6037: if( db->xTrace && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 ){
6038: z = sqlite3VdbeExpandSql(p, zTrace);
6039: db->xTrace(db->pTraceArg, z);
6040: sqlite3DbFree(db, z);
6041: }
6042: #ifdef SQLITE_DEBUG
6043: if( (db->flags & SQLITE_SqlTrace)!=0
6044: && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
6045: ){
6046: sqlite3DebugPrintf("SQL-trace: %s\n", zTrace);
6047: }
6048: #endif /* SQLITE_DEBUG */
6049: break;
6050: }
6051: #endif
6052:
6053:
6054: /* Opcode: Noop * * * * *
6055: **
6056: ** Do nothing. This instruction is often useful as a jump
6057: ** destination.
6058: */
6059: /*
6060: ** The magic Explain opcode are only inserted when explain==2 (which
6061: ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
6062: ** This opcode records information from the optimizer. It is the
6063: ** the same as a no-op. This opcodesnever appears in a real VM program.
6064: */
6065: default: { /* This is really OP_Noop and OP_Explain */
6066: assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
6067: break;
6068: }
6069:
6070: /*****************************************************************************
6071: ** The cases of the switch statement above this line should all be indented
6072: ** by 6 spaces. But the left-most 6 spaces have been removed to improve the
6073: ** readability. From this point on down, the normal indentation rules are
6074: ** restored.
6075: *****************************************************************************/
6076: }
6077:
6078: #ifdef VDBE_PROFILE
6079: {
6080: u64 elapsed = sqlite3Hwtime() - start;
6081: pOp->cycles += elapsed;
6082: pOp->cnt++;
6083: #if 0
6084: fprintf(stdout, "%10llu ", elapsed);
6085: sqlite3VdbePrintOp(stdout, origPc, &aOp[origPc]);
6086: #endif
6087: }
6088: #endif
6089:
6090: /* The following code adds nothing to the actual functionality
6091: ** of the program. It is only here for testing and debugging.
6092: ** On the other hand, it does burn CPU cycles every time through
6093: ** the evaluator loop. So we can leave it out when NDEBUG is defined.
6094: */
6095: #ifndef NDEBUG
6096: assert( pc>=-1 && pc<p->nOp );
6097:
6098: #ifdef SQLITE_DEBUG
6099: if( p->trace ){
6100: if( rc!=0 ) fprintf(p->trace,"rc=%d\n",rc);
6101: if( pOp->opflags & (OPFLG_OUT2_PRERELEASE|OPFLG_OUT2) ){
6102: registerTrace(p->trace, pOp->p2, &aMem[pOp->p2]);
6103: }
6104: if( pOp->opflags & OPFLG_OUT3 ){
6105: registerTrace(p->trace, pOp->p3, &aMem[pOp->p3]);
6106: }
6107: }
6108: #endif /* SQLITE_DEBUG */
6109: #endif /* NDEBUG */
6110: } /* The end of the for(;;) loop the loops through opcodes */
6111:
6112: /* If we reach this point, it means that execution is finished with
6113: ** an error of some kind.
6114: */
6115: vdbe_error_halt:
6116: assert( rc );
6117: p->rc = rc;
6118: testcase( sqlite3GlobalConfig.xLog!=0 );
6119: sqlite3_log(rc, "statement aborts at %d: [%s] %s",
6120: pc, p->zSql, p->zErrMsg);
6121: sqlite3VdbeHalt(p);
6122: if( rc==SQLITE_IOERR_NOMEM ) db->mallocFailed = 1;
6123: rc = SQLITE_ERROR;
6124: if( resetSchemaOnFault>0 ){
6125: sqlite3ResetInternalSchema(db, resetSchemaOnFault-1);
6126: }
6127:
6128: /* This is the only way out of this procedure. We have to
6129: ** release the mutexes on btrees that were acquired at the
6130: ** top. */
6131: vdbe_return:
6132: db->lastRowid = lastRowid;
6133: sqlite3VdbeLeave(p);
6134: return rc;
6135:
6136: /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
6137: ** is encountered.
6138: */
6139: too_big:
6140: sqlite3SetString(&p->zErrMsg, db, "string or blob too big");
6141: rc = SQLITE_TOOBIG;
6142: goto vdbe_error_halt;
6143:
6144: /* Jump to here if a malloc() fails.
6145: */
6146: no_mem:
6147: db->mallocFailed = 1;
6148: sqlite3SetString(&p->zErrMsg, db, "out of memory");
6149: rc = SQLITE_NOMEM;
6150: goto vdbe_error_halt;
6151:
6152: /* Jump to here for any other kind of fatal error. The "rc" variable
6153: ** should hold the error number.
6154: */
6155: abort_due_to_error:
6156: assert( p->zErrMsg==0 );
6157: if( db->mallocFailed ) rc = SQLITE_NOMEM;
6158: if( rc!=SQLITE_IOERR_NOMEM ){
6159: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
6160: }
6161: goto vdbe_error_halt;
6162:
6163: /* Jump to here if the sqlite3_interrupt() API sets the interrupt
6164: ** flag.
6165: */
6166: abort_due_to_interrupt:
6167: assert( db->u1.isInterrupted );
6168: rc = SQLITE_INTERRUPT;
6169: p->rc = rc;
6170: sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3ErrStr(rc));
6171: goto vdbe_error_halt;
6172: }
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 / sqlite3 / src