| /* |
| ** 2001 September 15 |
| ** |
| ** The author disclaims copyright to this source code. In place of |
| ** a legal notice, here is a blessing: |
| ** |
| ** May you do good and not evil. |
| ** May you find forgiveness for yourself and forgive others. |
| ** May you share freely, never taking more than you give. |
| ** |
| ************************************************************************* |
| ** The code in this file implements the function that runs the |
| ** bytecode of a prepared statement. |
| ** |
| ** Various scripts scan this source file in order to generate HTML |
| ** documentation, headers files, or other derived files. The formatting |
| ** of the code in this file is, therefore, important. See other comments |
| ** in this file for details. If in doubt, do not deviate from existing |
| ** commenting and indentation practices when changing or adding code. |
| */ |
| #include "sqliteInt.h" |
| #include "vdbeInt.h" |
| |
| /* |
| ** Invoke this macro on memory cells just prior to changing the |
| ** value of the cell. This macro verifies that shallow copies are |
| ** not misused. A shallow copy of a string or blob just copies a |
| ** pointer to the string or blob, not the content. If the original |
| ** is changed while the copy is still in use, the string or blob might |
| ** be changed out from under the copy. This macro verifies that nothing |
| ** like that ever happens. |
| */ |
| #ifdef SQLITE_DEBUG |
| # define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M) |
| #else |
| # define memAboutToChange(P,M) |
| #endif |
| |
| /* |
| ** The following global variable is incremented every time a cursor |
| ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes. The test |
| ** procedures use this information to make sure that indices are |
| ** working correctly. This variable has no function other than to |
| ** help verify the correct operation of the library. |
| */ |
| #ifdef SQLITE_TEST |
| int sqlite3_search_count = 0; |
| #endif |
| |
| /* |
| ** When this global variable is positive, it gets decremented once before |
| ** each instruction in the VDBE. When it reaches zero, the u1.isInterrupted |
| ** field of the sqlite3 structure is set in order to simulate an interrupt. |
| ** |
| ** This facility is used for testing purposes only. It does not function |
| ** in an ordinary build. |
| */ |
| #ifdef SQLITE_TEST |
| int sqlite3_interrupt_count = 0; |
| #endif |
| |
| /* |
| ** The next global variable is incremented each type the OP_Sort opcode |
| ** is executed. The test procedures use this information to make sure that |
| ** sorting is occurring or not occurring at appropriate times. This variable |
| ** has no function other than to help verify the correct operation of the |
| ** library. |
| */ |
| #ifdef SQLITE_TEST |
| int sqlite3_sort_count = 0; |
| #endif |
| |
| /* |
| ** The next global variable records the size of the largest MEM_Blob |
| ** or MEM_Str that has been used by a VDBE opcode. The test procedures |
| ** use this information to make sure that the zero-blob functionality |
| ** is working correctly. This variable has no function other than to |
| ** help verify the correct operation of the library. |
| */ |
| #ifdef SQLITE_TEST |
| int sqlite3_max_blobsize = 0; |
| static void updateMaxBlobsize(Mem *p){ |
| if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){ |
| sqlite3_max_blobsize = p->n; |
| } |
| } |
| #endif |
| |
| /* |
| ** This macro evaluates to true if either the update hook or the preupdate |
| ** hook are enabled for database connect DB. |
| */ |
| #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
| # define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback) |
| #else |
| # define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback) |
| #endif |
| |
| /* |
| ** The next global variable is incremented each time the OP_Found opcode |
| ** is executed. This is used to test whether or not the foreign key |
| ** operation implemented using OP_FkIsZero is working. This variable |
| ** has no function other than to help verify the correct operation of the |
| ** library. |
| */ |
| #ifdef SQLITE_TEST |
| int sqlite3_found_count = 0; |
| #endif |
| |
| /* |
| ** Test a register to see if it exceeds the current maximum blob size. |
| ** If it does, record the new maximum blob size. |
| */ |
| #if defined(SQLITE_TEST) && !defined(SQLITE_UNTESTABLE) |
| # define UPDATE_MAX_BLOBSIZE(P) updateMaxBlobsize(P) |
| #else |
| # define UPDATE_MAX_BLOBSIZE(P) |
| #endif |
| |
| /* |
| ** Invoke the VDBE coverage callback, if that callback is defined. This |
| ** feature is used for test suite validation only and does not appear an |
| ** production builds. |
| ** |
| ** M is an integer between 2 and 4. 2 indicates a ordinary two-way |
| ** branch (I=0 means fall through and I=1 means taken). 3 indicates |
| ** a 3-way branch where the third way is when one of the operands is |
| ** NULL. 4 indicates the OP_Jump instruction which has three destinations |
| ** depending on whether the first operand is less than, equal to, or greater |
| ** than the second. |
| ** |
| ** iSrcLine is the source code line (from the __LINE__ macro) that |
| ** generated the VDBE instruction combined with flag bits. The source |
| ** code line number is in the lower 24 bits of iSrcLine and the upper |
| ** 8 bytes are flags. The lower three bits of the flags indicate |
| ** values for I that should never occur. For example, if the branch is |
| ** always taken, the flags should be 0x05 since the fall-through and |
| ** alternate branch are never taken. If a branch is never taken then |
| ** flags should be 0x06 since only the fall-through approach is allowed. |
| ** |
| ** Bit 0x04 of the flags indicates an OP_Jump opcode that is only |
| ** interested in equal or not-equal. In other words, I==0 and I==2 |
| ** should be treated the same. |
| ** |
| ** Since only a line number is retained, not the filename, this macro |
| ** only works for amalgamation builds. But that is ok, since these macros |
| ** should be no-ops except for special builds used to measure test coverage. |
| */ |
| #if !defined(SQLITE_VDBE_COVERAGE) |
| # define VdbeBranchTaken(I,M) |
| #else |
| # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M) |
| static void vdbeTakeBranch(u32 iSrcLine, u8 I, u8 M){ |
| u8 mNever; |
| assert( I<=2 ); /* 0: fall through, 1: taken, 2: alternate taken */ |
| assert( M<=4 ); /* 2: two-way branch, 3: three-way branch, 4: OP_Jump */ |
| assert( I<M ); /* I can only be 2 if M is 3 or 4 */ |
| /* Transform I from a integer [0,1,2] into a bitmask of [1,2,4] */ |
| I = 1<<I; |
| /* The upper 8 bits of iSrcLine are flags. The lower three bits of |
| ** the flags indicate directions that the branch can never go. If |
| ** a branch really does go in one of those directions, assert right |
| ** away. */ |
| mNever = iSrcLine >> 24; |
| assert( (I & mNever)==0 ); |
| if( sqlite3GlobalConfig.xVdbeBranch==0 ) return; /*NO_TEST*/ |
| I |= mNever; |
| if( M==2 ) I |= 0x04; |
| if( M==4 ){ |
| I |= 0x08; |
| if( (mNever&0x08)!=0 && (I&0x05)!=0) I |= 0x05; /*NO_TEST*/ |
| } |
| sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg, |
| iSrcLine&0xffffff, I, M); |
| } |
| #endif |
| |
| /* |
| ** Convert the given register into a string if it isn't one |
| ** already. Return non-zero if a malloc() fails. |
| */ |
| #define Stringify(P, enc) \ |
| if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc,0)) \ |
| { goto no_mem; } |
| |
| /* |
| ** An ephemeral string value (signified by the MEM_Ephem flag) contains |
| ** a pointer to a dynamically allocated string where some other entity |
| ** is responsible for deallocating that string. Because the register |
| ** does not control the string, it might be deleted without the register |
| ** knowing it. |
| ** |
| ** This routine converts an ephemeral string into a dynamically allocated |
| ** string that the register itself controls. In other words, it |
| ** converts an MEM_Ephem string into a string with P.z==P.zMalloc. |
| */ |
| #define Deephemeralize(P) \ |
| if( ((P)->flags&MEM_Ephem)!=0 \ |
| && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;} |
| |
| /* Return true if the cursor was opened using the OP_OpenSorter opcode. */ |
| #define isSorter(x) ((x)->eCurType==CURTYPE_SORTER) |
| |
| /* |
| ** Allocate VdbeCursor number iCur. Return a pointer to it. Return NULL |
| ** if we run out of memory. |
| */ |
| static VdbeCursor *allocateCursor( |
| Vdbe *p, /* The virtual machine */ |
| int iCur, /* Index of the new VdbeCursor */ |
| int nField, /* Number of fields in the table or index */ |
| int iDb, /* Database the cursor belongs to, or -1 */ |
| u8 eCurType /* Type of the new cursor */ |
| ){ |
| /* Find the memory cell that will be used to store the blob of memory |
| ** required for this VdbeCursor structure. It is convenient to use a |
| ** vdbe memory cell to manage the memory allocation required for a |
| ** VdbeCursor structure for the following reasons: |
| ** |
| ** * Sometimes cursor numbers are used for a couple of different |
| ** purposes in a vdbe program. The different uses might require |
| ** different sized allocations. Memory cells provide growable |
| ** allocations. |
| ** |
| ** * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can |
| ** be freed lazily via the sqlite3_release_memory() API. This |
| ** minimizes the number of malloc calls made by the system. |
| ** |
| ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from |
| ** the top of the register space. Cursor 1 is at Mem[p->nMem-1]. |
| ** Cursor 2 is at Mem[p->nMem-2]. And so forth. |
| */ |
| Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem; |
| |
| int nByte; |
| VdbeCursor *pCx = 0; |
| nByte = |
| ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField + |
| (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0); |
| |
| assert( iCur>=0 && iCur<p->nCursor ); |
| if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/ |
| /* Before calling sqlite3VdbeFreeCursor(), ensure the isEphemeral flag |
| ** is clear. Otherwise, if this is an ephemeral cursor created by |
| ** OP_OpenDup, the cursor will not be closed and will still be part |
| ** of a BtShared.pCursor list. */ |
| p->apCsr[iCur]->isEphemeral = 0; |
| sqlite3VdbeFreeCursor(p, p->apCsr[iCur]); |
| p->apCsr[iCur] = 0; |
| } |
| if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){ |
| p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z; |
| memset(pCx, 0, offsetof(VdbeCursor,pAltCursor)); |
| pCx->eCurType = eCurType; |
| pCx->iDb = iDb; |
| pCx->nField = nField; |
| pCx->aOffset = &pCx->aType[nField]; |
| if( eCurType==CURTYPE_BTREE ){ |
| pCx->uc.pCursor = (BtCursor*) |
| &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField]; |
| sqlite3BtreeCursorZero(pCx->uc.pCursor); |
| } |
| } |
| return pCx; |
| } |
| |
| /* |
| ** Try to convert a value into a numeric representation if we can |
| ** do so without loss of information. In other words, if the string |
| ** looks like a number, convert it into a number. If it does not |
| ** look like a number, leave it alone. |
| ** |
| ** If the bTryForInt flag is true, then extra effort is made to give |
| ** an integer representation. Strings that look like floating point |
| ** values but which have no fractional component (example: '48.00') |
| ** will have a MEM_Int representation when bTryForInt is true. |
| ** |
| ** If bTryForInt is false, then if the input string contains a decimal |
| ** point or exponential notation, the result is only MEM_Real, even |
| ** if there is an exact integer representation of the quantity. |
| */ |
| static void applyNumericAffinity(Mem *pRec, int bTryForInt){ |
| double rValue; |
| i64 iValue; |
| u8 enc = pRec->enc; |
| assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str ); |
| if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return; |
| if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){ |
| pRec->u.i = iValue; |
| pRec->flags |= MEM_Int; |
| }else{ |
| pRec->u.r = rValue; |
| pRec->flags |= MEM_Real; |
| if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec); |
| } |
| /* TEXT->NUMERIC is many->one. Hence, it is important to invalidate the |
| ** string representation after computing a numeric equivalent, because the |
| ** string representation might not be the canonical representation for the |
| ** numeric value. Ticket [343634942dd54ab57b7024] 2018-01-31. */ |
| pRec->flags &= ~MEM_Str; |
| } |
| |
| /* |
| ** Processing is determine by the affinity parameter: |
| ** |
| ** SQLITE_AFF_INTEGER: |
| ** SQLITE_AFF_REAL: |
| ** SQLITE_AFF_NUMERIC: |
| ** Try to convert pRec to an integer representation or a |
| ** floating-point representation if an integer representation |
| ** is not possible. Note that the integer representation is |
| ** always preferred, even if the affinity is REAL, because |
| ** an integer representation is more space efficient on disk. |
| ** |
| ** SQLITE_AFF_TEXT: |
| ** Convert pRec to a text representation. |
| ** |
| ** SQLITE_AFF_BLOB: |
| ** No-op. pRec is unchanged. |
| */ |
| static void applyAffinity( |
| Mem *pRec, /* The value to apply affinity to */ |
| char affinity, /* The affinity to be applied */ |
| u8 enc /* Use this text encoding */ |
| ){ |
| if( affinity>=SQLITE_AFF_NUMERIC ){ |
| assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL |
| || affinity==SQLITE_AFF_NUMERIC ); |
| if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/ |
| if( (pRec->flags & MEM_Real)==0 ){ |
| if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1); |
| }else{ |
| sqlite3VdbeIntegerAffinity(pRec); |
| } |
| } |
| }else if( affinity==SQLITE_AFF_TEXT ){ |
| /* Only attempt the conversion to TEXT if there is an integer or real |
| ** representation (blob and NULL do not get converted) but no string |
| ** representation. It would be harmless to repeat the conversion if |
| ** there is already a string rep, but it is pointless to waste those |
| ** CPU cycles. */ |
| if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/ |
| if( (pRec->flags&(MEM_Real|MEM_Int)) ){ |
| sqlite3VdbeMemStringify(pRec, enc, 1); |
| } |
| } |
| pRec->flags &= ~(MEM_Real|MEM_Int); |
| } |
| } |
| |
| /* |
| ** Try to convert the type of a function argument or a result column |
| ** into a numeric representation. Use either INTEGER or REAL whichever |
| ** is appropriate. But only do the conversion if it is possible without |
| ** loss of information and return the revised type of the argument. |
| */ |
| int sqlite3_value_numeric_type(sqlite3_value *pVal){ |
| int eType = sqlite3_value_type(pVal); |
| if( eType==SQLITE_TEXT ){ |
| Mem *pMem = (Mem*)pVal; |
| applyNumericAffinity(pMem, 0); |
| eType = sqlite3_value_type(pVal); |
| } |
| return eType; |
| } |
| |
| /* |
| ** Exported version of applyAffinity(). This one works on sqlite3_value*, |
| ** not the internal Mem* type. |
| */ |
| void sqlite3ValueApplyAffinity( |
| sqlite3_value *pVal, |
| u8 affinity, |
| u8 enc |
| ){ |
| applyAffinity((Mem *)pVal, affinity, enc); |
| } |
| |
| /* |
| ** pMem currently only holds a string type (or maybe a BLOB that we can |
| ** interpret as a string if we want to). Compute its corresponding |
| ** numeric type, if has one. Set the pMem->u.r and pMem->u.i fields |
| ** accordingly. |
| */ |
| static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){ |
| assert( (pMem->flags & (MEM_Int|MEM_Real))==0 ); |
| assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 ); |
| ExpandBlob(pMem); |
| if( sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc)==0 ){ |
| return 0; |
| } |
| if( sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc)==0 ){ |
| return MEM_Int; |
| } |
| return MEM_Real; |
| } |
| |
| /* |
| ** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or |
| ** none. |
| ** |
| ** Unlike applyNumericAffinity(), this routine does not modify pMem->flags. |
| ** But it does set pMem->u.r and pMem->u.i appropriately. |
| */ |
| static u16 numericType(Mem *pMem){ |
| if( pMem->flags & (MEM_Int|MEM_Real) ){ |
| return pMem->flags & (MEM_Int|MEM_Real); |
| } |
| if( pMem->flags & (MEM_Str|MEM_Blob) ){ |
| return computeNumericType(pMem); |
| } |
| return 0; |
| } |
| |
| #ifdef SQLITE_DEBUG |
| /* |
| ** Write a nice string representation of the contents of cell pMem |
| ** into buffer zBuf, length nBuf. |
| */ |
| void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){ |
| char *zCsr = zBuf; |
| int f = pMem->flags; |
| |
| static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"}; |
| |
| if( f&MEM_Blob ){ |
| int i; |
| char c; |
| if( f & MEM_Dyn ){ |
| c = 'z'; |
| assert( (f & (MEM_Static|MEM_Ephem))==0 ); |
| }else if( f & MEM_Static ){ |
| c = 't'; |
| assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); |
| }else if( f & MEM_Ephem ){ |
| c = 'e'; |
| assert( (f & (MEM_Static|MEM_Dyn))==0 ); |
| }else{ |
| c = 's'; |
| } |
| *(zCsr++) = c; |
| sqlite3_snprintf(100, zCsr, "%d[", pMem->n); |
| zCsr += sqlite3Strlen30(zCsr); |
| for(i=0; i<16 && i<pMem->n; i++){ |
| sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF)); |
| zCsr += sqlite3Strlen30(zCsr); |
| } |
| for(i=0; i<16 && i<pMem->n; i++){ |
| char z = pMem->z[i]; |
| if( z<32 || z>126 ) *zCsr++ = '.'; |
| else *zCsr++ = z; |
| } |
| *(zCsr++) = ']'; |
| if( f & MEM_Zero ){ |
| sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero); |
| zCsr += sqlite3Strlen30(zCsr); |
| } |
| *zCsr = '\0'; |
| }else if( f & MEM_Str ){ |
| int j, k; |
| zBuf[0] = ' '; |
| if( f & MEM_Dyn ){ |
| zBuf[1] = 'z'; |
| assert( (f & (MEM_Static|MEM_Ephem))==0 ); |
| }else if( f & MEM_Static ){ |
| zBuf[1] = 't'; |
| assert( (f & (MEM_Dyn|MEM_Ephem))==0 ); |
| }else if( f & MEM_Ephem ){ |
| zBuf[1] = 'e'; |
| assert( (f & (MEM_Static|MEM_Dyn))==0 ); |
| }else{ |
| zBuf[1] = 's'; |
| } |
| k = 2; |
| sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n); |
| k += sqlite3Strlen30(&zBuf[k]); |
| zBuf[k++] = '['; |
| for(j=0; j<15 && j<pMem->n; j++){ |
| u8 c = pMem->z[j]; |
| if( c>=0x20 && c<0x7f ){ |
| zBuf[k++] = c; |
| }else{ |
| zBuf[k++] = '.'; |
| } |
| } |
| zBuf[k++] = ']'; |
| sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]); |
| k += sqlite3Strlen30(&zBuf[k]); |
| zBuf[k++] = 0; |
| } |
| } |
| #endif |
| |
| #ifdef SQLITE_DEBUG |
| /* |
| ** Print the value of a register for tracing purposes: |
| */ |
| static void memTracePrint(Mem *p){ |
| if( p->flags & MEM_Undefined ){ |
| printf(" undefined"); |
| }else if( p->flags & MEM_Null ){ |
| printf(p->flags & MEM_Zero ? " NULL-nochng" : " NULL"); |
| }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){ |
| printf(" si:%lld", p->u.i); |
| }else if( p->flags & MEM_Int ){ |
| printf(" i:%lld", p->u.i); |
| #ifndef SQLITE_OMIT_FLOATING_POINT |
| }else if( p->flags & MEM_Real ){ |
| printf(" r:%g", p->u.r); |
| #endif |
| }else if( sqlite3VdbeMemIsRowSet(p) ){ |
| printf(" (rowset)"); |
| }else{ |
| char zBuf[200]; |
| sqlite3VdbeMemPrettyPrint(p, zBuf); |
| printf(" %s", zBuf); |
| } |
| if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype); |
| } |
| static void registerTrace(int iReg, Mem *p){ |
| printf("REG[%d] = ", iReg); |
| memTracePrint(p); |
| printf("\n"); |
| sqlite3VdbeCheckMemInvariants(p); |
| } |
| #endif |
| |
| #ifdef SQLITE_DEBUG |
| # define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M) |
| #else |
| # define REGISTER_TRACE(R,M) |
| #endif |
| |
| |
| #ifdef VDBE_PROFILE |
| |
| /* |
| ** hwtime.h contains inline assembler code for implementing |
| ** high-performance timing routines. |
| */ |
| #include "hwtime.h" |
| |
| #endif |
| |
| #ifndef NDEBUG |
| /* |
| ** This function is only called from within an assert() expression. It |
| ** checks that the sqlite3.nTransaction variable is correctly set to |
| ** the number of non-transaction savepoints currently in the |
| ** linked list starting at sqlite3.pSavepoint. |
| ** |
| ** Usage: |
| ** |
| ** assert( checkSavepointCount(db) ); |
| */ |
| static int checkSavepointCount(sqlite3 *db){ |
| int n = 0; |
| Savepoint *p; |
| for(p=db->pSavepoint; p; p=p->pNext) n++; |
| assert( n==(db->nSavepoint + db->isTransactionSavepoint) ); |
| return 1; |
| } |
| #endif |
| |
| /* |
| ** Return the register of pOp->p2 after first preparing it to be |
| ** overwritten with an integer value. |
| */ |
| static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){ |
| sqlite3VdbeMemSetNull(pOut); |
| pOut->flags = MEM_Int; |
| return pOut; |
| } |
| static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){ |
| Mem *pOut; |
| assert( pOp->p2>0 ); |
| assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); |
| pOut = &p->aMem[pOp->p2]; |
| memAboutToChange(p, pOut); |
| if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/ |
| return out2PrereleaseWithClear(pOut); |
| }else{ |
| pOut->flags = MEM_Int; |
| return pOut; |
| } |
| } |
| |
| |
| /* |
| ** Execute as much of a VDBE program as we can. |
| ** This is the core of sqlite3_step(). |
| */ |
| int sqlite3VdbeExec( |
| Vdbe *p /* The VDBE */ |
| ){ |
| Op *aOp = p->aOp; /* Copy of p->aOp */ |
| Op *pOp = aOp; /* Current operation */ |
| #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) |
| Op *pOrigOp; /* Value of pOp at the top of the loop */ |
| #endif |
| #ifdef SQLITE_DEBUG |
| int nExtraDelete = 0; /* Verifies FORDELETE and AUXDELETE flags */ |
| #endif |
| int rc = SQLITE_OK; /* Value to return */ |
| sqlite3 *db = p->db; /* The database */ |
| u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */ |
| u8 encoding = ENC(db); /* The database encoding */ |
| int iCompare = 0; /* Result of last comparison */ |
| unsigned nVmStep = 0; /* Number of virtual machine steps */ |
| #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
| unsigned nProgressLimit; /* Invoke xProgress() when nVmStep reaches this */ |
| #endif |
| Mem *aMem = p->aMem; /* Copy of p->aMem */ |
| Mem *pIn1 = 0; /* 1st input operand */ |
| Mem *pIn2 = 0; /* 2nd input operand */ |
| Mem *pIn3 = 0; /* 3rd input operand */ |
| Mem *pOut = 0; /* Output operand */ |
| #ifdef VDBE_PROFILE |
| u64 start; /* CPU clock count at start of opcode */ |
| #endif |
| /*** INSERT STACK UNION HERE ***/ |
| |
| assert( p->magic==VDBE_MAGIC_RUN ); /* sqlite3_step() verifies this */ |
| sqlite3VdbeEnter(p); |
| if( p->rc==SQLITE_NOMEM ){ |
| /* This happens if a malloc() inside a call to sqlite3_column_text() or |
| ** sqlite3_column_text16() failed. */ |
| goto no_mem; |
| } |
| assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY ); |
| assert( p->bIsReader || p->readOnly!=0 ); |
| p->iCurrentTime = 0; |
| assert( p->explain==0 ); |
| p->pResultSet = 0; |
| db->busyHandler.nBusy = 0; |
| if( db->u1.isInterrupted ) goto abort_due_to_interrupt; |
| sqlite3VdbeIOTraceSql(p); |
| #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
| if( db->xProgress ){ |
| u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP]; |
| assert( 0 < db->nProgressOps ); |
| nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps); |
| }else{ |
| nProgressLimit = 0xffffffff; |
| } |
| #endif |
| #ifdef SQLITE_DEBUG |
| sqlite3BeginBenignMalloc(); |
| if( p->pc==0 |
| && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0 |
| ){ |
| int i; |
| int once = 1; |
| sqlite3VdbePrintSql(p); |
| if( p->db->flags & SQLITE_VdbeListing ){ |
| printf("VDBE Program Listing:\n"); |
| for(i=0; i<p->nOp; i++){ |
| sqlite3VdbePrintOp(stdout, i, &aOp[i]); |
| } |
| } |
| if( p->db->flags & SQLITE_VdbeEQP ){ |
| for(i=0; i<p->nOp; i++){ |
| if( aOp[i].opcode==OP_Explain ){ |
| if( once ) printf("VDBE Query Plan:\n"); |
| printf("%s\n", aOp[i].p4.z); |
| once = 0; |
| } |
| } |
| } |
| if( p->db->flags & SQLITE_VdbeTrace ) printf("VDBE Trace:\n"); |
| } |
| sqlite3EndBenignMalloc(); |
| #endif |
| for(pOp=&aOp[p->pc]; 1; pOp++){ |
| /* Errors are detected by individual opcodes, with an immediate |
| ** jumps to abort_due_to_error. */ |
| assert( rc==SQLITE_OK ); |
| |
| assert( pOp>=aOp && pOp<&aOp[p->nOp]); |
| #ifdef VDBE_PROFILE |
| start = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); |
| #endif |
| nVmStep++; |
| #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
| if( p->anExec ) p->anExec[(int)(pOp-aOp)]++; |
| #endif |
| |
| /* Only allow tracing if SQLITE_DEBUG is defined. |
| */ |
| #ifdef SQLITE_DEBUG |
| if( db->flags & SQLITE_VdbeTrace ){ |
| sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp); |
| } |
| #endif |
| |
| |
| /* Check to see if we need to simulate an interrupt. This only happens |
| ** if we have a special test build. |
| */ |
| #ifdef SQLITE_TEST |
| if( sqlite3_interrupt_count>0 ){ |
| sqlite3_interrupt_count--; |
| if( sqlite3_interrupt_count==0 ){ |
| sqlite3_interrupt(db); |
| } |
| } |
| #endif |
| |
| /* Sanity checking on other operands */ |
| #ifdef SQLITE_DEBUG |
| { |
| u8 opProperty = sqlite3OpcodeProperty[pOp->opcode]; |
| if( (opProperty & OPFLG_IN1)!=0 ){ |
| assert( pOp->p1>0 ); |
| assert( pOp->p1<=(p->nMem+1 - p->nCursor) ); |
| assert( memIsValid(&aMem[pOp->p1]) ); |
| assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) ); |
| REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]); |
| } |
| if( (opProperty & OPFLG_IN2)!=0 ){ |
| assert( pOp->p2>0 ); |
| assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); |
| assert( memIsValid(&aMem[pOp->p2]) ); |
| assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) ); |
| REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]); |
| } |
| if( (opProperty & OPFLG_IN3)!=0 ){ |
| assert( pOp->p3>0 ); |
| assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| assert( memIsValid(&aMem[pOp->p3]) ); |
| assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) ); |
| REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]); |
| } |
| if( (opProperty & OPFLG_OUT2)!=0 ){ |
| assert( pOp->p2>0 ); |
| assert( pOp->p2<=(p->nMem+1 - p->nCursor) ); |
| memAboutToChange(p, &aMem[pOp->p2]); |
| } |
| if( (opProperty & OPFLG_OUT3)!=0 ){ |
| assert( pOp->p3>0 ); |
| assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| memAboutToChange(p, &aMem[pOp->p3]); |
| } |
| } |
| #endif |
| #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE) |
| pOrigOp = pOp; |
| #endif |
| |
| switch( pOp->opcode ){ |
| |
| /***************************************************************************** |
| ** What follows is a massive switch statement where each case implements a |
| ** separate instruction in the virtual machine. If we follow the usual |
| ** indentation conventions, each case should be indented by 6 spaces. But |
| ** that is a lot of wasted space on the left margin. So the code within |
| ** the switch statement will break with convention and be flush-left. Another |
| ** big comment (similar to this one) will mark the point in the code where |
| ** we transition back to normal indentation. |
| ** |
| ** The formatting of each case is important. The makefile for SQLite |
| ** generates two C files "opcodes.h" and "opcodes.c" by scanning this |
| ** file looking for lines that begin with "case OP_". The opcodes.h files |
| ** will be filled with #defines that give unique integer values to each |
| ** opcode and the opcodes.c file is filled with an array of strings where |
| ** each string is the symbolic name for the corresponding opcode. If the |
| ** case statement is followed by a comment of the form "/# same as ... #/" |
| ** that comment is used to determine the particular value of the opcode. |
| ** |
| ** Other keywords in the comment that follows each case are used to |
| ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[]. |
| ** Keywords include: in1, in2, in3, out2, out3. See |
| ** the mkopcodeh.awk script for additional information. |
| ** |
| ** Documentation about VDBE opcodes is generated by scanning this file |
| ** for lines of that contain "Opcode:". That line and all subsequent |
| ** comment lines are used in the generation of the opcode.html documentation |
| ** file. |
| ** |
| ** SUMMARY: |
| ** |
| ** Formatting is important to scripts that scan this file. |
| ** Do not deviate from the formatting style currently in use. |
| ** |
| *****************************************************************************/ |
| |
| /* Opcode: Goto * P2 * * * |
| ** |
| ** An unconditional jump to address P2. |
| ** The next instruction executed will be |
| ** the one at index P2 from the beginning of |
| ** the program. |
| ** |
| ** The P1 parameter is not actually used by this opcode. However, it |
| ** is sometimes set to 1 instead of 0 as a hint to the command-line shell |
| ** that this Goto is the bottom of a loop and that the lines from P2 down |
| ** to the current line should be indented for EXPLAIN output. |
| */ |
| case OP_Goto: { /* jump */ |
| jump_to_p2_and_check_for_interrupt: |
| pOp = &aOp[pOp->p2 - 1]; |
| |
| /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev, |
| ** OP_VNext, or OP_SorterNext) all jump here upon |
| ** completion. Check to see if sqlite3_interrupt() has been called |
| ** or if the progress callback needs to be invoked. |
| ** |
| ** This code uses unstructured "goto" statements and does not look clean. |
| ** But that is not due to sloppy coding habits. The code is written this |
| ** way for performance, to avoid having to run the interrupt and progress |
| ** checks on every opcode. This helps sqlite3_step() to run about 1.5% |
| ** faster according to "valgrind --tool=cachegrind" */ |
| check_for_interrupt: |
| if( db->u1.isInterrupted ) goto abort_due_to_interrupt; |
| #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
| /* Call the progress callback if it is configured and the required number |
| ** of VDBE ops have been executed (either since this invocation of |
| ** sqlite3VdbeExec() or since last time the progress callback was called). |
| ** If the progress callback returns non-zero, exit the virtual machine with |
| ** a return code SQLITE_ABORT. |
| */ |
| if( nVmStep>=nProgressLimit && db->xProgress!=0 ){ |
| assert( db->nProgressOps!=0 ); |
| nProgressLimit = nVmStep + db->nProgressOps - (nVmStep%db->nProgressOps); |
| if( db->xProgress(db->pProgressArg) ){ |
| rc = SQLITE_INTERRUPT; |
| goto abort_due_to_error; |
| } |
| } |
| #endif |
| |
| break; |
| } |
| |
| /* Opcode: Gosub P1 P2 * * * |
| ** |
| ** Write the current address onto register P1 |
| ** and then jump to address P2. |
| */ |
| case OP_Gosub: { /* jump */ |
| assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
| pIn1 = &aMem[pOp->p1]; |
| assert( VdbeMemDynamic(pIn1)==0 ); |
| memAboutToChange(p, pIn1); |
| pIn1->flags = MEM_Int; |
| pIn1->u.i = (int)(pOp-aOp); |
| REGISTER_TRACE(pOp->p1, pIn1); |
| |
| /* Most jump operations do a goto to this spot in order to update |
| ** the pOp pointer. */ |
| jump_to_p2: |
| pOp = &aOp[pOp->p2 - 1]; |
| break; |
| } |
| |
| /* Opcode: Return P1 * * * * |
| ** |
| ** Jump to the next instruction after the address in register P1. After |
| ** the jump, register P1 becomes undefined. |
| */ |
| case OP_Return: { /* in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| assert( pIn1->flags==MEM_Int ); |
| pOp = &aOp[pIn1->u.i]; |
| pIn1->flags = MEM_Undefined; |
| break; |
| } |
| |
| /* Opcode: InitCoroutine P1 P2 P3 * * |
| ** |
| ** Set up register P1 so that it will Yield to the coroutine |
| ** located at address P3. |
| ** |
| ** If P2!=0 then the coroutine implementation immediately follows |
| ** this opcode. So jump over the coroutine implementation to |
| ** address P2. |
| ** |
| ** See also: EndCoroutine |
| */ |
| case OP_InitCoroutine: { /* jump */ |
| assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
| assert( pOp->p2>=0 && pOp->p2<p->nOp ); |
| assert( pOp->p3>=0 && pOp->p3<p->nOp ); |
| pOut = &aMem[pOp->p1]; |
| assert( !VdbeMemDynamic(pOut) ); |
| pOut->u.i = pOp->p3 - 1; |
| pOut->flags = MEM_Int; |
| if( pOp->p2 ) goto jump_to_p2; |
| break; |
| } |
| |
| /* Opcode: EndCoroutine P1 * * * * |
| ** |
| ** The instruction at the address in register P1 is a Yield. |
| ** Jump to the P2 parameter of that Yield. |
| ** After the jump, register P1 becomes undefined. |
| ** |
| ** See also: InitCoroutine |
| */ |
| case OP_EndCoroutine: { /* in1 */ |
| VdbeOp *pCaller; |
| pIn1 = &aMem[pOp->p1]; |
| assert( pIn1->flags==MEM_Int ); |
| assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp ); |
| pCaller = &aOp[pIn1->u.i]; |
| assert( pCaller->opcode==OP_Yield ); |
| assert( pCaller->p2>=0 && pCaller->p2<p->nOp ); |
| pOp = &aOp[pCaller->p2 - 1]; |
| pIn1->flags = MEM_Undefined; |
| break; |
| } |
| |
| /* Opcode: Yield P1 P2 * * * |
| ** |
| ** Swap the program counter with the value in register P1. This |
| ** has the effect of yielding to a coroutine. |
| ** |
| ** If the coroutine that is launched by this instruction ends with |
| ** Yield or Return then continue to the next instruction. But if |
| ** the coroutine launched by this instruction ends with |
| ** EndCoroutine, then jump to P2 rather than continuing with the |
| ** next instruction. |
| ** |
| ** See also: InitCoroutine |
| */ |
| case OP_Yield: { /* in1, jump */ |
| int pcDest; |
| pIn1 = &aMem[pOp->p1]; |
| assert( VdbeMemDynamic(pIn1)==0 ); |
| pIn1->flags = MEM_Int; |
| pcDest = (int)pIn1->u.i; |
| pIn1->u.i = (int)(pOp - aOp); |
| REGISTER_TRACE(pOp->p1, pIn1); |
| pOp = &aOp[pcDest]; |
| break; |
| } |
| |
| /* Opcode: HaltIfNull P1 P2 P3 P4 P5 |
| ** Synopsis: if r[P3]=null halt |
| ** |
| ** Check the value in register P3. If it is NULL then Halt using |
| ** parameter P1, P2, and P4 as if this were a Halt instruction. If the |
| ** value in register P3 is not NULL, then this routine is a no-op. |
| ** The P5 parameter should be 1. |
| */ |
| case OP_HaltIfNull: { /* in3 */ |
| pIn3 = &aMem[pOp->p3]; |
| #ifdef SQLITE_DEBUG |
| if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } |
| #endif |
| if( (pIn3->flags & MEM_Null)==0 ) break; |
| /* Fall through into OP_Halt */ |
| } |
| |
| /* Opcode: Halt P1 P2 * P4 P5 |
| ** |
| ** Exit immediately. All open cursors, etc are closed |
| ** automatically. |
| ** |
| ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(), |
| ** or sqlite3_finalize(). For a normal halt, this should be SQLITE_OK (0). |
| ** For errors, it can be some other value. If P1!=0 then P2 will determine |
| ** whether or not to rollback the current transaction. Do not rollback |
| ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback. If P2==OE_Abort, |
| ** then back out all changes that have occurred during this execution of the |
| ** VDBE, but do not rollback the transaction. |
| ** |
| ** If P4 is not null then it is an error message string. |
| ** |
| ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string. |
| ** |
| ** 0: (no change) |
| ** 1: NOT NULL contraint failed: P4 |
| ** 2: UNIQUE constraint failed: P4 |
| ** 3: CHECK constraint failed: P4 |
| ** 4: FOREIGN KEY constraint failed: P4 |
| ** |
| ** If P5 is not zero and P4 is NULL, then everything after the ":" is |
| ** omitted. |
| ** |
| ** There is an implied "Halt 0 0 0" instruction inserted at the very end of |
| ** every program. So a jump past the last instruction of the program |
| ** is the same as executing Halt. |
| */ |
| case OP_Halt: { |
| VdbeFrame *pFrame; |
| int pcx; |
| |
| pcx = (int)(pOp - aOp); |
| #ifdef SQLITE_DEBUG |
| if( pOp->p2==OE_Abort ){ sqlite3VdbeAssertAbortable(p); } |
| #endif |
| if( pOp->p1==SQLITE_OK && p->pFrame ){ |
| /* Halt the sub-program. Return control to the parent frame. */ |
| pFrame = p->pFrame; |
| p->pFrame = pFrame->pParent; |
| p->nFrame--; |
| sqlite3VdbeSetChanges(db, p->nChange); |
| pcx = sqlite3VdbeFrameRestore(pFrame); |
| if( pOp->p2==OE_Ignore ){ |
| /* Instruction pcx is the OP_Program that invoked the sub-program |
| ** currently being halted. If the p2 instruction of this OP_Halt |
| ** instruction is set to OE_Ignore, then the sub-program is throwing |
| ** an IGNORE exception. In this case jump to the address specified |
| ** as the p2 of the calling OP_Program. */ |
| pcx = p->aOp[pcx].p2-1; |
| } |
| aOp = p->aOp; |
| aMem = p->aMem; |
| pOp = &aOp[pcx]; |
| break; |
| } |
| p->rc = pOp->p1; |
| p->errorAction = (u8)pOp->p2; |
| p->pc = pcx; |
| assert( pOp->p5<=4 ); |
| if( p->rc ){ |
| if( pOp->p5 ){ |
| static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK", |
| "FOREIGN KEY" }; |
| testcase( pOp->p5==1 ); |
| testcase( pOp->p5==2 ); |
| testcase( pOp->p5==3 ); |
| testcase( pOp->p5==4 ); |
| sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]); |
| if( pOp->p4.z ){ |
| p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z); |
| } |
| }else{ |
| sqlite3VdbeError(p, "%s", pOp->p4.z); |
| } |
| sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg); |
| } |
| rc = sqlite3VdbeHalt(p); |
| assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR ); |
| if( rc==SQLITE_BUSY ){ |
| p->rc = SQLITE_BUSY; |
| }else{ |
| assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT ); |
| assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 ); |
| rc = p->rc ? SQLITE_ERROR : SQLITE_DONE; |
| } |
| goto vdbe_return; |
| } |
| |
| /* Opcode: Integer P1 P2 * * * |
| ** Synopsis: r[P2]=P1 |
| ** |
| ** The 32-bit integer value P1 is written into register P2. |
| */ |
| case OP_Integer: { /* out2 */ |
| pOut = out2Prerelease(p, pOp); |
| pOut->u.i = pOp->p1; |
| break; |
| } |
| |
| /* Opcode: Int64 * P2 * P4 * |
| ** Synopsis: r[P2]=P4 |
| ** |
| ** P4 is a pointer to a 64-bit integer value. |
| ** Write that value into register P2. |
| */ |
| case OP_Int64: { /* out2 */ |
| pOut = out2Prerelease(p, pOp); |
| assert( pOp->p4.pI64!=0 ); |
| pOut->u.i = *pOp->p4.pI64; |
| break; |
| } |
| |
| #ifndef SQLITE_OMIT_FLOATING_POINT |
| /* Opcode: Real * P2 * P4 * |
| ** Synopsis: r[P2]=P4 |
| ** |
| ** P4 is a pointer to a 64-bit floating point value. |
| ** Write that value into register P2. |
| */ |
| case OP_Real: { /* same as TK_FLOAT, out2 */ |
| pOut = out2Prerelease(p, pOp); |
| pOut->flags = MEM_Real; |
| assert( !sqlite3IsNaN(*pOp->p4.pReal) ); |
| pOut->u.r = *pOp->p4.pReal; |
| break; |
| } |
| #endif |
| |
| /* Opcode: String8 * P2 * P4 * |
| ** Synopsis: r[P2]='P4' |
| ** |
| ** P4 points to a nul terminated UTF-8 string. This opcode is transformed |
| ** into a String opcode before it is executed for the first time. During |
| ** this transformation, the length of string P4 is computed and stored |
| ** as the P1 parameter. |
| */ |
| case OP_String8: { /* same as TK_STRING, out2 */ |
| assert( pOp->p4.z!=0 ); |
| pOut = out2Prerelease(p, pOp); |
| pOp->opcode = OP_String; |
| pOp->p1 = sqlite3Strlen30(pOp->p4.z); |
| |
| #ifndef SQLITE_OMIT_UTF16 |
| if( encoding!=SQLITE_UTF8 ){ |
| rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC); |
| assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG ); |
| if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem; |
| assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z ); |
| assert( VdbeMemDynamic(pOut)==0 ); |
| pOut->szMalloc = 0; |
| pOut->flags |= MEM_Static; |
| if( pOp->p4type==P4_DYNAMIC ){ |
| sqlite3DbFree(db, pOp->p4.z); |
| } |
| pOp->p4type = P4_DYNAMIC; |
| pOp->p4.z = pOut->z; |
| pOp->p1 = pOut->n; |
| } |
| testcase( rc==SQLITE_TOOBIG ); |
| #endif |
| if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
| goto too_big; |
| } |
| assert( rc==SQLITE_OK ); |
| /* Fall through to the next case, OP_String */ |
| } |
| |
| /* Opcode: String P1 P2 P3 P4 P5 |
| ** Synopsis: r[P2]='P4' (len=P1) |
| ** |
| ** The string value P4 of length P1 (bytes) is stored in register P2. |
| ** |
| ** If P3 is not zero and the content of register P3 is equal to P5, then |
| ** the datatype of the register P2 is converted to BLOB. The content is |
| ** the same sequence of bytes, it is merely interpreted as a BLOB instead |
| ** of a string, as if it had been CAST. In other words: |
| ** |
| ** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB) |
| */ |
| case OP_String: { /* out2 */ |
| assert( pOp->p4.z!=0 ); |
| pOut = out2Prerelease(p, pOp); |
| pOut->flags = MEM_Str|MEM_Static|MEM_Term; |
| pOut->z = pOp->p4.z; |
| pOut->n = pOp->p1; |
| pOut->enc = encoding; |
| UPDATE_MAX_BLOBSIZE(pOut); |
| #ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS |
| if( pOp->p3>0 ){ |
| assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| pIn3 = &aMem[pOp->p3]; |
| assert( pIn3->flags & MEM_Int ); |
| if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term; |
| } |
| #endif |
| break; |
| } |
| |
| /* Opcode: Null P1 P2 P3 * * |
| ** Synopsis: r[P2..P3]=NULL |
| ** |
| ** Write a NULL into registers P2. If P3 greater than P2, then also write |
| ** NULL into register P3 and every register in between P2 and P3. If P3 |
| ** is less than P2 (typically P3 is zero) then only register P2 is |
| ** set to NULL. |
| ** |
| ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that |
| ** NULL values will not compare equal even if SQLITE_NULLEQ is set on |
| ** OP_Ne or OP_Eq. |
| */ |
| case OP_Null: { /* out2 */ |
| int cnt; |
| u16 nullFlag; |
| pOut = out2Prerelease(p, pOp); |
| cnt = pOp->p3-pOp->p2; |
| assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null; |
| pOut->n = 0; |
| #ifdef SQLITE_DEBUG |
| pOut->uTemp = 0; |
| #endif |
| while( cnt>0 ){ |
| pOut++; |
| memAboutToChange(p, pOut); |
| sqlite3VdbeMemSetNull(pOut); |
| pOut->flags = nullFlag; |
| pOut->n = 0; |
| cnt--; |
| } |
| break; |
| } |
| |
| /* Opcode: SoftNull P1 * * * * |
| ** Synopsis: r[P1]=NULL |
| ** |
| ** Set register P1 to have the value NULL as seen by the OP_MakeRecord |
| ** instruction, but do not free any string or blob memory associated with |
| ** the register, so that if the value was a string or blob that was |
| ** previously copied using OP_SCopy, the copies will continue to be valid. |
| */ |
| case OP_SoftNull: { |
| assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
| pOut = &aMem[pOp->p1]; |
| pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null; |
| break; |
| } |
| |
| /* Opcode: Blob P1 P2 * P4 * |
| ** Synopsis: r[P2]=P4 (len=P1) |
| ** |
| ** P4 points to a blob of data P1 bytes long. Store this |
| ** blob in register P2. |
| */ |
| case OP_Blob: { /* out2 */ |
| assert( pOp->p1 <= SQLITE_MAX_LENGTH ); |
| pOut = out2Prerelease(p, pOp); |
| sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0); |
| pOut->enc = encoding; |
| UPDATE_MAX_BLOBSIZE(pOut); |
| break; |
| } |
| |
| /* Opcode: Variable P1 P2 * P4 * |
| ** Synopsis: r[P2]=parameter(P1,P4) |
| ** |
| ** Transfer the values of bound parameter P1 into register P2 |
| ** |
| ** If the parameter is named, then its name appears in P4. |
| ** The P4 value is used by sqlite3_bind_parameter_name(). |
| */ |
| case OP_Variable: { /* out2 */ |
| Mem *pVar; /* Value being transferred */ |
| |
| assert( pOp->p1>0 && pOp->p1<=p->nVar ); |
| assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) ); |
| pVar = &p->aVar[pOp->p1 - 1]; |
| if( sqlite3VdbeMemTooBig(pVar) ){ |
| goto too_big; |
| } |
| pOut = &aMem[pOp->p2]; |
| sqlite3VdbeMemShallowCopy(pOut, pVar, MEM_Static); |
| UPDATE_MAX_BLOBSIZE(pOut); |
| break; |
| } |
| |
| /* Opcode: Move P1 P2 P3 * * |
| ** Synopsis: r[P2@P3]=r[P1@P3] |
| ** |
| ** Move the P3 values in register P1..P1+P3-1 over into |
| ** registers P2..P2+P3-1. Registers P1..P1+P3-1 are |
| ** left holding a NULL. It is an error for register ranges |
| ** P1..P1+P3-1 and P2..P2+P3-1 to overlap. It is an error |
| ** for P3 to be less than 1. |
| */ |
| case OP_Move: { |
| int n; /* Number of registers left to copy */ |
| int p1; /* Register to copy from */ |
| int p2; /* Register to copy to */ |
| |
| n = pOp->p3; |
| p1 = pOp->p1; |
| p2 = pOp->p2; |
| assert( n>0 && p1>0 && p2>0 ); |
| assert( p1+n<=p2 || p2+n<=p1 ); |
| |
| pIn1 = &aMem[p1]; |
| pOut = &aMem[p2]; |
| do{ |
| assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] ); |
| assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] ); |
| assert( memIsValid(pIn1) ); |
| memAboutToChange(p, pOut); |
| sqlite3VdbeMemMove(pOut, pIn1); |
| #ifdef SQLITE_DEBUG |
| if( pOut->pScopyFrom>=&aMem[p1] && pOut->pScopyFrom<pOut ){ |
| pOut->pScopyFrom += pOp->p2 - p1; |
| } |
| #endif |
| Deephemeralize(pOut); |
| REGISTER_TRACE(p2++, pOut); |
| pIn1++; |
| pOut++; |
| }while( --n ); |
| break; |
| } |
| |
| /* Opcode: Copy P1 P2 P3 * * |
| ** Synopsis: r[P2@P3+1]=r[P1@P3+1] |
| ** |
| ** Make a copy of registers P1..P1+P3 into registers P2..P2+P3. |
| ** |
| ** This instruction makes a deep copy of the value. A duplicate |
| ** is made of any string or blob constant. See also OP_SCopy. |
| */ |
| case OP_Copy: { |
| int n; |
| |
| n = pOp->p3; |
| pIn1 = &aMem[pOp->p1]; |
| pOut = &aMem[pOp->p2]; |
| assert( pOut!=pIn1 ); |
| while( 1 ){ |
| memAboutToChange(p, pOut); |
| sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); |
| Deephemeralize(pOut); |
| #ifdef SQLITE_DEBUG |
| pOut->pScopyFrom = 0; |
| #endif |
| REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut); |
| if( (n--)==0 ) break; |
| pOut++; |
| pIn1++; |
| } |
| break; |
| } |
| |
| /* Opcode: SCopy P1 P2 * * * |
| ** Synopsis: r[P2]=r[P1] |
| ** |
| ** Make a shallow copy of register P1 into register P2. |
| ** |
| ** This instruction makes a shallow copy of the value. If the value |
| ** is a string or blob, then the copy is only a pointer to the |
| ** original and hence if the original changes so will the copy. |
| ** Worse, if the original is deallocated, the copy becomes invalid. |
| ** Thus the program must guarantee that the original will not change |
| ** during the lifetime of the copy. Use OP_Copy to make a complete |
| ** copy. |
| */ |
| case OP_SCopy: { /* out2 */ |
| pIn1 = &aMem[pOp->p1]; |
| pOut = &aMem[pOp->p2]; |
| assert( pOut!=pIn1 ); |
| sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem); |
| #ifdef SQLITE_DEBUG |
| pOut->pScopyFrom = pIn1; |
| pOut->mScopyFlags = pIn1->flags; |
| #endif |
| break; |
| } |
| |
| /* Opcode: IntCopy P1 P2 * * * |
| ** Synopsis: r[P2]=r[P1] |
| ** |
| ** Transfer the integer value held in register P1 into register P2. |
| ** |
| ** This is an optimized version of SCopy that works only for integer |
| ** values. |
| */ |
| case OP_IntCopy: { /* out2 */ |
| pIn1 = &aMem[pOp->p1]; |
| assert( (pIn1->flags & MEM_Int)!=0 ); |
| pOut = &aMem[pOp->p2]; |
| sqlite3VdbeMemSetInt64(pOut, pIn1->u.i); |
| break; |
| } |
| |
| /* Opcode: ResultRow P1 P2 * * * |
| ** Synopsis: output=r[P1@P2] |
| ** |
| ** The registers P1 through P1+P2-1 contain a single row of |
| ** results. This opcode causes the sqlite3_step() call to terminate |
| ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt |
| ** structure to provide access to the r(P1)..r(P1+P2-1) values as |
| ** the result row. |
| */ |
| case OP_ResultRow: { |
| Mem *pMem; |
| int i; |
| assert( p->nResColumn==pOp->p2 ); |
| assert( pOp->p1>0 ); |
| assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 ); |
| |
| #ifndef SQLITE_OMIT_PROGRESS_CALLBACK |
| /* Run the progress counter just before returning. |
| */ |
| if( db->xProgress!=0 |
| && nVmStep>=nProgressLimit |
| && db->xProgress(db->pProgressArg)!=0 |
| ){ |
| rc = SQLITE_INTERRUPT; |
| goto abort_due_to_error; |
| } |
| #endif |
| |
| /* If this statement has violated immediate foreign key constraints, do |
| ** not return the number of rows modified. And do not RELEASE the statement |
| ** transaction. It needs to be rolled back. */ |
| if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){ |
| assert( db->flags&SQLITE_CountRows ); |
| assert( p->usesStmtJournal ); |
| goto abort_due_to_error; |
| } |
| |
| /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then |
| ** DML statements invoke this opcode to return the number of rows |
| ** modified to the user. This is the only way that a VM that |
| ** opens a statement transaction may invoke this opcode. |
| ** |
| ** In case this is such a statement, close any statement transaction |
| ** opened by this VM before returning control to the user. This is to |
| ** ensure that statement-transactions are always nested, not overlapping. |
| ** If the open statement-transaction is not closed here, then the user |
| ** may step another VM that opens its own statement transaction. This |
| ** may lead to overlapping statement transactions. |
| ** |
| ** The statement transaction is never a top-level transaction. Hence |
| ** the RELEASE call below can never fail. |
| */ |
| assert( p->iStatement==0 || db->flags&SQLITE_CountRows ); |
| rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE); |
| assert( rc==SQLITE_OK ); |
| |
| /* Invalidate all ephemeral cursor row caches */ |
| p->cacheCtr = (p->cacheCtr + 2)|1; |
| |
| /* Make sure the results of the current row are \000 terminated |
| ** and have an assigned type. The results are de-ephemeralized as |
| ** a side effect. |
| */ |
| pMem = p->pResultSet = &aMem[pOp->p1]; |
| for(i=0; i<pOp->p2; i++){ |
| assert( memIsValid(&pMem[i]) ); |
| Deephemeralize(&pMem[i]); |
| assert( (pMem[i].flags & MEM_Ephem)==0 |
| || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 ); |
| sqlite3VdbeMemNulTerminate(&pMem[i]); |
| REGISTER_TRACE(pOp->p1+i, &pMem[i]); |
| } |
| if( db->mallocFailed ) goto no_mem; |
| |
| if( db->mTrace & SQLITE_TRACE_ROW ){ |
| db->xTrace(SQLITE_TRACE_ROW, db->pTraceArg, p, 0); |
| } |
| |
| /* Return SQLITE_ROW |
| */ |
| p->pc = (int)(pOp - aOp) + 1; |
| rc = SQLITE_ROW; |
| goto vdbe_return; |
| } |
| |
| /* Opcode: Concat P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P2]+r[P1] |
| ** |
| ** Add the text in register P1 onto the end of the text in |
| ** register P2 and store the result in register P3. |
| ** If either the P1 or P2 text are NULL then store NULL in P3. |
| ** |
| ** P3 = P2 || P1 |
| ** |
| ** It is illegal for P1 and P3 to be the same register. Sometimes, |
| ** if P3 is the same register as P2, the implementation is able |
| ** to avoid a memcpy(). |
| */ |
| case OP_Concat: { /* same as TK_CONCAT, in1, in2, out3 */ |
| i64 nByte; |
| |
| pIn1 = &aMem[pOp->p1]; |
| pIn2 = &aMem[pOp->p2]; |
| pOut = &aMem[pOp->p3]; |
| assert( pIn1!=pOut ); |
| if( (pIn1->flags | pIn2->flags) & MEM_Null ){ |
| sqlite3VdbeMemSetNull(pOut); |
| break; |
| } |
| if( ExpandBlob(pIn1) || ExpandBlob(pIn2) ) goto no_mem; |
| Stringify(pIn1, encoding); |
| Stringify(pIn2, encoding); |
| nByte = pIn1->n + pIn2->n; |
| if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
| goto too_big; |
| } |
| if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){ |
| goto no_mem; |
| } |
| MemSetTypeFlag(pOut, MEM_Str); |
| if( pOut!=pIn2 ){ |
| memcpy(pOut->z, pIn2->z, pIn2->n); |
| } |
| memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n); |
| pOut->z[nByte]=0; |
| pOut->z[nByte+1] = 0; |
| pOut->flags |= MEM_Term; |
| pOut->n = (int)nByte; |
| pOut->enc = encoding; |
| UPDATE_MAX_BLOBSIZE(pOut); |
| break; |
| } |
| |
| /* Opcode: Add P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P1]+r[P2] |
| ** |
| ** Add the value in register P1 to the value in register P2 |
| ** and store the result in register P3. |
| ** If either input is NULL, the result is NULL. |
| */ |
| /* Opcode: Multiply P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P1]*r[P2] |
| ** |
| ** |
| ** Multiply the value in register P1 by the value in register P2 |
| ** and store the result in register P3. |
| ** If either input is NULL, the result is NULL. |
| */ |
| /* Opcode: Subtract P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P2]-r[P1] |
| ** |
| ** Subtract the value in register P1 from the value in register P2 |
| ** and store the result in register P3. |
| ** If either input is NULL, the result is NULL. |
| */ |
| /* Opcode: Divide P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P2]/r[P1] |
| ** |
| ** Divide the value in register P1 by the value in register P2 |
| ** and store the result in register P3 (P3=P2/P1). If the value in |
| ** register P1 is zero, then the result is NULL. If either input is |
| ** NULL, the result is NULL. |
| */ |
| /* Opcode: Remainder P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P2]%r[P1] |
| ** |
| ** Compute the remainder after integer register P2 is divided by |
| ** register P1 and store the result in register P3. |
| ** If the value in register P1 is zero the result is NULL. |
| ** If either operand is NULL, the result is NULL. |
| */ |
| case OP_Add: /* same as TK_PLUS, in1, in2, out3 */ |
| case OP_Subtract: /* same as TK_MINUS, in1, in2, out3 */ |
| case OP_Multiply: /* same as TK_STAR, in1, in2, out3 */ |
| case OP_Divide: /* same as TK_SLASH, in1, in2, out3 */ |
| case OP_Remainder: { /* same as TK_REM, in1, in2, out3 */ |
| char bIntint; /* Started out as two integer operands */ |
| u16 flags; /* Combined MEM_* flags from both inputs */ |
| u16 type1; /* Numeric type of left operand */ |
| u16 type2; /* Numeric type of right operand */ |
| i64 iA; /* Integer value of left operand */ |
| i64 iB; /* Integer value of right operand */ |
| double rA; /* Real value of left operand */ |
| double rB; /* Real value of right operand */ |
| |
| pIn1 = &aMem[pOp->p1]; |
| type1 = numericType(pIn1); |
| pIn2 = &aMem[pOp->p2]; |
| type2 = numericType(pIn2); |
| pOut = &aMem[pOp->p3]; |
| flags = pIn1->flags | pIn2->flags; |
| if( (type1 & type2 & MEM_Int)!=0 ){ |
| iA = pIn1->u.i; |
| iB = pIn2->u.i; |
| bIntint = 1; |
| switch( pOp->opcode ){ |
| case OP_Add: if( sqlite3AddInt64(&iB,iA) ) goto fp_math; break; |
| case OP_Subtract: if( sqlite3SubInt64(&iB,iA) ) goto fp_math; break; |
| case OP_Multiply: if( sqlite3MulInt64(&iB,iA) ) goto fp_math; break; |
| case OP_Divide: { |
| if( iA==0 ) goto arithmetic_result_is_null; |
| if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math; |
| iB /= iA; |
| break; |
| } |
| default: { |
| if( iA==0 ) goto arithmetic_result_is_null; |
| if( iA==-1 ) iA = 1; |
| iB %= iA; |
| break; |
| } |
| } |
| pOut->u.i = iB; |
| MemSetTypeFlag(pOut, MEM_Int); |
| }else if( (flags & MEM_Null)!=0 ){ |
| goto arithmetic_result_is_null; |
| }else{ |
| bIntint = 0; |
| fp_math: |
| rA = sqlite3VdbeRealValue(pIn1); |
| rB = sqlite3VdbeRealValue(pIn2); |
| switch( pOp->opcode ){ |
| case OP_Add: rB += rA; break; |
| case OP_Subtract: rB -= rA; break; |
| case OP_Multiply: rB *= rA; break; |
| case OP_Divide: { |
| /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */ |
| if( rA==(double)0 ) goto arithmetic_result_is_null; |
| rB /= rA; |
| break; |
| } |
| default: { |
| iA = sqlite3VdbeIntValue(pIn1); |
| iB = sqlite3VdbeIntValue(pIn2); |
| if( iA==0 ) goto arithmetic_result_is_null; |
| if( iA==-1 ) iA = 1; |
| rB = (double)(iB % iA); |
| break; |
| } |
| } |
| #ifdef SQLITE_OMIT_FLOATING_POINT |
| pOut->u.i = rB; |
| MemSetTypeFlag(pOut, MEM_Int); |
| #else |
| if( sqlite3IsNaN(rB) ){ |
| goto arithmetic_result_is_null; |
| } |
| pOut->u.r = rB; |
| MemSetTypeFlag(pOut, MEM_Real); |
| if( ((type1|type2)&MEM_Real)==0 && !bIntint ){ |
| sqlite3VdbeIntegerAffinity(pOut); |
| } |
| #endif |
| } |
| break; |
| |
| arithmetic_result_is_null: |
| sqlite3VdbeMemSetNull(pOut); |
| break; |
| } |
| |
| /* Opcode: CollSeq P1 * * P4 |
| ** |
| ** P4 is a pointer to a CollSeq object. If the next call to a user function |
| ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will |
| ** be returned. This is used by the built-in min(), max() and nullif() |
| ** functions. |
| ** |
| ** If P1 is not zero, then it is a register that a subsequent min() or |
| ** max() aggregate will set to 1 if the current row is not the minimum or |
| ** maximum. The P1 register is initialized to 0 by this instruction. |
| ** |
| ** The interface used by the implementation of the aforementioned functions |
| ** to retrieve the collation sequence set by this opcode is not available |
| ** publicly. Only built-in functions have access to this feature. |
| */ |
| case OP_CollSeq: { |
| assert( pOp->p4type==P4_COLLSEQ ); |
| if( pOp->p1 ){ |
| sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0); |
| } |
| break; |
| } |
| |
| /* Opcode: BitAnd P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P1]&r[P2] |
| ** |
| ** Take the bit-wise AND of the values in register P1 and P2 and |
| ** store the result in register P3. |
| ** If either input is NULL, the result is NULL. |
| */ |
| /* Opcode: BitOr P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P1]|r[P2] |
| ** |
| ** Take the bit-wise OR of the values in register P1 and P2 and |
| ** store the result in register P3. |
| ** If either input is NULL, the result is NULL. |
| */ |
| /* Opcode: ShiftLeft P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P2]<<r[P1] |
| ** |
| ** Shift the integer value in register P2 to the left by the |
| ** number of bits specified by the integer in register P1. |
| ** Store the result in register P3. |
| ** If either input is NULL, the result is NULL. |
| */ |
| /* Opcode: ShiftRight P1 P2 P3 * * |
| ** Synopsis: r[P3]=r[P2]>>r[P1] |
| ** |
| ** Shift the integer value in register P2 to the right by the |
| ** number of bits specified by the integer in register P1. |
| ** Store the result in register P3. |
| ** If either input is NULL, the result is NULL. |
| */ |
| case OP_BitAnd: /* same as TK_BITAND, in1, in2, out3 */ |
| case OP_BitOr: /* same as TK_BITOR, in1, in2, out3 */ |
| case OP_ShiftLeft: /* same as TK_LSHIFT, in1, in2, out3 */ |
| case OP_ShiftRight: { /* same as TK_RSHIFT, in1, in2, out3 */ |
| i64 iA; |
| u64 uA; |
| i64 iB; |
| u8 op; |
| |
| pIn1 = &aMem[pOp->p1]; |
| pIn2 = &aMem[pOp->p2]; |
| pOut = &aMem[pOp->p3]; |
| if( (pIn1->flags | pIn2->flags) & MEM_Null ){ |
| sqlite3VdbeMemSetNull(pOut); |
| break; |
| } |
| iA = sqlite3VdbeIntValue(pIn2); |
| iB = sqlite3VdbeIntValue(pIn1); |
| op = pOp->opcode; |
| if( op==OP_BitAnd ){ |
| iA &= iB; |
| }else if( op==OP_BitOr ){ |
| iA |= iB; |
| }else if( iB!=0 ){ |
| assert( op==OP_ShiftRight || op==OP_ShiftLeft ); |
| |
| /* If shifting by a negative amount, shift in the other direction */ |
| if( iB<0 ){ |
| assert( OP_ShiftRight==OP_ShiftLeft+1 ); |
| op = 2*OP_ShiftLeft + 1 - op; |
| iB = iB>(-64) ? -iB : 64; |
| } |
| |
| if( iB>=64 ){ |
| iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1; |
| }else{ |
| memcpy(&uA, &iA, sizeof(uA)); |
| if( op==OP_ShiftLeft ){ |
| uA <<= iB; |
| }else{ |
| uA >>= iB; |
| /* Sign-extend on a right shift of a negative number */ |
| if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB); |
| } |
| memcpy(&iA, &uA, sizeof(iA)); |
| } |
| } |
| pOut->u.i = iA; |
| MemSetTypeFlag(pOut, MEM_Int); |
| break; |
| } |
| |
| /* Opcode: AddImm P1 P2 * * * |
| ** Synopsis: r[P1]=r[P1]+P2 |
| ** |
| ** Add the constant P2 to the value in register P1. |
| ** The result is always an integer. |
| ** |
| ** To force any register to be an integer, just add 0. |
| */ |
| case OP_AddImm: { /* in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| memAboutToChange(p, pIn1); |
| sqlite3VdbeMemIntegerify(pIn1); |
| pIn1->u.i += pOp->p2; |
| break; |
| } |
| |
| /* Opcode: MustBeInt P1 P2 * * * |
| ** |
| ** Force the value in register P1 to be an integer. If the value |
| ** in P1 is not an integer and cannot be converted into an integer |
| ** without data loss, then jump immediately to P2, or if P2==0 |
| ** raise an SQLITE_MISMATCH exception. |
| */ |
| case OP_MustBeInt: { /* jump, in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| if( (pIn1->flags & MEM_Int)==0 ){ |
| applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding); |
| VdbeBranchTaken((pIn1->flags&MEM_Int)==0, 2); |
| if( (pIn1->flags & MEM_Int)==0 ){ |
| if( pOp->p2==0 ){ |
| rc = SQLITE_MISMATCH; |
| goto abort_due_to_error; |
| }else{ |
| goto jump_to_p2; |
| } |
| } |
| } |
| MemSetTypeFlag(pIn1, MEM_Int); |
| break; |
| } |
| |
| #ifndef SQLITE_OMIT_FLOATING_POINT |
| /* Opcode: RealAffinity P1 * * * * |
| ** |
| ** If register P1 holds an integer convert it to a real value. |
| ** |
| ** This opcode is used when extracting information from a column that |
| ** has REAL affinity. Such column values may still be stored as |
| ** integers, for space efficiency, but after extraction we want them |
| ** to have only a real value. |
| */ |
| case OP_RealAffinity: { /* in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| if( pIn1->flags & MEM_Int ){ |
| sqlite3VdbeMemRealify(pIn1); |
| } |
| break; |
| } |
| #endif |
| |
| #ifndef SQLITE_OMIT_CAST |
| /* Opcode: Cast P1 P2 * * * |
| ** Synopsis: affinity(r[P1]) |
| ** |
| ** Force the value in register P1 to be the type defined by P2. |
| ** |
| ** <ul> |
| ** <li> P2=='A' → BLOB |
| ** <li> P2=='B' → TEXT |
| ** <li> P2=='C' → NUMERIC |
| ** <li> P2=='D' → INTEGER |
| ** <li> P2=='E' → REAL |
| ** </ul> |
| ** |
| ** A NULL value is not changed by this routine. It remains NULL. |
| */ |
| case OP_Cast: { /* in1 */ |
| assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL ); |
| testcase( pOp->p2==SQLITE_AFF_TEXT ); |
| testcase( pOp->p2==SQLITE_AFF_BLOB ); |
| testcase( pOp->p2==SQLITE_AFF_NUMERIC ); |
| testcase( pOp->p2==SQLITE_AFF_INTEGER ); |
| testcase( pOp->p2==SQLITE_AFF_REAL ); |
| pIn1 = &aMem[pOp->p1]; |
| memAboutToChange(p, pIn1); |
| rc = ExpandBlob(pIn1); |
| sqlite3VdbeMemCast(pIn1, pOp->p2, encoding); |
| UPDATE_MAX_BLOBSIZE(pIn1); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif /* SQLITE_OMIT_CAST */ |
| |
| /* Opcode: Eq P1 P2 P3 P4 P5 |
| ** Synopsis: IF r[P3]==r[P1] |
| ** |
| ** Compare the values in register P1 and P3. If reg(P3)==reg(P1) then |
| ** jump to address P2. Or if the SQLITE_STOREP2 flag is set in P5, then |
| ** store the result of comparison in register P2. |
| ** |
| ** The SQLITE_AFF_MASK portion of P5 must be an affinity character - |
| ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made |
| ** to coerce both inputs according to this affinity before the |
| ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric |
| ** affinity is used. Note that the affinity conversions are stored |
| ** back into the input registers P1 and P3. So this opcode can cause |
| ** persistent changes to registers P1 and P3. |
| ** |
| ** Once any conversions have taken place, and neither value is NULL, |
| ** the values are compared. If both values are blobs then memcmp() is |
| ** used to determine the results of the comparison. If both values |
| ** are text, then the appropriate collating function specified in |
| ** P4 is used to do the comparison. If P4 is not specified then |
| ** memcmp() is used to compare text string. If both values are |
| ** numeric, then a numeric comparison is used. If the two values |
| ** are of different types, then numbers are considered less than |
| ** strings and strings are considered less than blobs. |
| ** |
| ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either |
| ** true or false and is never NULL. If both operands are NULL then the result |
| ** of comparison is true. If either operand is NULL then the result is false. |
| ** If neither operand is NULL the result is the same as it would be if |
| ** the SQLITE_NULLEQ flag were omitted from P5. |
| ** |
| ** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the |
| ** content of r[P2] is only changed if the new value is NULL or 0 (false). |
| ** In other words, a prior r[P2] value will not be overwritten by 1 (true). |
| */ |
| /* Opcode: Ne P1 P2 P3 P4 P5 |
| ** Synopsis: IF r[P3]!=r[P1] |
| ** |
| ** This works just like the Eq opcode except that the jump is taken if |
| ** the operands in registers P1 and P3 are not equal. See the Eq opcode for |
| ** additional information. |
| ** |
| ** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the |
| ** content of r[P2] is only changed if the new value is NULL or 1 (true). |
| ** In other words, a prior r[P2] value will not be overwritten by 0 (false). |
| */ |
| /* Opcode: Lt P1 P2 P3 P4 P5 |
| ** Synopsis: IF r[P3]<r[P1] |
| ** |
| ** Compare the values in register P1 and P3. If reg(P3)<reg(P1) then |
| ** jump to address P2. Or if the SQLITE_STOREP2 flag is set in P5 store |
| ** the result of comparison (0 or 1 or NULL) into register P2. |
| ** |
| ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or |
| ** reg(P3) is NULL then the take the jump. If the SQLITE_JUMPIFNULL |
| ** bit is clear then fall through if either operand is NULL. |
| ** |
| ** The SQLITE_AFF_MASK portion of P5 must be an affinity character - |
| ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made |
| ** to coerce both inputs according to this affinity before the |
| ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric |
| ** affinity is used. Note that the affinity conversions are stored |
| ** back into the input registers P1 and P3. So this opcode can cause |
| ** persistent changes to registers P1 and P3. |
| ** |
| ** Once any conversions have taken place, and neither value is NULL, |
| ** the values are compared. If both values are blobs then memcmp() is |
| ** used to determine the results of the comparison. If both values |
| ** are text, then the appropriate collating function specified in |
| ** P4 is used to do the comparison. If P4 is not specified then |
| ** memcmp() is used to compare text string. If both values are |
| ** numeric, then a numeric comparison is used. If the two values |
| ** are of different types, then numbers are considered less than |
| ** strings and strings are considered less than blobs. |
| */ |
| /* Opcode: Le P1 P2 P3 P4 P5 |
| ** Synopsis: IF r[P3]<=r[P1] |
| ** |
| ** This works just like the Lt opcode except that the jump is taken if |
| ** the content of register P3 is less than or equal to the content of |
| ** register P1. See the Lt opcode for additional information. |
| */ |
| /* Opcode: Gt P1 P2 P3 P4 P5 |
| ** Synopsis: IF r[P3]>r[P1] |
| ** |
| ** This works just like the Lt opcode except that the jump is taken if |
| ** the content of register P3 is greater than the content of |
| ** register P1. See the Lt opcode for additional information. |
| */ |
| /* Opcode: Ge P1 P2 P3 P4 P5 |
| ** Synopsis: IF r[P3]>=r[P1] |
| ** |
| ** This works just like the Lt opcode except that the jump is taken if |
| ** the content of register P3 is greater than or equal to the content of |
| ** register P1. See the Lt opcode for additional information. |
| */ |
| case OP_Eq: /* same as TK_EQ, jump, in1, in3 */ |
| case OP_Ne: /* same as TK_NE, jump, in1, in3 */ |
| case OP_Lt: /* same as TK_LT, jump, in1, in3 */ |
| case OP_Le: /* same as TK_LE, jump, in1, in3 */ |
| case OP_Gt: /* same as TK_GT, jump, in1, in3 */ |
| case OP_Ge: { /* same as TK_GE, jump, in1, in3 */ |
| int res, res2; /* Result of the comparison of pIn1 against pIn3 */ |
| char affinity; /* Affinity to use for comparison */ |
| u16 flags1; /* Copy of initial value of pIn1->flags */ |
| u16 flags3; /* Copy of initial value of pIn3->flags */ |
| |
| pIn1 = &aMem[pOp->p1]; |
| pIn3 = &aMem[pOp->p3]; |
| flags1 = pIn1->flags; |
| flags3 = pIn3->flags; |
| if( (flags1 | flags3)&MEM_Null ){ |
| /* One or both operands are NULL */ |
| if( pOp->p5 & SQLITE_NULLEQ ){ |
| /* If SQLITE_NULLEQ is set (which will only happen if the operator is |
| ** OP_Eq or OP_Ne) then take the jump or not depending on whether |
| ** or not both operands are null. |
| */ |
| assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne ); |
| assert( (flags1 & MEM_Cleared)==0 ); |
| assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 || CORRUPT_DB ); |
| testcase( (pOp->p5 & SQLITE_JUMPIFNULL)!=0 ); |
| if( (flags1&flags3&MEM_Null)!=0 |
| && (flags3&MEM_Cleared)==0 |
| ){ |
| res = 0; /* Operands are equal */ |
| }else{ |
| res = 1; /* Operands are not equal */ |
| } |
| }else{ |
| /* SQLITE_NULLEQ is clear and at least one operand is NULL, |
| ** then the result is always NULL. |
| ** The jump is taken if the SQLITE_JUMPIFNULL bit is set. |
| */ |
| if( pOp->p5 & SQLITE_STOREP2 ){ |
| pOut = &aMem[pOp->p2]; |
| iCompare = 1; /* Operands are not equal */ |
| memAboutToChange(p, pOut); |
| MemSetTypeFlag(pOut, MEM_Null); |
| REGISTER_TRACE(pOp->p2, pOut); |
| }else{ |
| VdbeBranchTaken(2,3); |
| if( pOp->p5 & SQLITE_JUMPIFNULL ){ |
| goto jump_to_p2; |
| } |
| } |
| break; |
| } |
| }else{ |
| /* Neither operand is NULL. Do a comparison. */ |
| affinity = pOp->p5 & SQLITE_AFF_MASK; |
| if( affinity>=SQLITE_AFF_NUMERIC ){ |
| if( (flags1 | flags3)&MEM_Str ){ |
| if( (flags1 & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){ |
| applyNumericAffinity(pIn1,0); |
| assert( flags3==pIn3->flags ); |
| /* testcase( flags3!=pIn3->flags ); |
| ** this used to be possible with pIn1==pIn3, but not since |
| ** the column cache was removed. The following assignment |
| ** is essentially a no-op. But, it provides defense-in-depth |
| ** in case our analysis is incorrect, so it is left in. */ |
| flags3 = pIn3->flags; |
| } |
| if( (flags3 & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){ |
| applyNumericAffinity(pIn3,0); |
| } |
| } |
| /* Handle the common case of integer comparison here, as an |
| ** optimization, to avoid a call to sqlite3MemCompare() */ |
| if( (pIn1->flags & pIn3->flags & MEM_Int)!=0 ){ |
| if( pIn3->u.i > pIn1->u.i ){ res = +1; goto compare_op; } |
| if( pIn3->u.i < pIn1->u.i ){ res = -1; goto compare_op; } |
| res = 0; |
| goto compare_op; |
| } |
| }else if( affinity==SQLITE_AFF_TEXT ){ |
| if( (flags1 & MEM_Str)==0 && (flags1 & (MEM_Int|MEM_Real))!=0 ){ |
| testcase( pIn1->flags & MEM_Int ); |
| testcase( pIn1->flags & MEM_Real ); |
| sqlite3VdbeMemStringify(pIn1, encoding, 1); |
| testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) ); |
| flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask); |
| assert( pIn1!=pIn3 ); |
| } |
| if( (flags3 & MEM_Str)==0 && (flags3 & (MEM_Int|MEM_Real))!=0 ){ |
| testcase( pIn3->flags & MEM_Int ); |
| testcase( pIn3->flags & MEM_Real ); |
| sqlite3VdbeMemStringify(pIn3, encoding, 1); |
| testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) ); |
| flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask); |
| } |
| } |
| assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 ); |
| res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl); |
| } |
| compare_op: |
| /* At this point, res is negative, zero, or positive if reg[P1] is |
| ** less than, equal to, or greater than reg[P3], respectively. Compute |
| ** the answer to this operator in res2, depending on what the comparison |
| ** operator actually is. The next block of code depends on the fact |
| ** that the 6 comparison operators are consecutive integers in this |
| ** order: NE, EQ, GT, LE, LT, GE */ |
| assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 ); |
| assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 ); |
| if( res<0 ){ /* ne, eq, gt, le, lt, ge */ |
| static const unsigned char aLTb[] = { 1, 0, 0, 1, 1, 0 }; |
| res2 = aLTb[pOp->opcode - OP_Ne]; |
| }else if( res==0 ){ |
| static const unsigned char aEQb[] = { 0, 1, 0, 1, 0, 1 }; |
| res2 = aEQb[pOp->opcode - OP_Ne]; |
| }else{ |
| static const unsigned char aGTb[] = { 1, 0, 1, 0, 0, 1 }; |
| res2 = aGTb[pOp->opcode - OP_Ne]; |
| } |
| |
| /* Undo any changes made by applyAffinity() to the input registers. */ |
| assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) ); |
| pIn1->flags = flags1; |
| assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) ); |
| pIn3->flags = flags3; |
| |
| if( pOp->p5 & SQLITE_STOREP2 ){ |
| pOut = &aMem[pOp->p2]; |
| iCompare = res; |
| if( (pOp->p5 & SQLITE_KEEPNULL)!=0 ){ |
| /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1 |
| ** and prevents OP_Ne from overwriting NULL with 0. This flag |
| ** is only used in contexts where either: |
| ** (1) op==OP_Eq && (r[P2]==NULL || r[P2]==0) |
| ** (2) op==OP_Ne && (r[P2]==NULL || r[P2]==1) |
| ** Therefore it is not necessary to check the content of r[P2] for |
| ** NULL. */ |
| assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq ); |
| assert( res2==0 || res2==1 ); |
| testcase( res2==0 && pOp->opcode==OP_Eq ); |
| testcase( res2==1 && pOp->opcode==OP_Eq ); |
| testcase( res2==0 && pOp->opcode==OP_Ne ); |
| testcase( res2==1 && pOp->opcode==OP_Ne ); |
| if( (pOp->opcode==OP_Eq)==res2 ) break; |
| } |
| memAboutToChange(p, pOut); |
| MemSetTypeFlag(pOut, MEM_Int); |
| pOut->u.i = res2; |
| REGISTER_TRACE(pOp->p2, pOut); |
| }else{ |
| VdbeBranchTaken(res!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3); |
| if( res2 ){ |
| goto jump_to_p2; |
| } |
| } |
| break; |
| } |
| |
| /* Opcode: ElseNotEq * P2 * * * |
| ** |
| ** This opcode must immediately follow an OP_Lt or OP_Gt comparison operator. |
| ** If result of an OP_Eq comparison on the same two operands |
| ** would have be NULL or false (0), then then jump to P2. |
| ** If the result of an OP_Eq comparison on the two previous operands |
| ** would have been true (1), then fall through. |
| */ |
| case OP_ElseNotEq: { /* same as TK_ESCAPE, jump */ |
| assert( pOp>aOp ); |
| assert( pOp[-1].opcode==OP_Lt || pOp[-1].opcode==OP_Gt ); |
| assert( pOp[-1].p5 & SQLITE_STOREP2 ); |
| VdbeBranchTaken(iCompare!=0, 2); |
| if( iCompare!=0 ) goto jump_to_p2; |
| break; |
| } |
| |
| |
| /* Opcode: Permutation * * * P4 * |
| ** |
| ** Set the permutation used by the OP_Compare operator in the next |
| ** instruction. The permutation is stored in the P4 operand. |
| ** |
| ** The permutation is only valid until the next OP_Compare that has |
| ** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should |
| ** occur immediately prior to the OP_Compare. |
| ** |
| ** The first integer in the P4 integer array is the length of the array |
| ** and does not become part of the permutation. |
| */ |
| case OP_Permutation: { |
| assert( pOp->p4type==P4_INTARRAY ); |
| assert( pOp->p4.ai ); |
| assert( pOp[1].opcode==OP_Compare ); |
| assert( pOp[1].p5 & OPFLAG_PERMUTE ); |
| break; |
| } |
| |
| /* Opcode: Compare P1 P2 P3 P4 P5 |
| ** Synopsis: r[P1@P3] <-> r[P2@P3] |
| ** |
| ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this |
| ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B"). Save the result of |
| ** the comparison for use by the next OP_Jump instruct. |
| ** |
| ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is |
| ** determined by the most recent OP_Permutation operator. If the |
| ** OPFLAG_PERMUTE bit is clear, then register are compared in sequential |
| ** order. |
| ** |
| ** P4 is a KeyInfo structure that defines collating sequences and sort |
| ** orders for the comparison. The permutation applies to registers |
| ** only. The KeyInfo elements are used sequentially. |
| ** |
| ** The comparison is a sort comparison, so NULLs compare equal, |
| ** NULLs are less than numbers, numbers are less than strings, |
| ** and strings are less than blobs. |
| */ |
| case OP_Compare: { |
| int n; |
| int i; |
| int p1; |
| int p2; |
| const KeyInfo *pKeyInfo; |
| int idx; |
| CollSeq *pColl; /* Collating sequence to use on this term */ |
| int bRev; /* True for DESCENDING sort order */ |
| int *aPermute; /* The permutation */ |
| |
| if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){ |
| aPermute = 0; |
| }else{ |
| assert( pOp>aOp ); |
| assert( pOp[-1].opcode==OP_Permutation ); |
| assert( pOp[-1].p4type==P4_INTARRAY ); |
| aPermute = pOp[-1].p4.ai + 1; |
| assert( aPermute!=0 ); |
| } |
| n = pOp->p3; |
| pKeyInfo = pOp->p4.pKeyInfo; |
| assert( n>0 ); |
| assert( pKeyInfo!=0 ); |
| p1 = pOp->p1; |
| p2 = pOp->p2; |
| #ifdef SQLITE_DEBUG |
| if( aPermute ){ |
| int k, mx = 0; |
| for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k]; |
| assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 ); |
| assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 ); |
| }else{ |
| assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 ); |
| assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 ); |
| } |
| #endif /* SQLITE_DEBUG */ |
| for(i=0; i<n; i++){ |
| idx = aPermute ? aPermute[i] : i; |
| assert( memIsValid(&aMem[p1+idx]) ); |
| assert( memIsValid(&aMem[p2+idx]) ); |
| REGISTER_TRACE(p1+idx, &aMem[p1+idx]); |
| REGISTER_TRACE(p2+idx, &aMem[p2+idx]); |
| assert( i<pKeyInfo->nKeyField ); |
| pColl = pKeyInfo->aColl[i]; |
| bRev = pKeyInfo->aSortOrder[i]; |
| iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl); |
| if( iCompare ){ |
| if( bRev ) iCompare = -iCompare; |
| break; |
| } |
| } |
| break; |
| } |
| |
| /* Opcode: Jump P1 P2 P3 * * |
| ** |
| ** Jump to the instruction at address P1, P2, or P3 depending on whether |
| ** in the most recent OP_Compare instruction the P1 vector was less than |
| ** equal to, or greater than the P2 vector, respectively. |
| */ |
| case OP_Jump: { /* jump */ |
| if( iCompare<0 ){ |
| VdbeBranchTaken(0,4); pOp = &aOp[pOp->p1 - 1]; |
| }else if( iCompare==0 ){ |
| VdbeBranchTaken(1,4); pOp = &aOp[pOp->p2 - 1]; |
| }else{ |
| VdbeBranchTaken(2,4); pOp = &aOp[pOp->p3 - 1]; |
| } |
| break; |
| } |
| |
| /* Opcode: And P1 P2 P3 * * |
| ** Synopsis: r[P3]=(r[P1] && r[P2]) |
| ** |
| ** Take the logical AND of the values in registers P1 and P2 and |
| ** write the result into register P3. |
| ** |
| ** If either P1 or P2 is 0 (false) then the result is 0 even if |
| ** the other input is NULL. A NULL and true or two NULLs give |
| ** a NULL output. |
| */ |
| /* Opcode: Or P1 P2 P3 * * |
| ** Synopsis: r[P3]=(r[P1] || r[P2]) |
| ** |
| ** Take the logical OR of the values in register P1 and P2 and |
| ** store the answer in register P3. |
| ** |
| ** If either P1 or P2 is nonzero (true) then the result is 1 (true) |
| ** even if the other input is NULL. A NULL and false or two NULLs |
| ** give a NULL output. |
| */ |
| case OP_And: /* same as TK_AND, in1, in2, out3 */ |
| case OP_Or: { /* same as TK_OR, in1, in2, out3 */ |
| int v1; /* Left operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ |
| int v2; /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */ |
| |
| v1 = sqlite3VdbeBooleanValue(&aMem[pOp->p1], 2); |
| v2 = sqlite3VdbeBooleanValue(&aMem[pOp->p2], 2); |
| if( pOp->opcode==OP_And ){ |
| static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 }; |
| v1 = and_logic[v1*3+v2]; |
| }else{ |
| static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 }; |
| v1 = or_logic[v1*3+v2]; |
| } |
| pOut = &aMem[pOp->p3]; |
| if( v1==2 ){ |
| MemSetTypeFlag(pOut, MEM_Null); |
| }else{ |
| pOut->u.i = v1; |
| MemSetTypeFlag(pOut, MEM_Int); |
| } |
| break; |
| } |
| |
| /* Opcode: IsTrue P1 P2 P3 P4 * |
| ** Synopsis: r[P2] = coalesce(r[P1]==TRUE,P3) ^ P4 |
| ** |
| ** This opcode implements the IS TRUE, IS FALSE, IS NOT TRUE, and |
| ** IS NOT FALSE operators. |
| ** |
| ** Interpret the value in register P1 as a boolean value. Store that |
| ** boolean (a 0 or 1) in register P2. Or if the value in register P1 is |
| ** NULL, then the P3 is stored in register P2. Invert the answer if P4 |
| ** is 1. |
| ** |
| ** The logic is summarized like this: |
| ** |
| ** <ul> |
| ** <li> If P3==0 and P4==0 then r[P2] := r[P1] IS TRUE |
| ** <li> If P3==1 and P4==1 then r[P2] := r[P1] IS FALSE |
| ** <li> If P3==0 and P4==1 then r[P2] := r[P1] IS NOT TRUE |
| ** <li> If P3==1 and P4==0 then r[P2] := r[P1] IS NOT FALSE |
| ** </ul> |
| */ |
| case OP_IsTrue: { /* in1, out2 */ |
| assert( pOp->p4type==P4_INT32 ); |
| assert( pOp->p4.i==0 || pOp->p4.i==1 ); |
| assert( pOp->p3==0 || pOp->p3==1 ); |
| sqlite3VdbeMemSetInt64(&aMem[pOp->p2], |
| sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3) ^ pOp->p4.i); |
| break; |
| } |
| |
| /* Opcode: Not P1 P2 * * * |
| ** Synopsis: r[P2]= !r[P1] |
| ** |
| ** Interpret the value in register P1 as a boolean value. Store the |
| ** boolean complement in register P2. If the value in register P1 is |
| ** NULL, then a NULL is stored in P2. |
| */ |
| case OP_Not: { /* same as TK_NOT, in1, out2 */ |
| pIn1 = &aMem[pOp->p1]; |
| pOut = &aMem[pOp->p2]; |
| if( (pIn1->flags & MEM_Null)==0 ){ |
| sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeBooleanValue(pIn1,0)); |
| }else{ |
| sqlite3VdbeMemSetNull(pOut); |
| } |
| break; |
| } |
| |
| /* Opcode: BitNot P1 P2 * * * |
| ** Synopsis: r[P2]= ~r[P1] |
| ** |
| ** Interpret the content of register P1 as an integer. Store the |
| ** ones-complement of the P1 value into register P2. If P1 holds |
| ** a NULL then store a NULL in P2. |
| */ |
| case OP_BitNot: { /* same as TK_BITNOT, in1, out2 */ |
| pIn1 = &aMem[pOp->p1]; |
| pOut = &aMem[pOp->p2]; |
| sqlite3VdbeMemSetNull(pOut); |
| if( (pIn1->flags & MEM_Null)==0 ){ |
| pOut->flags = MEM_Int; |
| pOut->u.i = ~sqlite3VdbeIntValue(pIn1); |
| } |
| break; |
| } |
| |
| /* Opcode: Once P1 P2 * * * |
| ** |
| ** Fall through to the next instruction the first time this opcode is |
| ** encountered on each invocation of the byte-code program. Jump to P2 |
| ** on the second and all subsequent encounters during the same invocation. |
| ** |
| ** Top-level programs determine first invocation by comparing the P1 |
| ** operand against the P1 operand on the OP_Init opcode at the beginning |
| ** of the program. If the P1 values differ, then fall through and make |
| ** the P1 of this opcode equal to the P1 of OP_Init. If P1 values are |
| ** the same then take the jump. |
| ** |
| ** For subprograms, there is a bitmask in the VdbeFrame that determines |
| ** whether or not the jump should be taken. The bitmask is necessary |
| ** because the self-altering code trick does not work for recursive |
| ** triggers. |
| */ |
| case OP_Once: { /* jump */ |
| u32 iAddr; /* Address of this instruction */ |
| assert( p->aOp[0].opcode==OP_Init ); |
| if( p->pFrame ){ |
| iAddr = (int)(pOp - p->aOp); |
| if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){ |
| VdbeBranchTaken(1, 2); |
| goto jump_to_p2; |
| } |
| p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7); |
| }else{ |
| if( p->aOp[0].p1==pOp->p1 ){ |
| VdbeBranchTaken(1, 2); |
| goto jump_to_p2; |
| } |
| } |
| VdbeBranchTaken(0, 2); |
| pOp->p1 = p->aOp[0].p1; |
| break; |
| } |
| |
| /* Opcode: If P1 P2 P3 * * |
| ** |
| ** Jump to P2 if the value in register P1 is true. The value |
| ** is considered true if it is numeric and non-zero. If the value |
| ** in P1 is NULL then take the jump if and only if P3 is non-zero. |
| */ |
| case OP_If: { /* jump, in1 */ |
| int c; |
| c = sqlite3VdbeBooleanValue(&aMem[pOp->p1], pOp->p3); |
| VdbeBranchTaken(c!=0, 2); |
| if( c ) goto jump_to_p2; |
| break; |
| } |
| |
| /* Opcode: IfNot P1 P2 P3 * * |
| ** |
| ** Jump to P2 if the value in register P1 is False. The value |
| ** is considered false if it has a numeric value of zero. If the value |
| ** in P1 is NULL then take the jump if and only if P3 is non-zero. |
| */ |
| case OP_IfNot: { /* jump, in1 */ |
| int c; |
| c = !sqlite3VdbeBooleanValue(&aMem[pOp->p1], !pOp->p3); |
| VdbeBranchTaken(c!=0, 2); |
| if( c ) goto jump_to_p2; |
| break; |
| } |
| |
| /* Opcode: IsNull P1 P2 * * * |
| ** Synopsis: if r[P1]==NULL goto P2 |
| ** |
| ** Jump to P2 if the value in register P1 is NULL. |
| */ |
| case OP_IsNull: { /* same as TK_ISNULL, jump, in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2); |
| if( (pIn1->flags & MEM_Null)!=0 ){ |
| goto jump_to_p2; |
| } |
| break; |
| } |
| |
| /* Opcode: NotNull P1 P2 * * * |
| ** Synopsis: if r[P1]!=NULL goto P2 |
| ** |
| ** Jump to P2 if the value in register P1 is not NULL. |
| */ |
| case OP_NotNull: { /* same as TK_NOTNULL, jump, in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2); |
| if( (pIn1->flags & MEM_Null)==0 ){ |
| goto jump_to_p2; |
| } |
| break; |
| } |
| |
| /* Opcode: IfNullRow P1 P2 P3 * * |
| ** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2 |
| ** |
| ** Check the cursor P1 to see if it is currently pointing at a NULL row. |
| ** If it is, then set register P3 to NULL and jump immediately to P2. |
| ** If P1 is not on a NULL row, then fall through without making any |
| ** changes. |
| */ |
| case OP_IfNullRow: { /* jump */ |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( p->apCsr[pOp->p1]!=0 ); |
| if( p->apCsr[pOp->p1]->nullRow ){ |
| sqlite3VdbeMemSetNull(aMem + pOp->p3); |
| goto jump_to_p2; |
| } |
| break; |
| } |
| |
| #ifdef SQLITE_ENABLE_OFFSET_SQL_FUNC |
| /* Opcode: Offset P1 P2 P3 * * |
| ** Synopsis: r[P3] = sqlite_offset(P1) |
| ** |
| ** Store in register r[P3] the byte offset into the database file that is the |
| ** start of the payload for the record at which that cursor P1 is currently |
| ** pointing. |
| ** |
| ** P2 is the column number for the argument to the sqlite_offset() function. |
| ** This opcode does not use P2 itself, but the P2 value is used by the |
| ** code generator. The P1, P2, and P3 operands to this opcode are the |
| ** same as for OP_Column. |
| ** |
| ** This opcode is only available if SQLite is compiled with the |
| ** -DSQLITE_ENABLE_OFFSET_SQL_FUNC option. |
| */ |
| case OP_Offset: { /* out3 */ |
| VdbeCursor *pC; /* The VDBE cursor */ |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| pOut = &p->aMem[pOp->p3]; |
| if( NEVER(pC==0) || pC->eCurType!=CURTYPE_BTREE ){ |
| sqlite3VdbeMemSetNull(pOut); |
| }else{ |
| sqlite3VdbeMemSetInt64(pOut, sqlite3BtreeOffset(pC->uc.pCursor)); |
| } |
| break; |
| } |
| #endif /* SQLITE_ENABLE_OFFSET_SQL_FUNC */ |
| |
| /* Opcode: Column P1 P2 P3 P4 P5 |
| ** Synopsis: r[P3]=PX |
| ** |
| ** Interpret the data that cursor P1 points to as a structure built using |
| ** the MakeRecord instruction. (See the MakeRecord opcode for additional |
| ** information about the format of the data.) Extract the P2-th column |
| ** from this record. If there are less that (P2+1) |
| ** values in the record, extract a NULL. |
| ** |
| ** The value extracted is stored in register P3. |
| ** |
| ** If the record contains fewer than P2 fields, then extract a NULL. Or, |
| ** if the P4 argument is a P4_MEM use the value of the P4 argument as |
| ** the result. |
| ** |
| ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor, |
| ** then the cache of the cursor is reset prior to extracting the column. |
| ** The first OP_Column against a pseudo-table after the value of the content |
| ** register has changed should have this bit set. |
| ** |
| ** If the OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG bits are set on P5 then |
| ** the result is guaranteed to only be used as the argument of a length() |
| ** or typeof() function, respectively. The loading of large blobs can be |
| ** skipped for length() and all content loading can be skipped for typeof(). |
| */ |
| case OP_Column: { |
| int p2; /* column number to retrieve */ |
| VdbeCursor *pC; /* The VDBE cursor */ |
| BtCursor *pCrsr; /* The BTree cursor */ |
| u32 *aOffset; /* aOffset[i] is offset to start of data for i-th column */ |
| int len; /* The length of the serialized data for the column */ |
| int i; /* Loop counter */ |
| Mem *pDest; /* Where to write the extracted value */ |
| Mem sMem; /* For storing the record being decoded */ |
| const u8 *zData; /* Part of the record being decoded */ |
| const u8 *zHdr; /* Next unparsed byte of the header */ |
| const u8 *zEndHdr; /* Pointer to first byte after the header */ |
| u64 offset64; /* 64-bit offset */ |
| u32 t; /* A type code from the record header */ |
| Mem *pReg; /* PseudoTable input register */ |
| |
| pC = p->apCsr[pOp->p1]; |
| p2 = pOp->p2; |
| |
| /* If the cursor cache is stale (meaning it is not currently point at |
| ** the correct row) then bring it up-to-date by doing the necessary |
| ** B-Tree seek. */ |
| rc = sqlite3VdbeCursorMoveto(&pC, &p2); |
| if( rc ) goto abort_due_to_error; |
| |
| assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| pDest = &aMem[pOp->p3]; |
| memAboutToChange(p, pDest); |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( pC!=0 ); |
| assert( p2<pC->nField ); |
| aOffset = pC->aOffset; |
| assert( pC->eCurType!=CURTYPE_VTAB ); |
| assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); |
| assert( pC->eCurType!=CURTYPE_SORTER ); |
| |
| if( pC->cacheStatus!=p->cacheCtr ){ /*OPTIMIZATION-IF-FALSE*/ |
| if( pC->nullRow ){ |
| if( pC->eCurType==CURTYPE_PSEUDO ){ |
| /* For the special case of as pseudo-cursor, the seekResult field |
| ** identifies the register that holds the record */ |
| assert( pC->seekResult>0 ); |
| pReg = &aMem[pC->seekResult]; |
| assert( pReg->flags & MEM_Blob ); |
| assert( memIsValid(pReg) ); |
| pC->payloadSize = pC->szRow = pReg->n; |
| pC->aRow = (u8*)pReg->z; |
| }else{ |
| sqlite3VdbeMemSetNull(pDest); |
| goto op_column_out; |
| } |
| }else{ |
| pCrsr = pC->uc.pCursor; |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pCrsr ); |
| assert( sqlite3BtreeCursorIsValid(pCrsr) ); |
| pC->payloadSize = sqlite3BtreePayloadSize(pCrsr); |
| pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow); |
| assert( pC->szRow<=pC->payloadSize ); |
| assert( pC->szRow<=65536 ); /* Maximum page size is 64KiB */ |
| if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
| goto too_big; |
| } |
| } |
| pC->cacheStatus = p->cacheCtr; |
| pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]); |
| pC->nHdrParsed = 0; |
| |
| |
| if( pC->szRow<aOffset[0] ){ /*OPTIMIZATION-IF-FALSE*/ |
| /* pC->aRow does not have to hold the entire row, but it does at least |
| ** need to cover the header of the record. If pC->aRow does not contain |
| ** the complete header, then set it to zero, forcing the header to be |
| ** dynamically allocated. */ |
| pC->aRow = 0; |
| pC->szRow = 0; |
| |
| /* Make sure a corrupt database has not given us an oversize header. |
| ** Do this now to avoid an oversize memory allocation. |
| ** |
| ** Type entries can be between 1 and 5 bytes each. But 4 and 5 byte |
| ** types use so much data space that there can only be 4096 and 32 of |
| ** them, respectively. So the maximum header length results from a |
| ** 3-byte type for each of the maximum of 32768 columns plus three |
| ** extra bytes for the header length itself. 32768*3 + 3 = 98307. |
| */ |
| if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){ |
| goto op_column_corrupt; |
| } |
| }else{ |
| /* This is an optimization. By skipping over the first few tests |
| ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a |
| ** measurable performance gain. |
| ** |
| ** This branch is taken even if aOffset[0]==0. Such a record is never |
| ** generated by SQLite, and could be considered corruption, but we |
| ** accept it for historical reasons. When aOffset[0]==0, the code this |
| ** branch jumps to reads past the end of the record, but never more |
| ** than a few bytes. Even if the record occurs at the end of the page |
| ** content area, the "page header" comes after the page content and so |
| ** this overread is harmless. Similar overreads can occur for a corrupt |
| ** database file. |
| */ |
| zData = pC->aRow; |
| assert( pC->nHdrParsed<=p2 ); /* Conditional skipped */ |
| testcase( aOffset[0]==0 ); |
| goto op_column_read_header; |
| } |
| } |
| |
| /* Make sure at least the first p2+1 entries of the header have been |
| ** parsed and valid information is in aOffset[] and pC->aType[]. |
| */ |
| if( pC->nHdrParsed<=p2 ){ |
| /* If there is more header available for parsing in the record, try |
| ** to extract additional fields up through the p2+1-th field |
| */ |
| if( pC->iHdrOffset<aOffset[0] ){ |
| /* Make sure zData points to enough of the record to cover the header. */ |
| if( pC->aRow==0 ){ |
| memset(&sMem, 0, sizeof(sMem)); |
| rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, 0, aOffset[0], &sMem); |
| if( rc!=SQLITE_OK ) goto abort_due_to_error; |
| zData = (u8*)sMem.z; |
| }else{ |
| zData = pC->aRow; |
| } |
| |
| /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */ |
| op_column_read_header: |
| i = pC->nHdrParsed; |
| offset64 = aOffset[i]; |
| zHdr = zData + pC->iHdrOffset; |
| zEndHdr = zData + aOffset[0]; |
| testcase( zHdr>=zEndHdr ); |
| do{ |
| if( (t = zHdr[0])<0x80 ){ |
| zHdr++; |
| offset64 += sqlite3VdbeOneByteSerialTypeLen(t); |
| }else{ |
| zHdr += sqlite3GetVarint32(zHdr, &t); |
| offset64 += sqlite3VdbeSerialTypeLen(t); |
| } |
| pC->aType[i++] = t; |
| aOffset[i] = (u32)(offset64 & 0xffffffff); |
| }while( i<=p2 && zHdr<zEndHdr ); |
| |
| /* The record is corrupt if any of the following are true: |
| ** (1) the bytes of the header extend past the declared header size |
| ** (2) the entire header was used but not all data was used |
| ** (3) the end of the data extends beyond the end of the record. |
| */ |
| if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize)) |
| || (offset64 > pC->payloadSize) |
| ){ |
| if( aOffset[0]==0 ){ |
| i = 0; |
| zHdr = zEndHdr; |
| }else{ |
| if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); |
| goto op_column_corrupt; |
| } |
| } |
| |
| pC->nHdrParsed = i; |
| pC->iHdrOffset = (u32)(zHdr - zData); |
| if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem); |
| }else{ |
| t = 0; |
| } |
| |
| /* If after trying to extract new entries from the header, nHdrParsed is |
| ** still not up to p2, that means that the record has fewer than p2 |
| ** columns. So the result will be either the default value or a NULL. |
| */ |
| if( pC->nHdrParsed<=p2 ){ |
| if( pOp->p4type==P4_MEM ){ |
| sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static); |
| }else{ |
| sqlite3VdbeMemSetNull(pDest); |
| } |
| goto op_column_out; |
| } |
| }else{ |
| t = pC->aType[p2]; |
| } |
| |
| /* Extract the content for the p2+1-th column. Control can only |
| ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are |
| ** all valid. |
| */ |
| assert( p2<pC->nHdrParsed ); |
| assert( rc==SQLITE_OK ); |
| assert( sqlite3VdbeCheckMemInvariants(pDest) ); |
| if( VdbeMemDynamic(pDest) ){ |
| sqlite3VdbeMemSetNull(pDest); |
| } |
| assert( t==pC->aType[p2] ); |
| if( pC->szRow>=aOffset[p2+1] ){ |
| /* This is the common case where the desired content fits on the original |
| ** page - where the content is not on an overflow page */ |
| zData = pC->aRow + aOffset[p2]; |
| if( t<12 ){ |
| sqlite3VdbeSerialGet(zData, t, pDest); |
| }else{ |
| /* If the column value is a string, we need a persistent value, not |
| ** a MEM_Ephem value. This branch is a fast short-cut that is equivalent |
| ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize(). |
| */ |
| static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term }; |
| pDest->n = len = (t-12)/2; |
| pDest->enc = encoding; |
| if( pDest->szMalloc < len+2 ){ |
| pDest->flags = MEM_Null; |
| if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem; |
| }else{ |
| pDest->z = pDest->zMalloc; |
| } |
| memcpy(pDest->z, zData, len); |
| pDest->z[len] = 0; |
| pDest->z[len+1] = 0; |
| pDest->flags = aFlag[t&1]; |
| } |
| }else{ |
| pDest->enc = encoding; |
| /* This branch happens only when content is on overflow pages */ |
| if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0 |
| && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0)) |
| || (len = sqlite3VdbeSerialTypeLen(t))==0 |
| ){ |
| /* Content is irrelevant for |
| ** 1. the typeof() function, |
| ** 2. the length(X) function if X is a blob, and |
| ** 3. if the content length is zero. |
| ** So we might as well use bogus content rather than reading |
| ** content from disk. |
| ** |
| ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the |
| ** buffer passed to it, debugging function VdbeMemPrettyPrint() may |
| ** read up to 16. So 16 bytes of bogus content is supplied. |
| */ |
| static u8 aZero[16]; /* This is the bogus content */ |
| sqlite3VdbeSerialGet(aZero, t, pDest); |
| }else{ |
| rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest); |
| if( rc!=SQLITE_OK ) goto abort_due_to_error; |
| sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest); |
| pDest->flags &= ~MEM_Ephem; |
| } |
| } |
| |
| op_column_out: |
| UPDATE_MAX_BLOBSIZE(pDest); |
| REGISTER_TRACE(pOp->p3, pDest); |
| break; |
| |
| op_column_corrupt: |
| if( aOp[0].p3>0 ){ |
| pOp = &aOp[aOp[0].p3-1]; |
| break; |
| }else{ |
| rc = SQLITE_CORRUPT_BKPT; |
| goto abort_due_to_error; |
| } |
| } |
| |
| /* Opcode: Affinity P1 P2 * P4 * |
| ** Synopsis: affinity(r[P1@P2]) |
| ** |
| ** Apply affinities to a range of P2 registers starting with P1. |
| ** |
| ** P4 is a string that is P2 characters long. The N-th character of the |
| ** string indicates the column affinity that should be used for the N-th |
| ** memory cell in the range. |
| */ |
| case OP_Affinity: { |
| const char *zAffinity; /* The affinity to be applied */ |
| |
| zAffinity = pOp->p4.z; |
| assert( zAffinity!=0 ); |
| assert( pOp->p2>0 ); |
| assert( zAffinity[pOp->p2]==0 ); |
| pIn1 = &aMem[pOp->p1]; |
| do{ |
| assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] ); |
| assert( memIsValid(pIn1) ); |
| applyAffinity(pIn1, *(zAffinity++), encoding); |
| pIn1++; |
| }while( zAffinity[0] ); |
| break; |
| } |
| |
| /* Opcode: MakeRecord P1 P2 P3 P4 * |
| ** Synopsis: r[P3]=mkrec(r[P1@P2]) |
| ** |
| ** Convert P2 registers beginning with P1 into the [record format] |
| ** use as a data record in a database table or as a key |
| ** in an index. The OP_Column opcode can decode the record later. |
| ** |
| ** P4 may be a string that is P2 characters long. The N-th character of the |
| ** string indicates the column affinity that should be used for the N-th |
| ** field of the index key. |
| ** |
| ** The mapping from character to affinity is given by the SQLITE_AFF_ |
| ** macros defined in sqliteInt.h. |
| ** |
| ** If P4 is NULL then all index fields have the affinity BLOB. |
| */ |
| case OP_MakeRecord: { |
| u8 *zNewRecord; /* A buffer to hold the data for the new record */ |
| Mem *pRec; /* The new record */ |
| u64 nData; /* Number of bytes of data space */ |
| int nHdr; /* Number of bytes of header space */ |
| i64 nByte; /* Data space required for this record */ |
| i64 nZero; /* Number of zero bytes at the end of the record */ |
| int nVarint; /* Number of bytes in a varint */ |
| u32 serial_type; /* Type field */ |
| Mem *pData0; /* First field to be combined into the record */ |
| Mem *pLast; /* Last field of the record */ |
| int nField; /* Number of fields in the record */ |
| char *zAffinity; /* The affinity string for the record */ |
| int file_format; /* File format to use for encoding */ |
| int i; /* Space used in zNewRecord[] header */ |
| int j; /* Space used in zNewRecord[] content */ |
| u32 len; /* Length of a field */ |
| |
| /* Assuming the record contains N fields, the record format looks |
| ** like this: |
| ** |
| ** ------------------------------------------------------------------------ |
| ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | |
| ** ------------------------------------------------------------------------ |
| ** |
| ** Data(0) is taken from register P1. Data(1) comes from register P1+1 |
| ** and so forth. |
| ** |
| ** Each type field is a varint representing the serial type of the |
| ** corresponding data element (see sqlite3VdbeSerialType()). The |
| ** hdr-size field is also a varint which is the offset from the beginning |
| ** of the record to data0. |
| */ |
| nData = 0; /* Number of bytes of data space */ |
| nHdr = 0; /* Number of bytes of header space */ |
| nZero = 0; /* Number of zero bytes at the end of the record */ |
| nField = pOp->p1; |
| zAffinity = pOp->p4.z; |
| assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 ); |
| pData0 = &aMem[nField]; |
| nField = pOp->p2; |
| pLast = &pData0[nField-1]; |
| file_format = p->minWriteFileFormat; |
| |
| /* Identify the output register */ |
| assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 ); |
| pOut = &aMem[pOp->p3]; |
| memAboutToChange(p, pOut); |
| |
| /* Apply the requested affinity to all inputs |
| */ |
| assert( pData0<=pLast ); |
| if( zAffinity ){ |
| pRec = pData0; |
| do{ |
| applyAffinity(pRec++, *(zAffinity++), encoding); |
| assert( zAffinity[0]==0 || pRec<=pLast ); |
| }while( zAffinity[0] ); |
| } |
| |
| #ifdef SQLITE_ENABLE_NULL_TRIM |
| /* NULLs can be safely trimmed from the end of the record, as long as |
| ** as the schema format is 2 or more and none of the omitted columns |
| ** have a non-NULL default value. Also, the record must be left with |
| ** at least one field. If P5>0 then it will be one more than the |
| ** index of the right-most column with a non-NULL default value */ |
| if( pOp->p5 ){ |
| while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){ |
| pLast--; |
| nField--; |
| } |
| } |
| #endif |
| |
| /* Loop through the elements that will make up the record to figure |
| ** out how much space is required for the new record. |
| */ |
| pRec = pLast; |
| do{ |
| assert( memIsValid(pRec) ); |
| serial_type = sqlite3VdbeSerialType(pRec, file_format, &len); |
| if( pRec->flags & MEM_Zero ){ |
| if( serial_type==0 ){ |
| /* Values with MEM_Null and MEM_Zero are created by xColumn virtual |
| ** table methods that never invoke sqlite3_result_xxxxx() while |
| ** computing an unchanging column value in an UPDATE statement. |
| ** Give such values a special internal-use-only serial-type of 10 |
| ** so that they can be passed through to xUpdate and have |
| ** a true sqlite3_value_nochange(). */ |
| assert( pOp->p5==OPFLAG_NOCHNG_MAGIC || CORRUPT_DB ); |
| serial_type = 10; |
| }else if( nData ){ |
| if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem; |
| }else{ |
| nZero += pRec->u.nZero; |
| len -= pRec->u.nZero; |
| } |
| } |
| nData += len; |
| testcase( serial_type==127 ); |
| testcase( serial_type==128 ); |
| nHdr += serial_type<=127 ? 1 : sqlite3VarintLen(serial_type); |
| pRec->uTemp = serial_type; |
| if( pRec==pData0 ) break; |
| pRec--; |
| }while(1); |
| |
| /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint |
| ** which determines the total number of bytes in the header. The varint |
| ** value is the size of the header in bytes including the size varint |
| ** itself. */ |
| testcase( nHdr==126 ); |
| testcase( nHdr==127 ); |
| if( nHdr<=126 ){ |
| /* The common case */ |
| nHdr += 1; |
| }else{ |
| /* Rare case of a really large header */ |
| nVarint = sqlite3VarintLen(nHdr); |
| nHdr += nVarint; |
| if( nVarint<sqlite3VarintLen(nHdr) ) nHdr++; |
| } |
| nByte = nHdr+nData; |
| |
| /* Make sure the output register has a buffer large enough to store |
| ** the new record. The output register (pOp->p3) is not allowed to |
| ** be one of the input registers (because the following call to |
| ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used). |
| */ |
| if( nByte+nZero<=pOut->szMalloc ){ |
| /* The output register is already large enough to hold the record. |
| ** No error checks or buffer enlargement is required */ |
| pOut->z = pOut->zMalloc; |
| }else{ |
| /* Need to make sure that the output is not too big and then enlarge |
| ** the output register to hold the full result */ |
| if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
| goto too_big; |
| } |
| if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){ |
| goto no_mem; |
| } |
| } |
| zNewRecord = (u8 *)pOut->z; |
| |
| /* Write the record */ |
| i = putVarint32(zNewRecord, nHdr); |
| j = nHdr; |
| assert( pData0<=pLast ); |
| pRec = pData0; |
| do{ |
| serial_type = pRec->uTemp; |
| /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more |
| ** additional varints, one per column. */ |
| i += putVarint32(&zNewRecord[i], serial_type); /* serial type */ |
| /* EVIDENCE-OF: R-64536-51728 The values for each column in the record |
| ** immediately follow the header. */ |
| j += sqlite3VdbeSerialPut(&zNewRecord[j], pRec, serial_type); /* content */ |
| }while( (++pRec)<=pLast ); |
| assert( i==nHdr ); |
| assert( j==nByte ); |
| |
| assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| pOut->n = (int)nByte; |
| pOut->flags = MEM_Blob; |
| if( nZero ){ |
| pOut->u.nZero = nZero; |
| pOut->flags |= MEM_Zero; |
| } |
| REGISTER_TRACE(pOp->p3, pOut); |
| UPDATE_MAX_BLOBSIZE(pOut); |
| break; |
| } |
| |
| /* Opcode: Count P1 P2 * * * |
| ** Synopsis: r[P2]=count() |
| ** |
| ** Store the number of entries (an integer value) in the table or index |
| ** opened by cursor P1 in register P2 |
| */ |
| #ifndef SQLITE_OMIT_BTREECOUNT |
| case OP_Count: { /* out2 */ |
| i64 nEntry; |
| BtCursor *pCrsr; |
| |
| assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE ); |
| pCrsr = p->apCsr[pOp->p1]->uc.pCursor; |
| assert( pCrsr ); |
| nEntry = 0; /* Not needed. Only used to silence a warning. */ |
| rc = sqlite3BtreeCount(pCrsr, &nEntry); |
| if( rc ) goto abort_due_to_error; |
| pOut = out2Prerelease(p, pOp); |
| pOut->u.i = nEntry; |
| break; |
| } |
| #endif |
| |
| /* Opcode: Savepoint P1 * * P4 * |
| ** |
| ** Open, release or rollback the savepoint named by parameter P4, depending |
| ** on the value of P1. To open a new savepoint, P1==0. To release (commit) an |
| ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2. |
| */ |
| case OP_Savepoint: { |
| int p1; /* Value of P1 operand */ |
| char *zName; /* Name of savepoint */ |
| int nName; |
| Savepoint *pNew; |
| Savepoint *pSavepoint; |
| Savepoint *pTmp; |
| int iSavepoint; |
| int ii; |
| |
| p1 = pOp->p1; |
| zName = pOp->p4.z; |
| |
| /* Assert that the p1 parameter is valid. Also that if there is no open |
| ** transaction, then there cannot be any savepoints. |
| */ |
| assert( db->pSavepoint==0 || db->autoCommit==0 ); |
| assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK ); |
| assert( db->pSavepoint || db->isTransactionSavepoint==0 ); |
| assert( checkSavepointCount(db) ); |
| assert( p->bIsReader ); |
| |
| if( p1==SAVEPOINT_BEGIN ){ |
| if( db->nVdbeWrite>0 ){ |
| /* A new savepoint cannot be created if there are active write |
| ** statements (i.e. open read/write incremental blob handles). |
| */ |
| sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress"); |
| rc = SQLITE_BUSY; |
| }else{ |
| nName = sqlite3Strlen30(zName); |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* This call is Ok even if this savepoint is actually a transaction |
| ** savepoint (and therefore should not prompt xSavepoint()) callbacks. |
| ** If this is a transaction savepoint being opened, it is guaranteed |
| ** that the db->aVTrans[] array is empty. */ |
| assert( db->autoCommit==0 || db->nVTrans==0 ); |
| rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, |
| db->nStatement+db->nSavepoint); |
| if( rc!=SQLITE_OK ) goto abort_due_to_error; |
| #endif |
| |
| /* Create a new savepoint structure. */ |
| pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1); |
| if( pNew ){ |
| pNew->zName = (char *)&pNew[1]; |
| memcpy(pNew->zName, zName, nName+1); |
| |
| /* If there is no open transaction, then mark this as a special |
| ** "transaction savepoint". */ |
| if( db->autoCommit ){ |
| db->autoCommit = 0; |
| db->isTransactionSavepoint = 1; |
| }else{ |
| db->nSavepoint++; |
| } |
| |
| /* Link the new savepoint into the database handle's list. */ |
| pNew->pNext = db->pSavepoint; |
| db->pSavepoint = pNew; |
| pNew->nDeferredCons = db->nDeferredCons; |
| pNew->nDeferredImmCons = db->nDeferredImmCons; |
| } |
| } |
| }else{ |
| iSavepoint = 0; |
| |
| /* Find the named savepoint. If there is no such savepoint, then an |
| ** an error is returned to the user. */ |
| for( |
| pSavepoint = db->pSavepoint; |
| pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName); |
| pSavepoint = pSavepoint->pNext |
| ){ |
| iSavepoint++; |
| } |
| if( !pSavepoint ){ |
| sqlite3VdbeError(p, "no such savepoint: %s", zName); |
| rc = SQLITE_ERROR; |
| }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){ |
| /* It is not possible to release (commit) a savepoint if there are |
| ** active write statements. |
| */ |
| sqlite3VdbeError(p, "cannot release savepoint - " |
| "SQL statements in progress"); |
| rc = SQLITE_BUSY; |
| }else{ |
| |
| /* Determine whether or not this is a transaction savepoint. If so, |
| ** and this is a RELEASE command, then the current transaction |
| ** is committed. |
| */ |
| int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint; |
| if( isTransaction && p1==SAVEPOINT_RELEASE ){ |
| if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ |
| goto vdbe_return; |
| } |
| db->autoCommit = 1; |
| if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ |
| p->pc = (int)(pOp - aOp); |
| db->autoCommit = 0; |
| p->rc = rc = SQLITE_BUSY; |
| goto vdbe_return; |
| } |
| db->isTransactionSavepoint = 0; |
| rc = p->rc; |
| }else{ |
| int isSchemaChange; |
| iSavepoint = db->nSavepoint - iSavepoint - 1; |
| if( p1==SAVEPOINT_ROLLBACK ){ |
| isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0; |
| for(ii=0; ii<db->nDb; ii++){ |
| rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt, |
| SQLITE_ABORT_ROLLBACK, |
| isSchemaChange==0); |
| if( rc!=SQLITE_OK ) goto abort_due_to_error; |
| } |
| }else{ |
| isSchemaChange = 0; |
| } |
| for(ii=0; ii<db->nDb; ii++){ |
| rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint); |
| if( rc!=SQLITE_OK ){ |
| goto abort_due_to_error; |
| } |
| } |
| if( isSchemaChange ){ |
| sqlite3ExpirePreparedStatements(db, 0); |
| sqlite3ResetAllSchemasOfConnection(db); |
| db->mDbFlags |= DBFLAG_SchemaChange; |
| } |
| } |
| |
| /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all |
| ** savepoints nested inside of the savepoint being operated on. */ |
| while( db->pSavepoint!=pSavepoint ){ |
| pTmp = db->pSavepoint; |
| db->pSavepoint = pTmp->pNext; |
| sqlite3DbFree(db, pTmp); |
| db->nSavepoint--; |
| } |
| |
| /* If it is a RELEASE, then destroy the savepoint being operated on |
| ** too. If it is a ROLLBACK TO, then set the number of deferred |
| ** constraint violations present in the database to the value stored |
| ** when the savepoint was created. */ |
| if( p1==SAVEPOINT_RELEASE ){ |
| assert( pSavepoint==db->pSavepoint ); |
| db->pSavepoint = pSavepoint->pNext; |
| sqlite3DbFree(db, pSavepoint); |
| if( !isTransaction ){ |
| db->nSavepoint--; |
| } |
| }else{ |
| db->nDeferredCons = pSavepoint->nDeferredCons; |
| db->nDeferredImmCons = pSavepoint->nDeferredImmCons; |
| } |
| |
| if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){ |
| rc = sqlite3VtabSavepoint(db, p1, iSavepoint); |
| if( rc!=SQLITE_OK ) goto abort_due_to_error; |
| } |
| } |
| } |
| if( rc ) goto abort_due_to_error; |
| |
| break; |
| } |
| |
| /* Opcode: AutoCommit P1 P2 * * * |
| ** |
| ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll |
| ** back any currently active btree transactions. If there are any active |
| ** VMs (apart from this one), then a ROLLBACK fails. A COMMIT fails if |
| ** there are active writing VMs or active VMs that use shared cache. |
| ** |
| ** This instruction causes the VM to halt. |
| */ |
| case OP_AutoCommit: { |
| int desiredAutoCommit; |
| int iRollback; |
| |
| desiredAutoCommit = pOp->p1; |
| iRollback = pOp->p2; |
| assert( desiredAutoCommit==1 || desiredAutoCommit==0 ); |
| assert( desiredAutoCommit==1 || iRollback==0 ); |
| assert( db->nVdbeActive>0 ); /* At least this one VM is active */ |
| assert( p->bIsReader ); |
| |
| if( desiredAutoCommit!=db->autoCommit ){ |
| if( iRollback ){ |
| assert( desiredAutoCommit==1 ); |
| sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK); |
| db->autoCommit = 1; |
| }else if( desiredAutoCommit && db->nVdbeWrite>0 ){ |
| /* If this instruction implements a COMMIT and other VMs are writing |
| ** return an error indicating that the other VMs must complete first. |
| */ |
| sqlite3VdbeError(p, "cannot commit transaction - " |
| "SQL statements in progress"); |
| rc = SQLITE_BUSY; |
| goto abort_due_to_error; |
| }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){ |
| goto vdbe_return; |
| }else{ |
| db->autoCommit = (u8)desiredAutoCommit; |
| } |
| if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){ |
| p->pc = (int)(pOp - aOp); |
| db->autoCommit = (u8)(1-desiredAutoCommit); |
| p->rc = rc = SQLITE_BUSY; |
| goto vdbe_return; |
| } |
| assert( db->nStatement==0 ); |
| sqlite3CloseSavepoints(db); |
| if( p->rc==SQLITE_OK ){ |
| rc = SQLITE_DONE; |
| }else{ |
| rc = SQLITE_ERROR; |
| } |
| goto vdbe_return; |
| }else{ |
| sqlite3VdbeError(p, |
| (!desiredAutoCommit)?"cannot start a transaction within a transaction":( |
| (iRollback)?"cannot rollback - no transaction is active": |
| "cannot commit - no transaction is active")); |
| |
| rc = SQLITE_ERROR; |
| goto abort_due_to_error; |
| } |
| break; |
| } |
| |
| /* Opcode: Transaction P1 P2 P3 P4 P5 |
| ** |
| ** Begin a transaction on database P1 if a transaction is not already |
| ** active. |
| ** If P2 is non-zero, then a write-transaction is started, or if a |
| ** read-transaction is already active, it is upgraded to a write-transaction. |
| ** If P2 is zero, then a read-transaction is started. |
| ** |
| ** P1 is the index of the database file on which the transaction is |
| ** started. Index 0 is the main database file and index 1 is the |
| ** file used for temporary tables. Indices of 2 or more are used for |
| ** attached databases. |
| ** |
| ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is |
| ** true (this flag is set if the Vdbe may modify more than one row and may |
| ** throw an ABORT exception), a statement transaction may also be opened. |
| ** More specifically, a statement transaction is opened iff the database |
| ** connection is currently not in autocommit mode, or if there are other |
| ** active statements. A statement transaction allows the changes made by this |
| ** VDBE to be rolled back after an error without having to roll back the |
| ** entire transaction. If no error is encountered, the statement transaction |
| ** will automatically commit when the VDBE halts. |
| ** |
| ** If P5!=0 then this opcode also checks the schema cookie against P3 |
| ** and the schema generation counter against P4. |
| ** The cookie changes its value whenever the database schema changes. |
| ** This operation is used to detect when that the cookie has changed |
| ** and that the current process needs to reread the schema. If the schema |
| ** cookie in P3 differs from the schema cookie in the database header or |
| ** if the schema generation counter in P4 differs from the current |
| ** generation counter, then an SQLITE_SCHEMA error is raised and execution |
| ** halts. The sqlite3_step() wrapper function might then reprepare the |
| ** statement and rerun it from the beginning. |
| */ |
| case OP_Transaction: { |
| Btree *pBt; |
| int iMeta = 0; |
| |
| assert( p->bIsReader ); |
| assert( p->readOnly==0 || pOp->p2==0 ); |
| assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
| assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
| if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){ |
| rc = SQLITE_READONLY; |
| goto abort_due_to_error; |
| } |
| pBt = db->aDb[pOp->p1].pBt; |
| |
| if( pBt ){ |
| rc = sqlite3BtreeBeginTrans(pBt, pOp->p2, &iMeta); |
| testcase( rc==SQLITE_BUSY_SNAPSHOT ); |
| testcase( rc==SQLITE_BUSY_RECOVERY ); |
| if( rc!=SQLITE_OK ){ |
| if( (rc&0xff)==SQLITE_BUSY ){ |
| p->pc = (int)(pOp - aOp); |
| p->rc = rc; |
| goto vdbe_return; |
| } |
| goto abort_due_to_error; |
| } |
| |
| if( pOp->p2 && p->usesStmtJournal |
| && (db->autoCommit==0 || db->nVdbeRead>1) |
| ){ |
| assert( sqlite3BtreeIsInTrans(pBt) ); |
| if( p->iStatement==0 ){ |
| assert( db->nStatement>=0 && db->nSavepoint>=0 ); |
| db->nStatement++; |
| p->iStatement = db->nSavepoint + db->nStatement; |
| } |
| |
| rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3BtreeBeginStmt(pBt, p->iStatement); |
| } |
| |
| /* Store the current value of the database handles deferred constraint |
| ** counter. If the statement transaction needs to be rolled back, |
| ** the value of this counter needs to be restored too. */ |
| p->nStmtDefCons = db->nDeferredCons; |
| p->nStmtDefImmCons = db->nDeferredImmCons; |
| } |
| } |
| assert( pOp->p5==0 || pOp->p4type==P4_INT32 ); |
| if( pOp->p5 |
| && (iMeta!=pOp->p3 |
| || db->aDb[pOp->p1].pSchema->iGeneration!=pOp->p4.i) |
| ){ |
| /* |
| ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema |
| ** version is checked to ensure that the schema has not changed since the |
| ** SQL statement was prepared. |
| */ |
| sqlite3DbFree(db, p->zErrMsg); |
| p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed"); |
| /* If the schema-cookie from the database file matches the cookie |
| ** stored with the in-memory representation of the schema, do |
| ** not reload the schema from the database file. |
| ** |
| ** If virtual-tables are in use, this is not just an optimization. |
| ** Often, v-tables store their data in other SQLite tables, which |
| ** are queried from within xNext() and other v-table methods using |
| ** prepared queries. If such a query is out-of-date, we do not want to |
| ** discard the database schema, as the user code implementing the |
| ** v-table would have to be ready for the sqlite3_vtab structure itself |
| ** to be invalidated whenever sqlite3_step() is called from within |
| ** a v-table method. |
| */ |
| if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){ |
| sqlite3ResetOneSchema(db, pOp->p1); |
| } |
| p->expired = 1; |
| rc = SQLITE_SCHEMA; |
| } |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: ReadCookie P1 P2 P3 * * |
| ** |
| ** Read cookie number P3 from database P1 and write it into register P2. |
| ** P3==1 is the schema version. P3==2 is the database format. |
| ** P3==3 is the recommended pager cache size, and so forth. P1==0 is |
| ** the main database file and P1==1 is the database file used to store |
| ** temporary tables. |
| ** |
| ** There must be a read-lock on the database (either a transaction |
| ** must be started or there must be an open cursor) before |
| ** executing this instruction. |
| */ |
| case OP_ReadCookie: { /* out2 */ |
| int iMeta; |
| int iDb; |
| int iCookie; |
| |
| assert( p->bIsReader ); |
| iDb = pOp->p1; |
| iCookie = pOp->p3; |
| assert( pOp->p3<SQLITE_N_BTREE_META ); |
| assert( iDb>=0 && iDb<db->nDb ); |
| assert( db->aDb[iDb].pBt!=0 ); |
| assert( DbMaskTest(p->btreeMask, iDb) ); |
| |
| sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta); |
| pOut = out2Prerelease(p, pOp); |
| pOut->u.i = iMeta; |
| break; |
| } |
| |
| /* Opcode: SetCookie P1 P2 P3 * * |
| ** |
| ** Write the integer value P3 into cookie number P2 of database P1. |
| ** P2==1 is the schema version. P2==2 is the database format. |
| ** P2==3 is the recommended pager cache |
| ** size, and so forth. P1==0 is the main database file and P1==1 is the |
| ** database file used to store temporary tables. |
| ** |
| ** A transaction must be started before executing this opcode. |
| */ |
| case OP_SetCookie: { |
| Db *pDb; |
| |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| assert( pOp->p2<SQLITE_N_BTREE_META ); |
| assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
| assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
| assert( p->readOnly==0 ); |
| pDb = &db->aDb[pOp->p1]; |
| assert( pDb->pBt!=0 ); |
| assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) ); |
| /* See note about index shifting on OP_ReadCookie */ |
| rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3); |
| if( pOp->p2==BTREE_SCHEMA_VERSION ){ |
| /* When the schema cookie changes, record the new cookie internally */ |
| pDb->pSchema->schema_cookie = pOp->p3; |
| db->mDbFlags |= DBFLAG_SchemaChange; |
| }else if( pOp->p2==BTREE_FILE_FORMAT ){ |
| /* Record changes in the file format */ |
| pDb->pSchema->file_format = pOp->p3; |
| } |
| if( pOp->p1==1 ){ |
| /* Invalidate all prepared statements whenever the TEMP database |
| ** schema is changed. Ticket #1644 */ |
| sqlite3ExpirePreparedStatements(db, 0); |
| p->expired = 0; |
| } |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: OpenRead P1 P2 P3 P4 P5 |
| ** Synopsis: root=P2 iDb=P3 |
| ** |
| ** Open a read-only cursor for the database table whose root page is |
| ** P2 in a database file. The database file is determined by P3. |
| ** P3==0 means the main database, P3==1 means the database used for |
| ** temporary tables, and P3>1 means used the corresponding attached |
| ** database. Give the new cursor an identifier of P1. The P1 |
| ** values need not be contiguous but all P1 values should be small integers. |
| ** It is an error for P1 to be negative. |
| ** |
| ** Allowed P5 bits: |
| ** <ul> |
| ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for |
| ** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT |
| ** of OP_SeekLE/OP_IdxGT) |
| ** </ul> |
| ** |
| ** The P4 value may be either an integer (P4_INT32) or a pointer to |
| ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo |
| ** object, then table being opened must be an [index b-tree] where the |
| ** KeyInfo object defines the content and collating |
| ** sequence of that index b-tree. Otherwise, if P4 is an integer |
| ** value, then the table being opened must be a [table b-tree] with a |
| ** number of columns no less than the value of P4. |
| ** |
| ** See also: OpenWrite, ReopenIdx |
| */ |
| /* Opcode: ReopenIdx P1 P2 P3 P4 P5 |
| ** Synopsis: root=P2 iDb=P3 |
| ** |
| ** The ReopenIdx opcode works like OP_OpenRead except that it first |
| ** checks to see if the cursor on P1 is already open on the same |
| ** b-tree and if it is this opcode becomes a no-op. In other words, |
| ** if the cursor is already open, do not reopen it. |
| ** |
| ** The ReopenIdx opcode may only be used with P5==0 or P5==OPFLAG_SEEKEQ |
| ** and with P4 being a P4_KEYINFO object. Furthermore, the P3 value must |
| ** be the same as every other ReopenIdx or OpenRead for the same cursor |
| ** number. |
| ** |
| ** Allowed P5 bits: |
| ** <ul> |
| ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for |
| ** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT |
| ** of OP_SeekLE/OP_IdxGT) |
| ** </ul> |
| ** |
| ** See also: OP_OpenRead, OP_OpenWrite |
| */ |
| /* Opcode: OpenWrite P1 P2 P3 P4 P5 |
| ** Synopsis: root=P2 iDb=P3 |
| ** |
| ** Open a read/write cursor named P1 on the table or index whose root |
| ** page is P2 (or whose root page is held in register P2 if the |
| ** OPFLAG_P2ISREG bit is set in P5 - see below). |
| ** |
| ** The P4 value may be either an integer (P4_INT32) or a pointer to |
| ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo |
| ** object, then table being opened must be an [index b-tree] where the |
| ** KeyInfo object defines the content and collating |
| ** sequence of that index b-tree. Otherwise, if P4 is an integer |
| ** value, then the table being opened must be a [table b-tree] with a |
| ** number of columns no less than the value of P4. |
| ** |
| ** Allowed P5 bits: |
| ** <ul> |
| ** <li> <b>0x02 OPFLAG_SEEKEQ</b>: This cursor will only be used for |
| ** equality lookups (implemented as a pair of opcodes OP_SeekGE/OP_IdxGT |
| ** of OP_SeekLE/OP_IdxGT) |
| ** <li> <b>0x08 OPFLAG_FORDELETE</b>: This cursor is used only to seek |
| ** and subsequently delete entries in an index btree. This is a |
| ** hint to the storage engine that the storage engine is allowed to |
| ** ignore. The hint is not used by the official SQLite b*tree storage |
| ** engine, but is used by COMDB2. |
| ** <li> <b>0x10 OPFLAG_P2ISREG</b>: Use the content of register P2 |
| ** as the root page, not the value of P2 itself. |
| ** </ul> |
| ** |
| ** This instruction works like OpenRead except that it opens the cursor |
| ** in read/write mode. |
| ** |
| ** See also: OP_OpenRead, OP_ReopenIdx |
| */ |
| case OP_ReopenIdx: { |
| int nField; |
| KeyInfo *pKeyInfo; |
| int p2; |
| int iDb; |
| int wrFlag; |
| Btree *pX; |
| VdbeCursor *pCur; |
| Db *pDb; |
| |
| assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); |
| assert( pOp->p4type==P4_KEYINFO ); |
| pCur = p->apCsr[pOp->p1]; |
| if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){ |
| assert( pCur->iDb==pOp->p3 ); /* Guaranteed by the code generator */ |
| goto open_cursor_set_hints; |
| } |
| /* If the cursor is not currently open or is open on a different |
| ** index, then fall through into OP_OpenRead to force a reopen */ |
| case OP_OpenRead: |
| case OP_OpenWrite: |
| |
| assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ ); |
| assert( p->bIsReader ); |
| assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx |
| || p->readOnly==0 ); |
| |
| if( p->expired==1 ){ |
| rc = SQLITE_ABORT_ROLLBACK; |
| goto abort_due_to_error; |
| } |
| |
| nField = 0; |
| pKeyInfo = 0; |
| p2 = pOp->p2; |
| iDb = pOp->p3; |
| assert( iDb>=0 && iDb<db->nDb ); |
| assert( DbMaskTest(p->btreeMask, iDb) ); |
| pDb = &db->aDb[iDb]; |
| pX = pDb->pBt; |
| assert( pX!=0 ); |
| if( pOp->opcode==OP_OpenWrite ){ |
| assert( OPFLAG_FORDELETE==BTREE_FORDELETE ); |
| wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE); |
| assert( sqlite3SchemaMutexHeld(db, iDb, 0) ); |
| if( pDb->pSchema->file_format < p->minWriteFileFormat ){ |
| p->minWriteFileFormat = pDb->pSchema->file_format; |
| } |
| }else{ |
| wrFlag = 0; |
| } |
| if( pOp->p5 & OPFLAG_P2ISREG ){ |
| assert( p2>0 ); |
| assert( p2<=(p->nMem+1 - p->nCursor) ); |
| assert( pOp->opcode==OP_OpenWrite ); |
| pIn2 = &aMem[p2]; |
| assert( memIsValid(pIn2) ); |
| assert( (pIn2->flags & MEM_Int)!=0 ); |
| sqlite3VdbeMemIntegerify(pIn2); |
| p2 = (int)pIn2->u.i; |
| /* The p2 value always comes from a prior OP_CreateBtree opcode and |
| ** that opcode will always set the p2 value to 2 or more or else fail. |
| ** If there were a failure, the prepared statement would have halted |
| ** before reaching this instruction. */ |
| assert( p2>=2 ); |
| } |
| if( pOp->p4type==P4_KEYINFO ){ |
| pKeyInfo = pOp->p4.pKeyInfo; |
| assert( pKeyInfo->enc==ENC(db) ); |
| assert( pKeyInfo->db==db ); |
| nField = pKeyInfo->nAllField; |
| }else if( pOp->p4type==P4_INT32 ){ |
| nField = pOp->p4.i; |
| } |
| assert( pOp->p1>=0 ); |
| assert( nField>=0 ); |
| testcase( nField==0 ); /* Table with INTEGER PRIMARY KEY and nothing else */ |
| pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE); |
| if( pCur==0 ) goto no_mem; |
| pCur->nullRow = 1; |
| pCur->isOrdered = 1; |
| pCur->pgnoRoot = p2; |
| #ifdef SQLITE_DEBUG |
| pCur->wrFlag = wrFlag; |
| #endif |
| rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor); |
| pCur->pKeyInfo = pKeyInfo; |
| /* Set the VdbeCursor.isTable variable. Previous versions of |
| ** SQLite used to check if the root-page flags were sane at this point |
| ** and report database corruption if they were not, but this check has |
| ** since moved into the btree layer. */ |
| pCur->isTable = pOp->p4type!=P4_KEYINFO; |
| |
| open_cursor_set_hints: |
| assert( OPFLAG_BULKCSR==BTREE_BULKLOAD ); |
| assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ ); |
| testcase( pOp->p5 & OPFLAG_BULKCSR ); |
| #ifdef SQLITE_ENABLE_CURSOR_HINTS |
| testcase( pOp->p2 & OPFLAG_SEEKEQ ); |
| #endif |
| sqlite3BtreeCursorHintFlags(pCur->uc.pCursor, |
| (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ))); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: OpenDup P1 P2 * * * |
| ** |
| ** Open a new cursor P1 that points to the same ephemeral table as |
| ** cursor P2. The P2 cursor must have been opened by a prior OP_OpenEphemeral |
| ** opcode. Only ephemeral cursors may be duplicated. |
| ** |
| ** Duplicate ephemeral cursors are used for self-joins of materialized views. |
| */ |
| case OP_OpenDup: { |
| VdbeCursor *pOrig; /* The original cursor to be duplicated */ |
| VdbeCursor *pCx; /* The new cursor */ |
| |
| pOrig = p->apCsr[pOp->p2]; |
| assert( pOrig->pBtx!=0 ); /* Only ephemeral cursors can be duplicated */ |
| |
| pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE); |
| if( pCx==0 ) goto no_mem; |
| pCx->nullRow = 1; |
| pCx->isEphemeral = 1; |
| pCx->pKeyInfo = pOrig->pKeyInfo; |
| pCx->isTable = pOrig->isTable; |
| pCx->pgnoRoot = pOrig->pgnoRoot; |
| rc = sqlite3BtreeCursor(pOrig->pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
| pCx->pKeyInfo, pCx->uc.pCursor); |
| /* The sqlite3BtreeCursor() routine can only fail for the first cursor |
| ** opened for a database. Since there is already an open cursor when this |
| ** opcode is run, the sqlite3BtreeCursor() cannot fail */ |
| assert( rc==SQLITE_OK ); |
| break; |
| } |
| |
| |
| /* Opcode: OpenEphemeral P1 P2 * P4 P5 |
| ** Synopsis: nColumn=P2 |
| ** |
| ** Open a new cursor P1 to a transient table. |
| ** The cursor is always opened read/write even if |
| ** the main database is read-only. The ephemeral |
| ** table is deleted automatically when the cursor is closed. |
| ** |
| ** If the cursor P1 is already opened on an ephemeral table, the table |
| ** is cleared (all content is erased). |
| ** |
| ** P2 is the number of columns in the ephemeral table. |
| ** The cursor points to a BTree table if P4==0 and to a BTree index |
| ** if P4 is not 0. If P4 is not NULL, it points to a KeyInfo structure |
| ** that defines the format of keys in the index. |
| ** |
| ** The P5 parameter can be a mask of the BTREE_* flags defined |
| ** in btree.h. These flags control aspects of the operation of |
| ** the btree. The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are |
| ** added automatically. |
| */ |
| /* Opcode: OpenAutoindex P1 P2 * P4 * |
| ** Synopsis: nColumn=P2 |
| ** |
| ** This opcode works the same as OP_OpenEphemeral. It has a |
| ** different name to distinguish its use. Tables created using |
| ** by this opcode will be used for automatically created transient |
| ** indices in joins. |
| */ |
| case OP_OpenAutoindex: |
| case OP_OpenEphemeral: { |
| VdbeCursor *pCx; |
| KeyInfo *pKeyInfo; |
| |
| static const int vfsFlags = |
| SQLITE_OPEN_READWRITE | |
| SQLITE_OPEN_CREATE | |
| SQLITE_OPEN_EXCLUSIVE | |
| SQLITE_OPEN_DELETEONCLOSE | |
| SQLITE_OPEN_TRANSIENT_DB; |
| assert( pOp->p1>=0 ); |
| assert( pOp->p2>=0 ); |
| pCx = p->apCsr[pOp->p1]; |
| if( pCx ){ |
| /* If the ephermeral table is already open, erase all existing content |
| ** so that the table is empty again, rather than creating a new table. */ |
| rc = sqlite3BtreeClearTable(pCx->pBtx, pCx->pgnoRoot, 0); |
| }else{ |
| pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE); |
| if( pCx==0 ) goto no_mem; |
| pCx->nullRow = 1; |
| pCx->isEphemeral = 1; |
| rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBtx, |
| BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, |
| vfsFlags); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1, 0); |
| } |
| if( rc==SQLITE_OK ){ |
| /* If a transient index is required, create it by calling |
| ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before |
| ** opening it. If a transient table is required, just use the |
| ** automatically created table with root-page 1 (an BLOB_INTKEY table). |
| */ |
| if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){ |
| assert( pOp->p4type==P4_KEYINFO ); |
| rc = sqlite3BtreeCreateTable(pCx->pBtx, (int*)&pCx->pgnoRoot, |
| BTREE_BLOBKEY | pOp->p5); |
| if( rc==SQLITE_OK ){ |
| assert( pCx->pgnoRoot==MASTER_ROOT+1 ); |
| assert( pKeyInfo->db==db ); |
| assert( pKeyInfo->enc==ENC(db) ); |
| rc = sqlite3BtreeCursor(pCx->pBtx, pCx->pgnoRoot, BTREE_WRCSR, |
| pKeyInfo, pCx->uc.pCursor); |
| } |
| pCx->isTable = 0; |
| }else{ |
| pCx->pgnoRoot = MASTER_ROOT; |
| rc = sqlite3BtreeCursor(pCx->pBtx, MASTER_ROOT, BTREE_WRCSR, |
| 0, pCx->uc.pCursor); |
| pCx->isTable = 1; |
| } |
| } |
| pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED); |
| } |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: SorterOpen P1 P2 P3 P4 * |
| ** |
| ** This opcode works like OP_OpenEphemeral except that it opens |
| ** a transient index that is specifically designed to sort large |
| ** tables using an external merge-sort algorithm. |
| ** |
| ** If argument P3 is non-zero, then it indicates that the sorter may |
| ** assume that a stable sort considering the first P3 fields of each |
| ** key is sufficient to produce the required results. |
| */ |
| case OP_SorterOpen: { |
| VdbeCursor *pCx; |
| |
| assert( pOp->p1>=0 ); |
| assert( pOp->p2>=0 ); |
| pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_SORTER); |
| if( pCx==0 ) goto no_mem; |
| pCx->pKeyInfo = pOp->p4.pKeyInfo; |
| assert( pCx->pKeyInfo->db==db ); |
| assert( pCx->pKeyInfo->enc==ENC(db) ); |
| rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: SequenceTest P1 P2 * * * |
| ** Synopsis: if( cursor[P1].ctr++ ) pc = P2 |
| ** |
| ** P1 is a sorter cursor. If the sequence counter is currently zero, jump |
| ** to P2. Regardless of whether or not the jump is taken, increment the |
| ** the sequence value. |
| */ |
| case OP_SequenceTest: { |
| VdbeCursor *pC; |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( isSorter(pC) ); |
| if( (pC->seqCount++)==0 ){ |
| goto jump_to_p2; |
| } |
| break; |
| } |
| |
| /* Opcode: OpenPseudo P1 P2 P3 * * |
| ** Synopsis: P3 columns in r[P2] |
| ** |
| ** Open a new cursor that points to a fake table that contains a single |
| ** row of data. The content of that one row is the content of memory |
| ** register P2. In other words, cursor P1 becomes an alias for the |
| ** MEM_Blob content contained in register P2. |
| ** |
| ** A pseudo-table created by this opcode is used to hold a single |
| ** row output from the sorter so that the row can be decomposed into |
| ** individual columns using the OP_Column opcode. The OP_Column opcode |
| ** is the only cursor opcode that works with a pseudo-table. |
| ** |
| ** P3 is the number of fields in the records that will be stored by |
| ** the pseudo-table. |
| */ |
| case OP_OpenPseudo: { |
| VdbeCursor *pCx; |
| |
| assert( pOp->p1>=0 ); |
| assert( pOp->p3>=0 ); |
| pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, CURTYPE_PSEUDO); |
| if( pCx==0 ) goto no_mem; |
| pCx->nullRow = 1; |
| pCx->seekResult = pOp->p2; |
| pCx->isTable = 1; |
| /* Give this pseudo-cursor a fake BtCursor pointer so that pCx |
| ** can be safely passed to sqlite3VdbeCursorMoveto(). This avoids a test |
| ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto() |
| ** which is a performance optimization */ |
| pCx->uc.pCursor = sqlite3BtreeFakeValidCursor(); |
| assert( pOp->p5==0 ); |
| break; |
| } |
| |
| /* Opcode: Close P1 * * * * |
| ** |
| ** Close a cursor previously opened as P1. If P1 is not |
| ** currently open, this instruction is a no-op. |
| */ |
| case OP_Close: { |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]); |
| p->apCsr[pOp->p1] = 0; |
| break; |
| } |
| |
| #ifdef SQLITE_ENABLE_COLUMN_USED_MASK |
| /* Opcode: ColumnsUsed P1 * * P4 * |
| ** |
| ** This opcode (which only exists if SQLite was compiled with |
| ** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the |
| ** table or index for cursor P1 are used. P4 is a 64-bit integer |
| ** (P4_INT64) in which the first 63 bits are one for each of the |
| ** first 63 columns of the table or index that are actually used |
| ** by the cursor. The high-order bit is set if any column after |
| ** the 64th is used. |
| */ |
| case OP_ColumnsUsed: { |
| VdbeCursor *pC; |
| pC = p->apCsr[pOp->p1]; |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| pC->maskUsed = *(u64*)pOp->p4.pI64; |
| break; |
| } |
| #endif |
| |
| /* Opcode: SeekGE P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
| ** use the value in register P3 as the key. If cursor P1 refers |
| ** to an SQL index, then P3 is the first in an array of P4 registers |
| ** that are used as an unpacked index key. |
| ** |
| ** Reposition cursor P1 so that it points to the smallest entry that |
| ** is greater than or equal to the key value. If there are no records |
| ** greater than or equal to the key and P2 is not zero, then jump to P2. |
| ** |
| ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this |
| ** opcode will always land on a record that equally equals the key, or |
| ** else jump immediately to P2. When the cursor is OPFLAG_SEEKEQ, this |
| ** opcode must be followed by an IdxLE opcode with the same arguments. |
| ** The IdxLE opcode will be skipped if this opcode succeeds, but the |
| ** IdxLE opcode will be used on subsequent loop iterations. |
| ** |
| ** This opcode leaves the cursor configured to move in forward order, |
| ** from the beginning toward the end. In other words, the cursor is |
| ** configured to use Next, not Prev. |
| ** |
| ** See also: Found, NotFound, SeekLt, SeekGt, SeekLe |
| */ |
| /* Opcode: SeekGT P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
| ** use the value in register P3 as a key. If cursor P1 refers |
| ** to an SQL index, then P3 is the first in an array of P4 registers |
| ** that are used as an unpacked index key. |
| ** |
| ** Reposition cursor P1 so that it points to the smallest entry that |
| ** is greater than the key value. If there are no records greater than |
| ** the key and P2 is not zero, then jump to P2. |
| ** |
| ** This opcode leaves the cursor configured to move in forward order, |
| ** from the beginning toward the end. In other words, the cursor is |
| ** configured to use Next, not Prev. |
| ** |
| ** See also: Found, NotFound, SeekLt, SeekGe, SeekLe |
| */ |
| /* Opcode: SeekLT P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
| ** use the value in register P3 as a key. If cursor P1 refers |
| ** to an SQL index, then P3 is the first in an array of P4 registers |
| ** that are used as an unpacked index key. |
| ** |
| ** Reposition cursor P1 so that it points to the largest entry that |
| ** is less than the key value. If there are no records less than |
| ** the key and P2 is not zero, then jump to P2. |
| ** |
| ** This opcode leaves the cursor configured to move in reverse order, |
| ** from the end toward the beginning. In other words, the cursor is |
| ** configured to use Prev, not Next. |
| ** |
| ** See also: Found, NotFound, SeekGt, SeekGe, SeekLe |
| */ |
| /* Opcode: SeekLE P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), |
| ** use the value in register P3 as a key. If cursor P1 refers |
| ** to an SQL index, then P3 is the first in an array of P4 registers |
| ** that are used as an unpacked index key. |
| ** |
| ** Reposition cursor P1 so that it points to the largest entry that |
| ** is less than or equal to the key value. If there are no records |
| ** less than or equal to the key and P2 is not zero, then jump to P2. |
| ** |
| ** This opcode leaves the cursor configured to move in reverse order, |
| ** from the end toward the beginning. In other words, the cursor is |
| ** configured to use Prev, not Next. |
| ** |
| ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this |
| ** opcode will always land on a record that equally equals the key, or |
| ** else jump immediately to P2. When the cursor is OPFLAG_SEEKEQ, this |
| ** opcode must be followed by an IdxGE opcode with the same arguments. |
| ** The IdxGE opcode will be skipped if this opcode succeeds, but the |
| ** IdxGE opcode will be used on subsequent loop iterations. |
| ** |
| ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt |
| */ |
| case OP_SeekLT: /* jump, in3, group */ |
| case OP_SeekLE: /* jump, in3, group */ |
| case OP_SeekGE: /* jump, in3, group */ |
| case OP_SeekGT: { /* jump, in3, group */ |
| int res; /* Comparison result */ |
| int oc; /* Opcode */ |
| VdbeCursor *pC; /* The cursor to seek */ |
| UnpackedRecord r; /* The key to seek for */ |
| int nField; /* Number of columns or fields in the key */ |
| i64 iKey; /* The rowid we are to seek to */ |
| int eqOnly; /* Only interested in == results */ |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( pOp->p2!=0 ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( OP_SeekLE == OP_SeekLT+1 ); |
| assert( OP_SeekGE == OP_SeekLT+2 ); |
| assert( OP_SeekGT == OP_SeekLT+3 ); |
| assert( pC->isOrdered ); |
| assert( pC->uc.pCursor!=0 ); |
| oc = pOp->opcode; |
| eqOnly = 0; |
| pC->nullRow = 0; |
| #ifdef SQLITE_DEBUG |
| pC->seekOp = pOp->opcode; |
| #endif |
| |
| if( pC->isTable ){ |
| /* The BTREE_SEEK_EQ flag is only set on index cursors */ |
| assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0 |
| || CORRUPT_DB ); |
| |
| /* The input value in P3 might be of any type: integer, real, string, |
| ** blob, or NULL. But it needs to be an integer before we can do |
| ** the seek, so convert it. */ |
| pIn3 = &aMem[pOp->p3]; |
| if( (pIn3->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){ |
| applyNumericAffinity(pIn3, 0); |
| } |
| iKey = sqlite3VdbeIntValue(pIn3); |
| |
| /* If the P3 value could not be converted into an integer without |
| ** loss of information, then special processing is required... */ |
| if( (pIn3->flags & MEM_Int)==0 ){ |
| if( (pIn3->flags & MEM_Real)==0 ){ |
| /* If the P3 value cannot be converted into any kind of a number, |
| ** then the seek is not possible, so jump to P2 */ |
| VdbeBranchTaken(1,2); goto jump_to_p2; |
| break; |
| } |
| |
| /* If the approximation iKey is larger than the actual real search |
| ** term, substitute >= for > and < for <=. e.g. if the search term |
| ** is 4.9 and the integer approximation 5: |
| ** |
| ** (x > 4.9) -> (x >= 5) |
| ** (x <= 4.9) -> (x < 5) |
| */ |
| if( pIn3->u.r<(double)iKey ){ |
| assert( OP_SeekGE==(OP_SeekGT-1) ); |
| assert( OP_SeekLT==(OP_SeekLE-1) ); |
| assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) ); |
| if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--; |
| } |
| |
| /* If the approximation iKey is smaller than the actual real search |
| ** term, substitute <= for < and > for >=. */ |
| else if( pIn3->u.r>(double)iKey ){ |
| assert( OP_SeekLE==(OP_SeekLT+1) ); |
| assert( OP_SeekGT==(OP_SeekGE+1) ); |
| assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) ); |
| if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++; |
| } |
| } |
| rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res); |
| pC->movetoTarget = iKey; /* Used by OP_Delete */ |
| if( rc!=SQLITE_OK ){ |
| goto abort_due_to_error; |
| } |
| }else{ |
| /* For a cursor with the BTREE_SEEK_EQ hint, only the OP_SeekGE and |
| ** OP_SeekLE opcodes are allowed, and these must be immediately followed |
| ** by an OP_IdxGT or OP_IdxLT opcode, respectively, with the same key. |
| */ |
| if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){ |
| eqOnly = 1; |
| assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE ); |
| assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); |
| assert( pOp[1].p1==pOp[0].p1 ); |
| assert( pOp[1].p2==pOp[0].p2 ); |
| assert( pOp[1].p3==pOp[0].p3 ); |
| assert( pOp[1].p4.i==pOp[0].p4.i ); |
| } |
| |
| nField = pOp->p4.i; |
| assert( pOp->p4type==P4_INT32 ); |
| assert( nField>0 ); |
| r.pKeyInfo = pC->pKeyInfo; |
| r.nField = (u16)nField; |
| |
| /* The next line of code computes as follows, only faster: |
| ** if( oc==OP_SeekGT || oc==OP_SeekLE ){ |
| ** r.default_rc = -1; |
| ** }else{ |
| ** r.default_rc = +1; |
| ** } |
| */ |
| r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1); |
| assert( oc!=OP_SeekGT || r.default_rc==-1 ); |
| assert( oc!=OP_SeekLE || r.default_rc==-1 ); |
| assert( oc!=OP_SeekGE || r.default_rc==+1 ); |
| assert( oc!=OP_SeekLT || r.default_rc==+1 ); |
| |
| r.aMem = &aMem[pOp->p3]; |
| #ifdef SQLITE_DEBUG |
| { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); } |
| #endif |
| r.eqSeen = 0; |
| rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res); |
| if( rc!=SQLITE_OK ){ |
| goto abort_due_to_error; |
| } |
| if( eqOnly && r.eqSeen==0 ){ |
| assert( res!=0 ); |
| goto seek_not_found; |
| } |
| } |
| pC->deferredMoveto = 0; |
| pC->cacheStatus = CACHE_STALE; |
| #ifdef SQLITE_TEST |
| sqlite3_search_count++; |
| #endif |
| if( oc>=OP_SeekGE ){ assert( oc==OP_SeekGE || oc==OP_SeekGT ); |
| if( res<0 || (res==0 && oc==OP_SeekGT) ){ |
| res = 0; |
| rc = sqlite3BtreeNext(pC->uc.pCursor, 0); |
| if( rc!=SQLITE_OK ){ |
| if( rc==SQLITE_DONE ){ |
| rc = SQLITE_OK; |
| res = 1; |
| }else{ |
| goto abort_due_to_error; |
| } |
| } |
| }else{ |
| res = 0; |
| } |
| }else{ |
| assert( oc==OP_SeekLT || oc==OP_SeekLE ); |
| if( res>0 || (res==0 && oc==OP_SeekLT) ){ |
| res = 0; |
| rc = sqlite3BtreePrevious(pC->uc.pCursor, 0); |
| if( rc!=SQLITE_OK ){ |
| if( rc==SQLITE_DONE ){ |
| rc = SQLITE_OK; |
| res = 1; |
| }else{ |
| goto abort_due_to_error; |
| } |
| } |
| }else{ |
| /* res might be negative because the table is empty. Check to |
| ** see if this is the case. |
| */ |
| res = sqlite3BtreeEof(pC->uc.pCursor); |
| } |
| } |
| seek_not_found: |
| assert( pOp->p2>0 ); |
| VdbeBranchTaken(res!=0,2); |
| if( res ){ |
| goto jump_to_p2; |
| }else if( eqOnly ){ |
| assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT ); |
| pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */ |
| } |
| break; |
| } |
| |
| /* Opcode: SeekHit P1 P2 * * * |
| ** Synopsis: seekHit=P2 |
| ** |
| ** Set the seekHit flag on cursor P1 to the value in P2. |
| ** The seekHit flag is used by the IfNoHope opcode. |
| ** |
| ** P1 must be a valid b-tree cursor. P2 must be a boolean value, |
| ** either 0 or 1. |
| */ |
| case OP_SeekHit: { |
| VdbeCursor *pC; |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pOp->p2==0 || pOp->p2==1 ); |
| pC->seekHit = pOp->p2 & 1; |
| break; |
| } |
| |
| /* Opcode: Found P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If |
| ** P4>0 then register P3 is the first of P4 registers that form an unpacked |
| ** record. |
| ** |
| ** Cursor P1 is on an index btree. If the record identified by P3 and P4 |
| ** is a prefix of any entry in P1 then a jump is made to P2 and |
| ** P1 is left pointing at the matching entry. |
| ** |
| ** This operation leaves the cursor in a state where it can be |
| ** advanced in the forward direction. The Next instruction will work, |
| ** but not the Prev instruction. |
| ** |
| ** See also: NotFound, NoConflict, NotExists. SeekGe |
| */ |
| /* Opcode: NotFound P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If |
| ** P4>0 then register P3 is the first of P4 registers that form an unpacked |
| ** record. |
| ** |
| ** Cursor P1 is on an index btree. If the record identified by P3 and P4 |
| ** is not the prefix of any entry in P1 then a jump is made to P2. If P1 |
| ** does contain an entry whose prefix matches the P3/P4 record then control |
| ** falls through to the next instruction and P1 is left pointing at the |
| ** matching entry. |
| ** |
| ** This operation leaves the cursor in a state where it cannot be |
| ** advanced in either direction. In other words, the Next and Prev |
| ** opcodes do not work after this operation. |
| ** |
| ** See also: Found, NotExists, NoConflict, IfNoHope |
| */ |
| /* Opcode: IfNoHope P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** Register P3 is the first of P4 registers that form an unpacked |
| ** record. |
| ** |
| ** Cursor P1 is on an index btree. If the seekHit flag is set on P1, then |
| ** this opcode is a no-op. But if the seekHit flag of P1 is clear, then |
| ** check to see if there is any entry in P1 that matches the |
| ** prefix identified by P3 and P4. If no entry matches the prefix, |
| ** jump to P2. Otherwise fall through. |
| ** |
| ** This opcode behaves like OP_NotFound if the seekHit |
| ** flag is clear and it behaves like OP_Noop if the seekHit flag is set. |
| ** |
| ** This opcode is used in IN clause processing for a multi-column key. |
| ** If an IN clause is attached to an element of the key other than the |
| ** left-most element, and if there are no matches on the most recent |
| ** seek over the whole key, then it might be that one of the key element |
| ** to the left is prohibiting a match, and hence there is "no hope" of |
| ** any match regardless of how many IN clause elements are checked. |
| ** In such a case, we abandon the IN clause search early, using this |
| ** opcode. The opcode name comes from the fact that the |
| ** jump is taken if there is "no hope" of achieving a match. |
| ** |
| ** See also: NotFound, SeekHit |
| */ |
| /* Opcode: NoConflict P1 P2 P3 P4 * |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** If P4==0 then register P3 holds a blob constructed by MakeRecord. If |
| ** P4>0 then register P3 is the first of P4 registers that form an unpacked |
| ** record. |
| ** |
| ** Cursor P1 is on an index btree. If the record identified by P3 and P4 |
| ** contains any NULL value, jump immediately to P2. If all terms of the |
| ** record are not-NULL then a check is done to determine if any row in the |
| ** P1 index btree has a matching key prefix. If there are no matches, jump |
| ** immediately to P2. If there is a match, fall through and leave the P1 |
| ** cursor pointing to the matching row. |
| ** |
| ** This opcode is similar to OP_NotFound with the exceptions that the |
| ** branch is always taken if any part of the search key input is NULL. |
| ** |
| ** This operation leaves the cursor in a state where it cannot be |
| ** advanced in either direction. In other words, the Next and Prev |
| ** opcodes do not work after this operation. |
| ** |
| ** See also: NotFound, Found, NotExists |
| */ |
| case OP_IfNoHope: { /* jump, in3 */ |
| VdbeCursor *pC; |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| if( pC->seekHit ) break; |
| /* Fall through into OP_NotFound */ |
| } |
| case OP_NoConflict: /* jump, in3 */ |
| case OP_NotFound: /* jump, in3 */ |
| case OP_Found: { /* jump, in3 */ |
| int alreadyExists; |
| int takeJump; |
| int ii; |
| VdbeCursor *pC; |
| int res; |
| UnpackedRecord *pFree; |
| UnpackedRecord *pIdxKey; |
| UnpackedRecord r; |
| |
| #ifdef SQLITE_TEST |
| if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++; |
| #endif |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( pOp->p4type==P4_INT32 ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| #ifdef SQLITE_DEBUG |
| pC->seekOp = pOp->opcode; |
| #endif |
| pIn3 = &aMem[pOp->p3]; |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->uc.pCursor!=0 ); |
| assert( pC->isTable==0 ); |
| if( pOp->p4.i>0 ){ |
| r.pKeyInfo = pC->pKeyInfo; |
| r.nField = (u16)pOp->p4.i; |
| r.aMem = pIn3; |
| #ifdef SQLITE_DEBUG |
| for(ii=0; ii<r.nField; ii++){ |
| assert( memIsValid(&r.aMem[ii]) ); |
| assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 ); |
| if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]); |
| } |
| #endif |
| pIdxKey = &r; |
| pFree = 0; |
| }else{ |
| assert( pIn3->flags & MEM_Blob ); |
| rc = ExpandBlob(pIn3); |
| assert( rc==SQLITE_OK || rc==SQLITE_NOMEM ); |
| if( rc ) goto no_mem; |
| pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo); |
| if( pIdxKey==0 ) goto no_mem; |
| sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey); |
| } |
| pIdxKey->default_rc = 0; |
| takeJump = 0; |
| if( pOp->opcode==OP_NoConflict ){ |
| /* For the OP_NoConflict opcode, take the jump if any of the |
| ** input fields are NULL, since any key with a NULL will not |
| ** conflict */ |
| for(ii=0; ii<pIdxKey->nField; ii++){ |
| if( pIdxKey->aMem[ii].flags & MEM_Null ){ |
| takeJump = 1; |
| break; |
| } |
| } |
| } |
| rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res); |
| if( pFree ) sqlite3DbFreeNN(db, pFree); |
| if( rc!=SQLITE_OK ){ |
| goto abort_due_to_error; |
| } |
| pC->seekResult = res; |
| alreadyExists = (res==0); |
| pC->nullRow = 1-alreadyExists; |
| pC->deferredMoveto = 0; |
| pC->cacheStatus = CACHE_STALE; |
| if( pOp->opcode==OP_Found ){ |
| VdbeBranchTaken(alreadyExists!=0,2); |
| if( alreadyExists ) goto jump_to_p2; |
| }else{ |
| VdbeBranchTaken(takeJump||alreadyExists==0,2); |
| if( takeJump || !alreadyExists ) goto jump_to_p2; |
| } |
| break; |
| } |
| |
| /* Opcode: SeekRowid P1 P2 P3 * * |
| ** Synopsis: intkey=r[P3] |
| ** |
| ** P1 is the index of a cursor open on an SQL table btree (with integer |
| ** keys). If register P3 does not contain an integer or if P1 does not |
| ** contain a record with rowid P3 then jump immediately to P2. |
| ** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain |
| ** a record with rowid P3 then |
| ** leave the cursor pointing at that record and fall through to the next |
| ** instruction. |
| ** |
| ** The OP_NotExists opcode performs the same operation, but with OP_NotExists |
| ** the P3 register must be guaranteed to contain an integer value. With this |
| ** opcode, register P3 might not contain an integer. |
| ** |
| ** The OP_NotFound opcode performs the same operation on index btrees |
| ** (with arbitrary multi-value keys). |
| ** |
| ** This opcode leaves the cursor in a state where it cannot be advanced |
| ** in either direction. In other words, the Next and Prev opcodes will |
| ** not work following this opcode. |
| ** |
| ** See also: Found, NotFound, NoConflict, SeekRowid |
| */ |
| /* Opcode: NotExists P1 P2 P3 * * |
| ** Synopsis: intkey=r[P3] |
| ** |
| ** P1 is the index of a cursor open on an SQL table btree (with integer |
| ** keys). P3 is an integer rowid. If P1 does not contain a record with |
| ** rowid P3 then jump immediately to P2. Or, if P2 is 0, raise an |
| ** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then |
| ** leave the cursor pointing at that record and fall through to the next |
| ** instruction. |
| ** |
| ** The OP_SeekRowid opcode performs the same operation but also allows the |
| ** P3 register to contain a non-integer value, in which case the jump is |
| ** always taken. This opcode requires that P3 always contain an integer. |
| ** |
| ** The OP_NotFound opcode performs the same operation on index btrees |
| ** (with arbitrary multi-value keys). |
| ** |
| ** This opcode leaves the cursor in a state where it cannot be advanced |
| ** in either direction. In other words, the Next and Prev opcodes will |
| ** not work following this opcode. |
| ** |
| ** See also: Found, NotFound, NoConflict, SeekRowid |
| */ |
| case OP_SeekRowid: { /* jump, in3 */ |
| VdbeCursor *pC; |
| BtCursor *pCrsr; |
| int res; |
| u64 iKey; |
| |
| pIn3 = &aMem[pOp->p3]; |
| if( (pIn3->flags & MEM_Int)==0 ){ |
| /* Make sure pIn3->u.i contains a valid integer representation of |
| ** the key value, but do not change the datatype of the register, as |
| ** other parts of the perpared statement might be depending on the |
| ** current datatype. */ |
| u16 origFlags = pIn3->flags; |
| int isNotInt; |
| applyAffinity(pIn3, SQLITE_AFF_NUMERIC, encoding); |
| isNotInt = (pIn3->flags & MEM_Int)==0; |
| pIn3->flags = origFlags; |
| if( isNotInt ) goto jump_to_p2; |
| } |
| /* Fall through into OP_NotExists */ |
| case OP_NotExists: /* jump, in3 */ |
| pIn3 = &aMem[pOp->p3]; |
| assert( (pIn3->flags & MEM_Int)!=0 || pOp->opcode==OP_SeekRowid ); |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| #ifdef SQLITE_DEBUG |
| if( pOp->opcode==OP_SeekRowid ) pC->seekOp = OP_SeekRowid; |
| #endif |
| assert( pC->isTable ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| pCrsr = pC->uc.pCursor; |
| assert( pCrsr!=0 ); |
| res = 0; |
| iKey = pIn3->u.i; |
| rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res); |
| assert( rc==SQLITE_OK || res==0 ); |
| pC->movetoTarget = iKey; /* Used by OP_Delete */ |
| pC->nullRow = 0; |
| pC->cacheStatus = CACHE_STALE; |
| pC->deferredMoveto = 0; |
| VdbeBranchTaken(res!=0,2); |
| pC->seekResult = res; |
| if( res!=0 ){ |
| assert( rc==SQLITE_OK ); |
| if( pOp->p2==0 ){ |
| rc = SQLITE_CORRUPT_BKPT; |
| }else{ |
| goto jump_to_p2; |
| } |
| } |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: Sequence P1 P2 * * * |
| ** Synopsis: r[P2]=cursor[P1].ctr++ |
| ** |
| ** Find the next available sequence number for cursor P1. |
| ** Write the sequence number into register P2. |
| ** The sequence number on the cursor is incremented after this |
| ** instruction. |
| */ |
| case OP_Sequence: { /* out2 */ |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( p->apCsr[pOp->p1]!=0 ); |
| assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB ); |
| pOut = out2Prerelease(p, pOp); |
| pOut->u.i = p->apCsr[pOp->p1]->seqCount++; |
| break; |
| } |
| |
| |
| /* Opcode: NewRowid P1 P2 P3 * * |
| ** Synopsis: r[P2]=rowid |
| ** |
| ** Get a new integer record number (a.k.a "rowid") used as the key to a table. |
| ** The record number is not previously used as a key in the database |
| ** table that cursor P1 points to. The new record number is written |
| ** written to register P2. |
| ** |
| ** If P3>0 then P3 is a register in the root frame of this VDBE that holds |
| ** the largest previously generated record number. No new record numbers are |
| ** allowed to be less than this value. When this value reaches its maximum, |
| ** an SQLITE_FULL error is generated. The P3 register is updated with the ' |
| ** generated record number. This P3 mechanism is used to help implement the |
| ** AUTOINCREMENT feature. |
| */ |
| case OP_NewRowid: { /* out2 */ |
| i64 v; /* The new rowid */ |
| VdbeCursor *pC; /* Cursor of table to get the new rowid */ |
| int res; /* Result of an sqlite3BtreeLast() */ |
| int cnt; /* Counter to limit the number of searches */ |
| Mem *pMem; /* Register holding largest rowid for AUTOINCREMENT */ |
| VdbeFrame *pFrame; /* Root frame of VDBE */ |
| |
| v = 0; |
| res = 0; |
| pOut = out2Prerelease(p, pOp); |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->isTable ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->uc.pCursor!=0 ); |
| { |
| /* The next rowid or record number (different terms for the same |
| ** thing) is obtained in a two-step algorithm. |
| ** |
| ** First we attempt to find the largest existing rowid and add one |
| ** to that. But if the largest existing rowid is already the maximum |
| ** positive integer, we have to fall through to the second |
| ** probabilistic algorithm |
| ** |
| ** The second algorithm is to select a rowid at random and see if |
| ** it already exists in the table. If it does not exist, we have |
| ** succeeded. If the random rowid does exist, we select a new one |
| ** and try again, up to 100 times. |
| */ |
| assert( pC->isTable ); |
| |
| #ifdef SQLITE_32BIT_ROWID |
| # define MAX_ROWID 0x7fffffff |
| #else |
| /* Some compilers complain about constants of the form 0x7fffffffffffffff. |
| ** Others complain about 0x7ffffffffffffffffLL. The following macro seems |
| ** to provide the constant while making all compilers happy. |
| */ |
| # define MAX_ROWID (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff ) |
| #endif |
| |
| if( !pC->useRandomRowid ){ |
| rc = sqlite3BtreeLast(pC->uc.pCursor, &res); |
| if( rc!=SQLITE_OK ){ |
| goto abort_due_to_error; |
| } |
| if( res ){ |
| v = 1; /* IMP: R-61914-48074 */ |
| }else{ |
| assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) ); |
| v = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
| if( v>=MAX_ROWID ){ |
| pC->useRandomRowid = 1; |
| }else{ |
| v++; /* IMP: R-29538-34987 */ |
| } |
| } |
| } |
| |
| #ifndef SQLITE_OMIT_AUTOINCREMENT |
| if( pOp->p3 ){ |
| /* Assert that P3 is a valid memory cell. */ |
| assert( pOp->p3>0 ); |
| if( p->pFrame ){ |
| for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); |
| /* Assert that P3 is a valid memory cell. */ |
| assert( pOp->p3<=pFrame->nMem ); |
| pMem = &pFrame->aMem[pOp->p3]; |
| }else{ |
| /* Assert that P3 is a valid memory cell. */ |
| assert( pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| pMem = &aMem[pOp->p3]; |
| memAboutToChange(p, pMem); |
| } |
| assert( memIsValid(pMem) ); |
| |
| REGISTER_TRACE(pOp->p3, pMem); |
| sqlite3VdbeMemIntegerify(pMem); |
| assert( (pMem->flags & MEM_Int)!=0 ); /* mem(P3) holds an integer */ |
| if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){ |
| rc = SQLITE_FULL; /* IMP: R-17817-00630 */ |
| goto abort_due_to_error; |
| } |
| if( v<pMem->u.i+1 ){ |
| v = pMem->u.i + 1; |
| } |
| pMem->u.i = v; |
| } |
| #endif |
| if( pC->useRandomRowid ){ |
| /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the |
| ** largest possible integer (9223372036854775807) then the database |
| ** engine starts picking positive candidate ROWIDs at random until |
| ** it finds one that is not previously used. */ |
| assert( pOp->p3==0 ); /* We cannot be in random rowid mode if this is |
| ** an AUTOINCREMENT table. */ |
| cnt = 0; |
| do{ |
| sqlite3_randomness(sizeof(v), &v); |
| v &= (MAX_ROWID>>1); v++; /* Ensure that v is greater than zero */ |
| }while( ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v, |
| 0, &res))==SQLITE_OK) |
| && (res==0) |
| && (++cnt<100)); |
| if( rc ) goto abort_due_to_error; |
| if( res==0 ){ |
| rc = SQLITE_FULL; /* IMP: R-38219-53002 */ |
| goto abort_due_to_error; |
| } |
| assert( v>0 ); /* EV: R-40812-03570 */ |
| } |
| pC->deferredMoveto = 0; |
| pC->cacheStatus = CACHE_STALE; |
| } |
| pOut->u.i = v; |
| break; |
| } |
| |
| /* Opcode: Insert P1 P2 P3 P4 P5 |
| ** Synopsis: intkey=r[P3] data=r[P2] |
| ** |
| ** Write an entry into the table of cursor P1. A new entry is |
| ** created if it doesn't already exist or the data for an existing |
| ** entry is overwritten. The data is the value MEM_Blob stored in register |
| ** number P2. The key is stored in register P3. The key must |
| ** be a MEM_Int. |
| ** |
| ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is |
| ** incremented (otherwise not). If the OPFLAG_LASTROWID flag of P5 is set, |
| ** then rowid is stored for subsequent return by the |
| ** sqlite3_last_insert_rowid() function (otherwise it is unmodified). |
| ** |
| ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might |
| ** run faster by avoiding an unnecessary seek on cursor P1. However, |
| ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior |
| ** seeks on the cursor or if the most recent seek used a key equal to P3. |
| ** |
| ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an |
| ** UPDATE operation. Otherwise (if the flag is clear) then this opcode |
| ** is part of an INSERT operation. The difference is only important to |
| ** the update hook. |
| ** |
| ** Parameter P4 may point to a Table structure, or may be NULL. If it is |
| ** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked |
| ** following a successful insert. |
| ** |
| ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically |
| ** allocated, then ownership of P2 is transferred to the pseudo-cursor |
| ** and register P2 becomes ephemeral. If the cursor is changed, the |
| ** value of register P2 will then change. Make sure this does not |
| ** cause any problems.) |
| ** |
| ** This instruction only works on tables. The equivalent instruction |
| ** for indices is OP_IdxInsert. |
| */ |
| case OP_Insert: { |
| Mem *pData; /* MEM cell holding data for the record to be inserted */ |
| Mem *pKey; /* MEM cell holding key for the record */ |
| VdbeCursor *pC; /* Cursor to table into which insert is written */ |
| int seekResult; /* Result of prior seek or 0 if no USESEEKRESULT flag */ |
| const char *zDb; /* database name - used by the update hook */ |
| Table *pTab; /* Table structure - used by update and pre-update hooks */ |
| BtreePayload x; /* Payload to be inserted */ |
| |
| pData = &aMem[pOp->p2]; |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( memIsValid(pData) ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->uc.pCursor!=0 ); |
| assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable ); |
| assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC ); |
| REGISTER_TRACE(pOp->p2, pData); |
| sqlite3VdbeIncrWriteCounter(p, pC); |
| |
| pKey = &aMem[pOp->p3]; |
| assert( pKey->flags & MEM_Int ); |
| assert( memIsValid(pKey) ); |
| REGISTER_TRACE(pOp->p3, pKey); |
| x.nKey = pKey->u.i; |
| |
| if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ |
| assert( pC->iDb>=0 ); |
| zDb = db->aDb[pC->iDb].zDbSName; |
| pTab = pOp->p4.pTab; |
| assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) ); |
| }else{ |
| pTab = 0; |
| zDb = 0; /* Not needed. Silence a compiler warning. */ |
| } |
| |
| #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
| /* Invoke the pre-update hook, if any */ |
| if( pTab ){ |
| if( db->xPreUpdateCallback && !(pOp->p5 & OPFLAG_ISUPDATE) ){ |
| sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey,pOp->p2); |
| } |
| if( db->xUpdateCallback==0 || pTab->aCol==0 ){ |
| /* Prevent post-update hook from running in cases when it should not */ |
| pTab = 0; |
| } |
| } |
| if( pOp->p5 & OPFLAG_ISNOOP ) break; |
| #endif |
| |
| if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; |
| if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey; |
| assert( pData->flags & (MEM_Blob|MEM_Str) ); |
| x.pData = pData->z; |
| x.nData = pData->n; |
| seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0); |
| if( pData->flags & MEM_Zero ){ |
| x.nZero = pData->u.nZero; |
| }else{ |
| x.nZero = 0; |
| } |
| x.pKey = 0; |
| rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, |
| (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), seekResult |
| ); |
| pC->deferredMoveto = 0; |
| pC->cacheStatus = CACHE_STALE; |
| |
| /* Invoke the update-hook if required. */ |
| if( rc ) goto abort_due_to_error; |
| if( pTab ){ |
| assert( db->xUpdateCallback!=0 ); |
| assert( pTab->aCol!=0 ); |
| db->xUpdateCallback(db->pUpdateArg, |
| (pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT, |
| zDb, pTab->zName, x.nKey); |
| } |
| break; |
| } |
| |
| /* Opcode: Delete P1 P2 P3 P4 P5 |
| ** |
| ** Delete the record at which the P1 cursor is currently pointing. |
| ** |
| ** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then |
| ** the cursor will be left pointing at either the next or the previous |
| ** record in the table. If it is left pointing at the next record, then |
| ** the next Next instruction will be a no-op. As a result, in this case |
| ** it is ok to delete a record from within a Next loop. If |
| ** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be |
| ** left in an undefined state. |
| ** |
| ** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this |
| ** delete one of several associated with deleting a table row and all its |
| ** associated index entries. Exactly one of those deletes is the "primary" |
| ** delete. The others are all on OPFLAG_FORDELETE cursors or else are |
| ** marked with the AUXDELETE flag. |
| ** |
| ** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row |
| ** change count is incremented (otherwise not). |
| ** |
| ** P1 must not be pseudo-table. It has to be a real table with |
| ** multiple rows. |
| ** |
| ** If P4 is not NULL then it points to a Table object. In this case either |
| ** the update or pre-update hook, or both, may be invoked. The P1 cursor must |
| ** have been positioned using OP_NotFound prior to invoking this opcode in |
| ** this case. Specifically, if one is configured, the pre-update hook is |
| ** invoked if P4 is not NULL. The update-hook is invoked if one is configured, |
| ** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2. |
| ** |
| ** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address |
| ** of the memory cell that contains the value that the rowid of the row will |
| ** be set to by the update. |
| */ |
| case OP_Delete: { |
| VdbeCursor *pC; |
| const char *zDb; |
| Table *pTab; |
| int opflags; |
| |
| opflags = pOp->p2; |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->uc.pCursor!=0 ); |
| assert( pC->deferredMoveto==0 ); |
| sqlite3VdbeIncrWriteCounter(p, pC); |
| |
| #ifdef SQLITE_DEBUG |
| if( pOp->p4type==P4_TABLE && HasRowid(pOp->p4.pTab) && pOp->p5==0 ){ |
| /* If p5 is zero, the seek operation that positioned the cursor prior to |
| ** OP_Delete will have also set the pC->movetoTarget field to the rowid of |
| ** the row that is being deleted */ |
| i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
| assert( pC->movetoTarget==iKey ); |
| } |
| #endif |
| |
| /* If the update-hook or pre-update-hook will be invoked, set zDb to |
| ** the name of the db to pass as to it. Also set local pTab to a copy |
| ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was |
| ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set |
| ** VdbeCursor.movetoTarget to the current rowid. */ |
| if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){ |
| assert( pC->iDb>=0 ); |
| assert( pOp->p4.pTab!=0 ); |
| zDb = db->aDb[pC->iDb].zDbSName; |
| pTab = pOp->p4.pTab; |
| if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){ |
| pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
| } |
| }else{ |
| zDb = 0; /* Not needed. Silence a compiler warning. */ |
| pTab = 0; /* Not needed. Silence a compiler warning. */ |
| } |
| |
| #ifdef SQLITE_ENABLE_PREUPDATE_HOOK |
| /* Invoke the pre-update-hook if required. */ |
| if( db->xPreUpdateCallback && pOp->p4.pTab ){ |
| assert( !(opflags & OPFLAG_ISUPDATE) |
| || HasRowid(pTab)==0 |
| || (aMem[pOp->p3].flags & MEM_Int) |
| ); |
| sqlite3VdbePreUpdateHook(p, pC, |
| (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE, |
| zDb, pTab, pC->movetoTarget, |
| pOp->p3 |
| ); |
| } |
| if( opflags & OPFLAG_ISNOOP ) break; |
| #endif |
| |
| /* Only flags that can be set are SAVEPOISTION and AUXDELETE */ |
| assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 ); |
| assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION ); |
| assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE ); |
| |
| #ifdef SQLITE_DEBUG |
| if( p->pFrame==0 ){ |
| if( pC->isEphemeral==0 |
| && (pOp->p5 & OPFLAG_AUXDELETE)==0 |
| && (pC->wrFlag & OPFLAG_FORDELETE)==0 |
| ){ |
| nExtraDelete++; |
| } |
| if( pOp->p2 & OPFLAG_NCHANGE ){ |
| nExtraDelete--; |
| } |
| } |
| #endif |
| |
| rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5); |
| pC->cacheStatus = CACHE_STALE; |
| pC->seekResult = 0; |
| if( rc ) goto abort_due_to_error; |
| |
| /* Invoke the update-hook if required. */ |
| if( opflags & OPFLAG_NCHANGE ){ |
| p->nChange++; |
| if( db->xUpdateCallback && HasRowid(pTab) ){ |
| db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName, |
| pC->movetoTarget); |
| assert( pC->iDb>=0 ); |
| } |
| } |
| |
| break; |
| } |
| /* Opcode: ResetCount * * * * * |
| ** |
| ** The value of the change counter is copied to the database handle |
| ** change counter (returned by subsequent calls to sqlite3_changes()). |
| ** Then the VMs internal change counter resets to 0. |
| ** This is used by trigger programs. |
| */ |
| case OP_ResetCount: { |
| sqlite3VdbeSetChanges(db, p->nChange); |
| p->nChange = 0; |
| break; |
| } |
| |
| /* Opcode: SorterCompare P1 P2 P3 P4 |
| ** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2 |
| ** |
| ** P1 is a sorter cursor. This instruction compares a prefix of the |
| ** record blob in register P3 against a prefix of the entry that |
| ** the sorter cursor currently points to. Only the first P4 fields |
| ** of r[P3] and the sorter record are compared. |
| ** |
| ** If either P3 or the sorter contains a NULL in one of their significant |
| ** fields (not counting the P4 fields at the end which are ignored) then |
| ** the comparison is assumed to be equal. |
| ** |
| ** Fall through to next instruction if the two records compare equal to |
| ** each other. Jump to P2 if they are different. |
| */ |
| case OP_SorterCompare: { |
| VdbeCursor *pC; |
| int res; |
| int nKeyCol; |
| |
| pC = p->apCsr[pOp->p1]; |
| assert( isSorter(pC) ); |
| assert( pOp->p4type==P4_INT32 ); |
| pIn3 = &aMem[pOp->p3]; |
| nKeyCol = pOp->p4.i; |
| res = 0; |
| rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res); |
| VdbeBranchTaken(res!=0,2); |
| if( rc ) goto abort_due_to_error; |
| if( res ) goto jump_to_p2; |
| break; |
| }; |
| |
| /* Opcode: SorterData P1 P2 P3 * * |
| ** Synopsis: r[P2]=data |
| ** |
| ** Write into register P2 the current sorter data for sorter cursor P1. |
| ** Then clear the column header cache on cursor P3. |
| ** |
| ** This opcode is normally use to move a record out of the sorter and into |
| ** a register that is the source for a pseudo-table cursor created using |
| ** OpenPseudo. That pseudo-table cursor is the one that is identified by |
| ** parameter P3. Clearing the P3 column cache as part of this opcode saves |
| ** us from having to issue a separate NullRow instruction to clear that cache. |
| */ |
| case OP_SorterData: { |
| VdbeCursor *pC; |
| |
| pOut = &aMem[pOp->p2]; |
| pC = p->apCsr[pOp->p1]; |
| assert( isSorter(pC) ); |
| rc = sqlite3VdbeSorterRowkey(pC, pOut); |
| assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) ); |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| if( rc ) goto abort_due_to_error; |
| p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE; |
| break; |
| } |
| |
| /* Opcode: RowData P1 P2 P3 * * |
| ** Synopsis: r[P2]=data |
| ** |
| ** Write into register P2 the complete row content for the row at |
| ** which cursor P1 is currently pointing. |
| ** There is no interpretation of the data. |
| ** It is just copied onto the P2 register exactly as |
| ** it is found in the database file. |
| ** |
| ** If cursor P1 is an index, then the content is the key of the row. |
| ** If cursor P2 is a table, then the content extracted is the data. |
| ** |
| ** If the P1 cursor must be pointing to a valid row (not a NULL row) |
| ** of a real table, not a pseudo-table. |
| ** |
| ** If P3!=0 then this opcode is allowed to make an ephemeral pointer |
| ** into the database page. That means that the content of the output |
| ** register will be invalidated as soon as the cursor moves - including |
| ** moves caused by other cursors that "save" the current cursors |
| ** position in order that they can write to the same table. If P3==0 |
| ** then a copy of the data is made into memory. P3!=0 is faster, but |
| ** P3==0 is safer. |
| ** |
| ** If P3!=0 then the content of the P2 register is unsuitable for use |
| ** in OP_Result and any OP_Result will invalidate the P2 register content. |
| ** The P2 register content is invalidated by opcodes like OP_Function or |
| ** by any use of another cursor pointing to the same table. |
| */ |
| case OP_RowData: { |
| VdbeCursor *pC; |
| BtCursor *pCrsr; |
| u32 n; |
| |
| pOut = out2Prerelease(p, pOp); |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( isSorter(pC)==0 ); |
| assert( pC->nullRow==0 ); |
| assert( pC->uc.pCursor!=0 ); |
| pCrsr = pC->uc.pCursor; |
| |
| /* The OP_RowData opcodes always follow OP_NotExists or |
| ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions |
| ** that might invalidate the cursor. |
| ** If this where not the case, on of the following assert()s |
| ** would fail. Should this ever change (because of changes in the code |
| ** generator) then the fix would be to insert a call to |
| ** sqlite3VdbeCursorMoveto(). |
| */ |
| assert( pC->deferredMoveto==0 ); |
| assert( sqlite3BtreeCursorIsValid(pCrsr) ); |
| #if 0 /* Not required due to the previous to assert() statements */ |
| rc = sqlite3VdbeCursorMoveto(pC); |
| if( rc!=SQLITE_OK ) goto abort_due_to_error; |
| #endif |
| |
| n = sqlite3BtreePayloadSize(pCrsr); |
| if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){ |
| goto too_big; |
| } |
| testcase( n==0 ); |
| rc = sqlite3VdbeMemFromBtree(pCrsr, 0, n, pOut); |
| if( rc ) goto abort_due_to_error; |
| if( !pOp->p3 ) Deephemeralize(pOut); |
| UPDATE_MAX_BLOBSIZE(pOut); |
| REGISTER_TRACE(pOp->p2, pOut); |
| break; |
| } |
| |
| /* Opcode: Rowid P1 P2 * * * |
| ** Synopsis: r[P2]=rowid |
| ** |
| ** Store in register P2 an integer which is the key of the table entry that |
| ** P1 is currently point to. |
| ** |
| ** P1 can be either an ordinary table or a virtual table. There used to |
| ** be a separate OP_VRowid opcode for use with virtual tables, but this |
| ** one opcode now works for both table types. |
| */ |
| case OP_Rowid: { /* out2 */ |
| VdbeCursor *pC; |
| i64 v; |
| sqlite3_vtab *pVtab; |
| const sqlite3_module *pModule; |
| |
| pOut = out2Prerelease(p, pOp); |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow ); |
| if( pC->nullRow ){ |
| pOut->flags = MEM_Null; |
| break; |
| }else if( pC->deferredMoveto ){ |
| v = pC->movetoTarget; |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| }else if( pC->eCurType==CURTYPE_VTAB ){ |
| assert( pC->uc.pVCur!=0 ); |
| pVtab = pC->uc.pVCur->pVtab; |
| pModule = pVtab->pModule; |
| assert( pModule->xRowid ); |
| rc = pModule->xRowid(pC->uc.pVCur, &v); |
| sqlite3VtabImportErrmsg(p, pVtab); |
| if( rc ) goto abort_due_to_error; |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| }else{ |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->uc.pCursor!=0 ); |
| rc = sqlite3VdbeCursorRestore(pC); |
| if( rc ) goto abort_due_to_error; |
| if( pC->nullRow ){ |
| pOut->flags = MEM_Null; |
| break; |
| } |
| v = sqlite3BtreeIntegerKey(pC->uc.pCursor); |
| } |
| pOut->u.i = v; |
| break; |
| } |
| |
| /* Opcode: NullRow P1 * * * * |
| ** |
| ** Move the cursor P1 to a null row. Any OP_Column operations |
| ** that occur while the cursor is on the null row will always |
| ** write a NULL. |
| */ |
| case OP_NullRow: { |
| VdbeCursor *pC; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| pC->nullRow = 1; |
| pC->cacheStatus = CACHE_STALE; |
| if( pC->eCurType==CURTYPE_BTREE ){ |
| assert( pC->uc.pCursor!=0 ); |
| sqlite3BtreeClearCursor(pC->uc.pCursor); |
| } |
| #ifdef SQLITE_DEBUG |
| if( pC->seekOp==0 ) pC->seekOp = OP_NullRow; |
| #endif |
| break; |
| } |
| |
| /* Opcode: SeekEnd P1 * * * * |
| ** |
| ** Position cursor P1 at the end of the btree for the purpose of |
| ** appending a new entry onto the btree. |
| ** |
| ** It is assumed that the cursor is used only for appending and so |
| ** if the cursor is valid, then the cursor must already be pointing |
| ** at the end of the btree and so no changes are made to |
| ** the cursor. |
| */ |
| /* Opcode: Last P1 P2 * * * |
| ** |
| ** The next use of the Rowid or Column or Prev instruction for P1 |
| ** will refer to the last entry in the database table or index. |
| ** If the table or index is empty and P2>0, then jump immediately to P2. |
| ** If P2 is 0 or if the table or index is not empty, fall through |
| ** to the following instruction. |
| ** |
| ** This opcode leaves the cursor configured to move in reverse order, |
| ** from the end toward the beginning. In other words, the cursor is |
| ** configured to use Prev, not Next. |
| */ |
| case OP_SeekEnd: |
| case OP_Last: { /* jump */ |
| VdbeCursor *pC; |
| BtCursor *pCrsr; |
| int res; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| pCrsr = pC->uc.pCursor; |
| res = 0; |
| assert( pCrsr!=0 ); |
| #ifdef SQLITE_DEBUG |
| pC->seekOp = pOp->opcode; |
| #endif |
| if( pOp->opcode==OP_SeekEnd ){ |
| assert( pOp->p2==0 ); |
| pC->seekResult = -1; |
| if( sqlite3BtreeCursorIsValidNN(pCrsr) ){ |
| break; |
| } |
| } |
| rc = sqlite3BtreeLast(pCrsr, &res); |
| pC->nullRow = (u8)res; |
| pC->deferredMoveto = 0; |
| pC->cacheStatus = CACHE_STALE; |
| if( rc ) goto abort_due_to_error; |
| if( pOp->p2>0 ){ |
| VdbeBranchTaken(res!=0,2); |
| if( res ) goto jump_to_p2; |
| } |
| break; |
| } |
| |
| /* Opcode: IfSmaller P1 P2 P3 * * |
| ** |
| ** Estimate the number of rows in the table P1. Jump to P2 if that |
| ** estimate is less than approximately 2**(0.1*P3). |
| */ |
| case OP_IfSmaller: { /* jump */ |
| VdbeCursor *pC; |
| BtCursor *pCrsr; |
| int res; |
| i64 sz; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| pCrsr = pC->uc.pCursor; |
| assert( pCrsr ); |
| rc = sqlite3BtreeFirst(pCrsr, &res); |
| if( rc ) goto abort_due_to_error; |
| if( res==0 ){ |
| sz = sqlite3BtreeRowCountEst(pCrsr); |
| if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1; |
| } |
| VdbeBranchTaken(res!=0,2); |
| if( res ) goto jump_to_p2; |
| break; |
| } |
| |
| |
| /* Opcode: SorterSort P1 P2 * * * |
| ** |
| ** After all records have been inserted into the Sorter object |
| ** identified by P1, invoke this opcode to actually do the sorting. |
| ** Jump to P2 if there are no records to be sorted. |
| ** |
| ** This opcode is an alias for OP_Sort and OP_Rewind that is used |
| ** for Sorter objects. |
| */ |
| /* Opcode: Sort P1 P2 * * * |
| ** |
| ** This opcode does exactly the same thing as OP_Rewind except that |
| ** it increments an undocumented global variable used for testing. |
| ** |
| ** Sorting is accomplished by writing records into a sorting index, |
| ** then rewinding that index and playing it back from beginning to |
| ** end. We use the OP_Sort opcode instead of OP_Rewind to do the |
| ** rewinding so that the global variable will be incremented and |
| ** regression tests can determine whether or not the optimizer is |
| ** correctly optimizing out sorts. |
| */ |
| case OP_SorterSort: /* jump */ |
| case OP_Sort: { /* jump */ |
| #ifdef SQLITE_TEST |
| sqlite3_sort_count++; |
| sqlite3_search_count--; |
| #endif |
| p->aCounter[SQLITE_STMTSTATUS_SORT]++; |
| /* Fall through into OP_Rewind */ |
| } |
| /* Opcode: Rewind P1 P2 * * P5 |
| ** |
| ** The next use of the Rowid or Column or Next instruction for P1 |
| ** will refer to the first entry in the database table or index. |
| ** If the table or index is empty, jump immediately to P2. |
| ** If the table or index is not empty, fall through to the following |
| ** instruction. |
| ** |
| ** If P5 is non-zero and the table is not empty, then the "skip-next" |
| ** flag is set on the cursor so that the next OP_Next instruction |
| ** executed on it is a no-op. |
| ** |
| ** This opcode leaves the cursor configured to move in forward order, |
| ** from the beginning toward the end. In other words, the cursor is |
| ** configured to use Next, not Prev. |
| */ |
| case OP_Rewind: { /* jump */ |
| VdbeCursor *pC; |
| BtCursor *pCrsr; |
| int res; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) ); |
| res = 1; |
| #ifdef SQLITE_DEBUG |
| pC->seekOp = OP_Rewind; |
| #endif |
| if( isSorter(pC) ){ |
| rc = sqlite3VdbeSorterRewind(pC, &res); |
| }else{ |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| pCrsr = pC->uc.pCursor; |
| assert( pCrsr ); |
| rc = sqlite3BtreeFirst(pCrsr, &res); |
| #ifndef SQLITE_OMIT_WINDOWFUNC |
| if( pOp->p5 ) sqlite3BtreeSkipNext(pCrsr); |
| #endif |
| pC->deferredMoveto = 0; |
| pC->cacheStatus = CACHE_STALE; |
| } |
| if( rc ) goto abort_due_to_error; |
| pC->nullRow = (u8)res; |
| assert( pOp->p2>0 && pOp->p2<p->nOp ); |
| VdbeBranchTaken(res!=0,2); |
| if( res ) goto jump_to_p2; |
| break; |
| } |
| |
| /* Opcode: Next P1 P2 P3 P4 P5 |
| ** |
| ** Advance cursor P1 so that it points to the next key/data pair in its |
| ** table or index. If there are no more key/value pairs then fall through |
| ** to the following instruction. But if the cursor advance was successful, |
| ** jump immediately to P2. |
| ** |
| ** The Next opcode is only valid following an SeekGT, SeekGE, or |
| ** OP_Rewind opcode used to position the cursor. Next is not allowed |
| ** to follow SeekLT, SeekLE, or OP_Last. |
| ** |
| ** The P1 cursor must be for a real table, not a pseudo-table. P1 must have |
| ** been opened prior to this opcode or the program will segfault. |
| ** |
| ** The P3 value is a hint to the btree implementation. If P3==1, that |
| ** means P1 is an SQL index and that this instruction could have been |
| ** omitted if that index had been unique. P3 is usually 0. P3 is |
| ** always either 0 or 1. |
| ** |
| ** P4 is always of type P4_ADVANCE. The function pointer points to |
| ** sqlite3BtreeNext(). |
| ** |
| ** If P5 is positive and the jump is taken, then event counter |
| ** number P5-1 in the prepared statement is incremented. |
| ** |
| ** See also: Prev |
| */ |
| /* Opcode: Prev P1 P2 P3 P4 P5 |
| ** |
| ** Back up cursor P1 so that it points to the previous key/data pair in its |
| ** table or index. If there is no previous key/value pairs then fall through |
| ** to the following instruction. But if the cursor backup was successful, |
| ** jump immediately to P2. |
| ** |
| ** |
| ** The Prev opcode is only valid following an SeekLT, SeekLE, or |
| ** OP_Last opcode used to position the cursor. Prev is not allowed |
| ** to follow SeekGT, SeekGE, or OP_Rewind. |
| ** |
| ** The P1 cursor must be for a real table, not a pseudo-table. If P1 is |
| ** not open then the behavior is undefined. |
| ** |
| ** The P3 value is a hint to the btree implementation. If P3==1, that |
| ** means P1 is an SQL index and that this instruction could have been |
| ** omitted if that index had been unique. P3 is usually 0. P3 is |
| ** always either 0 or 1. |
| ** |
| ** P4 is always of type P4_ADVANCE. The function pointer points to |
| ** sqlite3BtreePrevious(). |
| ** |
| ** If P5 is positive and the jump is taken, then event counter |
| ** number P5-1 in the prepared statement is incremented. |
| */ |
| /* Opcode: SorterNext P1 P2 * * P5 |
| ** |
| ** This opcode works just like OP_Next except that P1 must be a |
| ** sorter object for which the OP_SorterSort opcode has been |
| ** invoked. This opcode advances the cursor to the next sorted |
| ** record, or jumps to P2 if there are no more sorted records. |
| */ |
| case OP_SorterNext: { /* jump */ |
| VdbeCursor *pC; |
| |
| pC = p->apCsr[pOp->p1]; |
| assert( isSorter(pC) ); |
| rc = sqlite3VdbeSorterNext(db, pC); |
| goto next_tail; |
| case OP_Prev: /* jump */ |
| case OP_Next: /* jump */ |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( pOp->p5<ArraySize(p->aCounter) ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->deferredMoveto==0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext ); |
| assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious ); |
| |
| /* The Next opcode is only used after SeekGT, SeekGE, Rewind, and Found. |
| ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */ |
| assert( pOp->opcode!=OP_Next |
| || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE |
| || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found |
| || pC->seekOp==OP_NullRow|| pC->seekOp==OP_SeekRowid); |
| assert( pOp->opcode!=OP_Prev |
| || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE |
| || pC->seekOp==OP_Last |
| || pC->seekOp==OP_NullRow); |
| |
| rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3); |
| next_tail: |
| pC->cacheStatus = CACHE_STALE; |
| VdbeBranchTaken(rc==SQLITE_OK,2); |
| if( rc==SQLITE_OK ){ |
| pC->nullRow = 0; |
| p->aCounter[pOp->p5]++; |
| #ifdef SQLITE_TEST |
| sqlite3_search_count++; |
| #endif |
| goto jump_to_p2_and_check_for_interrupt; |
| } |
| if( rc!=SQLITE_DONE ) goto abort_due_to_error; |
| rc = SQLITE_OK; |
| pC->nullRow = 1; |
| goto check_for_interrupt; |
| } |
| |
| /* Opcode: IdxInsert P1 P2 P3 P4 P5 |
| ** Synopsis: key=r[P2] |
| ** |
| ** Register P2 holds an SQL index key made using the |
| ** MakeRecord instructions. This opcode writes that key |
| ** into the index P1. Data for the entry is nil. |
| ** |
| ** If P4 is not zero, then it is the number of values in the unpacked |
| ** key of reg(P2). In that case, P3 is the index of the first register |
| ** for the unpacked key. The availability of the unpacked key can sometimes |
| ** be an optimization. |
| ** |
| ** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer |
| ** that this insert is likely to be an append. |
| ** |
| ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is |
| ** incremented by this instruction. If the OPFLAG_NCHANGE bit is clear, |
| ** then the change counter is unchanged. |
| ** |
| ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might |
| ** run faster by avoiding an unnecessary seek on cursor P1. However, |
| ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior |
| ** seeks on the cursor or if the most recent seek used a key equivalent |
| ** to P2. |
| ** |
| ** This instruction only works for indices. The equivalent instruction |
| ** for tables is OP_Insert. |
| */ |
| /* Opcode: SorterInsert P1 P2 * * * |
| ** Synopsis: key=r[P2] |
| ** |
| ** Register P2 holds an SQL index key made using the |
| ** MakeRecord instructions. This opcode writes that key |
| ** into the sorter P1. Data for the entry is nil. |
| */ |
| case OP_SorterInsert: /* in2 */ |
| case OP_IdxInsert: { /* in2 */ |
| VdbeCursor *pC; |
| BtreePayload x; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| sqlite3VdbeIncrWriteCounter(p, pC); |
| assert( pC!=0 ); |
| assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) ); |
| pIn2 = &aMem[pOp->p2]; |
| assert( pIn2->flags & MEM_Blob ); |
| if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++; |
| assert( pC->eCurType==CURTYPE_BTREE || pOp->opcode==OP_SorterInsert ); |
| assert( pC->isTable==0 ); |
| rc = ExpandBlob(pIn2); |
| if( rc ) goto abort_due_to_error; |
| if( pOp->opcode==OP_SorterInsert ){ |
| rc = sqlite3VdbeSorterWrite(pC, pIn2); |
| }else{ |
| x.nKey = pIn2->n; |
| x.pKey = pIn2->z; |
| x.aMem = aMem + pOp->p3; |
| x.nMem = (u16)pOp->p4.i; |
| rc = sqlite3BtreeInsert(pC->uc.pCursor, &x, |
| (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), |
| ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0) |
| ); |
| assert( pC->deferredMoveto==0 ); |
| pC->cacheStatus = CACHE_STALE; |
| } |
| if( rc) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: IdxDelete P1 P2 P3 * * |
| ** Synopsis: key=r[P2@P3] |
| ** |
| ** The content of P3 registers starting at register P2 form |
| ** an unpacked index key. This opcode removes that entry from the |
| ** index opened by cursor P1. |
| */ |
| case OP_IdxDelete: { |
| VdbeCursor *pC; |
| BtCursor *pCrsr; |
| int res; |
| UnpackedRecord r; |
| |
| assert( pOp->p3>0 ); |
| assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 ); |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| sqlite3VdbeIncrWriteCounter(p, pC); |
| pCrsr = pC->uc.pCursor; |
| assert( pCrsr!=0 ); |
| assert( pOp->p5==0 ); |
| r.pKeyInfo = pC->pKeyInfo; |
| r.nField = (u16)pOp->p3; |
| r.default_rc = 0; |
| r.aMem = &aMem[pOp->p2]; |
| rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res); |
| if( rc ) goto abort_due_to_error; |
| if( res==0 ){ |
| rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE); |
| if( rc ) goto abort_due_to_error; |
| } |
| assert( pC->deferredMoveto==0 ); |
| pC->cacheStatus = CACHE_STALE; |
| pC->seekResult = 0; |
| break; |
| } |
| |
| /* Opcode: DeferredSeek P1 * P3 P4 * |
| ** Synopsis: Move P3 to P1.rowid if needed |
| ** |
| ** P1 is an open index cursor and P3 is a cursor on the corresponding |
| ** table. This opcode does a deferred seek of the P3 table cursor |
| ** to the row that corresponds to the current row of P1. |
| ** |
| ** This is a deferred seek. Nothing actually happens until |
| ** the cursor is used to read a record. That way, if no reads |
| ** occur, no unnecessary I/O happens. |
| ** |
| ** P4 may be an array of integers (type P4_INTARRAY) containing |
| ** one entry for each column in the P3 table. If array entry a(i) |
| ** is non-zero, then reading column a(i)-1 from cursor P3 is |
| ** equivalent to performing the deferred seek and then reading column i |
| ** from P1. This information is stored in P3 and used to redirect |
| ** reads against P3 over to P1, thus possibly avoiding the need to |
| ** seek and read cursor P3. |
| */ |
| /* Opcode: IdxRowid P1 P2 * * * |
| ** Synopsis: r[P2]=rowid |
| ** |
| ** Write into register P2 an integer which is the last entry in the record at |
| ** the end of the index key pointed to by cursor P1. This integer should be |
| ** the rowid of the table entry to which this index entry points. |
| ** |
| ** See also: Rowid, MakeRecord. |
| */ |
| case OP_DeferredSeek: |
| case OP_IdxRowid: { /* out2 */ |
| VdbeCursor *pC; /* The P1 index cursor */ |
| VdbeCursor *pTabCur; /* The P2 table cursor (OP_DeferredSeek only) */ |
| i64 rowid; /* Rowid that P1 current points to */ |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->uc.pCursor!=0 ); |
| assert( pC->isTable==0 ); |
| assert( pC->deferredMoveto==0 ); |
| assert( !pC->nullRow || pOp->opcode==OP_IdxRowid ); |
| |
| /* The IdxRowid and Seek opcodes are combined because of the commonality |
| ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */ |
| rc = sqlite3VdbeCursorRestore(pC); |
| |
| /* sqlite3VbeCursorRestore() can only fail if the record has been deleted |
| ** out from under the cursor. That will never happens for an IdxRowid |
| ** or Seek opcode */ |
| if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error; |
| |
| if( !pC->nullRow ){ |
| rowid = 0; /* Not needed. Only used to silence a warning. */ |
| rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid); |
| if( rc!=SQLITE_OK ){ |
| goto abort_due_to_error; |
| } |
| if( pOp->opcode==OP_DeferredSeek ){ |
| assert( pOp->p3>=0 && pOp->p3<p->nCursor ); |
| pTabCur = p->apCsr[pOp->p3]; |
| assert( pTabCur!=0 ); |
| assert( pTabCur->eCurType==CURTYPE_BTREE ); |
| assert( pTabCur->uc.pCursor!=0 ); |
| assert( pTabCur->isTable ); |
| pTabCur->nullRow = 0; |
| pTabCur->movetoTarget = rowid; |
| pTabCur->deferredMoveto = 1; |
| assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 ); |
| pTabCur->aAltMap = pOp->p4.ai; |
| pTabCur->pAltCursor = pC; |
| }else{ |
| pOut = out2Prerelease(p, pOp); |
| pOut->u.i = rowid; |
| } |
| }else{ |
| assert( pOp->opcode==OP_IdxRowid ); |
| sqlite3VdbeMemSetNull(&aMem[pOp->p2]); |
| } |
| break; |
| } |
| |
| /* Opcode: IdxGE P1 P2 P3 P4 P5 |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** The P4 register values beginning with P3 form an unpacked index |
| ** key that omits the PRIMARY KEY. Compare this key value against the index |
| ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID |
| ** fields at the end. |
| ** |
| ** If the P1 index entry is greater than or equal to the key value |
| ** then jump to P2. Otherwise fall through to the next instruction. |
| */ |
| /* Opcode: IdxGT P1 P2 P3 P4 P5 |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** The P4 register values beginning with P3 form an unpacked index |
| ** key that omits the PRIMARY KEY. Compare this key value against the index |
| ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID |
| ** fields at the end. |
| ** |
| ** If the P1 index entry is greater than the key value |
| ** then jump to P2. Otherwise fall through to the next instruction. |
| */ |
| /* Opcode: IdxLT P1 P2 P3 P4 P5 |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** The P4 register values beginning with P3 form an unpacked index |
| ** key that omits the PRIMARY KEY or ROWID. Compare this key value against |
| ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or |
| ** ROWID on the P1 index. |
| ** |
| ** If the P1 index entry is less than the key value then jump to P2. |
| ** Otherwise fall through to the next instruction. |
| */ |
| /* Opcode: IdxLE P1 P2 P3 P4 P5 |
| ** Synopsis: key=r[P3@P4] |
| ** |
| ** The P4 register values beginning with P3 form an unpacked index |
| ** key that omits the PRIMARY KEY or ROWID. Compare this key value against |
| ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or |
| ** ROWID on the P1 index. |
| ** |
| ** If the P1 index entry is less than or equal to the key value then jump |
| ** to P2. Otherwise fall through to the next instruction. |
| */ |
| case OP_IdxLE: /* jump */ |
| case OP_IdxGT: /* jump */ |
| case OP_IdxLT: /* jump */ |
| case OP_IdxGE: { /* jump */ |
| VdbeCursor *pC; |
| int res; |
| UnpackedRecord r; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| assert( pC->isOrdered ); |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->uc.pCursor!=0); |
| assert( pC->deferredMoveto==0 ); |
| assert( pOp->p5==0 || pOp->p5==1 ); |
| assert( pOp->p4type==P4_INT32 ); |
| r.pKeyInfo = pC->pKeyInfo; |
| r.nField = (u16)pOp->p4.i; |
| if( pOp->opcode<OP_IdxLT ){ |
| assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT ); |
| r.default_rc = -1; |
| }else{ |
| assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT ); |
| r.default_rc = 0; |
| } |
| r.aMem = &aMem[pOp->p3]; |
| #ifdef SQLITE_DEBUG |
| { |
| int i; |
| for(i=0; i<r.nField; i++){ |
| assert( memIsValid(&r.aMem[i]) ); |
| REGISTER_TRACE(pOp->p3+i, &aMem[pOp->p3+i]); |
| } |
| } |
| #endif |
| res = 0; /* Not needed. Only used to silence a warning. */ |
| rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res); |
| assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) ); |
| if( (pOp->opcode&1)==(OP_IdxLT&1) ){ |
| assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT ); |
| res = -res; |
| }else{ |
| assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT ); |
| res++; |
| } |
| VdbeBranchTaken(res>0,2); |
| if( rc ) goto abort_due_to_error; |
| if( res>0 ) goto jump_to_p2; |
| break; |
| } |
| |
| /* Opcode: Destroy P1 P2 P3 * * |
| ** |
| ** Delete an entire database table or index whose root page in the database |
| ** file is given by P1. |
| ** |
| ** The table being destroyed is in the main database file if P3==0. If |
| ** P3==1 then the table to be clear is in the auxiliary database file |
| ** that is used to store tables create using CREATE TEMPORARY TABLE. |
| ** |
| ** If AUTOVACUUM is enabled then it is possible that another root page |
| ** might be moved into the newly deleted root page in order to keep all |
| ** root pages contiguous at the beginning of the database. The former |
| ** value of the root page that moved - its value before the move occurred - |
| ** is stored in register P2. If no page movement was required (because the |
| ** table being dropped was already the last one in the database) then a |
| ** zero is stored in register P2. If AUTOVACUUM is disabled then a zero |
| ** is stored in register P2. |
| ** |
| ** This opcode throws an error if there are any active reader VMs when |
| ** it is invoked. This is done to avoid the difficulty associated with |
| ** updating existing cursors when a root page is moved in an AUTOVACUUM |
| ** database. This error is thrown even if the database is not an AUTOVACUUM |
| ** db in order to avoid introducing an incompatibility between autovacuum |
| ** and non-autovacuum modes. |
| ** |
| ** See also: Clear |
| */ |
| case OP_Destroy: { /* out2 */ |
| int iMoved; |
| int iDb; |
| |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| assert( p->readOnly==0 ); |
| assert( pOp->p1>1 ); |
| pOut = out2Prerelease(p, pOp); |
| pOut->flags = MEM_Null; |
| if( db->nVdbeRead > db->nVDestroy+1 ){ |
| rc = SQLITE_LOCKED; |
| p->errorAction = OE_Abort; |
| goto abort_due_to_error; |
| }else{ |
| iDb = pOp->p3; |
| assert( DbMaskTest(p->btreeMask, iDb) ); |
| iMoved = 0; /* Not needed. Only to silence a warning. */ |
| rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved); |
| pOut->flags = MEM_Int; |
| pOut->u.i = iMoved; |
| if( rc ) goto abort_due_to_error; |
| #ifndef SQLITE_OMIT_AUTOVACUUM |
| if( iMoved!=0 ){ |
| sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1); |
| /* All OP_Destroy operations occur on the same btree */ |
| assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 ); |
| resetSchemaOnFault = iDb+1; |
| } |
| #endif |
| } |
| break; |
| } |
| |
| /* Opcode: Clear P1 P2 P3 |
| ** |
| ** Delete all contents of the database table or index whose root page |
| ** in the database file is given by P1. But, unlike Destroy, do not |
| ** remove the table or index from the database file. |
| ** |
| ** The table being clear is in the main database file if P2==0. If |
| ** P2==1 then the table to be clear is in the auxiliary database file |
| ** that is used to store tables create using CREATE TEMPORARY TABLE. |
| ** |
| ** If the P3 value is non-zero, then the table referred to must be an |
| ** intkey table (an SQL table, not an index). In this case the row change |
| ** count is incremented by the number of rows in the table being cleared. |
| ** If P3 is greater than zero, then the value stored in register P3 is |
| ** also incremented by the number of rows in the table being cleared. |
| ** |
| ** See also: Destroy |
| */ |
| case OP_Clear: { |
| int nChange; |
| |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| nChange = 0; |
| assert( p->readOnly==0 ); |
| assert( DbMaskTest(p->btreeMask, pOp->p2) ); |
| rc = sqlite3BtreeClearTable( |
| db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0) |
| ); |
| if( pOp->p3 ){ |
| p->nChange += nChange; |
| if( pOp->p3>0 ){ |
| assert( memIsValid(&aMem[pOp->p3]) ); |
| memAboutToChange(p, &aMem[pOp->p3]); |
| aMem[pOp->p3].u.i += nChange; |
| } |
| } |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: ResetSorter P1 * * * * |
| ** |
| ** Delete all contents from the ephemeral table or sorter |
| ** that is open on cursor P1. |
| ** |
| ** This opcode only works for cursors used for sorting and |
| ** opened with OP_OpenEphemeral or OP_SorterOpen. |
| */ |
| case OP_ResetSorter: { |
| VdbeCursor *pC; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| pC = p->apCsr[pOp->p1]; |
| assert( pC!=0 ); |
| if( isSorter(pC) ){ |
| sqlite3VdbeSorterReset(db, pC->uc.pSorter); |
| }else{ |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| assert( pC->isEphemeral ); |
| rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor); |
| if( rc ) goto abort_due_to_error; |
| } |
| break; |
| } |
| |
| /* Opcode: CreateBtree P1 P2 P3 * * |
| ** Synopsis: r[P2]=root iDb=P1 flags=P3 |
| ** |
| ** Allocate a new b-tree in the main database file if P1==0 or in the |
| ** TEMP database file if P1==1 or in an attached database if |
| ** P1>1. The P3 argument must be 1 (BTREE_INTKEY) for a rowid table |
| ** it must be 2 (BTREE_BLOBKEY) for an index or WITHOUT ROWID table. |
| ** The root page number of the new b-tree is stored in register P2. |
| */ |
| case OP_CreateBtree: { /* out2 */ |
| int pgno; |
| Db *pDb; |
| |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| pOut = out2Prerelease(p, pOp); |
| pgno = 0; |
| assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY ); |
| assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
| assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
| assert( p->readOnly==0 ); |
| pDb = &db->aDb[pOp->p1]; |
| assert( pDb->pBt!=0 ); |
| rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3); |
| if( rc ) goto abort_due_to_error; |
| pOut->u.i = pgno; |
| break; |
| } |
| |
| /* Opcode: SqlExec * * * P4 * |
| ** |
| ** Run the SQL statement or statements specified in the P4 string. |
| */ |
| case OP_SqlExec: { |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| db->nSqlExec++; |
| rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0); |
| db->nSqlExec--; |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| |
| /* Opcode: ParseSchema P1 * * P4 * |
| ** |
| ** Read and parse all entries from the SQLITE_MASTER table of database P1 |
| ** that match the WHERE clause P4. If P4 is a NULL pointer, then the |
| ** entire schema for P1 is reparsed. |
| ** |
| ** This opcode invokes the parser to create a new virtual machine, |
| ** then runs the new virtual machine. It is thus a re-entrant opcode. |
| */ |
| case OP_ParseSchema: { |
| int iDb; |
| const char *zMaster; |
| char *zSql; |
| InitData initData; |
| |
| /* Any prepared statement that invokes this opcode will hold mutexes |
| ** on every btree. This is a prerequisite for invoking |
| ** sqlite3InitCallback(). |
| */ |
| #ifdef SQLITE_DEBUG |
| for(iDb=0; iDb<db->nDb; iDb++){ |
| assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) ); |
| } |
| #endif |
| |
| iDb = pOp->p1; |
| assert( iDb>=0 && iDb<db->nDb ); |
| assert( DbHasProperty(db, iDb, DB_SchemaLoaded) ); |
| |
| #ifndef SQLITE_OMIT_ALTERTABLE |
| if( pOp->p4.z==0 ){ |
| sqlite3SchemaClear(db->aDb[iDb].pSchema); |
| db->mDbFlags &= ~DBFLAG_SchemaKnownOk; |
| rc = sqlite3InitOne(db, iDb, &p->zErrMsg, INITFLAG_AlterTable); |
| db->mDbFlags |= DBFLAG_SchemaChange; |
| p->expired = 0; |
| }else |
| #endif |
| { |
| zMaster = MASTER_NAME; |
| initData.db = db; |
| initData.iDb = iDb; |
| initData.pzErrMsg = &p->zErrMsg; |
| initData.mInitFlags = 0; |
| zSql = sqlite3MPrintf(db, |
| "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid", |
| db->aDb[iDb].zDbSName, zMaster, pOp->p4.z); |
| if( zSql==0 ){ |
| rc = SQLITE_NOMEM_BKPT; |
| }else{ |
| assert( db->init.busy==0 ); |
| db->init.busy = 1; |
| initData.rc = SQLITE_OK; |
| initData.nInitRow = 0; |
| assert( !db->mallocFailed ); |
| rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0); |
| if( rc==SQLITE_OK ) rc = initData.rc; |
| if( rc==SQLITE_OK && initData.nInitRow==0 ){ |
| /* The OP_ParseSchema opcode with a non-NULL P4 argument should parse |
| ** at least one SQL statement. Any less than that indicates that |
| ** the sqlite_master table is corrupt. */ |
| rc = SQLITE_CORRUPT_BKPT; |
| } |
| sqlite3DbFreeNN(db, zSql); |
| db->init.busy = 0; |
| } |
| } |
| if( rc ){ |
| sqlite3ResetAllSchemasOfConnection(db); |
| if( rc==SQLITE_NOMEM ){ |
| goto no_mem; |
| } |
| goto abort_due_to_error; |
| } |
| break; |
| } |
| |
| #if !defined(SQLITE_OMIT_ANALYZE) |
| /* Opcode: LoadAnalysis P1 * * * * |
| ** |
| ** Read the sqlite_stat1 table for database P1 and load the content |
| ** of that table into the internal index hash table. This will cause |
| ** the analysis to be used when preparing all subsequent queries. |
| */ |
| case OP_LoadAnalysis: { |
| assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
| rc = sqlite3AnalysisLoad(db, pOp->p1); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif /* !defined(SQLITE_OMIT_ANALYZE) */ |
| |
| /* Opcode: DropTable P1 * * P4 * |
| ** |
| ** Remove the internal (in-memory) data structures that describe |
| ** the table named P4 in database P1. This is called after a table |
| ** is dropped from disk (using the Destroy opcode) in order to keep |
| ** the internal representation of the |
| ** schema consistent with what is on disk. |
| */ |
| case OP_DropTable: { |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z); |
| break; |
| } |
| |
| /* Opcode: DropIndex P1 * * P4 * |
| ** |
| ** Remove the internal (in-memory) data structures that describe |
| ** the index named P4 in database P1. This is called after an index |
| ** is dropped from disk (using the Destroy opcode) |
| ** in order to keep the internal representation of the |
| ** schema consistent with what is on disk. |
| */ |
| case OP_DropIndex: { |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z); |
| break; |
| } |
| |
| /* Opcode: DropTrigger P1 * * P4 * |
| ** |
| ** Remove the internal (in-memory) data structures that describe |
| ** the trigger named P4 in database P1. This is called after a trigger |
| ** is dropped from disk (using the Destroy opcode) in order to keep |
| ** the internal representation of the |
| ** schema consistent with what is on disk. |
| */ |
| case OP_DropTrigger: { |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z); |
| break; |
| } |
| |
| |
| #ifndef SQLITE_OMIT_INTEGRITY_CHECK |
| /* Opcode: IntegrityCk P1 P2 P3 P4 P5 |
| ** |
| ** Do an analysis of the currently open database. Store in |
| ** register P1 the text of an error message describing any problems. |
| ** If no problems are found, store a NULL in register P1. |
| ** |
| ** The register P3 contains one less than the maximum number of allowed errors. |
| ** At most reg(P3) errors will be reported. |
| ** In other words, the analysis stops as soon as reg(P1) errors are |
| ** seen. Reg(P1) is updated with the number of errors remaining. |
| ** |
| ** The root page numbers of all tables in the database are integers |
| ** stored in P4_INTARRAY argument. |
| ** |
| ** If P5 is not zero, the check is done on the auxiliary database |
| ** file, not the main database file. |
| ** |
| ** This opcode is used to implement the integrity_check pragma. |
| */ |
| case OP_IntegrityCk: { |
| int nRoot; /* Number of tables to check. (Number of root pages.) */ |
| int *aRoot; /* Array of rootpage numbers for tables to be checked */ |
| int nErr; /* Number of errors reported */ |
| char *z; /* Text of the error report */ |
| Mem *pnErr; /* Register keeping track of errors remaining */ |
| |
| assert( p->bIsReader ); |
| nRoot = pOp->p2; |
| aRoot = pOp->p4.ai; |
| assert( nRoot>0 ); |
| assert( aRoot[0]==nRoot ); |
| assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| pnErr = &aMem[pOp->p3]; |
| assert( (pnErr->flags & MEM_Int)!=0 ); |
| assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 ); |
| pIn1 = &aMem[pOp->p1]; |
| assert( pOp->p5<db->nDb ); |
| assert( DbMaskTest(p->btreeMask, pOp->p5) ); |
| z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, &aRoot[1], nRoot, |
| (int)pnErr->u.i+1, &nErr); |
| sqlite3VdbeMemSetNull(pIn1); |
| if( nErr==0 ){ |
| assert( z==0 ); |
| }else if( z==0 ){ |
| goto no_mem; |
| }else{ |
| pnErr->u.i -= nErr-1; |
| sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free); |
| } |
| UPDATE_MAX_BLOBSIZE(pIn1); |
| sqlite3VdbeChangeEncoding(pIn1, encoding); |
| break; |
| } |
| #endif /* SQLITE_OMIT_INTEGRITY_CHECK */ |
| |
| /* Opcode: RowSetAdd P1 P2 * * * |
| ** Synopsis: rowset(P1)=r[P2] |
| ** |
| ** Insert the integer value held by register P2 into a RowSet object |
| ** held in register P1. |
| ** |
| ** An assertion fails if P2 is not an integer. |
| */ |
| case OP_RowSetAdd: { /* in1, in2 */ |
| pIn1 = &aMem[pOp->p1]; |
| pIn2 = &aMem[pOp->p2]; |
| assert( (pIn2->flags & MEM_Int)!=0 ); |
| if( (pIn1->flags & MEM_Blob)==0 ){ |
| if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; |
| } |
| assert( sqlite3VdbeMemIsRowSet(pIn1) ); |
| sqlite3RowSetInsert((RowSet*)pIn1->z, pIn2->u.i); |
| break; |
| } |
| |
| /* Opcode: RowSetRead P1 P2 P3 * * |
| ** Synopsis: r[P3]=rowset(P1) |
| ** |
| ** Extract the smallest value from the RowSet object in P1 |
| ** and put that value into register P3. |
| ** Or, if RowSet object P1 is initially empty, leave P3 |
| ** unchanged and jump to instruction P2. |
| */ |
| case OP_RowSetRead: { /* jump, in1, out3 */ |
| i64 val; |
| |
| pIn1 = &aMem[pOp->p1]; |
| assert( (pIn1->flags & MEM_Blob)==0 || sqlite3VdbeMemIsRowSet(pIn1) ); |
| if( (pIn1->flags & MEM_Blob)==0 |
| || sqlite3RowSetNext((RowSet*)pIn1->z, &val)==0 |
| ){ |
| /* The boolean index is empty */ |
| sqlite3VdbeMemSetNull(pIn1); |
| VdbeBranchTaken(1,2); |
| goto jump_to_p2_and_check_for_interrupt; |
| }else{ |
| /* A value was pulled from the index */ |
| VdbeBranchTaken(0,2); |
| sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val); |
| } |
| goto check_for_interrupt; |
| } |
| |
| /* Opcode: RowSetTest P1 P2 P3 P4 |
| ** Synopsis: if r[P3] in rowset(P1) goto P2 |
| ** |
| ** Register P3 is assumed to hold a 64-bit integer value. If register P1 |
| ** contains a RowSet object and that RowSet object contains |
| ** the value held in P3, jump to register P2. Otherwise, insert the |
| ** integer in P3 into the RowSet and continue on to the |
| ** next opcode. |
| ** |
| ** The RowSet object is optimized for the case where sets of integers |
| ** are inserted in distinct phases, which each set contains no duplicates. |
| ** Each set is identified by a unique P4 value. The first set |
| ** must have P4==0, the final set must have P4==-1, and for all other sets |
| ** must have P4>0. |
| ** |
| ** This allows optimizations: (a) when P4==0 there is no need to test |
| ** the RowSet object for P3, as it is guaranteed not to contain it, |
| ** (b) when P4==-1 there is no need to insert the value, as it will |
| ** never be tested for, and (c) when a value that is part of set X is |
| ** inserted, there is no need to search to see if the same value was |
| ** previously inserted as part of set X (only if it was previously |
| ** inserted as part of some other set). |
| */ |
| case OP_RowSetTest: { /* jump, in1, in3 */ |
| int iSet; |
| int exists; |
| |
| pIn1 = &aMem[pOp->p1]; |
| pIn3 = &aMem[pOp->p3]; |
| iSet = pOp->p4.i; |
| assert( pIn3->flags&MEM_Int ); |
| |
| /* If there is anything other than a rowset object in memory cell P1, |
| ** delete it now and initialize P1 with an empty rowset |
| */ |
| if( (pIn1->flags & MEM_Blob)==0 ){ |
| if( sqlite3VdbeMemSetRowSet(pIn1) ) goto no_mem; |
| } |
| assert( sqlite3VdbeMemIsRowSet(pIn1) ); |
| assert( pOp->p4type==P4_INT32 ); |
| assert( iSet==-1 || iSet>=0 ); |
| if( iSet ){ |
| exists = sqlite3RowSetTest((RowSet*)pIn1->z, iSet, pIn3->u.i); |
| VdbeBranchTaken(exists!=0,2); |
| if( exists ) goto jump_to_p2; |
| } |
| if( iSet>=0 ){ |
| sqlite3RowSetInsert((RowSet*)pIn1->z, pIn3->u.i); |
| } |
| break; |
| } |
| |
| |
| #ifndef SQLITE_OMIT_TRIGGER |
| |
| /* Opcode: Program P1 P2 P3 P4 P5 |
| ** |
| ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). |
| ** |
| ** P1 contains the address of the memory cell that contains the first memory |
| ** cell in an array of values used as arguments to the sub-program. P2 |
| ** contains the address to jump to if the sub-program throws an IGNORE |
| ** exception using the RAISE() function. Register P3 contains the address |
| ** of a memory cell in this (the parent) VM that is used to allocate the |
| ** memory required by the sub-vdbe at runtime. |
| ** |
| ** P4 is a pointer to the VM containing the trigger program. |
| ** |
| ** If P5 is non-zero, then recursive program invocation is enabled. |
| */ |
| case OP_Program: { /* jump */ |
| int nMem; /* Number of memory registers for sub-program */ |
| int nByte; /* Bytes of runtime space required for sub-program */ |
| Mem *pRt; /* Register to allocate runtime space */ |
| Mem *pMem; /* Used to iterate through memory cells */ |
| Mem *pEnd; /* Last memory cell in new array */ |
| VdbeFrame *pFrame; /* New vdbe frame to execute in */ |
| SubProgram *pProgram; /* Sub-program to execute */ |
| void *t; /* Token identifying trigger */ |
| |
| pProgram = pOp->p4.pProgram; |
| pRt = &aMem[pOp->p3]; |
| assert( pProgram->nOp>0 ); |
| |
| /* If the p5 flag is clear, then recursive invocation of triggers is |
| ** disabled for backwards compatibility (p5 is set if this sub-program |
| ** is really a trigger, not a foreign key action, and the flag set |
| ** and cleared by the "PRAGMA recursive_triggers" command is clear). |
| ** |
| ** It is recursive invocation of triggers, at the SQL level, that is |
| ** disabled. In some cases a single trigger may generate more than one |
| ** SubProgram (if the trigger may be executed with more than one different |
| ** ON CONFLICT algorithm). SubProgram structures associated with a |
| ** single trigger all have the same value for the SubProgram.token |
| ** variable. */ |
| if( pOp->p5 ){ |
| t = pProgram->token; |
| for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent); |
| if( pFrame ) break; |
| } |
| |
| if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){ |
| rc = SQLITE_ERROR; |
| sqlite3VdbeError(p, "too many levels of trigger recursion"); |
| goto abort_due_to_error; |
| } |
| |
| /* Register pRt is used to store the memory required to save the state |
| ** of the current program, and the memory required at runtime to execute |
| ** the trigger program. If this trigger has been fired before, then pRt |
| ** is already allocated. Otherwise, it must be initialized. */ |
| if( (pRt->flags&MEM_Blob)==0 ){ |
| /* SubProgram.nMem is set to the number of memory cells used by the |
| ** program stored in SubProgram.aOp. As well as these, one memory |
| ** cell is required for each cursor used by the program. Set local |
| ** variable nMem (and later, VdbeFrame.nChildMem) to this value. |
| */ |
| nMem = pProgram->nMem + pProgram->nCsr; |
| assert( nMem>0 ); |
| if( pProgram->nCsr==0 ) nMem++; |
| nByte = ROUND8(sizeof(VdbeFrame)) |
| + nMem * sizeof(Mem) |
| + pProgram->nCsr * sizeof(VdbeCursor*) |
| + (pProgram->nOp + 7)/8; |
| pFrame = sqlite3DbMallocZero(db, nByte); |
| if( !pFrame ){ |
| goto no_mem; |
| } |
| sqlite3VdbeMemRelease(pRt); |
| pRt->flags = MEM_Blob|MEM_Dyn; |
| pRt->z = (char*)pFrame; |
| pRt->n = nByte; |
| pRt->xDel = sqlite3VdbeFrameMemDel; |
| |
| pFrame->v = p; |
| pFrame->nChildMem = nMem; |
| pFrame->nChildCsr = pProgram->nCsr; |
| pFrame->pc = (int)(pOp - aOp); |
| pFrame->aMem = p->aMem; |
| pFrame->nMem = p->nMem; |
| pFrame->apCsr = p->apCsr; |
| pFrame->nCursor = p->nCursor; |
| pFrame->aOp = p->aOp; |
| pFrame->nOp = p->nOp; |
| pFrame->token = pProgram->token; |
| #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
| pFrame->anExec = p->anExec; |
| #endif |
| #ifdef SQLITE_DEBUG |
| pFrame->iFrameMagic = SQLITE_FRAME_MAGIC; |
| #endif |
| |
| pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem]; |
| for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){ |
| pMem->flags = MEM_Undefined; |
| pMem->db = db; |
| } |
| }else{ |
| pFrame = (VdbeFrame*)pRt->z; |
| assert( pRt->xDel==sqlite3VdbeFrameMemDel ); |
| assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem |
| || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) ); |
| assert( pProgram->nCsr==pFrame->nChildCsr ); |
| assert( (int)(pOp - aOp)==pFrame->pc ); |
| } |
| |
| p->nFrame++; |
| pFrame->pParent = p->pFrame; |
| pFrame->lastRowid = db->lastRowid; |
| pFrame->nChange = p->nChange; |
| pFrame->nDbChange = p->db->nChange; |
| assert( pFrame->pAuxData==0 ); |
| pFrame->pAuxData = p->pAuxData; |
| p->pAuxData = 0; |
| p->nChange = 0; |
| p->pFrame = pFrame; |
| p->aMem = aMem = VdbeFrameMem(pFrame); |
| p->nMem = pFrame->nChildMem; |
| p->nCursor = (u16)pFrame->nChildCsr; |
| p->apCsr = (VdbeCursor **)&aMem[p->nMem]; |
| pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr]; |
| memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8); |
| p->aOp = aOp = pProgram->aOp; |
| p->nOp = pProgram->nOp; |
| #ifdef SQLITE_ENABLE_STMT_SCANSTATUS |
| p->anExec = 0; |
| #endif |
| #ifdef SQLITE_DEBUG |
| /* Verify that second and subsequent executions of the same trigger do not |
| ** try to reuse register values from the first use. */ |
| { |
| int i; |
| for(i=0; i<p->nMem; i++){ |
| aMem[i].pScopyFrom = 0; /* Prevent false-positive AboutToChange() errs */ |
| aMem[i].flags |= MEM_Undefined; /* Cause a fault if this reg is reused */ |
| } |
| } |
| #endif |
| pOp = &aOp[-1]; |
| |
| break; |
| } |
| |
| /* Opcode: Param P1 P2 * * * |
| ** |
| ** This opcode is only ever present in sub-programs called via the |
| ** OP_Program instruction. Copy a value currently stored in a memory |
| ** cell of the calling (parent) frame to cell P2 in the current frames |
| ** address space. This is used by trigger programs to access the new.* |
| ** and old.* values. |
| ** |
| ** The address of the cell in the parent frame is determined by adding |
| ** the value of the P1 argument to the value of the P1 argument to the |
| ** calling OP_Program instruction. |
| */ |
| case OP_Param: { /* out2 */ |
| VdbeFrame *pFrame; |
| Mem *pIn; |
| pOut = out2Prerelease(p, pOp); |
| pFrame = p->pFrame; |
| pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1]; |
| sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem); |
| break; |
| } |
| |
| #endif /* #ifndef SQLITE_OMIT_TRIGGER */ |
| |
| #ifndef SQLITE_OMIT_FOREIGN_KEY |
| /* Opcode: FkCounter P1 P2 * * * |
| ** Synopsis: fkctr[P1]+=P2 |
| ** |
| ** Increment a "constraint counter" by P2 (P2 may be negative or positive). |
| ** If P1 is non-zero, the database constraint counter is incremented |
| ** (deferred foreign key constraints). Otherwise, if P1 is zero, the |
| ** statement counter is incremented (immediate foreign key constraints). |
| */ |
| case OP_FkCounter: { |
| if( db->flags & SQLITE_DeferFKs ){ |
| db->nDeferredImmCons += pOp->p2; |
| }else if( pOp->p1 ){ |
| db->nDeferredCons += pOp->p2; |
| }else{ |
| p->nFkConstraint += pOp->p2; |
| } |
| break; |
| } |
| |
| /* Opcode: FkIfZero P1 P2 * * * |
| ** Synopsis: if fkctr[P1]==0 goto P2 |
| ** |
| ** This opcode tests if a foreign key constraint-counter is currently zero. |
| ** If so, jump to instruction P2. Otherwise, fall through to the next |
| ** instruction. |
| ** |
| ** If P1 is non-zero, then the jump is taken if the database constraint-counter |
| ** is zero (the one that counts deferred constraint violations). If P1 is |
| ** zero, the jump is taken if the statement constraint-counter is zero |
| ** (immediate foreign key constraint violations). |
| */ |
| case OP_FkIfZero: { /* jump */ |
| if( pOp->p1 ){ |
| VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2); |
| if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; |
| }else{ |
| VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2); |
| if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2; |
| } |
| break; |
| } |
| #endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */ |
| |
| #ifndef SQLITE_OMIT_AUTOINCREMENT |
| /* Opcode: MemMax P1 P2 * * * |
| ** Synopsis: r[P1]=max(r[P1],r[P2]) |
| ** |
| ** P1 is a register in the root frame of this VM (the root frame is |
| ** different from the current frame if this instruction is being executed |
| ** within a sub-program). Set the value of register P1 to the maximum of |
| ** its current value and the value in register P2. |
| ** |
| ** This instruction throws an error if the memory cell is not initially |
| ** an integer. |
| */ |
| case OP_MemMax: { /* in2 */ |
| VdbeFrame *pFrame; |
| if( p->pFrame ){ |
| for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent); |
| pIn1 = &pFrame->aMem[pOp->p1]; |
| }else{ |
| pIn1 = &aMem[pOp->p1]; |
| } |
| assert( memIsValid(pIn1) ); |
| sqlite3VdbeMemIntegerify(pIn1); |
| pIn2 = &aMem[pOp->p2]; |
| sqlite3VdbeMemIntegerify(pIn2); |
| if( pIn1->u.i<pIn2->u.i){ |
| pIn1->u.i = pIn2->u.i; |
| } |
| break; |
| } |
| #endif /* SQLITE_OMIT_AUTOINCREMENT */ |
| |
| /* Opcode: IfPos P1 P2 P3 * * |
| ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 |
| ** |
| ** Register P1 must contain an integer. |
| ** If the value of register P1 is 1 or greater, subtract P3 from the |
| ** value in P1 and jump to P2. |
| ** |
| ** If the initial value of register P1 is less than 1, then the |
| ** value is unchanged and control passes through to the next instruction. |
| */ |
| case OP_IfPos: { /* jump, in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| assert( pIn1->flags&MEM_Int ); |
| VdbeBranchTaken( pIn1->u.i>0, 2); |
| if( pIn1->u.i>0 ){ |
| pIn1->u.i -= pOp->p3; |
| goto jump_to_p2; |
| } |
| break; |
| } |
| |
| /* Opcode: OffsetLimit P1 P2 P3 * * |
| ** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) |
| ** |
| ** This opcode performs a commonly used computation associated with |
| ** LIMIT and OFFSET process. r[P1] holds the limit counter. r[P3] |
| ** holds the offset counter. The opcode computes the combined value |
| ** of the LIMIT and OFFSET and stores that value in r[P2]. The r[P2] |
| ** value computed is the total number of rows that will need to be |
| ** visited in order to complete the query. |
| ** |
| ** If r[P3] is zero or negative, that means there is no OFFSET |
| ** and r[P2] is set to be the value of the LIMIT, r[P1]. |
| ** |
| ** if r[P1] is zero or negative, that means there is no LIMIT |
| ** and r[P2] is set to -1. |
| ** |
| ** Otherwise, r[P2] is set to the sum of r[P1] and r[P3]. |
| */ |
| case OP_OffsetLimit: { /* in1, out2, in3 */ |
| i64 x; |
| pIn1 = &aMem[pOp->p1]; |
| pIn3 = &aMem[pOp->p3]; |
| pOut = out2Prerelease(p, pOp); |
| assert( pIn1->flags & MEM_Int ); |
| assert( pIn3->flags & MEM_Int ); |
| x = pIn1->u.i; |
| if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){ |
| /* If the LIMIT is less than or equal to zero, loop forever. This |
| ** is documented. But also, if the LIMIT+OFFSET exceeds 2^63 then |
| ** also loop forever. This is undocumented. In fact, one could argue |
| ** that the loop should terminate. But assuming 1 billion iterations |
| ** per second (far exceeding the capabilities of any current hardware) |
| ** it would take nearly 300 years to actually reach the limit. So |
| ** looping forever is a reasonable approximation. */ |
| pOut->u.i = -1; |
| }else{ |
| pOut->u.i = x; |
| } |
| break; |
| } |
| |
| /* Opcode: IfNotZero P1 P2 * * * |
| ** Synopsis: if r[P1]!=0 then r[P1]--, goto P2 |
| ** |
| ** Register P1 must contain an integer. If the content of register P1 is |
| ** initially greater than zero, then decrement the value in register P1. |
| ** If it is non-zero (negative or positive) and then also jump to P2. |
| ** If register P1 is initially zero, leave it unchanged and fall through. |
| */ |
| case OP_IfNotZero: { /* jump, in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| assert( pIn1->flags&MEM_Int ); |
| VdbeBranchTaken(pIn1->u.i<0, 2); |
| if( pIn1->u.i ){ |
| if( pIn1->u.i>0 ) pIn1->u.i--; |
| goto jump_to_p2; |
| } |
| break; |
| } |
| |
| /* Opcode: DecrJumpZero P1 P2 * * * |
| ** Synopsis: if (--r[P1])==0 goto P2 |
| ** |
| ** Register P1 must hold an integer. Decrement the value in P1 |
| ** and jump to P2 if the new value is exactly zero. |
| */ |
| case OP_DecrJumpZero: { /* jump, in1 */ |
| pIn1 = &aMem[pOp->p1]; |
| assert( pIn1->flags&MEM_Int ); |
| if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--; |
| VdbeBranchTaken(pIn1->u.i==0, 2); |
| if( pIn1->u.i==0 ) goto jump_to_p2; |
| break; |
| } |
| |
| |
| /* Opcode: AggStep * P2 P3 P4 P5 |
| ** Synopsis: accum=r[P3] step(r[P2@P5]) |
| ** |
| ** Execute the xStep function for an aggregate. |
| ** The function has P5 arguments. P4 is a pointer to the |
| ** FuncDef structure that specifies the function. Register P3 is the |
| ** accumulator. |
| ** |
| ** The P5 arguments are taken from register P2 and its |
| ** successors. |
| */ |
| /* Opcode: AggInverse * P2 P3 P4 P5 |
| ** Synopsis: accum=r[P3] inverse(r[P2@P5]) |
| ** |
| ** Execute the xInverse function for an aggregate. |
| ** The function has P5 arguments. P4 is a pointer to the |
| ** FuncDef structure that specifies the function. Register P3 is the |
| ** accumulator. |
| ** |
| ** The P5 arguments are taken from register P2 and its |
| ** successors. |
| */ |
| /* Opcode: AggStep1 P1 P2 P3 P4 P5 |
| ** Synopsis: accum=r[P3] step(r[P2@P5]) |
| ** |
| ** Execute the xStep (if P1==0) or xInverse (if P1!=0) function for an |
| ** aggregate. The function has P5 arguments. P4 is a pointer to the |
| ** FuncDef structure that specifies the function. Register P3 is the |
| ** accumulator. |
| ** |
| ** The P5 arguments are taken from register P2 and its |
| ** successors. |
| ** |
| ** This opcode is initially coded as OP_AggStep0. On first evaluation, |
| ** the FuncDef stored in P4 is converted into an sqlite3_context and |
| ** the opcode is changed. In this way, the initialization of the |
| ** sqlite3_context only happens once, instead of on each call to the |
| ** step function. |
| */ |
| case OP_AggInverse: |
| case OP_AggStep: { |
| int n; |
| sqlite3_context *pCtx; |
| |
| assert( pOp->p4type==P4_FUNCDEF ); |
| n = pOp->p5; |
| assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) ); |
| assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n ); |
| pCtx = sqlite3DbMallocRawNN(db, n*sizeof(sqlite3_value*) + |
| (sizeof(pCtx[0]) + sizeof(Mem) - sizeof(sqlite3_value*))); |
| if( pCtx==0 ) goto no_mem; |
| pCtx->pMem = 0; |
| pCtx->pOut = (Mem*)&(pCtx->argv[n]); |
| sqlite3VdbeMemInit(pCtx->pOut, db, MEM_Null); |
| pCtx->pFunc = pOp->p4.pFunc; |
| pCtx->iOp = (int)(pOp - aOp); |
| pCtx->pVdbe = p; |
| pCtx->skipFlag = 0; |
| pCtx->isError = 0; |
| pCtx->argc = n; |
| pOp->p4type = P4_FUNCCTX; |
| pOp->p4.pCtx = pCtx; |
| |
| /* OP_AggInverse must have P1==1 and OP_AggStep must have P1==0 */ |
| assert( pOp->p1==(pOp->opcode==OP_AggInverse) ); |
| |
| pOp->opcode = OP_AggStep1; |
| /* Fall through into OP_AggStep */ |
| } |
| case OP_AggStep1: { |
| int i; |
| sqlite3_context *pCtx; |
| Mem *pMem; |
| |
| assert( pOp->p4type==P4_FUNCCTX ); |
| pCtx = pOp->p4.pCtx; |
| pMem = &aMem[pOp->p3]; |
| |
| #ifdef SQLITE_DEBUG |
| if( pOp->p1 ){ |
| /* This is an OP_AggInverse call. Verify that xStep has always |
| ** been called at least once prior to any xInverse call. */ |
| assert( pMem->uTemp==0x1122e0e3 ); |
| }else{ |
| /* This is an OP_AggStep call. Mark it as such. */ |
| pMem->uTemp = 0x1122e0e3; |
| } |
| #endif |
| |
| /* If this function is inside of a trigger, the register array in aMem[] |
| ** might change from one evaluation to the next. The next block of code |
| ** checks to see if the register array has changed, and if so it |
| ** reinitializes the relavant parts of the sqlite3_context object */ |
| if( pCtx->pMem != pMem ){ |
| pCtx->pMem = pMem; |
| for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; |
| } |
| |
| #ifdef SQLITE_DEBUG |
| for(i=0; i<pCtx->argc; i++){ |
| assert( memIsValid(pCtx->argv[i]) ); |
| REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); |
| } |
| #endif |
| |
| pMem->n++; |
| assert( pCtx->pOut->flags==MEM_Null ); |
| assert( pCtx->isError==0 ); |
| assert( pCtx->skipFlag==0 ); |
| #ifndef SQLITE_OMIT_WINDOWFUNC |
| if( pOp->p1 ){ |
| (pCtx->pFunc->xInverse)(pCtx,pCtx->argc,pCtx->argv); |
| }else |
| #endif |
| (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */ |
| |
| if( pCtx->isError ){ |
| if( pCtx->isError>0 ){ |
| sqlite3VdbeError(p, "%s", sqlite3_value_text(pCtx->pOut)); |
| rc = pCtx->isError; |
| } |
| if( pCtx->skipFlag ){ |
| assert( pOp[-1].opcode==OP_CollSeq ); |
| i = pOp[-1].p1; |
| if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1); |
| pCtx->skipFlag = 0; |
| } |
| sqlite3VdbeMemRelease(pCtx->pOut); |
| pCtx->pOut->flags = MEM_Null; |
| pCtx->isError = 0; |
| if( rc ) goto abort_due_to_error; |
| } |
| assert( pCtx->pOut->flags==MEM_Null ); |
| assert( pCtx->skipFlag==0 ); |
| break; |
| } |
| |
| /* Opcode: AggFinal P1 P2 * P4 * |
| ** Synopsis: accum=r[P1] N=P2 |
| ** |
| ** P1 is the memory location that is the accumulator for an aggregate |
| ** or window function. Execute the finalizer function |
| ** for an aggregate and store the result in P1. |
| ** |
| ** P2 is the number of arguments that the step function takes and |
| ** P4 is a pointer to the FuncDef for this function. The P2 |
| ** argument is not used by this opcode. It is only there to disambiguate |
| ** functions that can take varying numbers of arguments. The |
| ** P4 argument is only needed for the case where |
| ** the step function was not previously called. |
| */ |
| /* Opcode: AggValue * P2 P3 P4 * |
| ** Synopsis: r[P3]=value N=P2 |
| ** |
| ** Invoke the xValue() function and store the result in register P3. |
| ** |
| ** P2 is the number of arguments that the step function takes and |
| ** P4 is a pointer to the FuncDef for this function. The P2 |
| ** argument is not used by this opcode. It is only there to disambiguate |
| ** functions that can take varying numbers of arguments. The |
| ** P4 argument is only needed for the case where |
| ** the step function was not previously called. |
| */ |
| case OP_AggValue: |
| case OP_AggFinal: { |
| Mem *pMem; |
| assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) ); |
| assert( pOp->p3==0 || pOp->opcode==OP_AggValue ); |
| pMem = &aMem[pOp->p1]; |
| assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 ); |
| #ifndef SQLITE_OMIT_WINDOWFUNC |
| if( pOp->p3 ){ |
| rc = sqlite3VdbeMemAggValue(pMem, &aMem[pOp->p3], pOp->p4.pFunc); |
| pMem = &aMem[pOp->p3]; |
| }else |
| #endif |
| { |
| rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc); |
| } |
| |
| if( rc ){ |
| sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem)); |
| goto abort_due_to_error; |
| } |
| sqlite3VdbeChangeEncoding(pMem, encoding); |
| UPDATE_MAX_BLOBSIZE(pMem); |
| if( sqlite3VdbeMemTooBig(pMem) ){ |
| goto too_big; |
| } |
| break; |
| } |
| |
| #ifndef SQLITE_OMIT_WAL |
| /* Opcode: Checkpoint P1 P2 P3 * * |
| ** |
| ** Checkpoint database P1. This is a no-op if P1 is not currently in |
| ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL, |
| ** RESTART, or TRUNCATE. Write 1 or 0 into mem[P3] if the checkpoint returns |
| ** SQLITE_BUSY or not, respectively. Write the number of pages in the |
| ** WAL after the checkpoint into mem[P3+1] and the number of pages |
| ** in the WAL that have been checkpointed after the checkpoint |
| ** completes into mem[P3+2]. However on an error, mem[P3+1] and |
| ** mem[P3+2] are initialized to -1. |
| */ |
| case OP_Checkpoint: { |
| int i; /* Loop counter */ |
| int aRes[3]; /* Results */ |
| Mem *pMem; /* Write results here */ |
| |
| assert( p->readOnly==0 ); |
| aRes[0] = 0; |
| aRes[1] = aRes[2] = -1; |
| assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE |
| || pOp->p2==SQLITE_CHECKPOINT_FULL |
| || pOp->p2==SQLITE_CHECKPOINT_RESTART |
| || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE |
| ); |
| rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]); |
| if( rc ){ |
| if( rc!=SQLITE_BUSY ) goto abort_due_to_error; |
| rc = SQLITE_OK; |
| aRes[0] = 1; |
| } |
| for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){ |
| sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]); |
| } |
| break; |
| }; |
| #endif |
| |
| #ifndef SQLITE_OMIT_PRAGMA |
| /* Opcode: JournalMode P1 P2 P3 * * |
| ** |
| ** Change the journal mode of database P1 to P3. P3 must be one of the |
| ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback |
| ** modes (delete, truncate, persist, off and memory), this is a simple |
| ** operation. No IO is required. |
| ** |
| ** If changing into or out of WAL mode the procedure is more complicated. |
| ** |
| ** Write a string containing the final journal-mode to register P2. |
| */ |
| case OP_JournalMode: { /* out2 */ |
| Btree *pBt; /* Btree to change journal mode of */ |
| Pager *pPager; /* Pager associated with pBt */ |
| int eNew; /* New journal mode */ |
| int eOld; /* The old journal mode */ |
| #ifndef SQLITE_OMIT_WAL |
| const char *zFilename; /* Name of database file for pPager */ |
| #endif |
| |
| pOut = out2Prerelease(p, pOp); |
| eNew = pOp->p3; |
| assert( eNew==PAGER_JOURNALMODE_DELETE |
| || eNew==PAGER_JOURNALMODE_TRUNCATE |
| || eNew==PAGER_JOURNALMODE_PERSIST |
| || eNew==PAGER_JOURNALMODE_OFF |
| || eNew==PAGER_JOURNALMODE_MEMORY |
| || eNew==PAGER_JOURNALMODE_WAL |
| || eNew==PAGER_JOURNALMODE_QUERY |
| ); |
| assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
| assert( p->readOnly==0 ); |
| |
| pBt = db->aDb[pOp->p1].pBt; |
| pPager = sqlite3BtreePager(pBt); |
| eOld = sqlite3PagerGetJournalMode(pPager); |
| if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld; |
| if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld; |
| |
| #ifndef SQLITE_OMIT_WAL |
| zFilename = sqlite3PagerFilename(pPager, 1); |
| |
| /* Do not allow a transition to journal_mode=WAL for a database |
| ** in temporary storage or if the VFS does not support shared memory |
| */ |
| if( eNew==PAGER_JOURNALMODE_WAL |
| && (sqlite3Strlen30(zFilename)==0 /* Temp file */ |
| || !sqlite3PagerWalSupported(pPager)) /* No shared-memory support */ |
| ){ |
| eNew = eOld; |
| } |
| |
| if( (eNew!=eOld) |
| && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL) |
| ){ |
| if( !db->autoCommit || db->nVdbeRead>1 ){ |
| rc = SQLITE_ERROR; |
| sqlite3VdbeError(p, |
| "cannot change %s wal mode from within a transaction", |
| (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of") |
| ); |
| goto abort_due_to_error; |
| }else{ |
| |
| if( eOld==PAGER_JOURNALMODE_WAL ){ |
| /* If leaving WAL mode, close the log file. If successful, the call |
| ** to PagerCloseWal() checkpoints and deletes the write-ahead-log |
| ** file. An EXCLUSIVE lock may still be held on the database file |
| ** after a successful return. |
| */ |
| rc = sqlite3PagerCloseWal(pPager, db); |
| if( rc==SQLITE_OK ){ |
| sqlite3PagerSetJournalMode(pPager, eNew); |
| } |
| }else if( eOld==PAGER_JOURNALMODE_MEMORY ){ |
| /* Cannot transition directly from MEMORY to WAL. Use mode OFF |
| ** as an intermediate */ |
| sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF); |
| } |
| |
| /* Open a transaction on the database file. Regardless of the journal |
| ** mode, this transaction always uses a rollback journal. |
| */ |
| assert( sqlite3BtreeIsInTrans(pBt)==0 ); |
| if( rc==SQLITE_OK ){ |
| rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1)); |
| } |
| } |
| } |
| #endif /* ifndef SQLITE_OMIT_WAL */ |
| |
| if( rc ) eNew = eOld; |
| eNew = sqlite3PagerSetJournalMode(pPager, eNew); |
| |
| pOut->flags = MEM_Str|MEM_Static|MEM_Term; |
| pOut->z = (char *)sqlite3JournalModename(eNew); |
| pOut->n = sqlite3Strlen30(pOut->z); |
| pOut->enc = SQLITE_UTF8; |
| sqlite3VdbeChangeEncoding(pOut, encoding); |
| if( rc ) goto abort_due_to_error; |
| break; |
| }; |
| #endif /* SQLITE_OMIT_PRAGMA */ |
| |
| #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH) |
| /* Opcode: Vacuum P1 P2 * * * |
| ** |
| ** Vacuum the entire database P1. P1 is 0 for "main", and 2 or more |
| ** for an attached database. The "temp" database may not be vacuumed. |
| ** |
| ** If P2 is not zero, then it is a register holding a string which is |
| ** the file into which the result of vacuum should be written. When |
| ** P2 is zero, the vacuum overwrites the original database. |
| */ |
| case OP_Vacuum: { |
| assert( p->readOnly==0 ); |
| rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1, |
| pOp->p2 ? &aMem[pOp->p2] : 0); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif |
| |
| #if !defined(SQLITE_OMIT_AUTOVACUUM) |
| /* Opcode: IncrVacuum P1 P2 * * * |
| ** |
| ** Perform a single step of the incremental vacuum procedure on |
| ** the P1 database. If the vacuum has finished, jump to instruction |
| ** P2. Otherwise, fall through to the next instruction. |
| */ |
| case OP_IncrVacuum: { /* jump */ |
| Btree *pBt; |
| |
| assert( pOp->p1>=0 && pOp->p1<db->nDb ); |
| assert( DbMaskTest(p->btreeMask, pOp->p1) ); |
| assert( p->readOnly==0 ); |
| pBt = db->aDb[pOp->p1].pBt; |
| rc = sqlite3BtreeIncrVacuum(pBt); |
| VdbeBranchTaken(rc==SQLITE_DONE,2); |
| if( rc ){ |
| if( rc!=SQLITE_DONE ) goto abort_due_to_error; |
| rc = SQLITE_OK; |
| goto jump_to_p2; |
| } |
| break; |
| } |
| #endif |
| |
| /* Opcode: Expire P1 P2 * * * |
| ** |
| ** Cause precompiled statements to expire. When an expired statement |
| ** is executed using sqlite3_step() it will either automatically |
| ** reprepare itself (if it was originally created using sqlite3_prepare_v2()) |
| ** or it will fail with SQLITE_SCHEMA. |
| ** |
| ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero, |
| ** then only the currently executing statement is expired. |
| ** |
| ** If P2 is 0, then SQL statements are expired immediately. If P2 is 1, |
| ** then running SQL statements are allowed to continue to run to completion. |
| ** The P2==1 case occurs when a CREATE INDEX or similar schema change happens |
| ** that might help the statement run faster but which does not affect the |
| ** correctness of operation. |
| */ |
| case OP_Expire: { |
| assert( pOp->p2==0 || pOp->p2==1 ); |
| if( !pOp->p1 ){ |
| sqlite3ExpirePreparedStatements(db, pOp->p2); |
| }else{ |
| p->expired = pOp->p2+1; |
| } |
| break; |
| } |
| |
| #ifndef SQLITE_OMIT_SHARED_CACHE |
| /* Opcode: TableLock P1 P2 P3 P4 * |
| ** Synopsis: iDb=P1 root=P2 write=P3 |
| ** |
| ** Obtain a lock on a particular table. This instruction is only used when |
| ** the shared-cache feature is enabled. |
| ** |
| ** P1 is the index of the database in sqlite3.aDb[] of the database |
| ** on which the lock is acquired. A readlock is obtained if P3==0 or |
| ** a write lock if P3==1. |
| ** |
| ** P2 contains the root-page of the table to lock. |
| ** |
| ** P4 contains a pointer to the name of the table being locked. This is only |
| ** used to generate an error message if the lock cannot be obtained. |
| */ |
| case OP_TableLock: { |
| u8 isWriteLock = (u8)pOp->p3; |
| if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){ |
| int p1 = pOp->p1; |
| assert( p1>=0 && p1<db->nDb ); |
| assert( DbMaskTest(p->btreeMask, p1) ); |
| assert( isWriteLock==0 || isWriteLock==1 ); |
| rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock); |
| if( rc ){ |
| if( (rc&0xFF)==SQLITE_LOCKED ){ |
| const char *z = pOp->p4.z; |
| sqlite3VdbeError(p, "database table is locked: %s", z); |
| } |
| goto abort_due_to_error; |
| } |
| } |
| break; |
| } |
| #endif /* SQLITE_OMIT_SHARED_CACHE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VBegin * * * P4 * |
| ** |
| ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the |
| ** xBegin method for that table. |
| ** |
| ** Also, whether or not P4 is set, check that this is not being called from |
| ** within a callback to a virtual table xSync() method. If it is, the error |
| ** code will be set to SQLITE_LOCKED. |
| */ |
| case OP_VBegin: { |
| VTable *pVTab; |
| pVTab = pOp->p4.pVtab; |
| rc = sqlite3VtabBegin(db, pVTab); |
| if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VCreate P1 P2 * * * |
| ** |
| ** P2 is a register that holds the name of a virtual table in database |
| ** P1. Call the xCreate method for that table. |
| */ |
| case OP_VCreate: { |
| Mem sMem; /* For storing the record being decoded */ |
| const char *zTab; /* Name of the virtual table */ |
| |
| memset(&sMem, 0, sizeof(sMem)); |
| sMem.db = db; |
| /* Because P2 is always a static string, it is impossible for the |
| ** sqlite3VdbeMemCopy() to fail */ |
| assert( (aMem[pOp->p2].flags & MEM_Str)!=0 ); |
| assert( (aMem[pOp->p2].flags & MEM_Static)!=0 ); |
| rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]); |
| assert( rc==SQLITE_OK ); |
| zTab = (const char*)sqlite3_value_text(&sMem); |
| assert( zTab || db->mallocFailed ); |
| if( zTab ){ |
| rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg); |
| } |
| sqlite3VdbeMemRelease(&sMem); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VDestroy P1 * * P4 * |
| ** |
| ** P4 is the name of a virtual table in database P1. Call the xDestroy method |
| ** of that table. |
| */ |
| case OP_VDestroy: { |
| db->nVDestroy++; |
| rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z); |
| db->nVDestroy--; |
| assert( p->errorAction==OE_Abort && p->usesStmtJournal ); |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VOpen P1 * * P4 * |
| ** |
| ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. |
| ** P1 is a cursor number. This opcode opens a cursor to the virtual |
| ** table and stores that cursor in P1. |
| */ |
| case OP_VOpen: { |
| VdbeCursor *pCur; |
| sqlite3_vtab_cursor *pVCur; |
| sqlite3_vtab *pVtab; |
| const sqlite3_module *pModule; |
| |
| assert( p->bIsReader ); |
| pCur = 0; |
| pVCur = 0; |
| pVtab = pOp->p4.pVtab->pVtab; |
| if( pVtab==0 || NEVER(pVtab->pModule==0) ){ |
| rc = SQLITE_LOCKED; |
| goto abort_due_to_error; |
| } |
| pModule = pVtab->pModule; |
| rc = pModule->xOpen(pVtab, &pVCur); |
| sqlite3VtabImportErrmsg(p, pVtab); |
| if( rc ) goto abort_due_to_error; |
| |
| /* Initialize sqlite3_vtab_cursor base class */ |
| pVCur->pVtab = pVtab; |
| |
| /* Initialize vdbe cursor object */ |
| pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB); |
| if( pCur ){ |
| pCur->uc.pVCur = pVCur; |
| pVtab->nRef++; |
| }else{ |
| assert( db->mallocFailed ); |
| pModule->xClose(pVCur); |
| goto no_mem; |
| } |
| break; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VFilter P1 P2 P3 P4 * |
| ** Synopsis: iplan=r[P3] zplan='P4' |
| ** |
| ** P1 is a cursor opened using VOpen. P2 is an address to jump to if |
| ** the filtered result set is empty. |
| ** |
| ** P4 is either NULL or a string that was generated by the xBestIndex |
| ** method of the module. The interpretation of the P4 string is left |
| ** to the module implementation. |
| ** |
| ** This opcode invokes the xFilter method on the virtual table specified |
| ** by P1. The integer query plan parameter to xFilter is stored in register |
| ** P3. Register P3+1 stores the argc parameter to be passed to the |
| ** xFilter method. Registers P3+2..P3+1+argc are the argc |
| ** additional parameters which are passed to |
| ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter. |
| ** |
| ** A jump is made to P2 if the result set after filtering would be empty. |
| */ |
| case OP_VFilter: { /* jump */ |
| int nArg; |
| int iQuery; |
| const sqlite3_module *pModule; |
| Mem *pQuery; |
| Mem *pArgc; |
| sqlite3_vtab_cursor *pVCur; |
| sqlite3_vtab *pVtab; |
| VdbeCursor *pCur; |
| int res; |
| int i; |
| Mem **apArg; |
| |
| pQuery = &aMem[pOp->p3]; |
| pArgc = &pQuery[1]; |
| pCur = p->apCsr[pOp->p1]; |
| assert( memIsValid(pQuery) ); |
| REGISTER_TRACE(pOp->p3, pQuery); |
| assert( pCur->eCurType==CURTYPE_VTAB ); |
| pVCur = pCur->uc.pVCur; |
| pVtab = pVCur->pVtab; |
| pModule = pVtab->pModule; |
| |
| /* Grab the index number and argc parameters */ |
| assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int ); |
| nArg = (int)pArgc->u.i; |
| iQuery = (int)pQuery->u.i; |
| |
| /* Invoke the xFilter method */ |
| res = 0; |
| apArg = p->apArg; |
| for(i = 0; i<nArg; i++){ |
| apArg[i] = &pArgc[i+1]; |
| } |
| rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg); |
| sqlite3VtabImportErrmsg(p, pVtab); |
| if( rc ) goto abort_due_to_error; |
| res = pModule->xEof(pVCur); |
| pCur->nullRow = 0; |
| VdbeBranchTaken(res!=0,2); |
| if( res ) goto jump_to_p2; |
| break; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VColumn P1 P2 P3 * P5 |
| ** Synopsis: r[P3]=vcolumn(P2) |
| ** |
| ** Store in register P3 the value of the P2-th column of |
| ** the current row of the virtual-table of cursor P1. |
| ** |
| ** If the VColumn opcode is being used to fetch the value of |
| ** an unchanging column during an UPDATE operation, then the P5 |
| ** value is OPFLAG_NOCHNG. This will cause the sqlite3_vtab_nochange() |
| ** function to return true inside the xColumn method of the virtual |
| ** table implementation. The P5 column might also contain other |
| ** bits (OPFLAG_LENGTHARG or OPFLAG_TYPEOFARG) but those bits are |
| ** unused by OP_VColumn. |
| */ |
| case OP_VColumn: { |
| sqlite3_vtab *pVtab; |
| const sqlite3_module *pModule; |
| Mem *pDest; |
| sqlite3_context sContext; |
| |
| VdbeCursor *pCur = p->apCsr[pOp->p1]; |
| assert( pCur->eCurType==CURTYPE_VTAB ); |
| assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| pDest = &aMem[pOp->p3]; |
| memAboutToChange(p, pDest); |
| if( pCur->nullRow ){ |
| sqlite3VdbeMemSetNull(pDest); |
| break; |
| } |
| pVtab = pCur->uc.pVCur->pVtab; |
| pModule = pVtab->pModule; |
| assert( pModule->xColumn ); |
| memset(&sContext, 0, sizeof(sContext)); |
| sContext.pOut = pDest; |
| testcase( (pOp->p5 & OPFLAG_NOCHNG)==0 && pOp->p5!=0 ); |
| if( pOp->p5 & OPFLAG_NOCHNG ){ |
| sqlite3VdbeMemSetNull(pDest); |
| pDest->flags = MEM_Null|MEM_Zero; |
| pDest->u.nZero = 0; |
| }else{ |
| MemSetTypeFlag(pDest, MEM_Null); |
| } |
| rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2); |
| sqlite3VtabImportErrmsg(p, pVtab); |
| if( sContext.isError>0 ){ |
| sqlite3VdbeError(p, "%s", sqlite3_value_text(pDest)); |
| rc = sContext.isError; |
| } |
| sqlite3VdbeChangeEncoding(pDest, encoding); |
| REGISTER_TRACE(pOp->p3, pDest); |
| UPDATE_MAX_BLOBSIZE(pDest); |
| |
| if( sqlite3VdbeMemTooBig(pDest) ){ |
| goto too_big; |
| } |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VNext P1 P2 * * * |
| ** |
| ** Advance virtual table P1 to the next row in its result set and |
| ** jump to instruction P2. Or, if the virtual table has reached |
| ** the end of its result set, then fall through to the next instruction. |
| */ |
| case OP_VNext: { /* jump */ |
| sqlite3_vtab *pVtab; |
| const sqlite3_module *pModule; |
| int res; |
| VdbeCursor *pCur; |
| |
| res = 0; |
| pCur = p->apCsr[pOp->p1]; |
| assert( pCur->eCurType==CURTYPE_VTAB ); |
| if( pCur->nullRow ){ |
| break; |
| } |
| pVtab = pCur->uc.pVCur->pVtab; |
| pModule = pVtab->pModule; |
| assert( pModule->xNext ); |
| |
| /* Invoke the xNext() method of the module. There is no way for the |
| ** underlying implementation to return an error if one occurs during |
| ** xNext(). Instead, if an error occurs, true is returned (indicating that |
| ** data is available) and the error code returned when xColumn or |
| ** some other method is next invoked on the save virtual table cursor. |
| */ |
| rc = pModule->xNext(pCur->uc.pVCur); |
| sqlite3VtabImportErrmsg(p, pVtab); |
| if( rc ) goto abort_due_to_error; |
| res = pModule->xEof(pCur->uc.pVCur); |
| VdbeBranchTaken(!res,2); |
| if( !res ){ |
| /* If there is data, jump to P2 */ |
| goto jump_to_p2_and_check_for_interrupt; |
| } |
| goto check_for_interrupt; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VRename P1 * * P4 * |
| ** |
| ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. |
| ** This opcode invokes the corresponding xRename method. The value |
| ** in register P1 is passed as the zName argument to the xRename method. |
| */ |
| case OP_VRename: { |
| sqlite3_vtab *pVtab; |
| Mem *pName; |
| int isLegacy; |
| |
| isLegacy = (db->flags & SQLITE_LegacyAlter); |
| db->flags |= SQLITE_LegacyAlter; |
| pVtab = pOp->p4.pVtab->pVtab; |
| pName = &aMem[pOp->p1]; |
| assert( pVtab->pModule->xRename ); |
| assert( memIsValid(pName) ); |
| assert( p->readOnly==0 ); |
| REGISTER_TRACE(pOp->p1, pName); |
| assert( pName->flags & MEM_Str ); |
| testcase( pName->enc==SQLITE_UTF8 ); |
| testcase( pName->enc==SQLITE_UTF16BE ); |
| testcase( pName->enc==SQLITE_UTF16LE ); |
| rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8); |
| if( rc ) goto abort_due_to_error; |
| rc = pVtab->pModule->xRename(pVtab, pName->z); |
| if( isLegacy==0 ) db->flags &= ~(u64)SQLITE_LegacyAlter; |
| sqlite3VtabImportErrmsg(p, pVtab); |
| p->expired = 0; |
| if( rc ) goto abort_due_to_error; |
| break; |
| } |
| #endif |
| |
| #ifndef SQLITE_OMIT_VIRTUALTABLE |
| /* Opcode: VUpdate P1 P2 P3 P4 P5 |
| ** Synopsis: data=r[P3@P2] |
| ** |
| ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure. |
| ** This opcode invokes the corresponding xUpdate method. P2 values |
| ** are contiguous memory cells starting at P3 to pass to the xUpdate |
| ** invocation. The value in register (P3+P2-1) corresponds to the |
| ** p2th element of the argv array passed to xUpdate. |
| ** |
| ** The xUpdate method will do a DELETE or an INSERT or both. |
| ** The argv[0] element (which corresponds to memory cell P3) |
| ** is the rowid of a row to delete. If argv[0] is NULL then no |
| ** deletion occurs. The argv[1] element is the rowid of the new |
| ** row. This can be NULL to have the virtual table select the new |
| ** rowid for itself. The subsequent elements in the array are |
| ** the values of columns in the new row. |
| ** |
| ** If P2==1 then no insert is performed. argv[0] is the rowid of |
| ** a row to delete. |
| ** |
| ** P1 is a boolean flag. If it is set to true and the xUpdate call |
| ** is successful, then the value returned by sqlite3_last_insert_rowid() |
| ** is set to the value of the rowid for the row just inserted. |
| ** |
| ** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to |
| ** apply in the case of a constraint failure on an insert or update. |
| */ |
| case OP_VUpdate: { |
| sqlite3_vtab *pVtab; |
| const sqlite3_module *pModule; |
| int nArg; |
| int i; |
| sqlite_int64 rowid; |
| Mem **apArg; |
| Mem *pX; |
| |
| assert( pOp->p2==1 || pOp->p5==OE_Fail || pOp->p5==OE_Rollback |
| || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace |
| ); |
| assert( p->readOnly==0 ); |
| if( db->mallocFailed ) goto no_mem; |
| sqlite3VdbeIncrWriteCounter(p, 0); |
| pVtab = pOp->p4.pVtab->pVtab; |
| if( pVtab==0 || NEVER(pVtab->pModule==0) ){ |
| rc = SQLITE_LOCKED; |
| goto abort_due_to_error; |
| } |
| pModule = pVtab->pModule; |
| nArg = pOp->p2; |
| assert( pOp->p4type==P4_VTAB ); |
| if( ALWAYS(pModule->xUpdate) ){ |
| u8 vtabOnConflict = db->vtabOnConflict; |
| apArg = p->apArg; |
| pX = &aMem[pOp->p3]; |
| for(i=0; i<nArg; i++){ |
| assert( memIsValid(pX) ); |
| memAboutToChange(p, pX); |
| apArg[i] = pX; |
| pX++; |
| } |
| db->vtabOnConflict = pOp->p5; |
| rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid); |
| db->vtabOnConflict = vtabOnConflict; |
| sqlite3VtabImportErrmsg(p, pVtab); |
| if( rc==SQLITE_OK && pOp->p1 ){ |
| assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) ); |
| db->lastRowid = rowid; |
| } |
| if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){ |
| if( pOp->p5==OE_Ignore ){ |
| rc = SQLITE_OK; |
| }else{ |
| p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5); |
| } |
| }else{ |
| p->nChange++; |
| } |
| if( rc ) goto abort_due_to_error; |
| } |
| break; |
| } |
| #endif /* SQLITE_OMIT_VIRTUALTABLE */ |
| |
| #ifndef SQLITE_OMIT_PAGER_PRAGMAS |
| /* Opcode: Pagecount P1 P2 * * * |
| ** |
| ** Write the current number of pages in database P1 to memory cell P2. |
| */ |
| case OP_Pagecount: { /* out2 */ |
| pOut = out2Prerelease(p, pOp); |
| pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt); |
| break; |
| } |
| #endif |
| |
| |
| #ifndef SQLITE_OMIT_PAGER_PRAGMAS |
| /* Opcode: MaxPgcnt P1 P2 P3 * * |
| ** |
| ** Try to set the maximum page count for database P1 to the value in P3. |
| ** Do not let the maximum page count fall below the current page count and |
| ** do not change the maximum page count value if P3==0. |
| ** |
| ** Store the maximum page count after the change in register P2. |
| */ |
| case OP_MaxPgcnt: { /* out2 */ |
| unsigned int newMax; |
| Btree *pBt; |
| |
| pOut = out2Prerelease(p, pOp); |
| pBt = db->aDb[pOp->p1].pBt; |
| newMax = 0; |
| if( pOp->p3 ){ |
| newMax = sqlite3BtreeLastPage(pBt); |
| if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3; |
| } |
| pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax); |
| break; |
| } |
| #endif |
| |
| /* Opcode: Function0 P1 P2 P3 P4 P5 |
| ** Synopsis: r[P3]=func(r[P2@P5]) |
| ** |
| ** Invoke a user function (P4 is a pointer to a FuncDef object that |
| ** defines the function) with P5 arguments taken from register P2 and |
| ** successors. The result of the function is stored in register P3. |
| ** Register P3 must not be one of the function inputs. |
| ** |
| ** P1 is a 32-bit bitmask indicating whether or not each argument to the |
| ** function was determined to be constant at compile time. If the first |
| ** argument was constant then bit 0 of P1 is set. This is used to determine |
| ** whether meta data associated with a user function argument using the |
| ** sqlite3_set_auxdata() API may be safely retained until the next |
| ** invocation of this opcode. |
| ** |
| ** See also: Function, AggStep, AggFinal |
| */ |
| /* Opcode: Function P1 P2 P3 P4 P5 |
| ** Synopsis: r[P3]=func(r[P2@P5]) |
| ** |
| ** Invoke a user function (P4 is a pointer to an sqlite3_context object that |
| ** contains a pointer to the function to be run) with P5 arguments taken |
| ** from register P2 and successors. The result of the function is stored |
| ** in register P3. Register P3 must not be one of the function inputs. |
| ** |
| ** P1 is a 32-bit bitmask indicating whether or not each argument to the |
| ** function was determined to be constant at compile time. If the first |
| ** argument was constant then bit 0 of P1 is set. This is used to determine |
| ** whether meta data associated with a user function argument using the |
| ** sqlite3_set_auxdata() API may be safely retained until the next |
| ** invocation of this opcode. |
| ** |
| ** SQL functions are initially coded as OP_Function0 with P4 pointing |
| ** to a FuncDef object. But on first evaluation, the P4 operand is |
| ** automatically converted into an sqlite3_context object and the operation |
| ** changed to this OP_Function opcode. In this way, the initialization of |
| ** the sqlite3_context object occurs only once, rather than once for each |
| ** evaluation of the function. |
| ** |
| ** See also: Function0, AggStep, AggFinal |
| */ |
| case OP_PureFunc0: /* group */ |
| case OP_Function0: { /* group */ |
| int n; |
| sqlite3_context *pCtx; |
| |
| assert( pOp->p4type==P4_FUNCDEF ); |
| n = pOp->p5; |
| assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) ); |
| assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) ); |
| assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n ); |
| pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*)); |
| if( pCtx==0 ) goto no_mem; |
| pCtx->pOut = 0; |
| pCtx->pFunc = pOp->p4.pFunc; |
| pCtx->iOp = (int)(pOp - aOp); |
| pCtx->pVdbe = p; |
| pCtx->isError = 0; |
| pCtx->argc = n; |
| pOp->p4type = P4_FUNCCTX; |
| pOp->p4.pCtx = pCtx; |
| assert( OP_PureFunc == OP_PureFunc0+2 ); |
| assert( OP_Function == OP_Function0+2 ); |
| pOp->opcode += 2; |
| /* Fall through into OP_Function */ |
| } |
| case OP_PureFunc: /* group */ |
| case OP_Function: { /* group */ |
| int i; |
| sqlite3_context *pCtx; |
| |
| assert( pOp->p4type==P4_FUNCCTX ); |
| pCtx = pOp->p4.pCtx; |
| |
| /* If this function is inside of a trigger, the register array in aMem[] |
| ** might change from one evaluation to the next. The next block of code |
| ** checks to see if the register array has changed, and if so it |
| ** reinitializes the relavant parts of the sqlite3_context object */ |
| pOut = &aMem[pOp->p3]; |
| if( pCtx->pOut != pOut ){ |
| pCtx->pOut = pOut; |
| for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i]; |
| } |
| |
| memAboutToChange(p, pOut); |
| #ifdef SQLITE_DEBUG |
| for(i=0; i<pCtx->argc; i++){ |
| assert( memIsValid(pCtx->argv[i]) ); |
| REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]); |
| } |
| #endif |
| MemSetTypeFlag(pOut, MEM_Null); |
| assert( pCtx->isError==0 ); |
| (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */ |
| |
| /* If the function returned an error, throw an exception */ |
| if( pCtx->isError ){ |
| if( pCtx->isError>0 ){ |
| sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut)); |
| rc = pCtx->isError; |
| } |
| sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1); |
| pCtx->isError = 0; |
| if( rc ) goto abort_due_to_error; |
| } |
| |
| /* Copy the result of the function into register P3 */ |
| if( pOut->flags & (MEM_Str|MEM_Blob) ){ |
| sqlite3VdbeChangeEncoding(pOut, encoding); |
| if( sqlite3VdbeMemTooBig(pOut) ) goto too_big; |
| } |
| |
| REGISTER_TRACE(pOp->p3, pOut); |
| UPDATE_MAX_BLOBSIZE(pOut); |
| break; |
| } |
| |
| /* Opcode: Trace P1 P2 * P4 * |
| ** |
| ** Write P4 on the statement trace output if statement tracing is |
| ** enabled. |
| ** |
| ** Operand P1 must be 0x7fffffff and P2 must positive. |
| */ |
| /* Opcode: Init P1 P2 P3 P4 * |
| ** Synopsis: Start at P2 |
| ** |
| ** Programs contain a single instance of this opcode as the very first |
| ** opcode. |
| ** |
| ** If tracing is enabled (by the sqlite3_trace()) interface, then |
| ** the UTF-8 string contained in P4 is emitted on the trace callback. |
| ** Or if P4 is blank, use the string returned by sqlite3_sql(). |
| ** |
| ** If P2 is not zero, jump to instruction P2. |
| ** |
| ** Increment the value of P1 so that OP_Once opcodes will jump the |
| ** first time they are evaluated for this run. |
| ** |
| ** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT |
| ** error is encountered. |
| */ |
| case OP_Trace: |
| case OP_Init: { /* jump */ |
| int i; |
| #ifndef SQLITE_OMIT_TRACE |
| char *zTrace; |
| #endif |
| |
| /* If the P4 argument is not NULL, then it must be an SQL comment string. |
| ** The "--" string is broken up to prevent false-positives with srcck1.c. |
| ** |
| ** This assert() provides evidence for: |
| ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that |
| ** would have been returned by the legacy sqlite3_trace() interface by |
| ** using the X argument when X begins with "--" and invoking |
| ** sqlite3_expanded_sql(P) otherwise. |
| */ |
| assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 ); |
| |
| /* OP_Init is always instruction 0 */ |
| assert( pOp==p->aOp || pOp->opcode==OP_Trace ); |
| |
| #ifndef SQLITE_OMIT_TRACE |
| if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0 |
| && !p->doingRerun |
| && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 |
| ){ |
| #ifndef SQLITE_OMIT_DEPRECATED |
| if( db->mTrace & SQLITE_TRACE_LEGACY ){ |
| void (*x)(void*,const char*) = (void(*)(void*,const char*))db->xTrace; |
| char *z = sqlite3VdbeExpandSql(p, zTrace); |
| x(db->pTraceArg, z); |
| sqlite3_free(z); |
| }else |
| #endif |
| if( db->nVdbeExec>1 ){ |
| char *z = sqlite3MPrintf(db, "-- %s", zTrace); |
| (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, z); |
| sqlite3DbFree(db, z); |
| }else{ |
| (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace); |
| } |
| } |
| #ifdef SQLITE_USE_FCNTL_TRACE |
| zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql); |
| if( zTrace ){ |
| int j; |
| for(j=0; j<db->nDb; j++){ |
| if( DbMaskTest(p->btreeMask, j)==0 ) continue; |
| sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace); |
| } |
| } |
| #endif /* SQLITE_USE_FCNTL_TRACE */ |
| #ifdef SQLITE_DEBUG |
| if( (db->flags & SQLITE_SqlTrace)!=0 |
| && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0 |
| ){ |
| sqlite3DebugPrintf("SQL-trace: %s\n", zTrace); |
| } |
| #endif /* SQLITE_DEBUG */ |
| #endif /* SQLITE_OMIT_TRACE */ |
| assert( pOp->p2>0 ); |
| if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){ |
| if( pOp->opcode==OP_Trace ) break; |
| for(i=1; i<p->nOp; i++){ |
| if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0; |
| } |
| pOp->p1 = 0; |
| } |
| pOp->p1++; |
| p->aCounter[SQLITE_STMTSTATUS_RUN]++; |
| goto jump_to_p2; |
| } |
| |
| #ifdef SQLITE_ENABLE_CURSOR_HINTS |
| /* Opcode: CursorHint P1 * * P4 * |
| ** |
| ** Provide a hint to cursor P1 that it only needs to return rows that |
| ** satisfy the Expr in P4. TK_REGISTER terms in the P4 expression refer |
| ** to values currently held in registers. TK_COLUMN terms in the P4 |
| ** expression refer to columns in the b-tree to which cursor P1 is pointing. |
| */ |
| case OP_CursorHint: { |
| VdbeCursor *pC; |
| |
| assert( pOp->p1>=0 && pOp->p1<p->nCursor ); |
| assert( pOp->p4type==P4_EXPR ); |
| pC = p->apCsr[pOp->p1]; |
| if( pC ){ |
| assert( pC->eCurType==CURTYPE_BTREE ); |
| sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE, |
| pOp->p4.pExpr, aMem); |
| } |
| break; |
| } |
| #endif /* SQLITE_ENABLE_CURSOR_HINTS */ |
| |
| #ifdef SQLITE_DEBUG |
| /* Opcode: Abortable * * * * * |
| ** |
| ** Verify that an Abort can happen. Assert if an Abort at this point |
| ** might cause database corruption. This opcode only appears in debugging |
| ** builds. |
| ** |
| ** An Abort is safe if either there have been no writes, or if there is |
| ** an active statement journal. |
| */ |
| case OP_Abortable: { |
| sqlite3VdbeAssertAbortable(p); |
| break; |
| } |
| #endif |
| |
| /* Opcode: Noop * * * * * |
| ** |
| ** Do nothing. This instruction is often useful as a jump |
| ** destination. |
| */ |
| /* |
| ** The magic Explain opcode are only inserted when explain==2 (which |
| ** is to say when the EXPLAIN QUERY PLAN syntax is used.) |
| ** This opcode records information from the optimizer. It is the |
| ** the same as a no-op. This opcodesnever appears in a real VM program. |
| */ |
| default: { /* This is really OP_Noop, OP_Explain */ |
| assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain ); |
| |
| break; |
| } |
| |
| /***************************************************************************** |
| ** The cases of the switch statement above this line should all be indented |
| ** by 6 spaces. But the left-most 6 spaces have been removed to improve the |
| ** readability. From this point on down, the normal indentation rules are |
| ** restored. |
| *****************************************************************************/ |
| } |
| |
| #ifdef VDBE_PROFILE |
| { |
| u64 endTime = sqlite3NProfileCnt ? sqlite3NProfileCnt : sqlite3Hwtime(); |
| if( endTime>start ) pOrigOp->cycles += endTime - start; |
| pOrigOp->cnt++; |
| } |
| #endif |
| |
| /* The following code adds nothing to the actual functionality |
| ** of the program. It is only here for testing and debugging. |
| ** On the other hand, it does burn CPU cycles every time through |
| ** the evaluator loop. So we can leave it out when NDEBUG is defined. |
| */ |
| #ifndef NDEBUG |
| assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] ); |
| |
| #ifdef SQLITE_DEBUG |
| if( db->flags & SQLITE_VdbeTrace ){ |
| u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode]; |
| if( rc!=0 ) printf("rc=%d\n",rc); |
| if( opProperty & (OPFLG_OUT2) ){ |
| registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]); |
| } |
| if( opProperty & OPFLG_OUT3 ){ |
| registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]); |
| } |
| } |
| #endif /* SQLITE_DEBUG */ |
| #endif /* NDEBUG */ |
| } /* The end of the for(;;) loop the loops through opcodes */ |
| |
| /* If we reach this point, it means that execution is finished with |
| ** an error of some kind. |
| */ |
| abort_due_to_error: |
| if( db->mallocFailed ) rc = SQLITE_NOMEM_BKPT; |
| assert( rc ); |
| if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){ |
| sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc)); |
| } |
| p->rc = rc; |
| sqlite3SystemError(db, rc); |
| testcase( sqlite3GlobalConfig.xLog!=0 ); |
| sqlite3_log(rc, "statement aborts at %d: [%s] %s", |
| (int)(pOp - aOp), p->zSql, p->zErrMsg); |
| sqlite3VdbeHalt(p); |
| if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db); |
| rc = SQLITE_ERROR; |
| if( resetSchemaOnFault>0 ){ |
| sqlite3ResetOneSchema(db, resetSchemaOnFault-1); |
| } |
| |
| /* This is the only way out of this procedure. We have to |
| ** release the mutexes on btrees that were acquired at the |
| ** top. */ |
| vdbe_return: |
| testcase( nVmStep>0 ); |
| p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep; |
| sqlite3VdbeLeave(p); |
| assert( rc!=SQLITE_OK || nExtraDelete==0 |
| || sqlite3_strlike("DELETE%",p->zSql,0)!=0 |
| ); |
| return rc; |
| |
| /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH |
| ** is encountered. |
| */ |
| too_big: |
| sqlite3VdbeError(p, "string or blob too big"); |
| rc = SQLITE_TOOBIG; |
| goto abort_due_to_error; |
| |
| /* Jump to here if a malloc() fails. |
| */ |
| no_mem: |
| sqlite3OomFault(db); |
| sqlite3VdbeError(p, "out of memory"); |
| rc = SQLITE_NOMEM_BKPT; |
| goto abort_due_to_error; |
| |
| /* Jump to here if the sqlite3_interrupt() API sets the interrupt |
| ** flag. |
| */ |
| abort_due_to_interrupt: |
| assert( db->u1.isInterrupted ); |
| rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT; |
| p->rc = rc; |
| sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc)); |
| goto abort_due_to_error; |
| } |