000001  /*
000002  ** 2001 September 15
000003  **
000004  ** The author disclaims copyright to this source code.  In place of
000005  ** a legal notice, here is a blessing:
000006  **
000007  **    May you do good and not evil.
000008  **    May you find forgiveness for yourself and forgive others.
000009  **    May you share freely, never taking more than you give.
000010  **
000011  *************************************************************************
000012  ** The code in this file implements the function that runs the
000013  ** bytecode of a prepared statement.
000014  **
000015  ** Various scripts scan this source file in order to generate HTML
000016  ** documentation, headers files, or other derived files.  The formatting
000017  ** of the code in this file is, therefore, important.  See other comments
000018  ** in this file for details.  If in doubt, do not deviate from existing
000019  ** commenting and indentation practices when changing or adding code.
000020  */
000021  #include "sqliteInt.h"
000022  #include "vdbeInt.h"
000023  
000024  /*
000025  ** Invoke this macro on memory cells just prior to changing the
000026  ** value of the cell.  This macro verifies that shallow copies are
000027  ** not misused.  A shallow copy of a string or blob just copies a
000028  ** pointer to the string or blob, not the content.  If the original
000029  ** is changed while the copy is still in use, the string or blob might
000030  ** be changed out from under the copy.  This macro verifies that nothing
000031  ** like that ever happens.
000032  */
000033  #ifdef SQLITE_DEBUG
000034  # define memAboutToChange(P,M) sqlite3VdbeMemAboutToChange(P,M)
000035  #else
000036  # define memAboutToChange(P,M)
000037  #endif
000038  
000039  /*
000040  ** The following global variable is incremented every time a cursor
000041  ** moves, either by the OP_SeekXX, OP_Next, or OP_Prev opcodes.  The test
000042  ** procedures use this information to make sure that indices are
000043  ** working correctly.  This variable has no function other than to
000044  ** help verify the correct operation of the library.
000045  */
000046  #ifdef SQLITE_TEST
000047  int sqlite3_search_count = 0;
000048  #endif
000049  
000050  /*
000051  ** When this global variable is positive, it gets decremented once before
000052  ** each instruction in the VDBE.  When it reaches zero, the u1.isInterrupted
000053  ** field of the sqlite3 structure is set in order to simulate an interrupt.
000054  **
000055  ** This facility is used for testing purposes only.  It does not function
000056  ** in an ordinary build.
000057  */
000058  #ifdef SQLITE_TEST
000059  int sqlite3_interrupt_count = 0;
000060  #endif
000061  
000062  /*
000063  ** The next global variable is incremented each type the OP_Sort opcode
000064  ** is executed.  The test procedures use this information to make sure that
000065  ** sorting is occurring or not occurring at appropriate times.   This variable
000066  ** has no function other than to help verify the correct operation of the
000067  ** library.
000068  */
000069  #ifdef SQLITE_TEST
000070  int sqlite3_sort_count = 0;
000071  #endif
000072  
000073  /*
000074  ** The next global variable records the size of the largest MEM_Blob
000075  ** or MEM_Str that has been used by a VDBE opcode.  The test procedures
000076  ** use this information to make sure that the zero-blob functionality
000077  ** is working correctly.   This variable has no function other than to
000078  ** help verify the correct operation of the library.
000079  */
000080  #ifdef SQLITE_TEST
000081  int sqlite3_max_blobsize = 0;
000082  static void updateMaxBlobsize(Mem *p){
000083    if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
000084      sqlite3_max_blobsize = p->n;
000085    }
000086  }
000087  #endif
000088  
000089  /*
000090  ** This macro evaluates to true if either the update hook or the preupdate
000091  ** hook are enabled for database connect DB.
000092  */
000093  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
000094  # define HAS_UPDATE_HOOK(DB) ((DB)->xPreUpdateCallback||(DB)->xUpdateCallback)
000095  #else
000096  # define HAS_UPDATE_HOOK(DB) ((DB)->xUpdateCallback)
000097  #endif
000098  
000099  /*
000100  ** The next global variable is incremented each time the OP_Found opcode
000101  ** is executed. This is used to test whether or not the foreign key
000102  ** operation implemented using OP_FkIsZero is working. This variable
000103  ** has no function other than to help verify the correct operation of the
000104  ** library.
000105  */
000106  #ifdef SQLITE_TEST
000107  int sqlite3_found_count = 0;
000108  #endif
000109  
000110  /*
000111  ** Test a register to see if it exceeds the current maximum blob size.
000112  ** If it does, record the new maximum blob size.
000113  */
000114  #if defined(SQLITE_TEST) && !defined(SQLITE_UNTESTABLE)
000115  # define UPDATE_MAX_BLOBSIZE(P)  updateMaxBlobsize(P)
000116  #else
000117  # define UPDATE_MAX_BLOBSIZE(P)
000118  #endif
000119  
000120  /*
000121  ** Invoke the VDBE coverage callback, if that callback is defined.  This
000122  ** feature is used for test suite validation only and does not appear an
000123  ** production builds.
000124  **
000125  ** M is an integer, 2 or 3, that indices how many different ways the
000126  ** branch can go.  It is usually 2.  "I" is the direction the branch
000127  ** goes.  0 means falls through.  1 means branch is taken.  2 means the
000128  ** second alternative branch is taken.
000129  **
000130  ** iSrcLine is the source code line (from the __LINE__ macro) that
000131  ** generated the VDBE instruction.  This instrumentation assumes that all
000132  ** source code is in a single file (the amalgamation).  Special values 1
000133  ** and 2 for the iSrcLine parameter mean that this particular branch is
000134  ** always taken or never taken, respectively.
000135  */
000136  #if !defined(SQLITE_VDBE_COVERAGE)
000137  # define VdbeBranchTaken(I,M)
000138  #else
000139  # define VdbeBranchTaken(I,M) vdbeTakeBranch(pOp->iSrcLine,I,M)
000140    static void vdbeTakeBranch(int iSrcLine, u8 I, u8 M){
000141      if( iSrcLine<=2 && ALWAYS(iSrcLine>0) ){
000142        M = iSrcLine;
000143        /* Assert the truth of VdbeCoverageAlwaysTaken() and 
000144        ** VdbeCoverageNeverTaken() */
000145        assert( (M & I)==I );
000146      }else{
000147        if( sqlite3GlobalConfig.xVdbeBranch==0 ) return;  /*NO_TEST*/
000148        sqlite3GlobalConfig.xVdbeBranch(sqlite3GlobalConfig.pVdbeBranchArg,
000149                                        iSrcLine,I,M);
000150      }
000151    }
000152  #endif
000153  
000154  /*
000155  ** Convert the given register into a string if it isn't one
000156  ** already. Return non-zero if a malloc() fails.
000157  */
000158  #define Stringify(P, enc) \
000159     if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc,0)) \
000160       { goto no_mem; }
000161  
000162  /*
000163  ** An ephemeral string value (signified by the MEM_Ephem flag) contains
000164  ** a pointer to a dynamically allocated string where some other entity
000165  ** is responsible for deallocating that string.  Because the register
000166  ** does not control the string, it might be deleted without the register
000167  ** knowing it.
000168  **
000169  ** This routine converts an ephemeral string into a dynamically allocated
000170  ** string that the register itself controls.  In other words, it
000171  ** converts an MEM_Ephem string into a string with P.z==P.zMalloc.
000172  */
000173  #define Deephemeralize(P) \
000174     if( ((P)->flags&MEM_Ephem)!=0 \
000175         && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
000176  
000177  /* Return true if the cursor was opened using the OP_OpenSorter opcode. */
000178  #define isSorter(x) ((x)->eCurType==CURTYPE_SORTER)
000179  
000180  /*
000181  ** Allocate VdbeCursor number iCur.  Return a pointer to it.  Return NULL
000182  ** if we run out of memory.
000183  */
000184  static VdbeCursor *allocateCursor(
000185    Vdbe *p,              /* The virtual machine */
000186    int iCur,             /* Index of the new VdbeCursor */
000187    int nField,           /* Number of fields in the table or index */
000188    int iDb,              /* Database the cursor belongs to, or -1 */
000189    u8 eCurType           /* Type of the new cursor */
000190  ){
000191    /* Find the memory cell that will be used to store the blob of memory
000192    ** required for this VdbeCursor structure. It is convenient to use a 
000193    ** vdbe memory cell to manage the memory allocation required for a
000194    ** VdbeCursor structure for the following reasons:
000195    **
000196    **   * Sometimes cursor numbers are used for a couple of different
000197    **     purposes in a vdbe program. The different uses might require
000198    **     different sized allocations. Memory cells provide growable
000199    **     allocations.
000200    **
000201    **   * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
000202    **     be freed lazily via the sqlite3_release_memory() API. This
000203    **     minimizes the number of malloc calls made by the system.
000204    **
000205    ** The memory cell for cursor 0 is aMem[0]. The rest are allocated from
000206    ** the top of the register space.  Cursor 1 is at Mem[p->nMem-1].
000207    ** Cursor 2 is at Mem[p->nMem-2]. And so forth.
000208    */
000209    Mem *pMem = iCur>0 ? &p->aMem[p->nMem-iCur] : p->aMem;
000210  
000211    int nByte;
000212    VdbeCursor *pCx = 0;
000213    nByte = 
000214        ROUND8(sizeof(VdbeCursor)) + 2*sizeof(u32)*nField + 
000215        (eCurType==CURTYPE_BTREE?sqlite3BtreeCursorSize():0);
000216  
000217    assert( iCur>=0 && iCur<p->nCursor );
000218    if( p->apCsr[iCur] ){ /*OPTIMIZATION-IF-FALSE*/
000219      sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
000220      p->apCsr[iCur] = 0;
000221    }
000222    if( SQLITE_OK==sqlite3VdbeMemClearAndResize(pMem, nByte) ){
000223      p->apCsr[iCur] = pCx = (VdbeCursor*)pMem->z;
000224      memset(pCx, 0, offsetof(VdbeCursor,pAltCursor));
000225      pCx->eCurType = eCurType;
000226      pCx->iDb = iDb;
000227      pCx->nField = nField;
000228      pCx->aOffset = &pCx->aType[nField];
000229      if( eCurType==CURTYPE_BTREE ){
000230        pCx->uc.pCursor = (BtCursor*)
000231            &pMem->z[ROUND8(sizeof(VdbeCursor))+2*sizeof(u32)*nField];
000232        sqlite3BtreeCursorZero(pCx->uc.pCursor);
000233      }
000234    }
000235    return pCx;
000236  }
000237  
000238  /*
000239  ** Try to convert a value into a numeric representation if we can
000240  ** do so without loss of information.  In other words, if the string
000241  ** looks like a number, convert it into a number.  If it does not
000242  ** look like a number, leave it alone.
000243  **
000244  ** If the bTryForInt flag is true, then extra effort is made to give
000245  ** an integer representation.  Strings that look like floating point
000246  ** values but which have no fractional component (example: '48.00')
000247  ** will have a MEM_Int representation when bTryForInt is true.
000248  **
000249  ** If bTryForInt is false, then if the input string contains a decimal
000250  ** point or exponential notation, the result is only MEM_Real, even
000251  ** if there is an exact integer representation of the quantity.
000252  */
000253  static void applyNumericAffinity(Mem *pRec, int bTryForInt){
000254    double rValue;
000255    i64 iValue;
000256    u8 enc = pRec->enc;
000257    assert( (pRec->flags & (MEM_Str|MEM_Int|MEM_Real))==MEM_Str );
000258    if( sqlite3AtoF(pRec->z, &rValue, pRec->n, enc)==0 ) return;
000259    if( 0==sqlite3Atoi64(pRec->z, &iValue, pRec->n, enc) ){
000260      pRec->u.i = iValue;
000261      pRec->flags |= MEM_Int;
000262    }else{
000263      pRec->u.r = rValue;
000264      pRec->flags |= MEM_Real;
000265      if( bTryForInt ) sqlite3VdbeIntegerAffinity(pRec);
000266    }
000267  }
000268  
000269  /*
000270  ** Processing is determine by the affinity parameter:
000271  **
000272  ** SQLITE_AFF_INTEGER:
000273  ** SQLITE_AFF_REAL:
000274  ** SQLITE_AFF_NUMERIC:
000275  **    Try to convert pRec to an integer representation or a 
000276  **    floating-point representation if an integer representation
000277  **    is not possible.  Note that the integer representation is
000278  **    always preferred, even if the affinity is REAL, because
000279  **    an integer representation is more space efficient on disk.
000280  **
000281  ** SQLITE_AFF_TEXT:
000282  **    Convert pRec to a text representation.
000283  **
000284  ** SQLITE_AFF_BLOB:
000285  **    No-op.  pRec is unchanged.
000286  */
000287  static void applyAffinity(
000288    Mem *pRec,          /* The value to apply affinity to */
000289    char affinity,      /* The affinity to be applied */
000290    u8 enc              /* Use this text encoding */
000291  ){
000292    if( affinity>=SQLITE_AFF_NUMERIC ){
000293      assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
000294               || affinity==SQLITE_AFF_NUMERIC );
000295      if( (pRec->flags & MEM_Int)==0 ){ /*OPTIMIZATION-IF-FALSE*/
000296        if( (pRec->flags & MEM_Real)==0 ){
000297          if( pRec->flags & MEM_Str ) applyNumericAffinity(pRec,1);
000298        }else{
000299          sqlite3VdbeIntegerAffinity(pRec);
000300        }
000301      }
000302    }else if( affinity==SQLITE_AFF_TEXT ){
000303      /* Only attempt the conversion to TEXT if there is an integer or real
000304      ** representation (blob and NULL do not get converted) but no string
000305      ** representation.  It would be harmless to repeat the conversion if 
000306      ** there is already a string rep, but it is pointless to waste those
000307      ** CPU cycles. */
000308      if( 0==(pRec->flags&MEM_Str) ){ /*OPTIMIZATION-IF-FALSE*/
000309        if( (pRec->flags&(MEM_Real|MEM_Int)) ){
000310          sqlite3VdbeMemStringify(pRec, enc, 1);
000311        }
000312      }
000313      pRec->flags &= ~(MEM_Real|MEM_Int);
000314    }
000315  }
000316  
000317  /*
000318  ** Try to convert the type of a function argument or a result column
000319  ** into a numeric representation.  Use either INTEGER or REAL whichever
000320  ** is appropriate.  But only do the conversion if it is possible without
000321  ** loss of information and return the revised type of the argument.
000322  */
000323  int sqlite3_value_numeric_type(sqlite3_value *pVal){
000324    int eType = sqlite3_value_type(pVal);
000325    if( eType==SQLITE_TEXT ){
000326      Mem *pMem = (Mem*)pVal;
000327      applyNumericAffinity(pMem, 0);
000328      eType = sqlite3_value_type(pVal);
000329    }
000330    return eType;
000331  }
000332  
000333  /*
000334  ** Exported version of applyAffinity(). This one works on sqlite3_value*, 
000335  ** not the internal Mem* type.
000336  */
000337  void sqlite3ValueApplyAffinity(
000338    sqlite3_value *pVal, 
000339    u8 affinity, 
000340    u8 enc
000341  ){
000342    applyAffinity((Mem *)pVal, affinity, enc);
000343  }
000344  
000345  /*
000346  ** pMem currently only holds a string type (or maybe a BLOB that we can
000347  ** interpret as a string if we want to).  Compute its corresponding
000348  ** numeric type, if has one.  Set the pMem->u.r and pMem->u.i fields
000349  ** accordingly.
000350  */
000351  static u16 SQLITE_NOINLINE computeNumericType(Mem *pMem){
000352    assert( (pMem->flags & (MEM_Int|MEM_Real))==0 );
000353    assert( (pMem->flags & (MEM_Str|MEM_Blob))!=0 );
000354    if( sqlite3AtoF(pMem->z, &pMem->u.r, pMem->n, pMem->enc)==0 ){
000355      return 0;
000356    }
000357    if( sqlite3Atoi64(pMem->z, &pMem->u.i, pMem->n, pMem->enc)==0 ){
000358      return MEM_Int;
000359    }
000360    return MEM_Real;
000361  }
000362  
000363  /*
000364  ** Return the numeric type for pMem, either MEM_Int or MEM_Real or both or
000365  ** none.  
000366  **
000367  ** Unlike applyNumericAffinity(), this routine does not modify pMem->flags.
000368  ** But it does set pMem->u.r and pMem->u.i appropriately.
000369  */
000370  static u16 numericType(Mem *pMem){
000371    if( pMem->flags & (MEM_Int|MEM_Real) ){
000372      return pMem->flags & (MEM_Int|MEM_Real);
000373    }
000374    if( pMem->flags & (MEM_Str|MEM_Blob) ){
000375      return computeNumericType(pMem);
000376    }
000377    return 0;
000378  }
000379  
000380  #ifdef SQLITE_DEBUG
000381  /*
000382  ** Write a nice string representation of the contents of cell pMem
000383  ** into buffer zBuf, length nBuf.
000384  */
000385  void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
000386    char *zCsr = zBuf;
000387    int f = pMem->flags;
000388  
000389    static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
000390  
000391    if( f&MEM_Blob ){
000392      int i;
000393      char c;
000394      if( f & MEM_Dyn ){
000395        c = 'z';
000396        assert( (f & (MEM_Static|MEM_Ephem))==0 );
000397      }else if( f & MEM_Static ){
000398        c = 't';
000399        assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
000400      }else if( f & MEM_Ephem ){
000401        c = 'e';
000402        assert( (f & (MEM_Static|MEM_Dyn))==0 );
000403      }else{
000404        c = 's';
000405      }
000406      *(zCsr++) = c;
000407      sqlite3_snprintf(100, zCsr, "%d[", pMem->n);
000408      zCsr += sqlite3Strlen30(zCsr);
000409      for(i=0; i<16 && i<pMem->n; i++){
000410        sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
000411        zCsr += sqlite3Strlen30(zCsr);
000412      }
000413      for(i=0; i<16 && i<pMem->n; i++){
000414        char z = pMem->z[i];
000415        if( z<32 || z>126 ) *zCsr++ = '.';
000416        else *zCsr++ = z;
000417      }
000418      *(zCsr++) = ']';
000419      if( f & MEM_Zero ){
000420        sqlite3_snprintf(100, zCsr,"+%dz",pMem->u.nZero);
000421        zCsr += sqlite3Strlen30(zCsr);
000422      }
000423      *zCsr = '\0';
000424    }else if( f & MEM_Str ){
000425      int j, k;
000426      zBuf[0] = ' ';
000427      if( f & MEM_Dyn ){
000428        zBuf[1] = 'z';
000429        assert( (f & (MEM_Static|MEM_Ephem))==0 );
000430      }else if( f & MEM_Static ){
000431        zBuf[1] = 't';
000432        assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
000433      }else if( f & MEM_Ephem ){
000434        zBuf[1] = 'e';
000435        assert( (f & (MEM_Static|MEM_Dyn))==0 );
000436      }else{
000437        zBuf[1] = 's';
000438      }
000439      k = 2;
000440      sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n);
000441      k += sqlite3Strlen30(&zBuf[k]);
000442      zBuf[k++] = '[';
000443      for(j=0; j<15 && j<pMem->n; j++){
000444        u8 c = pMem->z[j];
000445        if( c>=0x20 && c<0x7f ){
000446          zBuf[k++] = c;
000447        }else{
000448          zBuf[k++] = '.';
000449        }
000450      }
000451      zBuf[k++] = ']';
000452      sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]);
000453      k += sqlite3Strlen30(&zBuf[k]);
000454      zBuf[k++] = 0;
000455    }
000456  }
000457  #endif
000458  
000459  #ifdef SQLITE_DEBUG
000460  /*
000461  ** Print the value of a register for tracing purposes:
000462  */
000463  static void memTracePrint(Mem *p){
000464    if( p->flags & MEM_Undefined ){
000465      printf(" undefined");
000466    }else if( p->flags & MEM_Null ){
000467      printf(" NULL");
000468    }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
000469      printf(" si:%lld", p->u.i);
000470    }else if( p->flags & MEM_Int ){
000471      printf(" i:%lld", p->u.i);
000472  #ifndef SQLITE_OMIT_FLOATING_POINT
000473    }else if( p->flags & MEM_Real ){
000474      printf(" r:%g", p->u.r);
000475  #endif
000476    }else if( p->flags & MEM_RowSet ){
000477      printf(" (rowset)");
000478    }else{
000479      char zBuf[200];
000480      sqlite3VdbeMemPrettyPrint(p, zBuf);
000481      printf(" %s", zBuf);
000482    }
000483    if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype);
000484  }
000485  static void registerTrace(int iReg, Mem *p){
000486    printf("REG[%d] = ", iReg);
000487    memTracePrint(p);
000488    printf("\n");
000489    sqlite3VdbeCheckMemInvariants(p);
000490  }
000491  #endif
000492  
000493  #ifdef SQLITE_DEBUG
000494  #  define REGISTER_TRACE(R,M) if(db->flags&SQLITE_VdbeTrace)registerTrace(R,M)
000495  #else
000496  #  define REGISTER_TRACE(R,M)
000497  #endif
000498  
000499  
000500  #ifdef VDBE_PROFILE
000501  
000502  /* 
000503  ** hwtime.h contains inline assembler code for implementing 
000504  ** high-performance timing routines.
000505  */
000506  #include "hwtime.h"
000507  
000508  #endif
000509  
000510  #ifndef NDEBUG
000511  /*
000512  ** This function is only called from within an assert() expression. It
000513  ** checks that the sqlite3.nTransaction variable is correctly set to
000514  ** the number of non-transaction savepoints currently in the 
000515  ** linked list starting at sqlite3.pSavepoint.
000516  ** 
000517  ** Usage:
000518  **
000519  **     assert( checkSavepointCount(db) );
000520  */
000521  static int checkSavepointCount(sqlite3 *db){
000522    int n = 0;
000523    Savepoint *p;
000524    for(p=db->pSavepoint; p; p=p->pNext) n++;
000525    assert( n==(db->nSavepoint + db->isTransactionSavepoint) );
000526    return 1;
000527  }
000528  #endif
000529  
000530  /*
000531  ** Return the register of pOp->p2 after first preparing it to be
000532  ** overwritten with an integer value.
000533  */
000534  static SQLITE_NOINLINE Mem *out2PrereleaseWithClear(Mem *pOut){
000535    sqlite3VdbeMemSetNull(pOut);
000536    pOut->flags = MEM_Int;
000537    return pOut;
000538  }
000539  static Mem *out2Prerelease(Vdbe *p, VdbeOp *pOp){
000540    Mem *pOut;
000541    assert( pOp->p2>0 );
000542    assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
000543    pOut = &p->aMem[pOp->p2];
000544    memAboutToChange(p, pOut);
000545    if( VdbeMemDynamic(pOut) ){ /*OPTIMIZATION-IF-FALSE*/
000546      return out2PrereleaseWithClear(pOut);
000547    }else{
000548      pOut->flags = MEM_Int;
000549      return pOut;
000550    }
000551  }
000552  
000553  
000554  /*
000555  ** Execute as much of a VDBE program as we can.
000556  ** This is the core of sqlite3_step().  
000557  */
000558  int sqlite3VdbeExec(
000559    Vdbe *p                    /* The VDBE */
000560  ){
000561    Op *aOp = p->aOp;          /* Copy of p->aOp */
000562    Op *pOp = aOp;             /* Current operation */
000563  #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
000564    Op *pOrigOp;               /* Value of pOp at the top of the loop */
000565  #endif
000566  #ifdef SQLITE_DEBUG
000567    int nExtraDelete = 0;      /* Verifies FORDELETE and AUXDELETE flags */
000568  #endif
000569    int rc = SQLITE_OK;        /* Value to return */
000570    sqlite3 *db = p->db;       /* The database */
000571    u8 resetSchemaOnFault = 0; /* Reset schema after an error if positive */
000572    u8 encoding = ENC(db);     /* The database encoding */
000573    int iCompare = 0;          /* Result of last comparison */
000574    unsigned nVmStep = 0;      /* Number of virtual machine steps */
000575  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
000576    unsigned nProgressLimit;   /* Invoke xProgress() when nVmStep reaches this */
000577  #endif
000578    Mem *aMem = p->aMem;       /* Copy of p->aMem */
000579    Mem *pIn1 = 0;             /* 1st input operand */
000580    Mem *pIn2 = 0;             /* 2nd input operand */
000581    Mem *pIn3 = 0;             /* 3rd input operand */
000582    Mem *pOut = 0;             /* Output operand */
000583  #ifdef VDBE_PROFILE
000584    u64 start;                 /* CPU clock count at start of opcode */
000585  #endif
000586    /*** INSERT STACK UNION HERE ***/
000587  
000588    assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
000589    sqlite3VdbeEnter(p);
000590    if( p->rc==SQLITE_NOMEM ){
000591      /* This happens if a malloc() inside a call to sqlite3_column_text() or
000592      ** sqlite3_column_text16() failed.  */
000593      goto no_mem;
000594    }
000595    assert( p->rc==SQLITE_OK || (p->rc&0xff)==SQLITE_BUSY );
000596    assert( p->bIsReader || p->readOnly!=0 );
000597    p->iCurrentTime = 0;
000598    assert( p->explain==0 );
000599    p->pResultSet = 0;
000600    db->busyHandler.nBusy = 0;
000601    if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
000602    sqlite3VdbeIOTraceSql(p);
000603  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
000604    if( db->xProgress ){
000605      u32 iPrior = p->aCounter[SQLITE_STMTSTATUS_VM_STEP];
000606      assert( 0 < db->nProgressOps );
000607      nProgressLimit = db->nProgressOps - (iPrior % db->nProgressOps);
000608    }else{
000609      nProgressLimit = 0xffffffff;
000610    }
000611  #endif
000612  #ifdef SQLITE_DEBUG
000613    sqlite3BeginBenignMalloc();
000614    if( p->pc==0
000615     && (p->db->flags & (SQLITE_VdbeListing|SQLITE_VdbeEQP|SQLITE_VdbeTrace))!=0
000616    ){
000617      int i;
000618      int once = 1;
000619      sqlite3VdbePrintSql(p);
000620      if( p->db->flags & SQLITE_VdbeListing ){
000621        printf("VDBE Program Listing:\n");
000622        for(i=0; i<p->nOp; i++){
000623          sqlite3VdbePrintOp(stdout, i, &aOp[i]);
000624        }
000625      }
000626      if( p->db->flags & SQLITE_VdbeEQP ){
000627        for(i=0; i<p->nOp; i++){
000628          if( aOp[i].opcode==OP_Explain ){
000629            if( once ) printf("VDBE Query Plan:\n");
000630            printf("%s\n", aOp[i].p4.z);
000631            once = 0;
000632          }
000633        }
000634      }
000635      if( p->db->flags & SQLITE_VdbeTrace )  printf("VDBE Trace:\n");
000636    }
000637    sqlite3EndBenignMalloc();
000638  #endif
000639    for(pOp=&aOp[p->pc]; 1; pOp++){
000640      /* Errors are detected by individual opcodes, with an immediate
000641      ** jumps to abort_due_to_error. */
000642      assert( rc==SQLITE_OK );
000643  
000644      assert( pOp>=aOp && pOp<&aOp[p->nOp]);
000645  #ifdef VDBE_PROFILE
000646      start = sqlite3Hwtime();
000647  #endif
000648      nVmStep++;
000649  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
000650      if( p->anExec ) p->anExec[(int)(pOp-aOp)]++;
000651  #endif
000652  
000653      /* Only allow tracing if SQLITE_DEBUG is defined.
000654      */
000655  #ifdef SQLITE_DEBUG
000656      if( db->flags & SQLITE_VdbeTrace ){
000657        sqlite3VdbePrintOp(stdout, (int)(pOp - aOp), pOp);
000658      }
000659  #endif
000660        
000661  
000662      /* Check to see if we need to simulate an interrupt.  This only happens
000663      ** if we have a special test build.
000664      */
000665  #ifdef SQLITE_TEST
000666      if( sqlite3_interrupt_count>0 ){
000667        sqlite3_interrupt_count--;
000668        if( sqlite3_interrupt_count==0 ){
000669          sqlite3_interrupt(db);
000670        }
000671      }
000672  #endif
000673  
000674      /* Sanity checking on other operands */
000675  #ifdef SQLITE_DEBUG
000676      {
000677        u8 opProperty = sqlite3OpcodeProperty[pOp->opcode];
000678        if( (opProperty & OPFLG_IN1)!=0 ){
000679          assert( pOp->p1>0 );
000680          assert( pOp->p1<=(p->nMem+1 - p->nCursor) );
000681          assert( memIsValid(&aMem[pOp->p1]) );
000682          assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p1]) );
000683          REGISTER_TRACE(pOp->p1, &aMem[pOp->p1]);
000684        }
000685        if( (opProperty & OPFLG_IN2)!=0 ){
000686          assert( pOp->p2>0 );
000687          assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
000688          assert( memIsValid(&aMem[pOp->p2]) );
000689          assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p2]) );
000690          REGISTER_TRACE(pOp->p2, &aMem[pOp->p2]);
000691        }
000692        if( (opProperty & OPFLG_IN3)!=0 ){
000693          assert( pOp->p3>0 );
000694          assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
000695          assert( memIsValid(&aMem[pOp->p3]) );
000696          assert( sqlite3VdbeCheckMemInvariants(&aMem[pOp->p3]) );
000697          REGISTER_TRACE(pOp->p3, &aMem[pOp->p3]);
000698        }
000699        if( (opProperty & OPFLG_OUT2)!=0 ){
000700          assert( pOp->p2>0 );
000701          assert( pOp->p2<=(p->nMem+1 - p->nCursor) );
000702          memAboutToChange(p, &aMem[pOp->p2]);
000703        }
000704        if( (opProperty & OPFLG_OUT3)!=0 ){
000705          assert( pOp->p3>0 );
000706          assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
000707          memAboutToChange(p, &aMem[pOp->p3]);
000708        }
000709      }
000710  #endif
000711  #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
000712      pOrigOp = pOp;
000713  #endif
000714    
000715      switch( pOp->opcode ){
000716  
000717  /*****************************************************************************
000718  ** What follows is a massive switch statement where each case implements a
000719  ** separate instruction in the virtual machine.  If we follow the usual
000720  ** indentation conventions, each case should be indented by 6 spaces.  But
000721  ** that is a lot of wasted space on the left margin.  So the code within
000722  ** the switch statement will break with convention and be flush-left. Another
000723  ** big comment (similar to this one) will mark the point in the code where
000724  ** we transition back to normal indentation.
000725  **
000726  ** The formatting of each case is important.  The makefile for SQLite
000727  ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
000728  ** file looking for lines that begin with "case OP_".  The opcodes.h files
000729  ** will be filled with #defines that give unique integer values to each
000730  ** opcode and the opcodes.c file is filled with an array of strings where
000731  ** each string is the symbolic name for the corresponding opcode.  If the
000732  ** case statement is followed by a comment of the form "/# same as ... #/"
000733  ** that comment is used to determine the particular value of the opcode.
000734  **
000735  ** Other keywords in the comment that follows each case are used to
000736  ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
000737  ** Keywords include: in1, in2, in3, out2, out3.  See
000738  ** the mkopcodeh.awk script for additional information.
000739  **
000740  ** Documentation about VDBE opcodes is generated by scanning this file
000741  ** for lines of that contain "Opcode:".  That line and all subsequent
000742  ** comment lines are used in the generation of the opcode.html documentation
000743  ** file.
000744  **
000745  ** SUMMARY:
000746  **
000747  **     Formatting is important to scripts that scan this file.
000748  **     Do not deviate from the formatting style currently in use.
000749  **
000750  *****************************************************************************/
000751  
000752  /* Opcode:  Goto * P2 * * *
000753  **
000754  ** An unconditional jump to address P2.
000755  ** The next instruction executed will be 
000756  ** the one at index P2 from the beginning of
000757  ** the program.
000758  **
000759  ** The P1 parameter is not actually used by this opcode.  However, it
000760  ** is sometimes set to 1 instead of 0 as a hint to the command-line shell
000761  ** that this Goto is the bottom of a loop and that the lines from P2 down
000762  ** to the current line should be indented for EXPLAIN output.
000763  */
000764  case OP_Goto: {             /* jump */
000765  jump_to_p2_and_check_for_interrupt:
000766    pOp = &aOp[pOp->p2 - 1];
000767  
000768    /* Opcodes that are used as the bottom of a loop (OP_Next, OP_Prev,
000769    ** OP_VNext, or OP_SorterNext) all jump here upon
000770    ** completion.  Check to see if sqlite3_interrupt() has been called
000771    ** or if the progress callback needs to be invoked. 
000772    **
000773    ** This code uses unstructured "goto" statements and does not look clean.
000774    ** But that is not due to sloppy coding habits. The code is written this
000775    ** way for performance, to avoid having to run the interrupt and progress
000776    ** checks on every opcode.  This helps sqlite3_step() to run about 1.5%
000777    ** faster according to "valgrind --tool=cachegrind" */
000778  check_for_interrupt:
000779    if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
000780  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
000781    /* Call the progress callback if it is configured and the required number
000782    ** of VDBE ops have been executed (either since this invocation of
000783    ** sqlite3VdbeExec() or since last time the progress callback was called).
000784    ** If the progress callback returns non-zero, exit the virtual machine with
000785    ** a return code SQLITE_ABORT.
000786    */
000787    if( nVmStep>=nProgressLimit && db->xProgress!=0 ){
000788      assert( db->nProgressOps!=0 );
000789      nProgressLimit = nVmStep + db->nProgressOps - (nVmStep%db->nProgressOps);
000790      if( db->xProgress(db->pProgressArg) ){
000791        rc = SQLITE_INTERRUPT;
000792        goto abort_due_to_error;
000793      }
000794    }
000795  #endif
000796    
000797    break;
000798  }
000799  
000800  /* Opcode:  Gosub P1 P2 * * *
000801  **
000802  ** Write the current address onto register P1
000803  ** and then jump to address P2.
000804  */
000805  case OP_Gosub: {            /* jump */
000806    assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
000807    pIn1 = &aMem[pOp->p1];
000808    assert( VdbeMemDynamic(pIn1)==0 );
000809    memAboutToChange(p, pIn1);
000810    pIn1->flags = MEM_Int;
000811    pIn1->u.i = (int)(pOp-aOp);
000812    REGISTER_TRACE(pOp->p1, pIn1);
000813  
000814    /* Most jump operations do a goto to this spot in order to update
000815    ** the pOp pointer. */
000816  jump_to_p2:
000817    pOp = &aOp[pOp->p2 - 1];
000818    break;
000819  }
000820  
000821  /* Opcode:  Return P1 * * * *
000822  **
000823  ** Jump to the next instruction after the address in register P1.  After
000824  ** the jump, register P1 becomes undefined.
000825  */
000826  case OP_Return: {           /* in1 */
000827    pIn1 = &aMem[pOp->p1];
000828    assert( pIn1->flags==MEM_Int );
000829    pOp = &aOp[pIn1->u.i];
000830    pIn1->flags = MEM_Undefined;
000831    break;
000832  }
000833  
000834  /* Opcode: InitCoroutine P1 P2 P3 * *
000835  **
000836  ** Set up register P1 so that it will Yield to the coroutine
000837  ** located at address P3.
000838  **
000839  ** If P2!=0 then the coroutine implementation immediately follows
000840  ** this opcode.  So jump over the coroutine implementation to
000841  ** address P2.
000842  **
000843  ** See also: EndCoroutine
000844  */
000845  case OP_InitCoroutine: {     /* jump */
000846    assert( pOp->p1>0 &&  pOp->p1<=(p->nMem+1 - p->nCursor) );
000847    assert( pOp->p2>=0 && pOp->p2<p->nOp );
000848    assert( pOp->p3>=0 && pOp->p3<p->nOp );
000849    pOut = &aMem[pOp->p1];
000850    assert( !VdbeMemDynamic(pOut) );
000851    pOut->u.i = pOp->p3 - 1;
000852    pOut->flags = MEM_Int;
000853    if( pOp->p2 ) goto jump_to_p2;
000854    break;
000855  }
000856  
000857  /* Opcode:  EndCoroutine P1 * * * *
000858  **
000859  ** The instruction at the address in register P1 is a Yield.
000860  ** Jump to the P2 parameter of that Yield.
000861  ** After the jump, register P1 becomes undefined.
000862  **
000863  ** See also: InitCoroutine
000864  */
000865  case OP_EndCoroutine: {           /* in1 */
000866    VdbeOp *pCaller;
000867    pIn1 = &aMem[pOp->p1];
000868    assert( pIn1->flags==MEM_Int );
000869    assert( pIn1->u.i>=0 && pIn1->u.i<p->nOp );
000870    pCaller = &aOp[pIn1->u.i];
000871    assert( pCaller->opcode==OP_Yield );
000872    assert( pCaller->p2>=0 && pCaller->p2<p->nOp );
000873    pOp = &aOp[pCaller->p2 - 1];
000874    pIn1->flags = MEM_Undefined;
000875    break;
000876  }
000877  
000878  /* Opcode:  Yield P1 P2 * * *
000879  **
000880  ** Swap the program counter with the value in register P1.  This
000881  ** has the effect of yielding to a coroutine.
000882  **
000883  ** If the coroutine that is launched by this instruction ends with
000884  ** Yield or Return then continue to the next instruction.  But if
000885  ** the coroutine launched by this instruction ends with
000886  ** EndCoroutine, then jump to P2 rather than continuing with the
000887  ** next instruction.
000888  **
000889  ** See also: InitCoroutine
000890  */
000891  case OP_Yield: {            /* in1, jump */
000892    int pcDest;
000893    pIn1 = &aMem[pOp->p1];
000894    assert( VdbeMemDynamic(pIn1)==0 );
000895    pIn1->flags = MEM_Int;
000896    pcDest = (int)pIn1->u.i;
000897    pIn1->u.i = (int)(pOp - aOp);
000898    REGISTER_TRACE(pOp->p1, pIn1);
000899    pOp = &aOp[pcDest];
000900    break;
000901  }
000902  
000903  /* Opcode:  HaltIfNull  P1 P2 P3 P4 P5
000904  ** Synopsis: if r[P3]=null halt
000905  **
000906  ** Check the value in register P3.  If it is NULL then Halt using
000907  ** parameter P1, P2, and P4 as if this were a Halt instruction.  If the
000908  ** value in register P3 is not NULL, then this routine is a no-op.
000909  ** The P5 parameter should be 1.
000910  */
000911  case OP_HaltIfNull: {      /* in3 */
000912    pIn3 = &aMem[pOp->p3];
000913    if( (pIn3->flags & MEM_Null)==0 ) break;
000914    /* Fall through into OP_Halt */
000915  }
000916  
000917  /* Opcode:  Halt P1 P2 * P4 P5
000918  **
000919  ** Exit immediately.  All open cursors, etc are closed
000920  ** automatically.
000921  **
000922  ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
000923  ** or sqlite3_finalize().  For a normal halt, this should be SQLITE_OK (0).
000924  ** For errors, it can be some other value.  If P1!=0 then P2 will determine
000925  ** whether or not to rollback the current transaction.  Do not rollback
000926  ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback.  If P2==OE_Abort,
000927  ** then back out all changes that have occurred during this execution of the
000928  ** VDBE, but do not rollback the transaction. 
000929  **
000930  ** If P4 is not null then it is an error message string.
000931  **
000932  ** P5 is a value between 0 and 4, inclusive, that modifies the P4 string.
000933  **
000934  **    0:  (no change)
000935  **    1:  NOT NULL contraint failed: P4
000936  **    2:  UNIQUE constraint failed: P4
000937  **    3:  CHECK constraint failed: P4
000938  **    4:  FOREIGN KEY constraint failed: P4
000939  **
000940  ** If P5 is not zero and P4 is NULL, then everything after the ":" is
000941  ** omitted.
000942  **
000943  ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
000944  ** every program.  So a jump past the last instruction of the program
000945  ** is the same as executing Halt.
000946  */
000947  case OP_Halt: {
000948    VdbeFrame *pFrame;
000949    int pcx;
000950  
000951    pcx = (int)(pOp - aOp);
000952    if( pOp->p1==SQLITE_OK && p->pFrame ){
000953      /* Halt the sub-program. Return control to the parent frame. */
000954      pFrame = p->pFrame;
000955      p->pFrame = pFrame->pParent;
000956      p->nFrame--;
000957      sqlite3VdbeSetChanges(db, p->nChange);
000958      pcx = sqlite3VdbeFrameRestore(pFrame);
000959      if( pOp->p2==OE_Ignore ){
000960        /* Instruction pcx is the OP_Program that invoked the sub-program 
000961        ** currently being halted. If the p2 instruction of this OP_Halt
000962        ** instruction is set to OE_Ignore, then the sub-program is throwing
000963        ** an IGNORE exception. In this case jump to the address specified
000964        ** as the p2 of the calling OP_Program.  */
000965        pcx = p->aOp[pcx].p2-1;
000966      }
000967      aOp = p->aOp;
000968      aMem = p->aMem;
000969      pOp = &aOp[pcx];
000970      break;
000971    }
000972    p->rc = pOp->p1;
000973    p->errorAction = (u8)pOp->p2;
000974    p->pc = pcx;
000975    assert( pOp->p5<=4 );
000976    if( p->rc ){
000977      if( pOp->p5 ){
000978        static const char * const azType[] = { "NOT NULL", "UNIQUE", "CHECK",
000979                                               "FOREIGN KEY" };
000980        testcase( pOp->p5==1 );
000981        testcase( pOp->p5==2 );
000982        testcase( pOp->p5==3 );
000983        testcase( pOp->p5==4 );
000984        sqlite3VdbeError(p, "%s constraint failed", azType[pOp->p5-1]);
000985        if( pOp->p4.z ){
000986          p->zErrMsg = sqlite3MPrintf(db, "%z: %s", p->zErrMsg, pOp->p4.z);
000987        }
000988      }else{
000989        sqlite3VdbeError(p, "%s", pOp->p4.z);
000990      }
000991      sqlite3_log(pOp->p1, "abort at %d in [%s]: %s", pcx, p->zSql, p->zErrMsg);
000992    }
000993    rc = sqlite3VdbeHalt(p);
000994    assert( rc==SQLITE_BUSY || rc==SQLITE_OK || rc==SQLITE_ERROR );
000995    if( rc==SQLITE_BUSY ){
000996      p->rc = SQLITE_BUSY;
000997    }else{
000998      assert( rc==SQLITE_OK || (p->rc&0xff)==SQLITE_CONSTRAINT );
000999      assert( rc==SQLITE_OK || db->nDeferredCons>0 || db->nDeferredImmCons>0 );
001000      rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
001001    }
001002    goto vdbe_return;
001003  }
001004  
001005  /* Opcode: Integer P1 P2 * * *
001006  ** Synopsis: r[P2]=P1
001007  **
001008  ** The 32-bit integer value P1 is written into register P2.
001009  */
001010  case OP_Integer: {         /* out2 */
001011    pOut = out2Prerelease(p, pOp);
001012    pOut->u.i = pOp->p1;
001013    break;
001014  }
001015  
001016  /* Opcode: Int64 * P2 * P4 *
001017  ** Synopsis: r[P2]=P4
001018  **
001019  ** P4 is a pointer to a 64-bit integer value.
001020  ** Write that value into register P2.
001021  */
001022  case OP_Int64: {           /* out2 */
001023    pOut = out2Prerelease(p, pOp);
001024    assert( pOp->p4.pI64!=0 );
001025    pOut->u.i = *pOp->p4.pI64;
001026    break;
001027  }
001028  
001029  #ifndef SQLITE_OMIT_FLOATING_POINT
001030  /* Opcode: Real * P2 * P4 *
001031  ** Synopsis: r[P2]=P4
001032  **
001033  ** P4 is a pointer to a 64-bit floating point value.
001034  ** Write that value into register P2.
001035  */
001036  case OP_Real: {            /* same as TK_FLOAT, out2 */
001037    pOut = out2Prerelease(p, pOp);
001038    pOut->flags = MEM_Real;
001039    assert( !sqlite3IsNaN(*pOp->p4.pReal) );
001040    pOut->u.r = *pOp->p4.pReal;
001041    break;
001042  }
001043  #endif
001044  
001045  /* Opcode: String8 * P2 * P4 *
001046  ** Synopsis: r[P2]='P4'
001047  **
001048  ** P4 points to a nul terminated UTF-8 string. This opcode is transformed 
001049  ** into a String opcode before it is executed for the first time.  During
001050  ** this transformation, the length of string P4 is computed and stored
001051  ** as the P1 parameter.
001052  */
001053  case OP_String8: {         /* same as TK_STRING, out2 */
001054    assert( pOp->p4.z!=0 );
001055    pOut = out2Prerelease(p, pOp);
001056    pOp->opcode = OP_String;
001057    pOp->p1 = sqlite3Strlen30(pOp->p4.z);
001058  
001059  #ifndef SQLITE_OMIT_UTF16
001060    if( encoding!=SQLITE_UTF8 ){
001061      rc = sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
001062      assert( rc==SQLITE_OK || rc==SQLITE_TOOBIG );
001063      if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
001064      assert( pOut->szMalloc>0 && pOut->zMalloc==pOut->z );
001065      assert( VdbeMemDynamic(pOut)==0 );
001066      pOut->szMalloc = 0;
001067      pOut->flags |= MEM_Static;
001068      if( pOp->p4type==P4_DYNAMIC ){
001069        sqlite3DbFree(db, pOp->p4.z);
001070      }
001071      pOp->p4type = P4_DYNAMIC;
001072      pOp->p4.z = pOut->z;
001073      pOp->p1 = pOut->n;
001074    }
001075    testcase( rc==SQLITE_TOOBIG );
001076  #endif
001077    if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
001078      goto too_big;
001079    }
001080    assert( rc==SQLITE_OK );
001081    /* Fall through to the next case, OP_String */
001082  }
001083    
001084  /* Opcode: String P1 P2 P3 P4 P5
001085  ** Synopsis: r[P2]='P4' (len=P1)
001086  **
001087  ** The string value P4 of length P1 (bytes) is stored in register P2.
001088  **
001089  ** If P3 is not zero and the content of register P3 is equal to P5, then
001090  ** the datatype of the register P2 is converted to BLOB.  The content is
001091  ** the same sequence of bytes, it is merely interpreted as a BLOB instead
001092  ** of a string, as if it had been CAST.  In other words:
001093  **
001094  ** if( P3!=0 and reg[P3]==P5 ) reg[P2] := CAST(reg[P2] as BLOB)
001095  */
001096  case OP_String: {          /* out2 */
001097    assert( pOp->p4.z!=0 );
001098    pOut = out2Prerelease(p, pOp);
001099    pOut->flags = MEM_Str|MEM_Static|MEM_Term;
001100    pOut->z = pOp->p4.z;
001101    pOut->n = pOp->p1;
001102    pOut->enc = encoding;
001103    UPDATE_MAX_BLOBSIZE(pOut);
001104  #ifndef SQLITE_LIKE_DOESNT_MATCH_BLOBS
001105    if( pOp->p3>0 ){
001106      assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
001107      pIn3 = &aMem[pOp->p3];
001108      assert( pIn3->flags & MEM_Int );
001109      if( pIn3->u.i==pOp->p5 ) pOut->flags = MEM_Blob|MEM_Static|MEM_Term;
001110    }
001111  #endif
001112    break;
001113  }
001114  
001115  /* Opcode: Null P1 P2 P3 * *
001116  ** Synopsis: r[P2..P3]=NULL
001117  **
001118  ** Write a NULL into registers P2.  If P3 greater than P2, then also write
001119  ** NULL into register P3 and every register in between P2 and P3.  If P3
001120  ** is less than P2 (typically P3 is zero) then only register P2 is
001121  ** set to NULL.
001122  **
001123  ** If the P1 value is non-zero, then also set the MEM_Cleared flag so that
001124  ** NULL values will not compare equal even if SQLITE_NULLEQ is set on
001125  ** OP_Ne or OP_Eq.
001126  */
001127  case OP_Null: {           /* out2 */
001128    int cnt;
001129    u16 nullFlag;
001130    pOut = out2Prerelease(p, pOp);
001131    cnt = pOp->p3-pOp->p2;
001132    assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
001133    pOut->flags = nullFlag = pOp->p1 ? (MEM_Null|MEM_Cleared) : MEM_Null;
001134    pOut->n = 0;
001135    while( cnt>0 ){
001136      pOut++;
001137      memAboutToChange(p, pOut);
001138      sqlite3VdbeMemSetNull(pOut);
001139      pOut->flags = nullFlag;
001140      pOut->n = 0;
001141      cnt--;
001142    }
001143    break;
001144  }
001145  
001146  /* Opcode: SoftNull P1 * * * *
001147  ** Synopsis: r[P1]=NULL
001148  **
001149  ** Set register P1 to have the value NULL as seen by the OP_MakeRecord
001150  ** instruction, but do not free any string or blob memory associated with
001151  ** the register, so that if the value was a string or blob that was
001152  ** previously copied using OP_SCopy, the copies will continue to be valid.
001153  */
001154  case OP_SoftNull: {
001155    assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
001156    pOut = &aMem[pOp->p1];
001157    pOut->flags = (pOut->flags&~(MEM_Undefined|MEM_AffMask))|MEM_Null;
001158    break;
001159  }
001160  
001161  /* Opcode: Blob P1 P2 * P4 *
001162  ** Synopsis: r[P2]=P4 (len=P1)
001163  **
001164  ** P4 points to a blob of data P1 bytes long.  Store this
001165  ** blob in register P2.
001166  */
001167  case OP_Blob: {                /* out2 */
001168    assert( pOp->p1 <= SQLITE_MAX_LENGTH );
001169    pOut = out2Prerelease(p, pOp);
001170    sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
001171    pOut->enc = encoding;
001172    UPDATE_MAX_BLOBSIZE(pOut);
001173    break;
001174  }
001175  
001176  /* Opcode: Variable P1 P2 * P4 *
001177  ** Synopsis: r[P2]=parameter(P1,P4)
001178  **
001179  ** Transfer the values of bound parameter P1 into register P2
001180  **
001181  ** If the parameter is named, then its name appears in P4.
001182  ** The P4 value is used by sqlite3_bind_parameter_name().
001183  */
001184  case OP_Variable: {            /* out2 */
001185    Mem *pVar;       /* Value being transferred */
001186  
001187    assert( pOp->p1>0 && pOp->p1<=p->nVar );
001188    assert( pOp->p4.z==0 || pOp->p4.z==sqlite3VListNumToName(p->pVList,pOp->p1) );
001189    pVar = &p->aVar[pOp->p1 - 1];
001190    if( sqlite3VdbeMemTooBig(pVar) ){
001191      goto too_big;
001192    }
001193    pOut = &aMem[pOp->p2];
001194    sqlite3VdbeMemShallowCopy(pOut, pVar, MEM_Static);
001195    UPDATE_MAX_BLOBSIZE(pOut);
001196    break;
001197  }
001198  
001199  /* Opcode: Move P1 P2 P3 * *
001200  ** Synopsis: r[P2@P3]=r[P1@P3]
001201  **
001202  ** Move the P3 values in register P1..P1+P3-1 over into
001203  ** registers P2..P2+P3-1.  Registers P1..P1+P3-1 are
001204  ** left holding a NULL.  It is an error for register ranges
001205  ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.  It is an error
001206  ** for P3 to be less than 1.
001207  */
001208  case OP_Move: {
001209    int n;           /* Number of registers left to copy */
001210    int p1;          /* Register to copy from */
001211    int p2;          /* Register to copy to */
001212  
001213    n = pOp->p3;
001214    p1 = pOp->p1;
001215    p2 = pOp->p2;
001216    assert( n>0 && p1>0 && p2>0 );
001217    assert( p1+n<=p2 || p2+n<=p1 );
001218  
001219    pIn1 = &aMem[p1];
001220    pOut = &aMem[p2];
001221    do{
001222      assert( pOut<=&aMem[(p->nMem+1 - p->nCursor)] );
001223      assert( pIn1<=&aMem[(p->nMem+1 - p->nCursor)] );
001224      assert( memIsValid(pIn1) );
001225      memAboutToChange(p, pOut);
001226      sqlite3VdbeMemMove(pOut, pIn1);
001227  #ifdef SQLITE_DEBUG
001228      if( pOut->pScopyFrom>=&aMem[p1] && pOut->pScopyFrom<pOut ){
001229        pOut->pScopyFrom += pOp->p2 - p1;
001230      }
001231  #endif
001232      Deephemeralize(pOut);
001233      REGISTER_TRACE(p2++, pOut);
001234      pIn1++;
001235      pOut++;
001236    }while( --n );
001237    break;
001238  }
001239  
001240  /* Opcode: Copy P1 P2 P3 * *
001241  ** Synopsis: r[P2@P3+1]=r[P1@P3+1]
001242  **
001243  ** Make a copy of registers P1..P1+P3 into registers P2..P2+P3.
001244  **
001245  ** This instruction makes a deep copy of the value.  A duplicate
001246  ** is made of any string or blob constant.  See also OP_SCopy.
001247  */
001248  case OP_Copy: {
001249    int n;
001250  
001251    n = pOp->p3;
001252    pIn1 = &aMem[pOp->p1];
001253    pOut = &aMem[pOp->p2];
001254    assert( pOut!=pIn1 );
001255    while( 1 ){
001256      sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
001257      Deephemeralize(pOut);
001258  #ifdef SQLITE_DEBUG
001259      pOut->pScopyFrom = 0;
001260  #endif
001261      REGISTER_TRACE(pOp->p2+pOp->p3-n, pOut);
001262      if( (n--)==0 ) break;
001263      pOut++;
001264      pIn1++;
001265    }
001266    break;
001267  }
001268  
001269  /* Opcode: SCopy P1 P2 * * *
001270  ** Synopsis: r[P2]=r[P1]
001271  **
001272  ** Make a shallow copy of register P1 into register P2.
001273  **
001274  ** This instruction makes a shallow copy of the value.  If the value
001275  ** is a string or blob, then the copy is only a pointer to the
001276  ** original and hence if the original changes so will the copy.
001277  ** Worse, if the original is deallocated, the copy becomes invalid.
001278  ** Thus the program must guarantee that the original will not change
001279  ** during the lifetime of the copy.  Use OP_Copy to make a complete
001280  ** copy.
001281  */
001282  case OP_SCopy: {            /* out2 */
001283    pIn1 = &aMem[pOp->p1];
001284    pOut = &aMem[pOp->p2];
001285    assert( pOut!=pIn1 );
001286    sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
001287  #ifdef SQLITE_DEBUG
001288    if( pOut->pScopyFrom==0 ) pOut->pScopyFrom = pIn1;
001289  #endif
001290    break;
001291  }
001292  
001293  /* Opcode: IntCopy P1 P2 * * *
001294  ** Synopsis: r[P2]=r[P1]
001295  **
001296  ** Transfer the integer value held in register P1 into register P2.
001297  **
001298  ** This is an optimized version of SCopy that works only for integer
001299  ** values.
001300  */
001301  case OP_IntCopy: {            /* out2 */
001302    pIn1 = &aMem[pOp->p1];
001303    assert( (pIn1->flags & MEM_Int)!=0 );
001304    pOut = &aMem[pOp->p2];
001305    sqlite3VdbeMemSetInt64(pOut, pIn1->u.i);
001306    break;
001307  }
001308  
001309  /* Opcode: ResultRow P1 P2 * * *
001310  ** Synopsis: output=r[P1@P2]
001311  **
001312  ** The registers P1 through P1+P2-1 contain a single row of
001313  ** results. This opcode causes the sqlite3_step() call to terminate
001314  ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
001315  ** structure to provide access to the r(P1)..r(P1+P2-1) values as
001316  ** the result row.
001317  */
001318  case OP_ResultRow: {
001319    Mem *pMem;
001320    int i;
001321    assert( p->nResColumn==pOp->p2 );
001322    assert( pOp->p1>0 );
001323    assert( pOp->p1+pOp->p2<=(p->nMem+1 - p->nCursor)+1 );
001324  
001325  #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
001326    /* Run the progress counter just before returning.
001327    */
001328    if( db->xProgress!=0
001329     && nVmStep>=nProgressLimit 
001330     && db->xProgress(db->pProgressArg)!=0
001331    ){
001332      rc = SQLITE_INTERRUPT;
001333      goto abort_due_to_error;
001334    }
001335  #endif
001336  
001337    /* If this statement has violated immediate foreign key constraints, do
001338    ** not return the number of rows modified. And do not RELEASE the statement
001339    ** transaction. It needs to be rolled back.  */
001340    if( SQLITE_OK!=(rc = sqlite3VdbeCheckFk(p, 0)) ){
001341      assert( db->flags&SQLITE_CountRows );
001342      assert( p->usesStmtJournal );
001343      goto abort_due_to_error;
001344    }
001345  
001346    /* If the SQLITE_CountRows flag is set in sqlite3.flags mask, then 
001347    ** DML statements invoke this opcode to return the number of rows 
001348    ** modified to the user. This is the only way that a VM that
001349    ** opens a statement transaction may invoke this opcode.
001350    **
001351    ** In case this is such a statement, close any statement transaction
001352    ** opened by this VM before returning control to the user. This is to
001353    ** ensure that statement-transactions are always nested, not overlapping.
001354    ** If the open statement-transaction is not closed here, then the user
001355    ** may step another VM that opens its own statement transaction. This
001356    ** may lead to overlapping statement transactions.
001357    **
001358    ** The statement transaction is never a top-level transaction.  Hence
001359    ** the RELEASE call below can never fail.
001360    */
001361    assert( p->iStatement==0 || db->flags&SQLITE_CountRows );
001362    rc = sqlite3VdbeCloseStatement(p, SAVEPOINT_RELEASE);
001363    assert( rc==SQLITE_OK );
001364  
001365    /* Invalidate all ephemeral cursor row caches */
001366    p->cacheCtr = (p->cacheCtr + 2)|1;
001367  
001368    /* Make sure the results of the current row are \000 terminated
001369    ** and have an assigned type.  The results are de-ephemeralized as
001370    ** a side effect.
001371    */
001372    pMem = p->pResultSet = &aMem[pOp->p1];
001373    for(i=0; i<pOp->p2; i++){
001374      assert( memIsValid(&pMem[i]) );
001375      Deephemeralize(&pMem[i]);
001376      assert( (pMem[i].flags & MEM_Ephem)==0
001377              || (pMem[i].flags & (MEM_Str|MEM_Blob))==0 );
001378      sqlite3VdbeMemNulTerminate(&pMem[i]);
001379      REGISTER_TRACE(pOp->p1+i, &pMem[i]);
001380    }
001381    if( db->mallocFailed ) goto no_mem;
001382  
001383    if( db->mTrace & SQLITE_TRACE_ROW ){
001384      db->xTrace(SQLITE_TRACE_ROW, db->pTraceArg, p, 0);
001385    }
001386  
001387    /* Return SQLITE_ROW
001388    */
001389    p->pc = (int)(pOp - aOp) + 1;
001390    rc = SQLITE_ROW;
001391    goto vdbe_return;
001392  }
001393  
001394  /* Opcode: Concat P1 P2 P3 * *
001395  ** Synopsis: r[P3]=r[P2]+r[P1]
001396  **
001397  ** Add the text in register P1 onto the end of the text in
001398  ** register P2 and store the result in register P3.
001399  ** If either the P1 or P2 text are NULL then store NULL in P3.
001400  **
001401  **   P3 = P2 || P1
001402  **
001403  ** It is illegal for P1 and P3 to be the same register. Sometimes,
001404  ** if P3 is the same register as P2, the implementation is able
001405  ** to avoid a memcpy().
001406  */
001407  case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
001408    i64 nByte;
001409  
001410    pIn1 = &aMem[pOp->p1];
001411    pIn2 = &aMem[pOp->p2];
001412    pOut = &aMem[pOp->p3];
001413    assert( pIn1!=pOut );
001414    if( (pIn1->flags | pIn2->flags) & MEM_Null ){
001415      sqlite3VdbeMemSetNull(pOut);
001416      break;
001417    }
001418    if( ExpandBlob(pIn1) || ExpandBlob(pIn2) ) goto no_mem;
001419    Stringify(pIn1, encoding);
001420    Stringify(pIn2, encoding);
001421    nByte = pIn1->n + pIn2->n;
001422    if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
001423      goto too_big;
001424    }
001425    if( sqlite3VdbeMemGrow(pOut, (int)nByte+2, pOut==pIn2) ){
001426      goto no_mem;
001427    }
001428    MemSetTypeFlag(pOut, MEM_Str);
001429    if( pOut!=pIn2 ){
001430      memcpy(pOut->z, pIn2->z, pIn2->n);
001431    }
001432    memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
001433    pOut->z[nByte]=0;
001434    pOut->z[nByte+1] = 0;
001435    pOut->flags |= MEM_Term;
001436    pOut->n = (int)nByte;
001437    pOut->enc = encoding;
001438    UPDATE_MAX_BLOBSIZE(pOut);
001439    break;
001440  }
001441  
001442  /* Opcode: Add P1 P2 P3 * *
001443  ** Synopsis: r[P3]=r[P1]+r[P2]
001444  **
001445  ** Add the value in register P1 to the value in register P2
001446  ** and store the result in register P3.
001447  ** If either input is NULL, the result is NULL.
001448  */
001449  /* Opcode: Multiply P1 P2 P3 * *
001450  ** Synopsis: r[P3]=r[P1]*r[P2]
001451  **
001452  **
001453  ** Multiply the value in register P1 by the value in register P2
001454  ** and store the result in register P3.
001455  ** If either input is NULL, the result is NULL.
001456  */
001457  /* Opcode: Subtract P1 P2 P3 * *
001458  ** Synopsis: r[P3]=r[P2]-r[P1]
001459  **
001460  ** Subtract the value in register P1 from the value in register P2
001461  ** and store the result in register P3.
001462  ** If either input is NULL, the result is NULL.
001463  */
001464  /* Opcode: Divide P1 P2 P3 * *
001465  ** Synopsis: r[P3]=r[P2]/r[P1]
001466  **
001467  ** Divide the value in register P1 by the value in register P2
001468  ** and store the result in register P3 (P3=P2/P1). If the value in 
001469  ** register P1 is zero, then the result is NULL. If either input is 
001470  ** NULL, the result is NULL.
001471  */
001472  /* Opcode: Remainder P1 P2 P3 * *
001473  ** Synopsis: r[P3]=r[P2]%r[P1]
001474  **
001475  ** Compute the remainder after integer register P2 is divided by 
001476  ** register P1 and store the result in register P3. 
001477  ** If the value in register P1 is zero the result is NULL.
001478  ** If either operand is NULL, the result is NULL.
001479  */
001480  case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */
001481  case OP_Subtract:              /* same as TK_MINUS, in1, in2, out3 */
001482  case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */
001483  case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */
001484  case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */
001485    char bIntint;   /* Started out as two integer operands */
001486    u16 flags;      /* Combined MEM_* flags from both inputs */
001487    u16 type1;      /* Numeric type of left operand */
001488    u16 type2;      /* Numeric type of right operand */
001489    i64 iA;         /* Integer value of left operand */
001490    i64 iB;         /* Integer value of right operand */
001491    double rA;      /* Real value of left operand */
001492    double rB;      /* Real value of right operand */
001493  
001494    pIn1 = &aMem[pOp->p1];
001495    type1 = numericType(pIn1);
001496    pIn2 = &aMem[pOp->p2];
001497    type2 = numericType(pIn2);
001498    pOut = &aMem[pOp->p3];
001499    flags = pIn1->flags | pIn2->flags;
001500    if( (type1 & type2 & MEM_Int)!=0 ){
001501      iA = pIn1->u.i;
001502      iB = pIn2->u.i;
001503      bIntint = 1;
001504      switch( pOp->opcode ){
001505        case OP_Add:       if( sqlite3AddInt64(&iB,iA) ) goto fp_math;  break;
001506        case OP_Subtract:  if( sqlite3SubInt64(&iB,iA) ) goto fp_math;  break;
001507        case OP_Multiply:  if( sqlite3MulInt64(&iB,iA) ) goto fp_math;  break;
001508        case OP_Divide: {
001509          if( iA==0 ) goto arithmetic_result_is_null;
001510          if( iA==-1 && iB==SMALLEST_INT64 ) goto fp_math;
001511          iB /= iA;
001512          break;
001513        }
001514        default: {
001515          if( iA==0 ) goto arithmetic_result_is_null;
001516          if( iA==-1 ) iA = 1;
001517          iB %= iA;
001518          break;
001519        }
001520      }
001521      pOut->u.i = iB;
001522      MemSetTypeFlag(pOut, MEM_Int);
001523    }else if( (flags & MEM_Null)!=0 ){
001524      goto arithmetic_result_is_null;
001525    }else{
001526      bIntint = 0;
001527  fp_math:
001528      rA = sqlite3VdbeRealValue(pIn1);
001529      rB = sqlite3VdbeRealValue(pIn2);
001530      switch( pOp->opcode ){
001531        case OP_Add:         rB += rA;       break;
001532        case OP_Subtract:    rB -= rA;       break;
001533        case OP_Multiply:    rB *= rA;       break;
001534        case OP_Divide: {
001535          /* (double)0 In case of SQLITE_OMIT_FLOATING_POINT... */
001536          if( rA==(double)0 ) goto arithmetic_result_is_null;
001537          rB /= rA;
001538          break;
001539        }
001540        default: {
001541          iA = (i64)rA;
001542          iB = (i64)rB;
001543          if( iA==0 ) goto arithmetic_result_is_null;
001544          if( iA==-1 ) iA = 1;
001545          rB = (double)(iB % iA);
001546          break;
001547        }
001548      }
001549  #ifdef SQLITE_OMIT_FLOATING_POINT
001550      pOut->u.i = rB;
001551      MemSetTypeFlag(pOut, MEM_Int);
001552  #else
001553      if( sqlite3IsNaN(rB) ){
001554        goto arithmetic_result_is_null;
001555      }
001556      pOut->u.r = rB;
001557      MemSetTypeFlag(pOut, MEM_Real);
001558      if( ((type1|type2)&MEM_Real)==0 && !bIntint ){
001559        sqlite3VdbeIntegerAffinity(pOut);
001560      }
001561  #endif
001562    }
001563    break;
001564  
001565  arithmetic_result_is_null:
001566    sqlite3VdbeMemSetNull(pOut);
001567    break;
001568  }
001569  
001570  /* Opcode: CollSeq P1 * * P4
001571  **
001572  ** P4 is a pointer to a CollSeq object. If the next call to a user function
001573  ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
001574  ** be returned. This is used by the built-in min(), max() and nullif()
001575  ** functions.
001576  **
001577  ** If P1 is not zero, then it is a register that a subsequent min() or
001578  ** max() aggregate will set to 1 if the current row is not the minimum or
001579  ** maximum.  The P1 register is initialized to 0 by this instruction.
001580  **
001581  ** The interface used by the implementation of the aforementioned functions
001582  ** to retrieve the collation sequence set by this opcode is not available
001583  ** publicly.  Only built-in functions have access to this feature.
001584  */
001585  case OP_CollSeq: {
001586    assert( pOp->p4type==P4_COLLSEQ );
001587    if( pOp->p1 ){
001588      sqlite3VdbeMemSetInt64(&aMem[pOp->p1], 0);
001589    }
001590    break;
001591  }
001592  
001593  /* Opcode: BitAnd P1 P2 P3 * *
001594  ** Synopsis: r[P3]=r[P1]&r[P2]
001595  **
001596  ** Take the bit-wise AND of the values in register P1 and P2 and
001597  ** store the result in register P3.
001598  ** If either input is NULL, the result is NULL.
001599  */
001600  /* Opcode: BitOr P1 P2 P3 * *
001601  ** Synopsis: r[P3]=r[P1]|r[P2]
001602  **
001603  ** Take the bit-wise OR of the values in register P1 and P2 and
001604  ** store the result in register P3.
001605  ** If either input is NULL, the result is NULL.
001606  */
001607  /* Opcode: ShiftLeft P1 P2 P3 * *
001608  ** Synopsis: r[P3]=r[P2]<<r[P1]
001609  **
001610  ** Shift the integer value in register P2 to the left by the
001611  ** number of bits specified by the integer in register P1.
001612  ** Store the result in register P3.
001613  ** If either input is NULL, the result is NULL.
001614  */
001615  /* Opcode: ShiftRight P1 P2 P3 * *
001616  ** Synopsis: r[P3]=r[P2]>>r[P1]
001617  **
001618  ** Shift the integer value in register P2 to the right by the
001619  ** number of bits specified by the integer in register P1.
001620  ** Store the result in register P3.
001621  ** If either input is NULL, the result is NULL.
001622  */
001623  case OP_BitAnd:                 /* same as TK_BITAND, in1, in2, out3 */
001624  case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */
001625  case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */
001626  case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */
001627    i64 iA;
001628    u64 uA;
001629    i64 iB;
001630    u8 op;
001631  
001632    pIn1 = &aMem[pOp->p1];
001633    pIn2 = &aMem[pOp->p2];
001634    pOut = &aMem[pOp->p3];
001635    if( (pIn1->flags | pIn2->flags) & MEM_Null ){
001636      sqlite3VdbeMemSetNull(pOut);
001637      break;
001638    }
001639    iA = sqlite3VdbeIntValue(pIn2);
001640    iB = sqlite3VdbeIntValue(pIn1);
001641    op = pOp->opcode;
001642    if( op==OP_BitAnd ){
001643      iA &= iB;
001644    }else if( op==OP_BitOr ){
001645      iA |= iB;
001646    }else if( iB!=0 ){
001647      assert( op==OP_ShiftRight || op==OP_ShiftLeft );
001648  
001649      /* If shifting by a negative amount, shift in the other direction */
001650      if( iB<0 ){
001651        assert( OP_ShiftRight==OP_ShiftLeft+1 );
001652        op = 2*OP_ShiftLeft + 1 - op;
001653        iB = iB>(-64) ? -iB : 64;
001654      }
001655  
001656      if( iB>=64 ){
001657        iA = (iA>=0 || op==OP_ShiftLeft) ? 0 : -1;
001658      }else{
001659        memcpy(&uA, &iA, sizeof(uA));
001660        if( op==OP_ShiftLeft ){
001661          uA <<= iB;
001662        }else{
001663          uA >>= iB;
001664          /* Sign-extend on a right shift of a negative number */
001665          if( iA<0 ) uA |= ((((u64)0xffffffff)<<32)|0xffffffff) << (64-iB);
001666        }
001667        memcpy(&iA, &uA, sizeof(iA));
001668      }
001669    }
001670    pOut->u.i = iA;
001671    MemSetTypeFlag(pOut, MEM_Int);
001672    break;
001673  }
001674  
001675  /* Opcode: AddImm  P1 P2 * * *
001676  ** Synopsis: r[P1]=r[P1]+P2
001677  ** 
001678  ** Add the constant P2 to the value in register P1.
001679  ** The result is always an integer.
001680  **
001681  ** To force any register to be an integer, just add 0.
001682  */
001683  case OP_AddImm: {            /* in1 */
001684    pIn1 = &aMem[pOp->p1];
001685    memAboutToChange(p, pIn1);
001686    sqlite3VdbeMemIntegerify(pIn1);
001687    pIn1->u.i += pOp->p2;
001688    break;
001689  }
001690  
001691  /* Opcode: MustBeInt P1 P2 * * *
001692  ** 
001693  ** Force the value in register P1 to be an integer.  If the value
001694  ** in P1 is not an integer and cannot be converted into an integer
001695  ** without data loss, then jump immediately to P2, or if P2==0
001696  ** raise an SQLITE_MISMATCH exception.
001697  */
001698  case OP_MustBeInt: {            /* jump, in1 */
001699    pIn1 = &aMem[pOp->p1];
001700    if( (pIn1->flags & MEM_Int)==0 ){
001701      applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
001702      VdbeBranchTaken((pIn1->flags&MEM_Int)==0, 2);
001703      if( (pIn1->flags & MEM_Int)==0 ){
001704        if( pOp->p2==0 ){
001705          rc = SQLITE_MISMATCH;
001706          goto abort_due_to_error;
001707        }else{
001708          goto jump_to_p2;
001709        }
001710      }
001711    }
001712    MemSetTypeFlag(pIn1, MEM_Int);
001713    break;
001714  }
001715  
001716  #ifndef SQLITE_OMIT_FLOATING_POINT
001717  /* Opcode: RealAffinity P1 * * * *
001718  **
001719  ** If register P1 holds an integer convert it to a real value.
001720  **
001721  ** This opcode is used when extracting information from a column that
001722  ** has REAL affinity.  Such column values may still be stored as
001723  ** integers, for space efficiency, but after extraction we want them
001724  ** to have only a real value.
001725  */
001726  case OP_RealAffinity: {                  /* in1 */
001727    pIn1 = &aMem[pOp->p1];
001728    if( pIn1->flags & MEM_Int ){
001729      sqlite3VdbeMemRealify(pIn1);
001730    }
001731    break;
001732  }
001733  #endif
001734  
001735  #ifndef SQLITE_OMIT_CAST
001736  /* Opcode: Cast P1 P2 * * *
001737  ** Synopsis: affinity(r[P1])
001738  **
001739  ** Force the value in register P1 to be the type defined by P2.
001740  ** 
001741  ** <ul>
001742  ** <li> P2=='A' &rarr; BLOB
001743  ** <li> P2=='B' &rarr; TEXT
001744  ** <li> P2=='C' &rarr; NUMERIC
001745  ** <li> P2=='D' &rarr; INTEGER
001746  ** <li> P2=='E' &rarr; REAL
001747  ** </ul>
001748  **
001749  ** A NULL value is not changed by this routine.  It remains NULL.
001750  */
001751  case OP_Cast: {                  /* in1 */
001752    assert( pOp->p2>=SQLITE_AFF_BLOB && pOp->p2<=SQLITE_AFF_REAL );
001753    testcase( pOp->p2==SQLITE_AFF_TEXT );
001754    testcase( pOp->p2==SQLITE_AFF_BLOB );
001755    testcase( pOp->p2==SQLITE_AFF_NUMERIC );
001756    testcase( pOp->p2==SQLITE_AFF_INTEGER );
001757    testcase( pOp->p2==SQLITE_AFF_REAL );
001758    pIn1 = &aMem[pOp->p1];
001759    memAboutToChange(p, pIn1);
001760    rc = ExpandBlob(pIn1);
001761    sqlite3VdbeMemCast(pIn1, pOp->p2, encoding);
001762    UPDATE_MAX_BLOBSIZE(pIn1);
001763    if( rc ) goto abort_due_to_error;
001764    break;
001765  }
001766  #endif /* SQLITE_OMIT_CAST */
001767  
001768  /* Opcode: Eq P1 P2 P3 P4 P5
001769  ** Synopsis: IF r[P3]==r[P1]
001770  **
001771  ** Compare the values in register P1 and P3.  If reg(P3)==reg(P1) then
001772  ** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5, then
001773  ** store the result of comparison in register P2.
001774  **
001775  ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
001776  ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made 
001777  ** to coerce both inputs according to this affinity before the
001778  ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
001779  ** affinity is used. Note that the affinity conversions are stored
001780  ** back into the input registers P1 and P3.  So this opcode can cause
001781  ** persistent changes to registers P1 and P3.
001782  **
001783  ** Once any conversions have taken place, and neither value is NULL, 
001784  ** the values are compared. If both values are blobs then memcmp() is
001785  ** used to determine the results of the comparison.  If both values
001786  ** are text, then the appropriate collating function specified in
001787  ** P4 is used to do the comparison.  If P4 is not specified then
001788  ** memcmp() is used to compare text string.  If both values are
001789  ** numeric, then a numeric comparison is used. If the two values
001790  ** are of different types, then numbers are considered less than
001791  ** strings and strings are considered less than blobs.
001792  **
001793  ** If SQLITE_NULLEQ is set in P5 then the result of comparison is always either
001794  ** true or false and is never NULL.  If both operands are NULL then the result
001795  ** of comparison is true.  If either operand is NULL then the result is false.
001796  ** If neither operand is NULL the result is the same as it would be if
001797  ** the SQLITE_NULLEQ flag were omitted from P5.
001798  **
001799  ** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
001800  ** content of r[P2] is only changed if the new value is NULL or 0 (false).
001801  ** In other words, a prior r[P2] value will not be overwritten by 1 (true).
001802  */
001803  /* Opcode: Ne P1 P2 P3 P4 P5
001804  ** Synopsis: IF r[P3]!=r[P1]
001805  **
001806  ** This works just like the Eq opcode except that the jump is taken if
001807  ** the operands in registers P1 and P3 are not equal.  See the Eq opcode for
001808  ** additional information.
001809  **
001810  ** If both SQLITE_STOREP2 and SQLITE_KEEPNULL flags are set then the
001811  ** content of r[P2] is only changed if the new value is NULL or 1 (true).
001812  ** In other words, a prior r[P2] value will not be overwritten by 0 (false).
001813  */
001814  /* Opcode: Lt P1 P2 P3 P4 P5
001815  ** Synopsis: IF r[P3]<r[P1]
001816  **
001817  ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
001818  ** jump to address P2.  Or if the SQLITE_STOREP2 flag is set in P5 store
001819  ** the result of comparison (0 or 1 or NULL) into register P2.
001820  **
001821  ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
001822  ** reg(P3) is NULL then the take the jump.  If the SQLITE_JUMPIFNULL 
001823  ** bit is clear then fall through if either operand is NULL.
001824  **
001825  ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
001826  ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made 
001827  ** to coerce both inputs according to this affinity before the
001828  ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
001829  ** affinity is used. Note that the affinity conversions are stored
001830  ** back into the input registers P1 and P3.  So this opcode can cause
001831  ** persistent changes to registers P1 and P3.
001832  **
001833  ** Once any conversions have taken place, and neither value is NULL, 
001834  ** the values are compared. If both values are blobs then memcmp() is
001835  ** used to determine the results of the comparison.  If both values
001836  ** are text, then the appropriate collating function specified in
001837  ** P4 is  used to do the comparison.  If P4 is not specified then
001838  ** memcmp() is used to compare text string.  If both values are
001839  ** numeric, then a numeric comparison is used. If the two values
001840  ** are of different types, then numbers are considered less than
001841  ** strings and strings are considered less than blobs.
001842  */
001843  /* Opcode: Le P1 P2 P3 P4 P5
001844  ** Synopsis: IF r[P3]<=r[P1]
001845  **
001846  ** This works just like the Lt opcode except that the jump is taken if
001847  ** the content of register P3 is less than or equal to the content of
001848  ** register P1.  See the Lt opcode for additional information.
001849  */
001850  /* Opcode: Gt P1 P2 P3 P4 P5
001851  ** Synopsis: IF r[P3]>r[P1]
001852  **
001853  ** This works just like the Lt opcode except that the jump is taken if
001854  ** the content of register P3 is greater than the content of
001855  ** register P1.  See the Lt opcode for additional information.
001856  */
001857  /* Opcode: Ge P1 P2 P3 P4 P5
001858  ** Synopsis: IF r[P3]>=r[P1]
001859  **
001860  ** This works just like the Lt opcode except that the jump is taken if
001861  ** the content of register P3 is greater than or equal to the content of
001862  ** register P1.  See the Lt opcode for additional information.
001863  */
001864  case OP_Eq:               /* same as TK_EQ, jump, in1, in3 */
001865  case OP_Ne:               /* same as TK_NE, jump, in1, in3 */
001866  case OP_Lt:               /* same as TK_LT, jump, in1, in3 */
001867  case OP_Le:               /* same as TK_LE, jump, in1, in3 */
001868  case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
001869  case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
001870    int res, res2;      /* Result of the comparison of pIn1 against pIn3 */
001871    char affinity;      /* Affinity to use for comparison */
001872    u16 flags1;         /* Copy of initial value of pIn1->flags */
001873    u16 flags3;         /* Copy of initial value of pIn3->flags */
001874  
001875    pIn1 = &aMem[pOp->p1];
001876    pIn3 = &aMem[pOp->p3];
001877    flags1 = pIn1->flags;
001878    flags3 = pIn3->flags;
001879    if( (flags1 | flags3)&MEM_Null ){
001880      /* One or both operands are NULL */
001881      if( pOp->p5 & SQLITE_NULLEQ ){
001882        /* If SQLITE_NULLEQ is set (which will only happen if the operator is
001883        ** OP_Eq or OP_Ne) then take the jump or not depending on whether
001884        ** or not both operands are null.
001885        */
001886        assert( pOp->opcode==OP_Eq || pOp->opcode==OP_Ne );
001887        assert( (flags1 & MEM_Cleared)==0 );
001888        assert( (pOp->p5 & SQLITE_JUMPIFNULL)==0 );
001889        if( (flags1&flags3&MEM_Null)!=0
001890         && (flags3&MEM_Cleared)==0
001891        ){
001892          res = 0;  /* Operands are equal */
001893        }else{
001894          res = 1;  /* Operands are not equal */
001895        }
001896      }else{
001897        /* SQLITE_NULLEQ is clear and at least one operand is NULL,
001898        ** then the result is always NULL.
001899        ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.
001900        */
001901        if( pOp->p5 & SQLITE_STOREP2 ){
001902          pOut = &aMem[pOp->p2];
001903          iCompare = 1;    /* Operands are not equal */
001904          memAboutToChange(p, pOut);
001905          MemSetTypeFlag(pOut, MEM_Null);
001906          REGISTER_TRACE(pOp->p2, pOut);
001907        }else{
001908          VdbeBranchTaken(2,3);
001909          if( pOp->p5 & SQLITE_JUMPIFNULL ){
001910            goto jump_to_p2;
001911          }
001912        }
001913        break;
001914      }
001915    }else{
001916      /* Neither operand is NULL.  Do a comparison. */
001917      affinity = pOp->p5 & SQLITE_AFF_MASK;
001918      if( affinity>=SQLITE_AFF_NUMERIC ){
001919        if( (flags1 | flags3)&MEM_Str ){
001920          if( (flags1 & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){
001921            applyNumericAffinity(pIn1,0);
001922            testcase( flags3!=pIn3->flags ); /* Possible if pIn1==pIn3 */
001923            flags3 = pIn3->flags;
001924          }
001925          if( (flags3 & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){
001926            applyNumericAffinity(pIn3,0);
001927          }
001928        }
001929        /* Handle the common case of integer comparison here, as an
001930        ** optimization, to avoid a call to sqlite3MemCompare() */
001931        if( (pIn1->flags & pIn3->flags & MEM_Int)!=0 ){
001932          if( pIn3->u.i > pIn1->u.i ){ res = +1; goto compare_op; }
001933          if( pIn3->u.i < pIn1->u.i ){ res = -1; goto compare_op; }
001934          res = 0;
001935          goto compare_op;
001936        }
001937      }else if( affinity==SQLITE_AFF_TEXT ){
001938        if( (flags1 & MEM_Str)==0 && (flags1 & (MEM_Int|MEM_Real))!=0 ){
001939          testcase( pIn1->flags & MEM_Int );
001940          testcase( pIn1->flags & MEM_Real );
001941          sqlite3VdbeMemStringify(pIn1, encoding, 1);
001942          testcase( (flags1&MEM_Dyn) != (pIn1->flags&MEM_Dyn) );
001943          flags1 = (pIn1->flags & ~MEM_TypeMask) | (flags1 & MEM_TypeMask);
001944          assert( pIn1!=pIn3 );
001945        }
001946        if( (flags3 & MEM_Str)==0 && (flags3 & (MEM_Int|MEM_Real))!=0 ){
001947          testcase( pIn3->flags & MEM_Int );
001948          testcase( pIn3->flags & MEM_Real );
001949          sqlite3VdbeMemStringify(pIn3, encoding, 1);
001950          testcase( (flags3&MEM_Dyn) != (pIn3->flags&MEM_Dyn) );
001951          flags3 = (pIn3->flags & ~MEM_TypeMask) | (flags3 & MEM_TypeMask);
001952        }
001953      }
001954      assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
001955      res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
001956    }
001957  compare_op:
001958    /* At this point, res is negative, zero, or positive if reg[P1] is
001959    ** less than, equal to, or greater than reg[P3], respectively.  Compute
001960    ** the answer to this operator in res2, depending on what the comparison
001961    ** operator actually is.  The next block of code depends on the fact
001962    ** that the 6 comparison operators are consecutive integers in this
001963    ** order:  NE, EQ, GT, LE, LT, GE */
001964    assert( OP_Eq==OP_Ne+1 ); assert( OP_Gt==OP_Ne+2 ); assert( OP_Le==OP_Ne+3 );
001965    assert( OP_Lt==OP_Ne+4 ); assert( OP_Ge==OP_Ne+5 );
001966    if( res<0 ){                        /* ne, eq, gt, le, lt, ge */
001967      static const unsigned char aLTb[] = { 1,  0,  0,  1,  1,  0 };
001968      res2 = aLTb[pOp->opcode - OP_Ne];
001969    }else if( res==0 ){
001970      static const unsigned char aEQb[] = { 0,  1,  0,  1,  0,  1 };
001971      res2 = aEQb[pOp->opcode - OP_Ne];
001972    }else{
001973      static const unsigned char aGTb[] = { 1,  0,  1,  0,  0,  1 };
001974      res2 = aGTb[pOp->opcode - OP_Ne];
001975    }
001976  
001977    /* Undo any changes made by applyAffinity() to the input registers. */
001978    assert( (pIn1->flags & MEM_Dyn) == (flags1 & MEM_Dyn) );
001979    pIn1->flags = flags1;
001980    assert( (pIn3->flags & MEM_Dyn) == (flags3 & MEM_Dyn) );
001981    pIn3->flags = flags3;
001982  
001983    if( pOp->p5 & SQLITE_STOREP2 ){
001984      pOut = &aMem[pOp->p2];
001985      iCompare = res;
001986      if( (pOp->p5 & SQLITE_KEEPNULL)!=0 ){
001987        /* The KEEPNULL flag prevents OP_Eq from overwriting a NULL with 1
001988        ** and prevents OP_Ne from overwriting NULL with 0.  This flag
001989        ** is only used in contexts where either:
001990        **   (1) op==OP_Eq && (r[P2]==NULL || r[P2]==0)
001991        **   (2) op==OP_Ne && (r[P2]==NULL || r[P2]==1)
001992        ** Therefore it is not necessary to check the content of r[P2] for
001993        ** NULL. */
001994        assert( pOp->opcode==OP_Ne || pOp->opcode==OP_Eq );
001995        assert( res2==0 || res2==1 );
001996        testcase( res2==0 && pOp->opcode==OP_Eq );
001997        testcase( res2==1 && pOp->opcode==OP_Eq );
001998        testcase( res2==0 && pOp->opcode==OP_Ne );
001999        testcase( res2==1 && pOp->opcode==OP_Ne );
002000        if( (pOp->opcode==OP_Eq)==res2 ) break;
002001      }
002002      memAboutToChange(p, pOut);
002003      MemSetTypeFlag(pOut, MEM_Int);
002004      pOut->u.i = res2;
002005      REGISTER_TRACE(pOp->p2, pOut);
002006    }else{
002007      VdbeBranchTaken(res!=0, (pOp->p5 & SQLITE_NULLEQ)?2:3);
002008      if( res2 ){
002009        goto jump_to_p2;
002010      }
002011    }
002012    break;
002013  }
002014  
002015  /* Opcode: ElseNotEq * P2 * * *
002016  **
002017  ** This opcode must immediately follow an OP_Lt or OP_Gt comparison operator.
002018  ** If result of an OP_Eq comparison on the same two operands
002019  ** would have be NULL or false (0), then then jump to P2. 
002020  ** If the result of an OP_Eq comparison on the two previous operands
002021  ** would have been true (1), then fall through.
002022  */
002023  case OP_ElseNotEq: {       /* same as TK_ESCAPE, jump */
002024    assert( pOp>aOp );
002025    assert( pOp[-1].opcode==OP_Lt || pOp[-1].opcode==OP_Gt );
002026    assert( pOp[-1].p5 & SQLITE_STOREP2 );
002027    VdbeBranchTaken(iCompare!=0, 2);
002028    if( iCompare!=0 ) goto jump_to_p2;
002029    break;
002030  }
002031  
002032  
002033  /* Opcode: Permutation * * * P4 *
002034  **
002035  ** Set the permutation used by the OP_Compare operator in the next
002036  ** instruction.  The permutation is stored in the P4 operand.
002037  **
002038  ** The permutation is only valid until the next OP_Compare that has
002039  ** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should 
002040  ** occur immediately prior to the OP_Compare.
002041  **
002042  ** The first integer in the P4 integer array is the length of the array
002043  ** and does not become part of the permutation.
002044  */
002045  case OP_Permutation: {
002046    assert( pOp->p4type==P4_INTARRAY );
002047    assert( pOp->p4.ai );
002048    assert( pOp[1].opcode==OP_Compare );
002049    assert( pOp[1].p5 & OPFLAG_PERMUTE );
002050    break;
002051  }
002052  
002053  /* Opcode: Compare P1 P2 P3 P4 P5
002054  ** Synopsis: r[P1@P3] <-> r[P2@P3]
002055  **
002056  ** Compare two vectors of registers in reg(P1)..reg(P1+P3-1) (call this
002057  ** vector "A") and in reg(P2)..reg(P2+P3-1) ("B").  Save the result of
002058  ** the comparison for use by the next OP_Jump instruct.
002059  **
002060  ** If P5 has the OPFLAG_PERMUTE bit set, then the order of comparison is
002061  ** determined by the most recent OP_Permutation operator.  If the
002062  ** OPFLAG_PERMUTE bit is clear, then register are compared in sequential
002063  ** order.
002064  **
002065  ** P4 is a KeyInfo structure that defines collating sequences and sort
002066  ** orders for the comparison.  The permutation applies to registers
002067  ** only.  The KeyInfo elements are used sequentially.
002068  **
002069  ** The comparison is a sort comparison, so NULLs compare equal,
002070  ** NULLs are less than numbers, numbers are less than strings,
002071  ** and strings are less than blobs.
002072  */
002073  case OP_Compare: {
002074    int n;
002075    int i;
002076    int p1;
002077    int p2;
002078    const KeyInfo *pKeyInfo;
002079    int idx;
002080    CollSeq *pColl;    /* Collating sequence to use on this term */
002081    int bRev;          /* True for DESCENDING sort order */
002082    int *aPermute;     /* The permutation */
002083  
002084    if( (pOp->p5 & OPFLAG_PERMUTE)==0 ){
002085      aPermute = 0;
002086    }else{
002087      assert( pOp>aOp );
002088      assert( pOp[-1].opcode==OP_Permutation );
002089      assert( pOp[-1].p4type==P4_INTARRAY );
002090      aPermute = pOp[-1].p4.ai + 1;
002091      assert( aPermute!=0 );
002092    }
002093    n = pOp->p3;
002094    pKeyInfo = pOp->p4.pKeyInfo;
002095    assert( n>0 );
002096    assert( pKeyInfo!=0 );
002097    p1 = pOp->p1;
002098    p2 = pOp->p2;
002099  #ifdef SQLITE_DEBUG
002100    if( aPermute ){
002101      int k, mx = 0;
002102      for(k=0; k<n; k++) if( aPermute[k]>mx ) mx = aPermute[k];
002103      assert( p1>0 && p1+mx<=(p->nMem+1 - p->nCursor)+1 );
002104      assert( p2>0 && p2+mx<=(p->nMem+1 - p->nCursor)+1 );
002105    }else{
002106      assert( p1>0 && p1+n<=(p->nMem+1 - p->nCursor)+1 );
002107      assert( p2>0 && p2+n<=(p->nMem+1 - p->nCursor)+1 );
002108    }
002109  #endif /* SQLITE_DEBUG */
002110    for(i=0; i<n; i++){
002111      idx = aPermute ? aPermute[i] : i;
002112      assert( memIsValid(&aMem[p1+idx]) );
002113      assert( memIsValid(&aMem[p2+idx]) );
002114      REGISTER_TRACE(p1+idx, &aMem[p1+idx]);
002115      REGISTER_TRACE(p2+idx, &aMem[p2+idx]);
002116      assert( i<pKeyInfo->nKeyField );
002117      pColl = pKeyInfo->aColl[i];
002118      bRev = pKeyInfo->aSortOrder[i];
002119      iCompare = sqlite3MemCompare(&aMem[p1+idx], &aMem[p2+idx], pColl);
002120      if( iCompare ){
002121        if( bRev ) iCompare = -iCompare;
002122        break;
002123      }
002124    }
002125    break;
002126  }
002127  
002128  /* Opcode: Jump P1 P2 P3 * *
002129  **
002130  ** Jump to the instruction at address P1, P2, or P3 depending on whether
002131  ** in the most recent OP_Compare instruction the P1 vector was less than
002132  ** equal to, or greater than the P2 vector, respectively.
002133  */
002134  case OP_Jump: {             /* jump */
002135    if( iCompare<0 ){
002136      VdbeBranchTaken(0,3); pOp = &aOp[pOp->p1 - 1];
002137    }else if( iCompare==0 ){
002138      VdbeBranchTaken(1,3); pOp = &aOp[pOp->p2 - 1];
002139    }else{
002140      VdbeBranchTaken(2,3); pOp = &aOp[pOp->p3 - 1];
002141    }
002142    break;
002143  }
002144  
002145  /* Opcode: And P1 P2 P3 * *
002146  ** Synopsis: r[P3]=(r[P1] && r[P2])
002147  **
002148  ** Take the logical AND of the values in registers P1 and P2 and
002149  ** write the result into register P3.
002150  **
002151  ** If either P1 or P2 is 0 (false) then the result is 0 even if
002152  ** the other input is NULL.  A NULL and true or two NULLs give
002153  ** a NULL output.
002154  */
002155  /* Opcode: Or P1 P2 P3 * *
002156  ** Synopsis: r[P3]=(r[P1] || r[P2])
002157  **
002158  ** Take the logical OR of the values in register P1 and P2 and
002159  ** store the answer in register P3.
002160  **
002161  ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
002162  ** even if the other input is NULL.  A NULL and false or two NULLs
002163  ** give a NULL output.
002164  */
002165  case OP_And:              /* same as TK_AND, in1, in2, out3 */
002166  case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
002167    int v1;    /* Left operand:  0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
002168    int v2;    /* Right operand: 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
002169  
002170    pIn1 = &aMem[pOp->p1];
002171    if( pIn1->flags & MEM_Null ){
002172      v1 = 2;
002173    }else{
002174      v1 = sqlite3VdbeIntValue(pIn1)!=0;
002175    }
002176    pIn2 = &aMem[pOp->p2];
002177    if( pIn2->flags & MEM_Null ){
002178      v2 = 2;
002179    }else{
002180      v2 = sqlite3VdbeIntValue(pIn2)!=0;
002181    }
002182    if( pOp->opcode==OP_And ){
002183      static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
002184      v1 = and_logic[v1*3+v2];
002185    }else{
002186      static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
002187      v1 = or_logic[v1*3+v2];
002188    }
002189    pOut = &aMem[pOp->p3];
002190    if( v1==2 ){
002191      MemSetTypeFlag(pOut, MEM_Null);
002192    }else{
002193      pOut->u.i = v1;
002194      MemSetTypeFlag(pOut, MEM_Int);
002195    }
002196    break;
002197  }
002198  
002199  /* Opcode: Not P1 P2 * * *
002200  ** Synopsis: r[P2]= !r[P1]
002201  **
002202  ** Interpret the value in register P1 as a boolean value.  Store the
002203  ** boolean complement in register P2.  If the value in register P1 is 
002204  ** NULL, then a NULL is stored in P2.
002205  */
002206  case OP_Not: {                /* same as TK_NOT, in1, out2 */
002207    pIn1 = &aMem[pOp->p1];
002208    pOut = &aMem[pOp->p2];
002209    sqlite3VdbeMemSetNull(pOut);
002210    if( (pIn1->flags & MEM_Null)==0 ){
002211      pOut->flags = MEM_Int;
002212      pOut->u.i = !sqlite3VdbeIntValue(pIn1);
002213    }
002214    break;
002215  }
002216  
002217  /* Opcode: BitNot P1 P2 * * *
002218  ** Synopsis: r[P1]= ~r[P1]
002219  **
002220  ** Interpret the content of register P1 as an integer.  Store the
002221  ** ones-complement of the P1 value into register P2.  If P1 holds
002222  ** a NULL then store a NULL in P2.
002223  */
002224  case OP_BitNot: {             /* same as TK_BITNOT, in1, out2 */
002225    pIn1 = &aMem[pOp->p1];
002226    pOut = &aMem[pOp->p2];
002227    sqlite3VdbeMemSetNull(pOut);
002228    if( (pIn1->flags & MEM_Null)==0 ){
002229      pOut->flags = MEM_Int;
002230      pOut->u.i = ~sqlite3VdbeIntValue(pIn1);
002231    }
002232    break;
002233  }
002234  
002235  /* Opcode: Once P1 P2 * * *
002236  **
002237  ** Fall through to the next instruction the first time this opcode is
002238  ** encountered on each invocation of the byte-code program.  Jump to P2
002239  ** on the second and all subsequent encounters during the same invocation.
002240  **
002241  ** Top-level programs determine first invocation by comparing the P1
002242  ** operand against the P1 operand on the OP_Init opcode at the beginning
002243  ** of the program.  If the P1 values differ, then fall through and make
002244  ** the P1 of this opcode equal to the P1 of OP_Init.  If P1 values are
002245  ** the same then take the jump.
002246  **
002247  ** For subprograms, there is a bitmask in the VdbeFrame that determines
002248  ** whether or not the jump should be taken.  The bitmask is necessary
002249  ** because the self-altering code trick does not work for recursive
002250  ** triggers.
002251  */
002252  case OP_Once: {             /* jump */
002253    u32 iAddr;                /* Address of this instruction */
002254    assert( p->aOp[0].opcode==OP_Init );
002255    if( p->pFrame ){
002256      iAddr = (int)(pOp - p->aOp);
002257      if( (p->pFrame->aOnce[iAddr/8] & (1<<(iAddr & 7)))!=0 ){
002258        VdbeBranchTaken(1, 2);
002259        goto jump_to_p2;
002260      }
002261      p->pFrame->aOnce[iAddr/8] |= 1<<(iAddr & 7);
002262    }else{
002263      if( p->aOp[0].p1==pOp->p1 ){
002264        VdbeBranchTaken(1, 2);
002265        goto jump_to_p2;
002266      }
002267    }
002268    VdbeBranchTaken(0, 2);
002269    pOp->p1 = p->aOp[0].p1;
002270    break;
002271  }
002272  
002273  /* Opcode: If P1 P2 P3 * *
002274  **
002275  ** Jump to P2 if the value in register P1 is true.  The value
002276  ** is considered true if it is numeric and non-zero.  If the value
002277  ** in P1 is NULL then take the jump if and only if P3 is non-zero.
002278  */
002279  /* Opcode: IfNot P1 P2 P3 * *
002280  **
002281  ** Jump to P2 if the value in register P1 is False.  The value
002282  ** is considered false if it has a numeric value of zero.  If the value
002283  ** in P1 is NULL then take the jump if and only if P3 is non-zero.
002284  */
002285  case OP_If:                 /* jump, in1 */
002286  case OP_IfNot: {            /* jump, in1 */
002287    int c;
002288    pIn1 = &aMem[pOp->p1];
002289    if( pIn1->flags & MEM_Null ){
002290      c = pOp->p3;
002291    }else{
002292  #ifdef SQLITE_OMIT_FLOATING_POINT
002293      c = sqlite3VdbeIntValue(pIn1)!=0;
002294  #else
002295      c = sqlite3VdbeRealValue(pIn1)!=0.0;
002296  #endif
002297      if( pOp->opcode==OP_IfNot ) c = !c;
002298    }
002299    VdbeBranchTaken(c!=0, 2);
002300    if( c ){
002301      goto jump_to_p2;
002302    }
002303    break;
002304  }
002305  
002306  /* Opcode: IsNull P1 P2 * * *
002307  ** Synopsis: if r[P1]==NULL goto P2
002308  **
002309  ** Jump to P2 if the value in register P1 is NULL.
002310  */
002311  case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
002312    pIn1 = &aMem[pOp->p1];
002313    VdbeBranchTaken( (pIn1->flags & MEM_Null)!=0, 2);
002314    if( (pIn1->flags & MEM_Null)!=0 ){
002315      goto jump_to_p2;
002316    }
002317    break;
002318  }
002319  
002320  /* Opcode: NotNull P1 P2 * * *
002321  ** Synopsis: if r[P1]!=NULL goto P2
002322  **
002323  ** Jump to P2 if the value in register P1 is not NULL.  
002324  */
002325  case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */
002326    pIn1 = &aMem[pOp->p1];
002327    VdbeBranchTaken( (pIn1->flags & MEM_Null)==0, 2);
002328    if( (pIn1->flags & MEM_Null)==0 ){
002329      goto jump_to_p2;
002330    }
002331    break;
002332  }
002333  
002334  /* Opcode: IfNullRow P1 P2 P3 * *
002335  ** Synopsis: if P1.nullRow then r[P3]=NULL, goto P2
002336  **
002337  ** Check the cursor P1 to see if it is currently pointing at a NULL row.
002338  ** If it is, then set register P3 to NULL and jump immediately to P2.
002339  ** If P1 is not on a NULL row, then fall through without making any
002340  ** changes.
002341  */
002342  case OP_IfNullRow: {         /* jump */
002343    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
002344    assert( p->apCsr[pOp->p1]!=0 );
002345    if( p->apCsr[pOp->p1]->nullRow ){
002346      sqlite3VdbeMemSetNull(aMem + pOp->p3);
002347      goto jump_to_p2;
002348    }
002349    break;
002350  }
002351  
002352  /* Opcode: Column P1 P2 P3 P4 P5
002353  ** Synopsis: r[P3]=PX
002354  **
002355  ** Interpret the data that cursor P1 points to as a structure built using
002356  ** the MakeRecord instruction.  (See the MakeRecord opcode for additional
002357  ** information about the format of the data.)  Extract the P2-th column
002358  ** from this record.  If there are less that (P2+1) 
002359  ** values in the record, extract a NULL.
002360  **
002361  ** The value extracted is stored in register P3.
002362  **
002363  ** If the record contains fewer than P2 fields, then extract a NULL.  Or,
002364  ** if the P4 argument is a P4_MEM use the value of the P4 argument as
002365  ** the result.
002366  **
002367  ** If the OPFLAG_CLEARCACHE bit is set on P5 and P1 is a pseudo-table cursor,
002368  ** then the cache of the cursor is reset prior to extracting the column.
002369  ** The first OP_Column against a pseudo-table after the value of the content
002370  ** register has changed should have this bit set.
002371  **
002372  ** If the OPFLAG_LENGTHARG and OPFLAG_TYPEOFARG bits are set on P5 then
002373  ** the result is guaranteed to only be used as the argument of a length()
002374  ** or typeof() function, respectively.  The loading of large blobs can be
002375  ** skipped for length() and all content loading can be skipped for typeof().
002376  */
002377  case OP_Column: {
002378    int p2;            /* column number to retrieve */
002379    VdbeCursor *pC;    /* The VDBE cursor */
002380    BtCursor *pCrsr;   /* The BTree cursor */
002381    u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
002382    int len;           /* The length of the serialized data for the column */
002383    int i;             /* Loop counter */
002384    Mem *pDest;        /* Where to write the extracted value */
002385    Mem sMem;          /* For storing the record being decoded */
002386    const u8 *zData;   /* Part of the record being decoded */
002387    const u8 *zHdr;    /* Next unparsed byte of the header */
002388    const u8 *zEndHdr; /* Pointer to first byte after the header */
002389    u64 offset64;      /* 64-bit offset */
002390    u32 t;             /* A type code from the record header */
002391    Mem *pReg;         /* PseudoTable input register */
002392  
002393    pC = p->apCsr[pOp->p1];
002394    p2 = pOp->p2;
002395  
002396    /* If the cursor cache is stale (meaning it is not currently point at
002397    ** the correct row) then bring it up-to-date by doing the necessary 
002398    ** B-Tree seek. */
002399    rc = sqlite3VdbeCursorMoveto(&pC, &p2);
002400    if( rc ) goto abort_due_to_error;
002401  
002402    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
002403    pDest = &aMem[pOp->p3];
002404    memAboutToChange(p, pDest);
002405    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
002406    assert( pC!=0 );
002407    assert( p2<pC->nField );
002408    aOffset = pC->aOffset;
002409    assert( pC->eCurType!=CURTYPE_VTAB );
002410    assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
002411    assert( pC->eCurType!=CURTYPE_SORTER );
002412  
002413    if( pC->cacheStatus!=p->cacheCtr ){                /*OPTIMIZATION-IF-FALSE*/
002414      if( pC->nullRow ){
002415        if( pC->eCurType==CURTYPE_PSEUDO ){
002416          /* For the special case of as pseudo-cursor, the seekResult field
002417          ** identifies the register that holds the record */
002418          assert( pC->seekResult>0 );
002419          pReg = &aMem[pC->seekResult];
002420          assert( pReg->flags & MEM_Blob );
002421          assert( memIsValid(pReg) );
002422          pC->payloadSize = pC->szRow = pReg->n;
002423          pC->aRow = (u8*)pReg->z;
002424        }else{
002425          sqlite3VdbeMemSetNull(pDest);
002426          goto op_column_out;
002427        }
002428      }else{
002429        pCrsr = pC->uc.pCursor;
002430        assert( pC->eCurType==CURTYPE_BTREE );
002431        assert( pCrsr );
002432        assert( sqlite3BtreeCursorIsValid(pCrsr) );
002433        pC->payloadSize = sqlite3BtreePayloadSize(pCrsr);
002434        pC->aRow = sqlite3BtreePayloadFetch(pCrsr, &pC->szRow);
002435        assert( pC->szRow<=pC->payloadSize );
002436        assert( pC->szRow<=65536 );  /* Maximum page size is 64KiB */
002437        if( pC->payloadSize > (u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
002438          goto too_big;
002439        }
002440      }
002441      pC->cacheStatus = p->cacheCtr;
002442      pC->iHdrOffset = getVarint32(pC->aRow, aOffset[0]);
002443      pC->nHdrParsed = 0;
002444  
002445  
002446      if( pC->szRow<aOffset[0] ){      /*OPTIMIZATION-IF-FALSE*/
002447        /* pC->aRow does not have to hold the entire row, but it does at least
002448        ** need to cover the header of the record.  If pC->aRow does not contain
002449        ** the complete header, then set it to zero, forcing the header to be
002450        ** dynamically allocated. */
002451        pC->aRow = 0;
002452        pC->szRow = 0;
002453  
002454        /* Make sure a corrupt database has not given us an oversize header.
002455        ** Do this now to avoid an oversize memory allocation.
002456        **
002457        ** Type entries can be between 1 and 5 bytes each.  But 4 and 5 byte
002458        ** types use so much data space that there can only be 4096 and 32 of
002459        ** them, respectively.  So the maximum header length results from a
002460        ** 3-byte type for each of the maximum of 32768 columns plus three
002461        ** extra bytes for the header length itself.  32768*3 + 3 = 98307.
002462        */
002463        if( aOffset[0] > 98307 || aOffset[0] > pC->payloadSize ){
002464          goto op_column_corrupt;
002465        }
002466      }else{
002467        /* This is an optimization.  By skipping over the first few tests
002468        ** (ex: pC->nHdrParsed<=p2) in the next section, we achieve a
002469        ** measurable performance gain.
002470        **
002471        ** This branch is taken even if aOffset[0]==0.  Such a record is never
002472        ** generated by SQLite, and could be considered corruption, but we
002473        ** accept it for historical reasons.  When aOffset[0]==0, the code this
002474        ** branch jumps to reads past the end of the record, but never more
002475        ** than a few bytes.  Even if the record occurs at the end of the page
002476        ** content area, the "page header" comes after the page content and so
002477        ** this overread is harmless.  Similar overreads can occur for a corrupt
002478        ** database file.
002479        */
002480        zData = pC->aRow;
002481        assert( pC->nHdrParsed<=p2 );         /* Conditional skipped */
002482        testcase( aOffset[0]==0 );
002483        goto op_column_read_header;
002484      }
002485    }
002486  
002487    /* Make sure at least the first p2+1 entries of the header have been
002488    ** parsed and valid information is in aOffset[] and pC->aType[].
002489    */
002490    if( pC->nHdrParsed<=p2 ){
002491      /* If there is more header available for parsing in the record, try
002492      ** to extract additional fields up through the p2+1-th field 
002493      */
002494      if( pC->iHdrOffset<aOffset[0] ){
002495        /* Make sure zData points to enough of the record to cover the header. */
002496        if( pC->aRow==0 ){
002497          memset(&sMem, 0, sizeof(sMem));
002498          rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, 0, aOffset[0], &sMem);
002499          if( rc!=SQLITE_OK ) goto abort_due_to_error;
002500          zData = (u8*)sMem.z;
002501        }else{
002502          zData = pC->aRow;
002503        }
002504    
002505        /* Fill in pC->aType[i] and aOffset[i] values through the p2-th field. */
002506      op_column_read_header:
002507        i = pC->nHdrParsed;
002508        offset64 = aOffset[i];
002509        zHdr = zData + pC->iHdrOffset;
002510        zEndHdr = zData + aOffset[0];
002511        testcase( zHdr>=zEndHdr );
002512        do{
002513          if( (t = zHdr[0])<0x80 ){
002514            zHdr++;
002515            offset64 += sqlite3VdbeOneByteSerialTypeLen(t);
002516          }else{
002517            zHdr += sqlite3GetVarint32(zHdr, &t);
002518            offset64 += sqlite3VdbeSerialTypeLen(t);
002519          }
002520          pC->aType[i++] = t;
002521          aOffset[i] = (u32)(offset64 & 0xffffffff);
002522        }while( i<=p2 && zHdr<zEndHdr );
002523  
002524        /* The record is corrupt if any of the following are true:
002525        ** (1) the bytes of the header extend past the declared header size
002526        ** (2) the entire header was used but not all data was used
002527        ** (3) the end of the data extends beyond the end of the record.
002528        */
002529        if( (zHdr>=zEndHdr && (zHdr>zEndHdr || offset64!=pC->payloadSize))
002530         || (offset64 > pC->payloadSize)
002531        ){
002532          if( aOffset[0]==0 ){
002533            i = 0;
002534            zHdr = zEndHdr;
002535          }else{
002536            if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
002537            goto op_column_corrupt;
002538          }
002539        }
002540  
002541        pC->nHdrParsed = i;
002542        pC->iHdrOffset = (u32)(zHdr - zData);
002543        if( pC->aRow==0 ) sqlite3VdbeMemRelease(&sMem);
002544      }else{
002545        t = 0;
002546      }
002547  
002548      /* If after trying to extract new entries from the header, nHdrParsed is
002549      ** still not up to p2, that means that the record has fewer than p2
002550      ** columns.  So the result will be either the default value or a NULL.
002551      */
002552      if( pC->nHdrParsed<=p2 ){
002553        if( pOp->p4type==P4_MEM ){
002554          sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
002555        }else{
002556          sqlite3VdbeMemSetNull(pDest);
002557        }
002558        goto op_column_out;
002559      }
002560    }else{
002561      t = pC->aType[p2];
002562    }
002563  
002564    /* Extract the content for the p2+1-th column.  Control can only
002565    ** reach this point if aOffset[p2], aOffset[p2+1], and pC->aType[p2] are
002566    ** all valid.
002567    */
002568    assert( p2<pC->nHdrParsed );
002569    assert( rc==SQLITE_OK );
002570    assert( sqlite3VdbeCheckMemInvariants(pDest) );
002571    if( VdbeMemDynamic(pDest) ){
002572      sqlite3VdbeMemSetNull(pDest);
002573    }
002574    assert( t==pC->aType[p2] );
002575    if( pC->szRow>=aOffset[p2+1] ){
002576      /* This is the common case where the desired content fits on the original
002577      ** page - where the content is not on an overflow page */
002578      zData = pC->aRow + aOffset[p2];
002579      if( t<12 ){
002580        sqlite3VdbeSerialGet(zData, t, pDest);
002581      }else{
002582        /* If the column value is a string, we need a persistent value, not
002583        ** a MEM_Ephem value.  This branch is a fast short-cut that is equivalent
002584        ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize().
002585        */
002586        static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term };
002587        pDest->n = len = (t-12)/2;
002588        pDest->enc = encoding;
002589        if( pDest->szMalloc < len+2 ){
002590          pDest->flags = MEM_Null;
002591          if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem;
002592        }else{
002593          pDest->z = pDest->zMalloc;
002594        }
002595        memcpy(pDest->z, zData, len);
002596        pDest->z[len] = 0;
002597        pDest->z[len+1] = 0;
002598        pDest->flags = aFlag[t&1];
002599      }
002600    }else{
002601      pDest->enc = encoding;
002602      /* This branch happens only when content is on overflow pages */
002603      if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0
002604            && ((t>=12 && (t&1)==0) || (pOp->p5 & OPFLAG_TYPEOFARG)!=0))
002605       || (len = sqlite3VdbeSerialTypeLen(t))==0
002606      ){
002607        /* Content is irrelevant for
002608        **    1. the typeof() function,
002609        **    2. the length(X) function if X is a blob, and
002610        **    3. if the content length is zero.
002611        ** So we might as well use bogus content rather than reading
002612        ** content from disk. 
002613        **
002614        ** Although sqlite3VdbeSerialGet() may read at most 8 bytes from the
002615        ** buffer passed to it, debugging function VdbeMemPrettyPrint() may
002616        ** read up to 16. So 16 bytes of bogus content is supplied.
002617        */
002618        static u8 aZero[16];  /* This is the bogus content */
002619        sqlite3VdbeSerialGet(aZero, t, pDest);
002620      }else{
002621        rc = sqlite3VdbeMemFromBtree(pC->uc.pCursor, aOffset[p2], len, pDest);
002622        if( rc!=SQLITE_OK ) goto abort_due_to_error;
002623        sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
002624        pDest->flags &= ~MEM_Ephem;
002625      }
002626    }
002627  
002628  op_column_out:
002629    UPDATE_MAX_BLOBSIZE(pDest);
002630    REGISTER_TRACE(pOp->p3, pDest);
002631    break;
002632  
002633  op_column_corrupt:
002634    if( aOp[0].p3>0 ){
002635      pOp = &aOp[aOp[0].p3-1];
002636      break;
002637    }else{
002638      rc = SQLITE_CORRUPT_BKPT;
002639      goto abort_due_to_error;
002640    }
002641  }
002642  
002643  /* Opcode: Affinity P1 P2 * P4 *
002644  ** Synopsis: affinity(r[P1@P2])
002645  **
002646  ** Apply affinities to a range of P2 registers starting with P1.
002647  **
002648  ** P4 is a string that is P2 characters long. The N-th character of the
002649  ** string indicates the column affinity that should be used for the N-th
002650  ** memory cell in the range.
002651  */
002652  case OP_Affinity: {
002653    const char *zAffinity;   /* The affinity to be applied */
002654  
002655    zAffinity = pOp->p4.z;
002656    assert( zAffinity!=0 );
002657    assert( pOp->p2>0 );
002658    assert( zAffinity[pOp->p2]==0 );
002659    pIn1 = &aMem[pOp->p1];
002660    do{
002661      assert( pIn1 <= &p->aMem[(p->nMem+1 - p->nCursor)] );
002662      assert( memIsValid(pIn1) );
002663      applyAffinity(pIn1, *(zAffinity++), encoding);
002664      pIn1++;
002665    }while( zAffinity[0] );
002666    break;
002667  }
002668  
002669  /* Opcode: MakeRecord P1 P2 P3 P4 *
002670  ** Synopsis: r[P3]=mkrec(r[P1@P2])
002671  **
002672  ** Convert P2 registers beginning with P1 into the [record format]
002673  ** use as a data record in a database table or as a key
002674  ** in an index.  The OP_Column opcode can decode the record later.
002675  **
002676  ** P4 may be a string that is P2 characters long.  The N-th character of the
002677  ** string indicates the column affinity that should be used for the N-th
002678  ** field of the index key.
002679  **
002680  ** The mapping from character to affinity is given by the SQLITE_AFF_
002681  ** macros defined in sqliteInt.h.
002682  **
002683  ** If P4 is NULL then all index fields have the affinity BLOB.
002684  */
002685  case OP_MakeRecord: {
002686    u8 *zNewRecord;        /* A buffer to hold the data for the new record */
002687    Mem *pRec;             /* The new record */
002688    u64 nData;             /* Number of bytes of data space */
002689    int nHdr;              /* Number of bytes of header space */
002690    i64 nByte;             /* Data space required for this record */
002691    i64 nZero;             /* Number of zero bytes at the end of the record */
002692    int nVarint;           /* Number of bytes in a varint */
002693    u32 serial_type;       /* Type field */
002694    Mem *pData0;           /* First field to be combined into the record */
002695    Mem *pLast;            /* Last field of the record */
002696    int nField;            /* Number of fields in the record */
002697    char *zAffinity;       /* The affinity string for the record */
002698    int file_format;       /* File format to use for encoding */
002699    int i;                 /* Space used in zNewRecord[] header */
002700    int j;                 /* Space used in zNewRecord[] content */
002701    u32 len;               /* Length of a field */
002702  
002703    /* Assuming the record contains N fields, the record format looks
002704    ** like this:
002705    **
002706    ** ------------------------------------------------------------------------
002707    ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | 
002708    ** ------------------------------------------------------------------------
002709    **
002710    ** Data(0) is taken from register P1.  Data(1) comes from register P1+1
002711    ** and so forth.
002712    **
002713    ** Each type field is a varint representing the serial type of the 
002714    ** corresponding data element (see sqlite3VdbeSerialType()). The
002715    ** hdr-size field is also a varint which is the offset from the beginning
002716    ** of the record to data0.
002717    */
002718    nData = 0;         /* Number of bytes of data space */
002719    nHdr = 0;          /* Number of bytes of header space */
002720    nZero = 0;         /* Number of zero bytes at the end of the record */
002721    nField = pOp->p1;
002722    zAffinity = pOp->p4.z;
002723    assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=(p->nMem+1 - p->nCursor)+1 );
002724    pData0 = &aMem[nField];
002725    nField = pOp->p2;
002726    pLast = &pData0[nField-1];
002727    file_format = p->minWriteFileFormat;
002728  
002729    /* Identify the output register */
002730    assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
002731    pOut = &aMem[pOp->p3];
002732    memAboutToChange(p, pOut);
002733  
002734    /* Apply the requested affinity to all inputs
002735    */
002736    assert( pData0<=pLast );
002737    if( zAffinity ){
002738      pRec = pData0;
002739      do{
002740        applyAffinity(pRec++, *(zAffinity++), encoding);
002741        assert( zAffinity[0]==0 || pRec<=pLast );
002742      }while( zAffinity[0] );
002743    }
002744  
002745  #ifdef SQLITE_ENABLE_NULL_TRIM
002746    /* NULLs can be safely trimmed from the end of the record, as long as
002747    ** as the schema format is 2 or more and none of the omitted columns
002748    ** have a non-NULL default value.  Also, the record must be left with
002749    ** at least one field.  If P5>0 then it will be one more than the
002750    ** index of the right-most column with a non-NULL default value */
002751    if( pOp->p5 ){
002752      while( (pLast->flags & MEM_Null)!=0 && nField>pOp->p5 ){
002753        pLast--;
002754        nField--;
002755      }
002756    }
002757  #endif
002758  
002759    /* Loop through the elements that will make up the record to figure
002760    ** out how much space is required for the new record.
002761    */
002762    pRec = pLast;
002763    do{
002764      assert( memIsValid(pRec) );
002765      pRec->uTemp = serial_type = sqlite3VdbeSerialType(pRec, file_format, &len);
002766      if( pRec->flags & MEM_Zero ){
002767        if( nData ){
002768          if( sqlite3VdbeMemExpandBlob(pRec) ) goto no_mem;
002769        }else{
002770          nZero += pRec->u.nZero;
002771          len -= pRec->u.nZero;
002772        }
002773      }
002774      nData += len;
002775      testcase( serial_type==127 );
002776      testcase( serial_type==128 );
002777      nHdr += serial_type<=127 ? 1 : sqlite3VarintLen(serial_type);
002778      if( pRec==pData0 ) break;
002779      pRec--;
002780    }while(1);
002781  
002782    /* EVIDENCE-OF: R-22564-11647 The header begins with a single varint
002783    ** which determines the total number of bytes in the header. The varint
002784    ** value is the size of the header in bytes including the size varint
002785    ** itself. */
002786    testcase( nHdr==126 );
002787    testcase( nHdr==127 );
002788    if( nHdr<=126 ){
002789      /* The common case */
002790      nHdr += 1;
002791    }else{
002792      /* Rare case of a really large header */
002793      nVarint = sqlite3VarintLen(nHdr);
002794      nHdr += nVarint;
002795      if( nVarint<sqlite3VarintLen(nHdr) ) nHdr++;
002796    }
002797    nByte = nHdr+nData;
002798    if( nByte+nZero>db->aLimit[SQLITE_LIMIT_LENGTH] ){
002799      goto too_big;
002800    }
002801  
002802    /* Make sure the output register has a buffer large enough to store 
002803    ** the new record. The output register (pOp->p3) is not allowed to
002804    ** be one of the input registers (because the following call to
002805    ** sqlite3VdbeMemClearAndResize() could clobber the value before it is used).
002806    */
002807    if( sqlite3VdbeMemClearAndResize(pOut, (int)nByte) ){
002808      goto no_mem;
002809    }
002810    zNewRecord = (u8 *)pOut->z;
002811  
002812    /* Write the record */
002813    i = putVarint32(zNewRecord, nHdr);
002814    j = nHdr;
002815    assert( pData0<=pLast );
002816    pRec = pData0;
002817    do{
002818      serial_type = pRec->uTemp;
002819      /* EVIDENCE-OF: R-06529-47362 Following the size varint are one or more
002820      ** additional varints, one per column. */
002821      i += putVarint32(&zNewRecord[i], serial_type);            /* serial type */
002822      /* EVIDENCE-OF: R-64536-51728 The values for each column in the record
002823      ** immediately follow the header. */
002824      j += sqlite3VdbeSerialPut(&zNewRecord[j], pRec, serial_type); /* content */
002825    }while( (++pRec)<=pLast );
002826    assert( i==nHdr );
002827    assert( j==nByte );
002828  
002829    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
002830    pOut->n = (int)nByte;
002831    pOut->flags = MEM_Blob;
002832    if( nZero ){
002833      pOut->u.nZero = nZero;
002834      pOut->flags |= MEM_Zero;
002835    }
002836    REGISTER_TRACE(pOp->p3, pOut);
002837    UPDATE_MAX_BLOBSIZE(pOut);
002838    break;
002839  }
002840  
002841  /* Opcode: Count P1 P2 * * *
002842  ** Synopsis: r[P2]=count()
002843  **
002844  ** Store the number of entries (an integer value) in the table or index 
002845  ** opened by cursor P1 in register P2
002846  */
002847  #ifndef SQLITE_OMIT_BTREECOUNT
002848  case OP_Count: {         /* out2 */
002849    i64 nEntry;
002850    BtCursor *pCrsr;
002851  
002852    assert( p->apCsr[pOp->p1]->eCurType==CURTYPE_BTREE );
002853    pCrsr = p->apCsr[pOp->p1]->uc.pCursor;
002854    assert( pCrsr );
002855    nEntry = 0;  /* Not needed.  Only used to silence a warning. */
002856    rc = sqlite3BtreeCount(pCrsr, &nEntry);
002857    if( rc ) goto abort_due_to_error;
002858    pOut = out2Prerelease(p, pOp);
002859    pOut->u.i = nEntry;
002860    break;
002861  }
002862  #endif
002863  
002864  /* Opcode: Savepoint P1 * * P4 *
002865  **
002866  ** Open, release or rollback the savepoint named by parameter P4, depending
002867  ** on the value of P1. To open a new savepoint, P1==0. To release (commit) an
002868  ** existing savepoint, P1==1, or to rollback an existing savepoint P1==2.
002869  */
002870  case OP_Savepoint: {
002871    int p1;                         /* Value of P1 operand */
002872    char *zName;                    /* Name of savepoint */
002873    int nName;
002874    Savepoint *pNew;
002875    Savepoint *pSavepoint;
002876    Savepoint *pTmp;
002877    int iSavepoint;
002878    int ii;
002879  
002880    p1 = pOp->p1;
002881    zName = pOp->p4.z;
002882  
002883    /* Assert that the p1 parameter is valid. Also that if there is no open
002884    ** transaction, then there cannot be any savepoints. 
002885    */
002886    assert( db->pSavepoint==0 || db->autoCommit==0 );
002887    assert( p1==SAVEPOINT_BEGIN||p1==SAVEPOINT_RELEASE||p1==SAVEPOINT_ROLLBACK );
002888    assert( db->pSavepoint || db->isTransactionSavepoint==0 );
002889    assert( checkSavepointCount(db) );
002890    assert( p->bIsReader );
002891  
002892    if( p1==SAVEPOINT_BEGIN ){
002893      if( db->nVdbeWrite>0 ){
002894        /* A new savepoint cannot be created if there are active write 
002895        ** statements (i.e. open read/write incremental blob handles).
002896        */
002897        sqlite3VdbeError(p, "cannot open savepoint - SQL statements in progress");
002898        rc = SQLITE_BUSY;
002899      }else{
002900        nName = sqlite3Strlen30(zName);
002901  
002902  #ifndef SQLITE_OMIT_VIRTUALTABLE
002903        /* This call is Ok even if this savepoint is actually a transaction
002904        ** savepoint (and therefore should not prompt xSavepoint()) callbacks.
002905        ** If this is a transaction savepoint being opened, it is guaranteed
002906        ** that the db->aVTrans[] array is empty.  */
002907        assert( db->autoCommit==0 || db->nVTrans==0 );
002908        rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN,
002909                                  db->nStatement+db->nSavepoint);
002910        if( rc!=SQLITE_OK ) goto abort_due_to_error;
002911  #endif
002912  
002913        /* Create a new savepoint structure. */
002914        pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
002915        if( pNew ){
002916          pNew->zName = (char *)&pNew[1];
002917          memcpy(pNew->zName, zName, nName+1);
002918      
002919          /* If there is no open transaction, then mark this as a special
002920          ** "transaction savepoint". */
002921          if( db->autoCommit ){
002922            db->autoCommit = 0;
002923            db->isTransactionSavepoint = 1;
002924          }else{
002925            db->nSavepoint++;
002926          }
002927  
002928          /* Link the new savepoint into the database handle's list. */
002929          pNew->pNext = db->pSavepoint;
002930          db->pSavepoint = pNew;
002931          pNew->nDeferredCons = db->nDeferredCons;
002932          pNew->nDeferredImmCons = db->nDeferredImmCons;
002933        }
002934      }
002935    }else{
002936      iSavepoint = 0;
002937  
002938      /* Find the named savepoint. If there is no such savepoint, then an
002939      ** an error is returned to the user.  */
002940      for(
002941        pSavepoint = db->pSavepoint; 
002942        pSavepoint && sqlite3StrICmp(pSavepoint->zName, zName);
002943        pSavepoint = pSavepoint->pNext
002944      ){
002945        iSavepoint++;
002946      }
002947      if( !pSavepoint ){
002948        sqlite3VdbeError(p, "no such savepoint: %s", zName);
002949        rc = SQLITE_ERROR;
002950      }else if( db->nVdbeWrite>0 && p1==SAVEPOINT_RELEASE ){
002951        /* It is not possible to release (commit) a savepoint if there are 
002952        ** active write statements.
002953        */
002954        sqlite3VdbeError(p, "cannot release savepoint - "
002955                            "SQL statements in progress");
002956        rc = SQLITE_BUSY;
002957      }else{
002958  
002959        /* Determine whether or not this is a transaction savepoint. If so,
002960        ** and this is a RELEASE command, then the current transaction 
002961        ** is committed. 
002962        */
002963        int isTransaction = pSavepoint->pNext==0 && db->isTransactionSavepoint;
002964        if( isTransaction && p1==SAVEPOINT_RELEASE ){
002965          if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
002966            goto vdbe_return;
002967          }
002968          db->autoCommit = 1;
002969          if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
002970            p->pc = (int)(pOp - aOp);
002971            db->autoCommit = 0;
002972            p->rc = rc = SQLITE_BUSY;
002973            goto vdbe_return;
002974          }
002975          db->isTransactionSavepoint = 0;
002976          rc = p->rc;
002977        }else{
002978          int isSchemaChange;
002979          iSavepoint = db->nSavepoint - iSavepoint - 1;
002980          if( p1==SAVEPOINT_ROLLBACK ){
002981            isSchemaChange = (db->mDbFlags & DBFLAG_SchemaChange)!=0;
002982            for(ii=0; ii<db->nDb; ii++){
002983              rc = sqlite3BtreeTripAllCursors(db->aDb[ii].pBt,
002984                                         SQLITE_ABORT_ROLLBACK,
002985                                         isSchemaChange==0);
002986              if( rc!=SQLITE_OK ) goto abort_due_to_error;
002987            }
002988          }else{
002989            isSchemaChange = 0;
002990          }
002991          for(ii=0; ii<db->nDb; ii++){
002992            rc = sqlite3BtreeSavepoint(db->aDb[ii].pBt, p1, iSavepoint);
002993            if( rc!=SQLITE_OK ){
002994              goto abort_due_to_error;
002995            }
002996          }
002997          if( isSchemaChange ){
002998            sqlite3ExpirePreparedStatements(db);
002999            sqlite3ResetAllSchemasOfConnection(db);
003000            db->mDbFlags |= DBFLAG_SchemaChange;
003001          }
003002        }
003003    
003004        /* Regardless of whether this is a RELEASE or ROLLBACK, destroy all 
003005        ** savepoints nested inside of the savepoint being operated on. */
003006        while( db->pSavepoint!=pSavepoint ){
003007          pTmp = db->pSavepoint;
003008          db->pSavepoint = pTmp->pNext;
003009          sqlite3DbFree(db, pTmp);
003010          db->nSavepoint--;
003011        }
003012  
003013        /* If it is a RELEASE, then destroy the savepoint being operated on 
003014        ** too. If it is a ROLLBACK TO, then set the number of deferred 
003015        ** constraint violations present in the database to the value stored
003016        ** when the savepoint was created.  */
003017        if( p1==SAVEPOINT_RELEASE ){
003018          assert( pSavepoint==db->pSavepoint );
003019          db->pSavepoint = pSavepoint->pNext;
003020          sqlite3DbFree(db, pSavepoint);
003021          if( !isTransaction ){
003022            db->nSavepoint--;
003023          }
003024        }else{
003025          db->nDeferredCons = pSavepoint->nDeferredCons;
003026          db->nDeferredImmCons = pSavepoint->nDeferredImmCons;
003027        }
003028  
003029        if( !isTransaction || p1==SAVEPOINT_ROLLBACK ){
003030          rc = sqlite3VtabSavepoint(db, p1, iSavepoint);
003031          if( rc!=SQLITE_OK ) goto abort_due_to_error;
003032        }
003033      }
003034    }
003035    if( rc ) goto abort_due_to_error;
003036  
003037    break;
003038  }
003039  
003040  /* Opcode: AutoCommit P1 P2 * * *
003041  **
003042  ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
003043  ** back any currently active btree transactions. If there are any active
003044  ** VMs (apart from this one), then a ROLLBACK fails.  A COMMIT fails if
003045  ** there are active writing VMs or active VMs that use shared cache.
003046  **
003047  ** This instruction causes the VM to halt.
003048  */
003049  case OP_AutoCommit: {
003050    int desiredAutoCommit;
003051    int iRollback;
003052  
003053    desiredAutoCommit = pOp->p1;
003054    iRollback = pOp->p2;
003055    assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
003056    assert( desiredAutoCommit==1 || iRollback==0 );
003057    assert( db->nVdbeActive>0 );  /* At least this one VM is active */
003058    assert( p->bIsReader );
003059  
003060    if( desiredAutoCommit!=db->autoCommit ){
003061      if( iRollback ){
003062        assert( desiredAutoCommit==1 );
003063        sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
003064        db->autoCommit = 1;
003065      }else if( desiredAutoCommit && db->nVdbeWrite>0 ){
003066        /* If this instruction implements a COMMIT and other VMs are writing
003067        ** return an error indicating that the other VMs must complete first. 
003068        */
003069        sqlite3VdbeError(p, "cannot commit transaction - "
003070                            "SQL statements in progress");
003071        rc = SQLITE_BUSY;
003072        goto abort_due_to_error;
003073      }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
003074        goto vdbe_return;
003075      }else{
003076        db->autoCommit = (u8)desiredAutoCommit;
003077      }
003078      if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
003079        p->pc = (int)(pOp - aOp);
003080        db->autoCommit = (u8)(1-desiredAutoCommit);
003081        p->rc = rc = SQLITE_BUSY;
003082        goto vdbe_return;
003083      }
003084      assert( db->nStatement==0 );
003085      sqlite3CloseSavepoints(db);
003086      if( p->rc==SQLITE_OK ){
003087        rc = SQLITE_DONE;
003088      }else{
003089        rc = SQLITE_ERROR;
003090      }
003091      goto vdbe_return;
003092    }else{
003093      sqlite3VdbeError(p,
003094          (!desiredAutoCommit)?"cannot start a transaction within a transaction":(
003095          (iRollback)?"cannot rollback - no transaction is active":
003096                     "cannot commit - no transaction is active"));
003097           
003098      rc = SQLITE_ERROR;
003099      goto abort_due_to_error;
003100    }
003101    break;
003102  }
003103  
003104  /* Opcode: Transaction P1 P2 P3 P4 P5
003105  **
003106  ** Begin a transaction on database P1 if a transaction is not already
003107  ** active.
003108  ** If P2 is non-zero, then a write-transaction is started, or if a 
003109  ** read-transaction is already active, it is upgraded to a write-transaction.
003110  ** If P2 is zero, then a read-transaction is started.
003111  **
003112  ** P1 is the index of the database file on which the transaction is
003113  ** started.  Index 0 is the main database file and index 1 is the
003114  ** file used for temporary tables.  Indices of 2 or more are used for
003115  ** attached databases.
003116  **
003117  ** If a write-transaction is started and the Vdbe.usesStmtJournal flag is
003118  ** true (this flag is set if the Vdbe may modify more than one row and may
003119  ** throw an ABORT exception), a statement transaction may also be opened.
003120  ** More specifically, a statement transaction is opened iff the database
003121  ** connection is currently not in autocommit mode, or if there are other
003122  ** active statements. A statement transaction allows the changes made by this
003123  ** VDBE to be rolled back after an error without having to roll back the
003124  ** entire transaction. If no error is encountered, the statement transaction
003125  ** will automatically commit when the VDBE halts.
003126  **
003127  ** If P5!=0 then this opcode also checks the schema cookie against P3
003128  ** and the schema generation counter against P4.
003129  ** The cookie changes its value whenever the database schema changes.
003130  ** This operation is used to detect when that the cookie has changed
003131  ** and that the current process needs to reread the schema.  If the schema
003132  ** cookie in P3 differs from the schema cookie in the database header or
003133  ** if the schema generation counter in P4 differs from the current
003134  ** generation counter, then an SQLITE_SCHEMA error is raised and execution
003135  ** halts.  The sqlite3_step() wrapper function might then reprepare the
003136  ** statement and rerun it from the beginning.
003137  */
003138  case OP_Transaction: {
003139    Btree *pBt;
003140    int iMeta;
003141    int iGen;
003142  
003143    assert( p->bIsReader );
003144    assert( p->readOnly==0 || pOp->p2==0 );
003145    assert( pOp->p1>=0 && pOp->p1<db->nDb );
003146    assert( DbMaskTest(p->btreeMask, pOp->p1) );
003147    if( pOp->p2 && (db->flags & SQLITE_QueryOnly)!=0 ){
003148      rc = SQLITE_READONLY;
003149      goto abort_due_to_error;
003150    }
003151    pBt = db->aDb[pOp->p1].pBt;
003152  
003153    if( pBt ){
003154      rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);
003155      testcase( rc==SQLITE_BUSY_SNAPSHOT );
003156      testcase( rc==SQLITE_BUSY_RECOVERY );
003157      if( rc!=SQLITE_OK ){
003158        if( (rc&0xff)==SQLITE_BUSY ){
003159          p->pc = (int)(pOp - aOp);
003160          p->rc = rc;
003161          goto vdbe_return;
003162        }
003163        goto abort_due_to_error;
003164      }
003165  
003166      if( pOp->p2 && p->usesStmtJournal 
003167       && (db->autoCommit==0 || db->nVdbeRead>1) 
003168      ){
003169        assert( sqlite3BtreeIsInTrans(pBt) );
003170        if( p->iStatement==0 ){
003171          assert( db->nStatement>=0 && db->nSavepoint>=0 );
003172          db->nStatement++; 
003173          p->iStatement = db->nSavepoint + db->nStatement;
003174        }
003175  
003176        rc = sqlite3VtabSavepoint(db, SAVEPOINT_BEGIN, p->iStatement-1);
003177        if( rc==SQLITE_OK ){
003178          rc = sqlite3BtreeBeginStmt(pBt, p->iStatement);
003179        }
003180  
003181        /* Store the current value of the database handles deferred constraint
003182        ** counter. If the statement transaction needs to be rolled back,
003183        ** the value of this counter needs to be restored too.  */
003184        p->nStmtDefCons = db->nDeferredCons;
003185        p->nStmtDefImmCons = db->nDeferredImmCons;
003186      }
003187  
003188      /* Gather the schema version number for checking:
003189      ** IMPLEMENTATION-OF: R-03189-51135 As each SQL statement runs, the schema
003190      ** version is checked to ensure that the schema has not changed since the
003191      ** SQL statement was prepared.
003192      */
003193      sqlite3BtreeGetMeta(pBt, BTREE_SCHEMA_VERSION, (u32 *)&iMeta);
003194      iGen = db->aDb[pOp->p1].pSchema->iGeneration;
003195    }else{
003196      iGen = iMeta = 0;
003197    }
003198    assert( pOp->p5==0 || pOp->p4type==P4_INT32 );
003199    if( pOp->p5 && (iMeta!=pOp->p3 || iGen!=pOp->p4.i) ){
003200      sqlite3DbFree(db, p->zErrMsg);
003201      p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
003202      /* If the schema-cookie from the database file matches the cookie 
003203      ** stored with the in-memory representation of the schema, do
003204      ** not reload the schema from the database file.
003205      **
003206      ** If virtual-tables are in use, this is not just an optimization.
003207      ** Often, v-tables store their data in other SQLite tables, which
003208      ** are queried from within xNext() and other v-table methods using
003209      ** prepared queries. If such a query is out-of-date, we do not want to
003210      ** discard the database schema, as the user code implementing the
003211      ** v-table would have to be ready for the sqlite3_vtab structure itself
003212      ** to be invalidated whenever sqlite3_step() is called from within 
003213      ** a v-table method.
003214      */
003215      if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
003216        sqlite3ResetOneSchema(db, pOp->p1);
003217      }
003218      p->expired = 1;
003219      rc = SQLITE_SCHEMA;
003220    }
003221    if( rc ) goto abort_due_to_error;
003222    break;
003223  }
003224  
003225  /* Opcode: ReadCookie P1 P2 P3 * *
003226  **
003227  ** Read cookie number P3 from database P1 and write it into register P2.
003228  ** P3==1 is the schema version.  P3==2 is the database format.
003229  ** P3==3 is the recommended pager cache size, and so forth.  P1==0 is
003230  ** the main database file and P1==1 is the database file used to store
003231  ** temporary tables.
003232  **
003233  ** There must be a read-lock on the database (either a transaction
003234  ** must be started or there must be an open cursor) before
003235  ** executing this instruction.
003236  */
003237  case OP_ReadCookie: {               /* out2 */
003238    int iMeta;
003239    int iDb;
003240    int iCookie;
003241  
003242    assert( p->bIsReader );
003243    iDb = pOp->p1;
003244    iCookie = pOp->p3;
003245    assert( pOp->p3<SQLITE_N_BTREE_META );
003246    assert( iDb>=0 && iDb<db->nDb );
003247    assert( db->aDb[iDb].pBt!=0 );
003248    assert( DbMaskTest(p->btreeMask, iDb) );
003249  
003250    sqlite3BtreeGetMeta(db->aDb[iDb].pBt, iCookie, (u32 *)&iMeta);
003251    pOut = out2Prerelease(p, pOp);
003252    pOut->u.i = iMeta;
003253    break;
003254  }
003255  
003256  /* Opcode: SetCookie P1 P2 P3 * *
003257  **
003258  ** Write the integer value P3 into cookie number P2 of database P1.
003259  ** P2==1 is the schema version.  P2==2 is the database format.
003260  ** P2==3 is the recommended pager cache 
003261  ** size, and so forth.  P1==0 is the main database file and P1==1 is the 
003262  ** database file used to store temporary tables.
003263  **
003264  ** A transaction must be started before executing this opcode.
003265  */
003266  case OP_SetCookie: {
003267    Db *pDb;
003268    assert( pOp->p2<SQLITE_N_BTREE_META );
003269    assert( pOp->p1>=0 && pOp->p1<db->nDb );
003270    assert( DbMaskTest(p->btreeMask, pOp->p1) );
003271    assert( p->readOnly==0 );
003272    pDb = &db->aDb[pOp->p1];
003273    assert( pDb->pBt!=0 );
003274    assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
003275    /* See note about index shifting on OP_ReadCookie */
003276    rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
003277    if( pOp->p2==BTREE_SCHEMA_VERSION ){
003278      /* When the schema cookie changes, record the new cookie internally */
003279      pDb->pSchema->schema_cookie = pOp->p3;
003280      db->mDbFlags |= DBFLAG_SchemaChange;
003281    }else if( pOp->p2==BTREE_FILE_FORMAT ){
003282      /* Record changes in the file format */
003283      pDb->pSchema->file_format = pOp->p3;
003284    }
003285    if( pOp->p1==1 ){
003286      /* Invalidate all prepared statements whenever the TEMP database
003287      ** schema is changed.  Ticket #1644 */
003288      sqlite3ExpirePreparedStatements(db);
003289      p->expired = 0;
003290    }
003291    if( rc ) goto abort_due_to_error;
003292    break;
003293  }
003294  
003295  /* Opcode: OpenRead P1 P2 P3 P4 P5
003296  ** Synopsis: root=P2 iDb=P3
003297  **
003298  ** Open a read-only cursor for the database table whose root page is
003299  ** P2 in a database file.  The database file is determined by P3. 
003300  ** P3==0 means the main database, P3==1 means the database used for 
003301  ** temporary tables, and P3>1 means used the corresponding attached
003302  ** database.  Give the new cursor an identifier of P1.  The P1
003303  ** values need not be contiguous but all P1 values should be small integers.
003304  ** It is an error for P1 to be negative.
003305  **
003306  ** If P5!=0 then use the content of register P2 as the root page, not
003307  ** the value of P2 itself.
003308  **
003309  ** There will be a read lock on the database whenever there is an
003310  ** open cursor.  If the database was unlocked prior to this instruction
003311  ** then a read lock is acquired as part of this instruction.  A read
003312  ** lock allows other processes to read the database but prohibits
003313  ** any other process from modifying the database.  The read lock is
003314  ** released when all cursors are closed.  If this instruction attempts
003315  ** to get a read lock but fails, the script terminates with an
003316  ** SQLITE_BUSY error code.
003317  **
003318  ** The P4 value may be either an integer (P4_INT32) or a pointer to
003319  ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo 
003320  ** structure, then said structure defines the content and collating 
003321  ** sequence of the index being opened. Otherwise, if P4 is an integer 
003322  ** value, it is set to the number of columns in the table.
003323  **
003324  ** See also: OpenWrite, ReopenIdx
003325  */
003326  /* Opcode: ReopenIdx P1 P2 P3 P4 P5
003327  ** Synopsis: root=P2 iDb=P3
003328  **
003329  ** The ReopenIdx opcode works exactly like ReadOpen except that it first
003330  ** checks to see if the cursor on P1 is already open with a root page
003331  ** number of P2 and if it is this opcode becomes a no-op.  In other words,
003332  ** if the cursor is already open, do not reopen it.
003333  **
003334  ** The ReopenIdx opcode may only be used with P5==0 and with P4 being
003335  ** a P4_KEYINFO object.  Furthermore, the P3 value must be the same as
003336  ** every other ReopenIdx or OpenRead for the same cursor number.
003337  **
003338  ** See the OpenRead opcode documentation for additional information.
003339  */
003340  /* Opcode: OpenWrite P1 P2 P3 P4 P5
003341  ** Synopsis: root=P2 iDb=P3
003342  **
003343  ** Open a read/write cursor named P1 on the table or index whose root
003344  ** page is P2.  Or if P5!=0 use the content of register P2 to find the
003345  ** root page.
003346  **
003347  ** The P4 value may be either an integer (P4_INT32) or a pointer to
003348  ** a KeyInfo structure (P4_KEYINFO). If it is a pointer to a KeyInfo 
003349  ** structure, then said structure defines the content and collating 
003350  ** sequence of the index being opened. Otherwise, if P4 is an integer 
003351  ** value, it is set to the number of columns in the table, or to the
003352  ** largest index of any column of the table that is actually used.
003353  **
003354  ** This instruction works just like OpenRead except that it opens the cursor
003355  ** in read/write mode.  For a given table, there can be one or more read-only
003356  ** cursors or a single read/write cursor but not both.
003357  **
003358  ** See also OpenRead.
003359  */
003360  case OP_ReopenIdx: {
003361    int nField;
003362    KeyInfo *pKeyInfo;
003363    int p2;
003364    int iDb;
003365    int wrFlag;
003366    Btree *pX;
003367    VdbeCursor *pCur;
003368    Db *pDb;
003369  
003370    assert( pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
003371    assert( pOp->p4type==P4_KEYINFO );
003372    pCur = p->apCsr[pOp->p1];
003373    if( pCur && pCur->pgnoRoot==(u32)pOp->p2 ){
003374      assert( pCur->iDb==pOp->p3 );      /* Guaranteed by the code generator */
003375      goto open_cursor_set_hints;
003376    }
003377    /* If the cursor is not currently open or is open on a different
003378    ** index, then fall through into OP_OpenRead to force a reopen */
003379  case OP_OpenRead:
003380  case OP_OpenWrite:
003381  
003382    assert( pOp->opcode==OP_OpenWrite || pOp->p5==0 || pOp->p5==OPFLAG_SEEKEQ );
003383    assert( p->bIsReader );
003384    assert( pOp->opcode==OP_OpenRead || pOp->opcode==OP_ReopenIdx
003385            || p->readOnly==0 );
003386  
003387    if( p->expired ){
003388      rc = SQLITE_ABORT_ROLLBACK;
003389      goto abort_due_to_error;
003390    }
003391  
003392    nField = 0;
003393    pKeyInfo = 0;
003394    p2 = pOp->p2;
003395    iDb = pOp->p3;
003396    assert( iDb>=0 && iDb<db->nDb );
003397    assert( DbMaskTest(p->btreeMask, iDb) );
003398    pDb = &db->aDb[iDb];
003399    pX = pDb->pBt;
003400    assert( pX!=0 );
003401    if( pOp->opcode==OP_OpenWrite ){
003402      assert( OPFLAG_FORDELETE==BTREE_FORDELETE );
003403      wrFlag = BTREE_WRCSR | (pOp->p5 & OPFLAG_FORDELETE);
003404      assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
003405      if( pDb->pSchema->file_format < p->minWriteFileFormat ){
003406        p->minWriteFileFormat = pDb->pSchema->file_format;
003407      }
003408    }else{
003409      wrFlag = 0;
003410    }
003411    if( pOp->p5 & OPFLAG_P2ISREG ){
003412      assert( p2>0 );
003413      assert( p2<=(p->nMem+1 - p->nCursor) );
003414      pIn2 = &aMem[p2];
003415      assert( memIsValid(pIn2) );
003416      assert( (pIn2->flags & MEM_Int)!=0 );
003417      sqlite3VdbeMemIntegerify(pIn2);
003418      p2 = (int)pIn2->u.i;
003419      /* The p2 value always comes from a prior OP_CreateBtree opcode and
003420      ** that opcode will always set the p2 value to 2 or more or else fail.
003421      ** If there were a failure, the prepared statement would have halted
003422      ** before reaching this instruction. */
003423      assert( p2>=2 );
003424    }
003425    if( pOp->p4type==P4_KEYINFO ){
003426      pKeyInfo = pOp->p4.pKeyInfo;
003427      assert( pKeyInfo->enc==ENC(db) );
003428      assert( pKeyInfo->db==db );
003429      nField = pKeyInfo->nAllField;
003430    }else if( pOp->p4type==P4_INT32 ){
003431      nField = pOp->p4.i;
003432    }
003433    assert( pOp->p1>=0 );
003434    assert( nField>=0 );
003435    testcase( nField==0 );  /* Table with INTEGER PRIMARY KEY and nothing else */
003436    pCur = allocateCursor(p, pOp->p1, nField, iDb, CURTYPE_BTREE);
003437    if( pCur==0 ) goto no_mem;
003438    pCur->nullRow = 1;
003439    pCur->isOrdered = 1;
003440    pCur->pgnoRoot = p2;
003441  #ifdef SQLITE_DEBUG
003442    pCur->wrFlag = wrFlag;
003443  #endif
003444    rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
003445    pCur->pKeyInfo = pKeyInfo;
003446    /* Set the VdbeCursor.isTable variable. Previous versions of
003447    ** SQLite used to check if the root-page flags were sane at this point
003448    ** and report database corruption if they were not, but this check has
003449    ** since moved into the btree layer.  */  
003450    pCur->isTable = pOp->p4type!=P4_KEYINFO;
003451  
003452  open_cursor_set_hints:
003453    assert( OPFLAG_BULKCSR==BTREE_BULKLOAD );
003454    assert( OPFLAG_SEEKEQ==BTREE_SEEK_EQ );
003455    testcase( pOp->p5 & OPFLAG_BULKCSR );
003456  #ifdef SQLITE_ENABLE_CURSOR_HINTS
003457    testcase( pOp->p2 & OPFLAG_SEEKEQ );
003458  #endif
003459    sqlite3BtreeCursorHintFlags(pCur->uc.pCursor,
003460                                 (pOp->p5 & (OPFLAG_BULKCSR|OPFLAG_SEEKEQ)));
003461    if( rc ) goto abort_due_to_error;
003462    break;
003463  }
003464  
003465  /* Opcode: OpenDup P1 P2 * * *
003466  **
003467  ** Open a new cursor P1 that points to the same ephemeral table as
003468  ** cursor P2.  The P2 cursor must have been opened by a prior OP_OpenEphemeral
003469  ** opcode.  Only ephemeral cursors may be duplicated.
003470  **
003471  ** Duplicate ephemeral cursors are used for self-joins of materialized views.
003472  */
003473  case OP_OpenDup: {
003474    VdbeCursor *pOrig;    /* The original cursor to be duplicated */
003475    VdbeCursor *pCx;      /* The new cursor */
003476  
003477    pOrig = p->apCsr[pOp->p2];
003478    assert( pOrig->pBtx!=0 );  /* Only ephemeral cursors can be duplicated */
003479  
003480    pCx = allocateCursor(p, pOp->p1, pOrig->nField, -1, CURTYPE_BTREE);
003481    if( pCx==0 ) goto no_mem;
003482    pCx->nullRow = 1;
003483    pCx->isEphemeral = 1;
003484    pCx->pKeyInfo = pOrig->pKeyInfo;
003485    pCx->isTable = pOrig->isTable;
003486    rc = sqlite3BtreeCursor(pOrig->pBtx, MASTER_ROOT, BTREE_WRCSR,
003487                            pCx->pKeyInfo, pCx->uc.pCursor);
003488    /* The sqlite3BtreeCursor() routine can only fail for the first cursor
003489    ** opened for a database.  Since there is already an open cursor when this
003490    ** opcode is run, the sqlite3BtreeCursor() cannot fail */
003491    assert( rc==SQLITE_OK );
003492    break;
003493  }
003494  
003495  
003496  /* Opcode: OpenEphemeral P1 P2 * P4 P5
003497  ** Synopsis: nColumn=P2
003498  **
003499  ** Open a new cursor P1 to a transient table.
003500  ** The cursor is always opened read/write even if 
003501  ** the main database is read-only.  The ephemeral
003502  ** table is deleted automatically when the cursor is closed.
003503  **
003504  ** P2 is the number of columns in the ephemeral table.
003505  ** The cursor points to a BTree table if P4==0 and to a BTree index
003506  ** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
003507  ** that defines the format of keys in the index.
003508  **
003509  ** The P5 parameter can be a mask of the BTREE_* flags defined
003510  ** in btree.h.  These flags control aspects of the operation of
003511  ** the btree.  The BTREE_OMIT_JOURNAL and BTREE_SINGLE flags are
003512  ** added automatically.
003513  */
003514  /* Opcode: OpenAutoindex P1 P2 * P4 *
003515  ** Synopsis: nColumn=P2
003516  **
003517  ** This opcode works the same as OP_OpenEphemeral.  It has a
003518  ** different name to distinguish its use.  Tables created using
003519  ** by this opcode will be used for automatically created transient
003520  ** indices in joins.
003521  */
003522  case OP_OpenAutoindex: 
003523  case OP_OpenEphemeral: {
003524    VdbeCursor *pCx;
003525    KeyInfo *pKeyInfo;
003526  
003527    static const int vfsFlags = 
003528        SQLITE_OPEN_READWRITE |
003529        SQLITE_OPEN_CREATE |
003530        SQLITE_OPEN_EXCLUSIVE |
003531        SQLITE_OPEN_DELETEONCLOSE |
003532        SQLITE_OPEN_TRANSIENT_DB;
003533    assert( pOp->p1>=0 );
003534    assert( pOp->p2>=0 );
003535    pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_BTREE);
003536    if( pCx==0 ) goto no_mem;
003537    pCx->nullRow = 1;
003538    pCx->isEphemeral = 1;
003539    rc = sqlite3BtreeOpen(db->pVfs, 0, db, &pCx->pBtx, 
003540                          BTREE_OMIT_JOURNAL | BTREE_SINGLE | pOp->p5, vfsFlags);
003541    if( rc==SQLITE_OK ){
003542      rc = sqlite3BtreeBeginTrans(pCx->pBtx, 1);
003543    }
003544    if( rc==SQLITE_OK ){
003545      /* If a transient index is required, create it by calling
003546      ** sqlite3BtreeCreateTable() with the BTREE_BLOBKEY flag before
003547      ** opening it. If a transient table is required, just use the
003548      ** automatically created table with root-page 1 (an BLOB_INTKEY table).
003549      */
003550      if( (pCx->pKeyInfo = pKeyInfo = pOp->p4.pKeyInfo)!=0 ){
003551        int pgno;
003552        assert( pOp->p4type==P4_KEYINFO );
003553        rc = sqlite3BtreeCreateTable(pCx->pBtx, &pgno, BTREE_BLOBKEY | pOp->p5); 
003554        if( rc==SQLITE_OK ){
003555          assert( pgno==MASTER_ROOT+1 );
003556          assert( pKeyInfo->db==db );
003557          assert( pKeyInfo->enc==ENC(db) );
003558          rc = sqlite3BtreeCursor(pCx->pBtx, pgno, BTREE_WRCSR,
003559                                  pKeyInfo, pCx->uc.pCursor);
003560        }
003561        pCx->isTable = 0;
003562      }else{
003563        rc = sqlite3BtreeCursor(pCx->pBtx, MASTER_ROOT, BTREE_WRCSR,
003564                                0, pCx->uc.pCursor);
003565        pCx->isTable = 1;
003566      }
003567    }
003568    if( rc ) goto abort_due_to_error;
003569    pCx->isOrdered = (pOp->p5!=BTREE_UNORDERED);
003570    break;
003571  }
003572  
003573  /* Opcode: SorterOpen P1 P2 P3 P4 *
003574  **
003575  ** This opcode works like OP_OpenEphemeral except that it opens
003576  ** a transient index that is specifically designed to sort large
003577  ** tables using an external merge-sort algorithm.
003578  **
003579  ** If argument P3 is non-zero, then it indicates that the sorter may
003580  ** assume that a stable sort considering the first P3 fields of each
003581  ** key is sufficient to produce the required results.
003582  */
003583  case OP_SorterOpen: {
003584    VdbeCursor *pCx;
003585  
003586    assert( pOp->p1>=0 );
003587    assert( pOp->p2>=0 );
003588    pCx = allocateCursor(p, pOp->p1, pOp->p2, -1, CURTYPE_SORTER);
003589    if( pCx==0 ) goto no_mem;
003590    pCx->pKeyInfo = pOp->p4.pKeyInfo;
003591    assert( pCx->pKeyInfo->db==db );
003592    assert( pCx->pKeyInfo->enc==ENC(db) );
003593    rc = sqlite3VdbeSorterInit(db, pOp->p3, pCx);
003594    if( rc ) goto abort_due_to_error;
003595    break;
003596  }
003597  
003598  /* Opcode: SequenceTest P1 P2 * * *
003599  ** Synopsis: if( cursor[P1].ctr++ ) pc = P2
003600  **
003601  ** P1 is a sorter cursor. If the sequence counter is currently zero, jump
003602  ** to P2. Regardless of whether or not the jump is taken, increment the
003603  ** the sequence value.
003604  */
003605  case OP_SequenceTest: {
003606    VdbeCursor *pC;
003607    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
003608    pC = p->apCsr[pOp->p1];
003609    assert( isSorter(pC) );
003610    if( (pC->seqCount++)==0 ){
003611      goto jump_to_p2;
003612    }
003613    break;
003614  }
003615  
003616  /* Opcode: OpenPseudo P1 P2 P3 * *
003617  ** Synopsis: P3 columns in r[P2]
003618  **
003619  ** Open a new cursor that points to a fake table that contains a single
003620  ** row of data.  The content of that one row is the content of memory
003621  ** register P2.  In other words, cursor P1 becomes an alias for the 
003622  ** MEM_Blob content contained in register P2.
003623  **
003624  ** A pseudo-table created by this opcode is used to hold a single
003625  ** row output from the sorter so that the row can be decomposed into
003626  ** individual columns using the OP_Column opcode.  The OP_Column opcode
003627  ** is the only cursor opcode that works with a pseudo-table.
003628  **
003629  ** P3 is the number of fields in the records that will be stored by
003630  ** the pseudo-table.
003631  */
003632  case OP_OpenPseudo: {
003633    VdbeCursor *pCx;
003634  
003635    assert( pOp->p1>=0 );
003636    assert( pOp->p3>=0 );
003637    pCx = allocateCursor(p, pOp->p1, pOp->p3, -1, CURTYPE_PSEUDO);
003638    if( pCx==0 ) goto no_mem;
003639    pCx->nullRow = 1;
003640    pCx->seekResult = pOp->p2;
003641    pCx->isTable = 1;
003642    /* Give this pseudo-cursor a fake BtCursor pointer so that pCx
003643    ** can be safely passed to sqlite3VdbeCursorMoveto().  This avoids a test
003644    ** for pCx->eCurType==CURTYPE_BTREE inside of sqlite3VdbeCursorMoveto()
003645    ** which is a performance optimization */
003646    pCx->uc.pCursor = sqlite3BtreeFakeValidCursor();
003647    assert( pOp->p5==0 );
003648    break;
003649  }
003650  
003651  /* Opcode: Close P1 * * * *
003652  **
003653  ** Close a cursor previously opened as P1.  If P1 is not
003654  ** currently open, this instruction is a no-op.
003655  */
003656  case OP_Close: {
003657    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
003658    sqlite3VdbeFreeCursor(p, p->apCsr[pOp->p1]);
003659    p->apCsr[pOp->p1] = 0;
003660    break;
003661  }
003662  
003663  #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
003664  /* Opcode: ColumnsUsed P1 * * P4 *
003665  **
003666  ** This opcode (which only exists if SQLite was compiled with
003667  ** SQLITE_ENABLE_COLUMN_USED_MASK) identifies which columns of the
003668  ** table or index for cursor P1 are used.  P4 is a 64-bit integer
003669  ** (P4_INT64) in which the first 63 bits are one for each of the
003670  ** first 63 columns of the table or index that are actually used
003671  ** by the cursor.  The high-order bit is set if any column after
003672  ** the 64th is used.
003673  */
003674  case OP_ColumnsUsed: {
003675    VdbeCursor *pC;
003676    pC = p->apCsr[pOp->p1];
003677    assert( pC->eCurType==CURTYPE_BTREE );
003678    pC->maskUsed = *(u64*)pOp->p4.pI64;
003679    break;
003680  }
003681  #endif
003682  
003683  /* Opcode: SeekGE P1 P2 P3 P4 *
003684  ** Synopsis: key=r[P3@P4]
003685  **
003686  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
003687  ** use the value in register P3 as the key.  If cursor P1 refers 
003688  ** to an SQL index, then P3 is the first in an array of P4 registers 
003689  ** that are used as an unpacked index key. 
003690  **
003691  ** Reposition cursor P1 so that  it points to the smallest entry that 
003692  ** is greater than or equal to the key value. If there are no records 
003693  ** greater than or equal to the key and P2 is not zero, then jump to P2.
003694  **
003695  ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
003696  ** opcode will always land on a record that equally equals the key, or
003697  ** else jump immediately to P2.  When the cursor is OPFLAG_SEEKEQ, this
003698  ** opcode must be followed by an IdxLE opcode with the same arguments.
003699  ** The IdxLE opcode will be skipped if this opcode succeeds, but the
003700  ** IdxLE opcode will be used on subsequent loop iterations.
003701  **
003702  ** This opcode leaves the cursor configured to move in forward order,
003703  ** from the beginning toward the end.  In other words, the cursor is
003704  ** configured to use Next, not Prev.
003705  **
003706  ** See also: Found, NotFound, SeekLt, SeekGt, SeekLe
003707  */
003708  /* Opcode: SeekGT P1 P2 P3 P4 *
003709  ** Synopsis: key=r[P3@P4]
003710  **
003711  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
003712  ** use the value in register P3 as a key. If cursor P1 refers 
003713  ** to an SQL index, then P3 is the first in an array of P4 registers 
003714  ** that are used as an unpacked index key. 
003715  **
003716  ** Reposition cursor P1 so that  it points to the smallest entry that 
003717  ** is greater than the key value. If there are no records greater than 
003718  ** the key and P2 is not zero, then jump to P2.
003719  **
003720  ** This opcode leaves the cursor configured to move in forward order,
003721  ** from the beginning toward the end.  In other words, the cursor is
003722  ** configured to use Next, not Prev.
003723  **
003724  ** See also: Found, NotFound, SeekLt, SeekGe, SeekLe
003725  */
003726  /* Opcode: SeekLT P1 P2 P3 P4 * 
003727  ** Synopsis: key=r[P3@P4]
003728  **
003729  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
003730  ** use the value in register P3 as a key. If cursor P1 refers 
003731  ** to an SQL index, then P3 is the first in an array of P4 registers 
003732  ** that are used as an unpacked index key. 
003733  **
003734  ** Reposition cursor P1 so that  it points to the largest entry that 
003735  ** is less than the key value. If there are no records less than 
003736  ** the key and P2 is not zero, then jump to P2.
003737  **
003738  ** This opcode leaves the cursor configured to move in reverse order,
003739  ** from the end toward the beginning.  In other words, the cursor is
003740  ** configured to use Prev, not Next.
003741  **
003742  ** See also: Found, NotFound, SeekGt, SeekGe, SeekLe
003743  */
003744  /* Opcode: SeekLE P1 P2 P3 P4 *
003745  ** Synopsis: key=r[P3@P4]
003746  **
003747  ** If cursor P1 refers to an SQL table (B-Tree that uses integer keys), 
003748  ** use the value in register P3 as a key. If cursor P1 refers 
003749  ** to an SQL index, then P3 is the first in an array of P4 registers 
003750  ** that are used as an unpacked index key. 
003751  **
003752  ** Reposition cursor P1 so that it points to the largest entry that 
003753  ** is less than or equal to the key value. If there are no records 
003754  ** less than or equal to the key and P2 is not zero, then jump to P2.
003755  **
003756  ** This opcode leaves the cursor configured to move in reverse order,
003757  ** from the end toward the beginning.  In other words, the cursor is
003758  ** configured to use Prev, not Next.
003759  **
003760  ** If the cursor P1 was opened using the OPFLAG_SEEKEQ flag, then this
003761  ** opcode will always land on a record that equally equals the key, or
003762  ** else jump immediately to P2.  When the cursor is OPFLAG_SEEKEQ, this
003763  ** opcode must be followed by an IdxGE opcode with the same arguments.
003764  ** The IdxGE opcode will be skipped if this opcode succeeds, but the
003765  ** IdxGE opcode will be used on subsequent loop iterations.
003766  **
003767  ** See also: Found, NotFound, SeekGt, SeekGe, SeekLt
003768  */
003769  case OP_SeekLT:         /* jump, in3 */
003770  case OP_SeekLE:         /* jump, in3 */
003771  case OP_SeekGE:         /* jump, in3 */
003772  case OP_SeekGT: {       /* jump, in3 */
003773    int res;           /* Comparison result */
003774    int oc;            /* Opcode */
003775    VdbeCursor *pC;    /* The cursor to seek */
003776    UnpackedRecord r;  /* The key to seek for */
003777    int nField;        /* Number of columns or fields in the key */
003778    i64 iKey;          /* The rowid we are to seek to */
003779    int eqOnly;        /* Only interested in == results */
003780  
003781    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
003782    assert( pOp->p2!=0 );
003783    pC = p->apCsr[pOp->p1];
003784    assert( pC!=0 );
003785    assert( pC->eCurType==CURTYPE_BTREE );
003786    assert( OP_SeekLE == OP_SeekLT+1 );
003787    assert( OP_SeekGE == OP_SeekLT+2 );
003788    assert( OP_SeekGT == OP_SeekLT+3 );
003789    assert( pC->isOrdered );
003790    assert( pC->uc.pCursor!=0 );
003791    oc = pOp->opcode;
003792    eqOnly = 0;
003793    pC->nullRow = 0;
003794  #ifdef SQLITE_DEBUG
003795    pC->seekOp = pOp->opcode;
003796  #endif
003797  
003798    if( pC->isTable ){
003799      /* The BTREE_SEEK_EQ flag is only set on index cursors */
003800      assert( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ)==0
003801                || CORRUPT_DB );
003802  
003803      /* The input value in P3 might be of any type: integer, real, string,
003804      ** blob, or NULL.  But it needs to be an integer before we can do
003805      ** the seek, so convert it. */
003806      pIn3 = &aMem[pOp->p3];
003807      if( (pIn3->flags & (MEM_Int|MEM_Real|MEM_Str))==MEM_Str ){
003808        applyNumericAffinity(pIn3, 0);
003809      }
003810      iKey = sqlite3VdbeIntValue(pIn3);
003811  
003812      /* If the P3 value could not be converted into an integer without
003813      ** loss of information, then special processing is required... */
003814      if( (pIn3->flags & MEM_Int)==0 ){
003815        if( (pIn3->flags & MEM_Real)==0 ){
003816          /* If the P3 value cannot be converted into any kind of a number,
003817          ** then the seek is not possible, so jump to P2 */
003818          VdbeBranchTaken(1,2); goto jump_to_p2;
003819          break;
003820        }
003821  
003822        /* If the approximation iKey is larger than the actual real search
003823        ** term, substitute >= for > and < for <=. e.g. if the search term
003824        ** is 4.9 and the integer approximation 5:
003825        **
003826        **        (x >  4.9)    ->     (x >= 5)
003827        **        (x <= 4.9)    ->     (x <  5)
003828        */
003829        if( pIn3->u.r<(double)iKey ){
003830          assert( OP_SeekGE==(OP_SeekGT-1) );
003831          assert( OP_SeekLT==(OP_SeekLE-1) );
003832          assert( (OP_SeekLE & 0x0001)==(OP_SeekGT & 0x0001) );
003833          if( (oc & 0x0001)==(OP_SeekGT & 0x0001) ) oc--;
003834        }
003835  
003836        /* If the approximation iKey is smaller than the actual real search
003837        ** term, substitute <= for < and > for >=.  */
003838        else if( pIn3->u.r>(double)iKey ){
003839          assert( OP_SeekLE==(OP_SeekLT+1) );
003840          assert( OP_SeekGT==(OP_SeekGE+1) );
003841          assert( (OP_SeekLT & 0x0001)==(OP_SeekGE & 0x0001) );
003842          if( (oc & 0x0001)==(OP_SeekLT & 0x0001) ) oc++;
003843        }
003844      } 
003845      rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)iKey, 0, &res);
003846      pC->movetoTarget = iKey;  /* Used by OP_Delete */
003847      if( rc!=SQLITE_OK ){
003848        goto abort_due_to_error;
003849      }
003850    }else{
003851      /* For a cursor with the BTREE_SEEK_EQ hint, only the OP_SeekGE and
003852      ** OP_SeekLE opcodes are allowed, and these must be immediately followed
003853      ** by an OP_IdxGT or OP_IdxLT opcode, respectively, with the same key.
003854      */
003855      if( sqlite3BtreeCursorHasHint(pC->uc.pCursor, BTREE_SEEK_EQ) ){
003856        eqOnly = 1;
003857        assert( pOp->opcode==OP_SeekGE || pOp->opcode==OP_SeekLE );
003858        assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
003859        assert( pOp[1].p1==pOp[0].p1 );
003860        assert( pOp[1].p2==pOp[0].p2 );
003861        assert( pOp[1].p3==pOp[0].p3 );
003862        assert( pOp[1].p4.i==pOp[0].p4.i );
003863      }
003864  
003865      nField = pOp->p4.i;
003866      assert( pOp->p4type==P4_INT32 );
003867      assert( nField>0 );
003868      r.pKeyInfo = pC->pKeyInfo;
003869      r.nField = (u16)nField;
003870  
003871      /* The next line of code computes as follows, only faster:
003872      **   if( oc==OP_SeekGT || oc==OP_SeekLE ){
003873      **     r.default_rc = -1;
003874      **   }else{
003875      **     r.default_rc = +1;
003876      **   }
003877      */
003878      r.default_rc = ((1 & (oc - OP_SeekLT)) ? -1 : +1);
003879      assert( oc!=OP_SeekGT || r.default_rc==-1 );
003880      assert( oc!=OP_SeekLE || r.default_rc==-1 );
003881      assert( oc!=OP_SeekGE || r.default_rc==+1 );
003882      assert( oc!=OP_SeekLT || r.default_rc==+1 );
003883  
003884      r.aMem = &aMem[pOp->p3];
003885  #ifdef SQLITE_DEBUG
003886      { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
003887  #endif
003888      r.eqSeen = 0;
003889      rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, &r, 0, 0, &res);
003890      if( rc!=SQLITE_OK ){
003891        goto abort_due_to_error;
003892      }
003893      if( eqOnly && r.eqSeen==0 ){
003894        assert( res!=0 );
003895        goto seek_not_found;
003896      }
003897    }
003898    pC->deferredMoveto = 0;
003899    pC->cacheStatus = CACHE_STALE;
003900  #ifdef SQLITE_TEST
003901    sqlite3_search_count++;
003902  #endif
003903    if( oc>=OP_SeekGE ){  assert( oc==OP_SeekGE || oc==OP_SeekGT );
003904      if( res<0 || (res==0 && oc==OP_SeekGT) ){
003905        res = 0;
003906        rc = sqlite3BtreeNext(pC->uc.pCursor, 0);
003907        if( rc!=SQLITE_OK ){
003908          if( rc==SQLITE_DONE ){
003909            rc = SQLITE_OK;
003910            res = 1;
003911          }else{
003912            goto abort_due_to_error;
003913          }
003914        }
003915      }else{
003916        res = 0;
003917      }
003918    }else{
003919      assert( oc==OP_SeekLT || oc==OP_SeekLE );
003920      if( res>0 || (res==0 && oc==OP_SeekLT) ){
003921        res = 0;
003922        rc = sqlite3BtreePrevious(pC->uc.pCursor, 0);
003923        if( rc!=SQLITE_OK ){
003924          if( rc==SQLITE_DONE ){
003925            rc = SQLITE_OK;
003926            res = 1;
003927          }else{
003928            goto abort_due_to_error;
003929          }
003930        }
003931      }else{
003932        /* res might be negative because the table is empty.  Check to
003933        ** see if this is the case.
003934        */
003935        res = sqlite3BtreeEof(pC->uc.pCursor);
003936      }
003937    }
003938  seek_not_found:
003939    assert( pOp->p2>0 );
003940    VdbeBranchTaken(res!=0,2);
003941    if( res ){
003942      goto jump_to_p2;
003943    }else if( eqOnly ){
003944      assert( pOp[1].opcode==OP_IdxLT || pOp[1].opcode==OP_IdxGT );
003945      pOp++; /* Skip the OP_IdxLt or OP_IdxGT that follows */
003946    }
003947    break;
003948  }
003949  
003950  /* Opcode: Found P1 P2 P3 P4 *
003951  ** Synopsis: key=r[P3@P4]
003952  **
003953  ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
003954  ** P4>0 then register P3 is the first of P4 registers that form an unpacked
003955  ** record.
003956  **
003957  ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
003958  ** is a prefix of any entry in P1 then a jump is made to P2 and
003959  ** P1 is left pointing at the matching entry.
003960  **
003961  ** This operation leaves the cursor in a state where it can be
003962  ** advanced in the forward direction.  The Next instruction will work,
003963  ** but not the Prev instruction.
003964  **
003965  ** See also: NotFound, NoConflict, NotExists. SeekGe
003966  */
003967  /* Opcode: NotFound P1 P2 P3 P4 *
003968  ** Synopsis: key=r[P3@P4]
003969  **
003970  ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
003971  ** P4>0 then register P3 is the first of P4 registers that form an unpacked
003972  ** record.
003973  ** 
003974  ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
003975  ** is not the prefix of any entry in P1 then a jump is made to P2.  If P1 
003976  ** does contain an entry whose prefix matches the P3/P4 record then control
003977  ** falls through to the next instruction and P1 is left pointing at the
003978  ** matching entry.
003979  **
003980  ** This operation leaves the cursor in a state where it cannot be
003981  ** advanced in either direction.  In other words, the Next and Prev
003982  ** opcodes do not work after this operation.
003983  **
003984  ** See also: Found, NotExists, NoConflict
003985  */
003986  /* Opcode: NoConflict P1 P2 P3 P4 *
003987  ** Synopsis: key=r[P3@P4]
003988  **
003989  ** If P4==0 then register P3 holds a blob constructed by MakeRecord.  If
003990  ** P4>0 then register P3 is the first of P4 registers that form an unpacked
003991  ** record.
003992  ** 
003993  ** Cursor P1 is on an index btree.  If the record identified by P3 and P4
003994  ** contains any NULL value, jump immediately to P2.  If all terms of the
003995  ** record are not-NULL then a check is done to determine if any row in the
003996  ** P1 index btree has a matching key prefix.  If there are no matches, jump
003997  ** immediately to P2.  If there is a match, fall through and leave the P1
003998  ** cursor pointing to the matching row.
003999  **
004000  ** This opcode is similar to OP_NotFound with the exceptions that the
004001  ** branch is always taken if any part of the search key input is NULL.
004002  **
004003  ** This operation leaves the cursor in a state where it cannot be
004004  ** advanced in either direction.  In other words, the Next and Prev
004005  ** opcodes do not work after this operation.
004006  **
004007  ** See also: NotFound, Found, NotExists
004008  */
004009  case OP_NoConflict:     /* jump, in3 */
004010  case OP_NotFound:       /* jump, in3 */
004011  case OP_Found: {        /* jump, in3 */
004012    int alreadyExists;
004013    int takeJump;
004014    int ii;
004015    VdbeCursor *pC;
004016    int res;
004017    UnpackedRecord *pFree;
004018    UnpackedRecord *pIdxKey;
004019    UnpackedRecord r;
004020  
004021  #ifdef SQLITE_TEST
004022    if( pOp->opcode!=OP_NoConflict ) sqlite3_found_count++;
004023  #endif
004024  
004025    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004026    assert( pOp->p4type==P4_INT32 );
004027    pC = p->apCsr[pOp->p1];
004028    assert( pC!=0 );
004029  #ifdef SQLITE_DEBUG
004030    pC->seekOp = pOp->opcode;
004031  #endif
004032    pIn3 = &aMem[pOp->p3];
004033    assert( pC->eCurType==CURTYPE_BTREE );
004034    assert( pC->uc.pCursor!=0 );
004035    assert( pC->isTable==0 );
004036    if( pOp->p4.i>0 ){
004037      r.pKeyInfo = pC->pKeyInfo;
004038      r.nField = (u16)pOp->p4.i;
004039      r.aMem = pIn3;
004040  #ifdef SQLITE_DEBUG
004041      for(ii=0; ii<r.nField; ii++){
004042        assert( memIsValid(&r.aMem[ii]) );
004043        assert( (r.aMem[ii].flags & MEM_Zero)==0 || r.aMem[ii].n==0 );
004044        if( ii ) REGISTER_TRACE(pOp->p3+ii, &r.aMem[ii]);
004045      }
004046  #endif
004047      pIdxKey = &r;
004048      pFree = 0;
004049    }else{
004050      assert( pIn3->flags & MEM_Blob );
004051      rc = ExpandBlob(pIn3);
004052      assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
004053      if( rc ) goto no_mem;
004054      pFree = pIdxKey = sqlite3VdbeAllocUnpackedRecord(pC->pKeyInfo);
004055      if( pIdxKey==0 ) goto no_mem;
004056      sqlite3VdbeRecordUnpack(pC->pKeyInfo, pIn3->n, pIn3->z, pIdxKey);
004057    }
004058    pIdxKey->default_rc = 0;
004059    takeJump = 0;
004060    if( pOp->opcode==OP_NoConflict ){
004061      /* For the OP_NoConflict opcode, take the jump if any of the
004062      ** input fields are NULL, since any key with a NULL will not
004063      ** conflict */
004064      for(ii=0; ii<pIdxKey->nField; ii++){
004065        if( pIdxKey->aMem[ii].flags & MEM_Null ){
004066          takeJump = 1;
004067          break;
004068        }
004069      }
004070    }
004071    rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, pIdxKey, 0, 0, &res);
004072    if( pFree ) sqlite3DbFreeNN(db, pFree);
004073    if( rc!=SQLITE_OK ){
004074      goto abort_due_to_error;
004075    }
004076    pC->seekResult = res;
004077    alreadyExists = (res==0);
004078    pC->nullRow = 1-alreadyExists;
004079    pC->deferredMoveto = 0;
004080    pC->cacheStatus = CACHE_STALE;
004081    if( pOp->opcode==OP_Found ){
004082      VdbeBranchTaken(alreadyExists!=0,2);
004083      if( alreadyExists ) goto jump_to_p2;
004084    }else{
004085      VdbeBranchTaken(takeJump||alreadyExists==0,2);
004086      if( takeJump || !alreadyExists ) goto jump_to_p2;
004087    }
004088    break;
004089  }
004090  
004091  /* Opcode: SeekRowid P1 P2 P3 * *
004092  ** Synopsis: intkey=r[P3]
004093  **
004094  ** P1 is the index of a cursor open on an SQL table btree (with integer
004095  ** keys).  If register P3 does not contain an integer or if P1 does not
004096  ** contain a record with rowid P3 then jump immediately to P2.  
004097  ** Or, if P2 is 0, raise an SQLITE_CORRUPT error. If P1 does contain
004098  ** a record with rowid P3 then 
004099  ** leave the cursor pointing at that record and fall through to the next
004100  ** instruction.
004101  **
004102  ** The OP_NotExists opcode performs the same operation, but with OP_NotExists
004103  ** the P3 register must be guaranteed to contain an integer value.  With this
004104  ** opcode, register P3 might not contain an integer.
004105  **
004106  ** The OP_NotFound opcode performs the same operation on index btrees
004107  ** (with arbitrary multi-value keys).
004108  **
004109  ** This opcode leaves the cursor in a state where it cannot be advanced
004110  ** in either direction.  In other words, the Next and Prev opcodes will
004111  ** not work following this opcode.
004112  **
004113  ** See also: Found, NotFound, NoConflict, SeekRowid
004114  */
004115  /* Opcode: NotExists P1 P2 P3 * *
004116  ** Synopsis: intkey=r[P3]
004117  **
004118  ** P1 is the index of a cursor open on an SQL table btree (with integer
004119  ** keys).  P3 is an integer rowid.  If P1 does not contain a record with
004120  ** rowid P3 then jump immediately to P2.  Or, if P2 is 0, raise an
004121  ** SQLITE_CORRUPT error. If P1 does contain a record with rowid P3 then 
004122  ** leave the cursor pointing at that record and fall through to the next
004123  ** instruction.
004124  **
004125  ** The OP_SeekRowid opcode performs the same operation but also allows the
004126  ** P3 register to contain a non-integer value, in which case the jump is
004127  ** always taken.  This opcode requires that P3 always contain an integer.
004128  **
004129  ** The OP_NotFound opcode performs the same operation on index btrees
004130  ** (with arbitrary multi-value keys).
004131  **
004132  ** This opcode leaves the cursor in a state where it cannot be advanced
004133  ** in either direction.  In other words, the Next and Prev opcodes will
004134  ** not work following this opcode.
004135  **
004136  ** See also: Found, NotFound, NoConflict, SeekRowid
004137  */
004138  case OP_SeekRowid: {        /* jump, in3 */
004139    VdbeCursor *pC;
004140    BtCursor *pCrsr;
004141    int res;
004142    u64 iKey;
004143  
004144    pIn3 = &aMem[pOp->p3];
004145    if( (pIn3->flags & MEM_Int)==0 ){
004146      applyAffinity(pIn3, SQLITE_AFF_NUMERIC, encoding);
004147      if( (pIn3->flags & MEM_Int)==0 ) goto jump_to_p2;
004148    }
004149    /* Fall through into OP_NotExists */
004150  case OP_NotExists:          /* jump, in3 */
004151    pIn3 = &aMem[pOp->p3];
004152    assert( pIn3->flags & MEM_Int );
004153    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004154    pC = p->apCsr[pOp->p1];
004155    assert( pC!=0 );
004156  #ifdef SQLITE_DEBUG
004157    pC->seekOp = 0;
004158  #endif
004159    assert( pC->isTable );
004160    assert( pC->eCurType==CURTYPE_BTREE );
004161    pCrsr = pC->uc.pCursor;
004162    assert( pCrsr!=0 );
004163    res = 0;
004164    iKey = pIn3->u.i;
004165    rc = sqlite3BtreeMovetoUnpacked(pCrsr, 0, iKey, 0, &res);
004166    assert( rc==SQLITE_OK || res==0 );
004167    pC->movetoTarget = iKey;  /* Used by OP_Delete */
004168    pC->nullRow = 0;
004169    pC->cacheStatus = CACHE_STALE;
004170    pC->deferredMoveto = 0;
004171    VdbeBranchTaken(res!=0,2);
004172    pC->seekResult = res;
004173    if( res!=0 ){
004174      assert( rc==SQLITE_OK );
004175      if( pOp->p2==0 ){
004176        rc = SQLITE_CORRUPT_BKPT;
004177      }else{
004178        goto jump_to_p2;
004179      }
004180    }
004181    if( rc ) goto abort_due_to_error;
004182    break;
004183  }
004184  
004185  /* Opcode: Sequence P1 P2 * * *
004186  ** Synopsis: r[P2]=cursor[P1].ctr++
004187  **
004188  ** Find the next available sequence number for cursor P1.
004189  ** Write the sequence number into register P2.
004190  ** The sequence number on the cursor is incremented after this
004191  ** instruction.  
004192  */
004193  case OP_Sequence: {           /* out2 */
004194    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004195    assert( p->apCsr[pOp->p1]!=0 );
004196    assert( p->apCsr[pOp->p1]->eCurType!=CURTYPE_VTAB );
004197    pOut = out2Prerelease(p, pOp);
004198    pOut->u.i = p->apCsr[pOp->p1]->seqCount++;
004199    break;
004200  }
004201  
004202  
004203  /* Opcode: NewRowid P1 P2 P3 * *
004204  ** Synopsis: r[P2]=rowid
004205  **
004206  ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
004207  ** The record number is not previously used as a key in the database
004208  ** table that cursor P1 points to.  The new record number is written
004209  ** written to register P2.
004210  **
004211  ** If P3>0 then P3 is a register in the root frame of this VDBE that holds 
004212  ** the largest previously generated record number. No new record numbers are
004213  ** allowed to be less than this value. When this value reaches its maximum, 
004214  ** an SQLITE_FULL error is generated. The P3 register is updated with the '
004215  ** generated record number. This P3 mechanism is used to help implement the
004216  ** AUTOINCREMENT feature.
004217  */
004218  case OP_NewRowid: {           /* out2 */
004219    i64 v;                 /* The new rowid */
004220    VdbeCursor *pC;        /* Cursor of table to get the new rowid */
004221    int res;               /* Result of an sqlite3BtreeLast() */
004222    int cnt;               /* Counter to limit the number of searches */
004223    Mem *pMem;             /* Register holding largest rowid for AUTOINCREMENT */
004224    VdbeFrame *pFrame;     /* Root frame of VDBE */
004225  
004226    v = 0;
004227    res = 0;
004228    pOut = out2Prerelease(p, pOp);
004229    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004230    pC = p->apCsr[pOp->p1];
004231    assert( pC!=0 );
004232    assert( pC->eCurType==CURTYPE_BTREE );
004233    assert( pC->uc.pCursor!=0 );
004234    {
004235      /* The next rowid or record number (different terms for the same
004236      ** thing) is obtained in a two-step algorithm.
004237      **
004238      ** First we attempt to find the largest existing rowid and add one
004239      ** to that.  But if the largest existing rowid is already the maximum
004240      ** positive integer, we have to fall through to the second
004241      ** probabilistic algorithm
004242      **
004243      ** The second algorithm is to select a rowid at random and see if
004244      ** it already exists in the table.  If it does not exist, we have
004245      ** succeeded.  If the random rowid does exist, we select a new one
004246      ** and try again, up to 100 times.
004247      */
004248      assert( pC->isTable );
004249  
004250  #ifdef SQLITE_32BIT_ROWID
004251  #   define MAX_ROWID 0x7fffffff
004252  #else
004253      /* Some compilers complain about constants of the form 0x7fffffffffffffff.
004254      ** Others complain about 0x7ffffffffffffffffLL.  The following macro seems
004255      ** to provide the constant while making all compilers happy.
004256      */
004257  #   define MAX_ROWID  (i64)( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
004258  #endif
004259  
004260      if( !pC->useRandomRowid ){
004261        rc = sqlite3BtreeLast(pC->uc.pCursor, &res);
004262        if( rc!=SQLITE_OK ){
004263          goto abort_due_to_error;
004264        }
004265        if( res ){
004266          v = 1;   /* IMP: R-61914-48074 */
004267        }else{
004268          assert( sqlite3BtreeCursorIsValid(pC->uc.pCursor) );
004269          v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
004270          if( v>=MAX_ROWID ){
004271            pC->useRandomRowid = 1;
004272          }else{
004273            v++;   /* IMP: R-29538-34987 */
004274          }
004275        }
004276      }
004277  
004278  #ifndef SQLITE_OMIT_AUTOINCREMENT
004279      if( pOp->p3 ){
004280        /* Assert that P3 is a valid memory cell. */
004281        assert( pOp->p3>0 );
004282        if( p->pFrame ){
004283          for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
004284          /* Assert that P3 is a valid memory cell. */
004285          assert( pOp->p3<=pFrame->nMem );
004286          pMem = &pFrame->aMem[pOp->p3];
004287        }else{
004288          /* Assert that P3 is a valid memory cell. */
004289          assert( pOp->p3<=(p->nMem+1 - p->nCursor) );
004290          pMem = &aMem[pOp->p3];
004291          memAboutToChange(p, pMem);
004292        }
004293        assert( memIsValid(pMem) );
004294  
004295        REGISTER_TRACE(pOp->p3, pMem);
004296        sqlite3VdbeMemIntegerify(pMem);
004297        assert( (pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
004298        if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
004299          rc = SQLITE_FULL;   /* IMP: R-17817-00630 */
004300          goto abort_due_to_error;
004301        }
004302        if( v<pMem->u.i+1 ){
004303          v = pMem->u.i + 1;
004304        }
004305        pMem->u.i = v;
004306      }
004307  #endif
004308      if( pC->useRandomRowid ){
004309        /* IMPLEMENTATION-OF: R-07677-41881 If the largest ROWID is equal to the
004310        ** largest possible integer (9223372036854775807) then the database
004311        ** engine starts picking positive candidate ROWIDs at random until
004312        ** it finds one that is not previously used. */
004313        assert( pOp->p3==0 );  /* We cannot be in random rowid mode if this is
004314                               ** an AUTOINCREMENT table. */
004315        cnt = 0;
004316        do{
004317          sqlite3_randomness(sizeof(v), &v);
004318          v &= (MAX_ROWID>>1); v++;  /* Ensure that v is greater than zero */
004319        }while(  ((rc = sqlite3BtreeMovetoUnpacked(pC->uc.pCursor, 0, (u64)v,
004320                                                   0, &res))==SQLITE_OK)
004321              && (res==0)
004322              && (++cnt<100));
004323        if( rc ) goto abort_due_to_error;
004324        if( res==0 ){
004325          rc = SQLITE_FULL;   /* IMP: R-38219-53002 */
004326          goto abort_due_to_error;
004327        }
004328        assert( v>0 );  /* EV: R-40812-03570 */
004329      }
004330      pC->deferredMoveto = 0;
004331      pC->cacheStatus = CACHE_STALE;
004332    }
004333    pOut->u.i = v;
004334    break;
004335  }
004336  
004337  /* Opcode: Insert P1 P2 P3 P4 P5
004338  ** Synopsis: intkey=r[P3] data=r[P2]
004339  **
004340  ** Write an entry into the table of cursor P1.  A new entry is
004341  ** created if it doesn't already exist or the data for an existing
004342  ** entry is overwritten.  The data is the value MEM_Blob stored in register
004343  ** number P2. The key is stored in register P3. The key must
004344  ** be a MEM_Int.
004345  **
004346  ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
004347  ** incremented (otherwise not).  If the OPFLAG_LASTROWID flag of P5 is set,
004348  ** then rowid is stored for subsequent return by the
004349  ** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
004350  **
004351  ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
004352  ** run faster by avoiding an unnecessary seek on cursor P1.  However,
004353  ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
004354  ** seeks on the cursor or if the most recent seek used a key equal to P3.
004355  **
004356  ** If the OPFLAG_ISUPDATE flag is set, then this opcode is part of an
004357  ** UPDATE operation.  Otherwise (if the flag is clear) then this opcode
004358  ** is part of an INSERT operation.  The difference is only important to
004359  ** the update hook.
004360  **
004361  ** Parameter P4 may point to a Table structure, or may be NULL. If it is 
004362  ** not NULL, then the update-hook (sqlite3.xUpdateCallback) is invoked 
004363  ** following a successful insert.
004364  **
004365  ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
004366  ** allocated, then ownership of P2 is transferred to the pseudo-cursor
004367  ** and register P2 becomes ephemeral.  If the cursor is changed, the
004368  ** value of register P2 will then change.  Make sure this does not
004369  ** cause any problems.)
004370  **
004371  ** This instruction only works on tables.  The equivalent instruction
004372  ** for indices is OP_IdxInsert.
004373  */
004374  /* Opcode: InsertInt P1 P2 P3 P4 P5
004375  ** Synopsis: intkey=P3 data=r[P2]
004376  **
004377  ** This works exactly like OP_Insert except that the key is the
004378  ** integer value P3, not the value of the integer stored in register P3.
004379  */
004380  case OP_Insert: 
004381  case OP_InsertInt: {
004382    Mem *pData;       /* MEM cell holding data for the record to be inserted */
004383    Mem *pKey;        /* MEM cell holding key  for the record */
004384    VdbeCursor *pC;   /* Cursor to table into which insert is written */
004385    int seekResult;   /* Result of prior seek or 0 if no USESEEKRESULT flag */
004386    const char *zDb;  /* database name - used by the update hook */
004387    Table *pTab;      /* Table structure - used by update and pre-update hooks */
004388    int op;           /* Opcode for update hook: SQLITE_UPDATE or SQLITE_INSERT */
004389    BtreePayload x;   /* Payload to be inserted */
004390  
004391    op = 0;
004392    pData = &aMem[pOp->p2];
004393    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004394    assert( memIsValid(pData) );
004395    pC = p->apCsr[pOp->p1];
004396    assert( pC!=0 );
004397    assert( pC->eCurType==CURTYPE_BTREE );
004398    assert( pC->uc.pCursor!=0 );
004399    assert( (pOp->p5 & OPFLAG_ISNOOP) || pC->isTable );
004400    assert( pOp->p4type==P4_TABLE || pOp->p4type>=P4_STATIC );
004401    REGISTER_TRACE(pOp->p2, pData);
004402  
004403    if( pOp->opcode==OP_Insert ){
004404      pKey = &aMem[pOp->p3];
004405      assert( pKey->flags & MEM_Int );
004406      assert( memIsValid(pKey) );
004407      REGISTER_TRACE(pOp->p3, pKey);
004408      x.nKey = pKey->u.i;
004409    }else{
004410      assert( pOp->opcode==OP_InsertInt );
004411      x.nKey = pOp->p3;
004412    }
004413  
004414    if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
004415      assert( pC->iDb>=0 );
004416      zDb = db->aDb[pC->iDb].zDbSName;
004417      pTab = pOp->p4.pTab;
004418      assert( (pOp->p5 & OPFLAG_ISNOOP) || HasRowid(pTab) );
004419      op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
004420    }else{
004421      pTab = 0; /* Not needed.  Silence a compiler warning. */
004422      zDb = 0;  /* Not needed.  Silence a compiler warning. */
004423    }
004424  
004425  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
004426    /* Invoke the pre-update hook, if any */
004427    if( db->xPreUpdateCallback 
004428     && pOp->p4type==P4_TABLE
004429     && !(pOp->p5 & OPFLAG_ISUPDATE)
004430    ){
004431      sqlite3VdbePreUpdateHook(p, pC, SQLITE_INSERT, zDb, pTab, x.nKey, pOp->p2);
004432    }
004433    if( pOp->p5 & OPFLAG_ISNOOP ) break;
004434  #endif
004435  
004436    if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
004437    if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = x.nKey;
004438    assert( pData->flags & (MEM_Blob|MEM_Str) );
004439    x.pData = pData->z;
004440    x.nData = pData->n;
004441    seekResult = ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0);
004442    if( pData->flags & MEM_Zero ){
004443      x.nZero = pData->u.nZero;
004444    }else{
004445      x.nZero = 0;
004446    }
004447    x.pKey = 0;
004448    rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
004449        (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), seekResult
004450    );
004451    pC->deferredMoveto = 0;
004452    pC->cacheStatus = CACHE_STALE;
004453  
004454    /* Invoke the update-hook if required. */
004455    if( rc ) goto abort_due_to_error;
004456    if( db->xUpdateCallback && op ){
004457      db->xUpdateCallback(db->pUpdateArg, op, zDb, pTab->zName, x.nKey);
004458    }
004459    break;
004460  }
004461  
004462  /* Opcode: Delete P1 P2 P3 P4 P5
004463  **
004464  ** Delete the record at which the P1 cursor is currently pointing.
004465  **
004466  ** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then
004467  ** the cursor will be left pointing at  either the next or the previous
004468  ** record in the table. If it is left pointing at the next record, then
004469  ** the next Next instruction will be a no-op. As a result, in this case
004470  ** it is ok to delete a record from within a Next loop. If 
004471  ** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be
004472  ** left in an undefined state.
004473  **
004474  ** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this
004475  ** delete one of several associated with deleting a table row and all its
004476  ** associated index entries.  Exactly one of those deletes is the "primary"
004477  ** delete.  The others are all on OPFLAG_FORDELETE cursors or else are
004478  ** marked with the AUXDELETE flag.
004479  **
004480  ** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row
004481  ** change count is incremented (otherwise not).
004482  **
004483  ** P1 must not be pseudo-table.  It has to be a real table with
004484  ** multiple rows.
004485  **
004486  ** If P4 is not NULL then it points to a Table object. In this case either 
004487  ** the update or pre-update hook, or both, may be invoked. The P1 cursor must
004488  ** have been positioned using OP_NotFound prior to invoking this opcode in 
004489  ** this case. Specifically, if one is configured, the pre-update hook is 
004490  ** invoked if P4 is not NULL. The update-hook is invoked if one is configured, 
004491  ** P4 is not NULL, and the OPFLAG_NCHANGE flag is set in P2.
004492  **
004493  ** If the OPFLAG_ISUPDATE flag is set in P2, then P3 contains the address
004494  ** of the memory cell that contains the value that the rowid of the row will
004495  ** be set to by the update.
004496  */
004497  case OP_Delete: {
004498    VdbeCursor *pC;
004499    const char *zDb;
004500    Table *pTab;
004501    int opflags;
004502  
004503    opflags = pOp->p2;
004504    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004505    pC = p->apCsr[pOp->p1];
004506    assert( pC!=0 );
004507    assert( pC->eCurType==CURTYPE_BTREE );
004508    assert( pC->uc.pCursor!=0 );
004509    assert( pC->deferredMoveto==0 );
004510  
004511  #ifdef SQLITE_DEBUG
004512    if( pOp->p4type==P4_TABLE && HasRowid(pOp->p4.pTab) && pOp->p5==0 ){
004513      /* If p5 is zero, the seek operation that positioned the cursor prior to
004514      ** OP_Delete will have also set the pC->movetoTarget field to the rowid of
004515      ** the row that is being deleted */
004516      i64 iKey = sqlite3BtreeIntegerKey(pC->uc.pCursor);
004517      assert( pC->movetoTarget==iKey );
004518    }
004519  #endif
004520  
004521    /* If the update-hook or pre-update-hook will be invoked, set zDb to
004522    ** the name of the db to pass as to it. Also set local pTab to a copy
004523    ** of p4.pTab. Finally, if p5 is true, indicating that this cursor was
004524    ** last moved with OP_Next or OP_Prev, not Seek or NotFound, set 
004525    ** VdbeCursor.movetoTarget to the current rowid.  */
004526    if( pOp->p4type==P4_TABLE && HAS_UPDATE_HOOK(db) ){
004527      assert( pC->iDb>=0 );
004528      assert( pOp->p4.pTab!=0 );
004529      zDb = db->aDb[pC->iDb].zDbSName;
004530      pTab = pOp->p4.pTab;
004531      if( (pOp->p5 & OPFLAG_SAVEPOSITION)!=0 && pC->isTable ){
004532        pC->movetoTarget = sqlite3BtreeIntegerKey(pC->uc.pCursor);
004533      }
004534    }else{
004535      zDb = 0;   /* Not needed.  Silence a compiler warning. */
004536      pTab = 0;  /* Not needed.  Silence a compiler warning. */
004537    }
004538  
004539  #ifdef SQLITE_ENABLE_PREUPDATE_HOOK
004540    /* Invoke the pre-update-hook if required. */
004541    if( db->xPreUpdateCallback && pOp->p4.pTab ){
004542      assert( !(opflags & OPFLAG_ISUPDATE) 
004543           || HasRowid(pTab)==0 
004544           || (aMem[pOp->p3].flags & MEM_Int) 
004545      );
004546      sqlite3VdbePreUpdateHook(p, pC,
004547          (opflags & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_DELETE, 
004548          zDb, pTab, pC->movetoTarget,
004549          pOp->p3
004550      );
004551    }
004552    if( opflags & OPFLAG_ISNOOP ) break;
004553  #endif
004554   
004555    /* Only flags that can be set are SAVEPOISTION and AUXDELETE */ 
004556    assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
004557    assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION );
004558    assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE );
004559  
004560  #ifdef SQLITE_DEBUG
004561    if( p->pFrame==0 ){
004562      if( pC->isEphemeral==0
004563          && (pOp->p5 & OPFLAG_AUXDELETE)==0
004564          && (pC->wrFlag & OPFLAG_FORDELETE)==0
004565        ){
004566        nExtraDelete++;
004567      }
004568      if( pOp->p2 & OPFLAG_NCHANGE ){
004569        nExtraDelete--;
004570      }
004571    }
004572  #endif
004573  
004574    rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
004575    pC->cacheStatus = CACHE_STALE;
004576    pC->seekResult = 0;
004577    if( rc ) goto abort_due_to_error;
004578  
004579    /* Invoke the update-hook if required. */
004580    if( opflags & OPFLAG_NCHANGE ){
004581      p->nChange++;
004582      if( db->xUpdateCallback && HasRowid(pTab) ){
004583        db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, pTab->zName,
004584            pC->movetoTarget);
004585        assert( pC->iDb>=0 );
004586      }
004587    }
004588  
004589    break;
004590  }
004591  /* Opcode: ResetCount * * * * *
004592  **
004593  ** The value of the change counter is copied to the database handle
004594  ** change counter (returned by subsequent calls to sqlite3_changes()).
004595  ** Then the VMs internal change counter resets to 0.
004596  ** This is used by trigger programs.
004597  */
004598  case OP_ResetCount: {
004599    sqlite3VdbeSetChanges(db, p->nChange);
004600    p->nChange = 0;
004601    break;
004602  }
004603  
004604  /* Opcode: SorterCompare P1 P2 P3 P4
004605  ** Synopsis: if key(P1)!=trim(r[P3],P4) goto P2
004606  **
004607  ** P1 is a sorter cursor. This instruction compares a prefix of the
004608  ** record blob in register P3 against a prefix of the entry that 
004609  ** the sorter cursor currently points to.  Only the first P4 fields
004610  ** of r[P3] and the sorter record are compared.
004611  **
004612  ** If either P3 or the sorter contains a NULL in one of their significant
004613  ** fields (not counting the P4 fields at the end which are ignored) then
004614  ** the comparison is assumed to be equal.
004615  **
004616  ** Fall through to next instruction if the two records compare equal to
004617  ** each other.  Jump to P2 if they are different.
004618  */
004619  case OP_SorterCompare: {
004620    VdbeCursor *pC;
004621    int res;
004622    int nKeyCol;
004623  
004624    pC = p->apCsr[pOp->p1];
004625    assert( isSorter(pC) );
004626    assert( pOp->p4type==P4_INT32 );
004627    pIn3 = &aMem[pOp->p3];
004628    nKeyCol = pOp->p4.i;
004629    res = 0;
004630    rc = sqlite3VdbeSorterCompare(pC, pIn3, nKeyCol, &res);
004631    VdbeBranchTaken(res!=0,2);
004632    if( rc ) goto abort_due_to_error;
004633    if( res ) goto jump_to_p2;
004634    break;
004635  };
004636  
004637  /* Opcode: SorterData P1 P2 P3 * *
004638  ** Synopsis: r[P2]=data
004639  **
004640  ** Write into register P2 the current sorter data for sorter cursor P1.
004641  ** Then clear the column header cache on cursor P3.
004642  **
004643  ** This opcode is normally use to move a record out of the sorter and into
004644  ** a register that is the source for a pseudo-table cursor created using
004645  ** OpenPseudo.  That pseudo-table cursor is the one that is identified by
004646  ** parameter P3.  Clearing the P3 column cache as part of this opcode saves
004647  ** us from having to issue a separate NullRow instruction to clear that cache.
004648  */
004649  case OP_SorterData: {
004650    VdbeCursor *pC;
004651  
004652    pOut = &aMem[pOp->p2];
004653    pC = p->apCsr[pOp->p1];
004654    assert( isSorter(pC) );
004655    rc = sqlite3VdbeSorterRowkey(pC, pOut);
004656    assert( rc!=SQLITE_OK || (pOut->flags & MEM_Blob) );
004657    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004658    if( rc ) goto abort_due_to_error;
004659    p->apCsr[pOp->p3]->cacheStatus = CACHE_STALE;
004660    break;
004661  }
004662  
004663  /* Opcode: RowData P1 P2 P3 * *
004664  ** Synopsis: r[P2]=data
004665  **
004666  ** Write into register P2 the complete row content for the row at 
004667  ** which cursor P1 is currently pointing.
004668  ** There is no interpretation of the data.  
004669  ** It is just copied onto the P2 register exactly as 
004670  ** it is found in the database file.
004671  **
004672  ** If cursor P1 is an index, then the content is the key of the row.
004673  ** If cursor P2 is a table, then the content extracted is the data.
004674  **
004675  ** If the P1 cursor must be pointing to a valid row (not a NULL row)
004676  ** of a real table, not a pseudo-table.
004677  **
004678  ** If P3!=0 then this opcode is allowed to make an ephermeral pointer
004679  ** into the database page.  That means that the content of the output
004680  ** register will be invalidated as soon as the cursor moves - including
004681  ** moves caused by other cursors that "save" the the current cursors
004682  ** position in order that they can write to the same table.  If P3==0
004683  ** then a copy of the data is made into memory.  P3!=0 is faster, but
004684  ** P3==0 is safer.
004685  **
004686  ** If P3!=0 then the content of the P2 register is unsuitable for use
004687  ** in OP_Result and any OP_Result will invalidate the P2 register content.
004688  ** The P2 register content is invalidated by opcodes like OP_Function or
004689  ** by any use of another cursor pointing to the same table.
004690  */
004691  case OP_RowData: {
004692    VdbeCursor *pC;
004693    BtCursor *pCrsr;
004694    u32 n;
004695  
004696    pOut = out2Prerelease(p, pOp);
004697  
004698    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004699    pC = p->apCsr[pOp->p1];
004700    assert( pC!=0 );
004701    assert( pC->eCurType==CURTYPE_BTREE );
004702    assert( isSorter(pC)==0 );
004703    assert( pC->nullRow==0 );
004704    assert( pC->uc.pCursor!=0 );
004705    pCrsr = pC->uc.pCursor;
004706  
004707    /* The OP_RowData opcodes always follow OP_NotExists or
004708    ** OP_SeekRowid or OP_Rewind/Op_Next with no intervening instructions
004709    ** that might invalidate the cursor.
004710    ** If this where not the case, on of the following assert()s
004711    ** would fail.  Should this ever change (because of changes in the code
004712    ** generator) then the fix would be to insert a call to
004713    ** sqlite3VdbeCursorMoveto().
004714    */
004715    assert( pC->deferredMoveto==0 );
004716    assert( sqlite3BtreeCursorIsValid(pCrsr) );
004717  #if 0  /* Not required due to the previous to assert() statements */
004718    rc = sqlite3VdbeCursorMoveto(pC);
004719    if( rc!=SQLITE_OK ) goto abort_due_to_error;
004720  #endif
004721  
004722    n = sqlite3BtreePayloadSize(pCrsr);
004723    if( n>(u32)db->aLimit[SQLITE_LIMIT_LENGTH] ){
004724      goto too_big;
004725    }
004726    testcase( n==0 );
004727    rc = sqlite3VdbeMemFromBtree(pCrsr, 0, n, pOut);
004728    if( rc ) goto abort_due_to_error;
004729    if( !pOp->p3 ) Deephemeralize(pOut);
004730    UPDATE_MAX_BLOBSIZE(pOut);
004731    REGISTER_TRACE(pOp->p2, pOut);
004732    break;
004733  }
004734  
004735  /* Opcode: Rowid P1 P2 * * *
004736  ** Synopsis: r[P2]=rowid
004737  **
004738  ** Store in register P2 an integer which is the key of the table entry that
004739  ** P1 is currently point to.
004740  **
004741  ** P1 can be either an ordinary table or a virtual table.  There used to
004742  ** be a separate OP_VRowid opcode for use with virtual tables, but this
004743  ** one opcode now works for both table types.
004744  */
004745  case OP_Rowid: {                 /* out2 */
004746    VdbeCursor *pC;
004747    i64 v;
004748    sqlite3_vtab *pVtab;
004749    const sqlite3_module *pModule;
004750  
004751    pOut = out2Prerelease(p, pOp);
004752    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004753    pC = p->apCsr[pOp->p1];
004754    assert( pC!=0 );
004755    assert( pC->eCurType!=CURTYPE_PSEUDO || pC->nullRow );
004756    if( pC->nullRow ){
004757      pOut->flags = MEM_Null;
004758      break;
004759    }else if( pC->deferredMoveto ){
004760      v = pC->movetoTarget;
004761  #ifndef SQLITE_OMIT_VIRTUALTABLE
004762    }else if( pC->eCurType==CURTYPE_VTAB ){
004763      assert( pC->uc.pVCur!=0 );
004764      pVtab = pC->uc.pVCur->pVtab;
004765      pModule = pVtab->pModule;
004766      assert( pModule->xRowid );
004767      rc = pModule->xRowid(pC->uc.pVCur, &v);
004768      sqlite3VtabImportErrmsg(p, pVtab);
004769      if( rc ) goto abort_due_to_error;
004770  #endif /* SQLITE_OMIT_VIRTUALTABLE */
004771    }else{
004772      assert( pC->eCurType==CURTYPE_BTREE );
004773      assert( pC->uc.pCursor!=0 );
004774      rc = sqlite3VdbeCursorRestore(pC);
004775      if( rc ) goto abort_due_to_error;
004776      if( pC->nullRow ){
004777        pOut->flags = MEM_Null;
004778        break;
004779      }
004780      v = sqlite3BtreeIntegerKey(pC->uc.pCursor);
004781    }
004782    pOut->u.i = v;
004783    break;
004784  }
004785  
004786  /* Opcode: NullRow P1 * * * *
004787  **
004788  ** Move the cursor P1 to a null row.  Any OP_Column operations
004789  ** that occur while the cursor is on the null row will always
004790  ** write a NULL.
004791  */
004792  case OP_NullRow: {
004793    VdbeCursor *pC;
004794  
004795    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004796    pC = p->apCsr[pOp->p1];
004797    assert( pC!=0 );
004798    pC->nullRow = 1;
004799    pC->cacheStatus = CACHE_STALE;
004800    if( pC->eCurType==CURTYPE_BTREE ){
004801      assert( pC->uc.pCursor!=0 );
004802      sqlite3BtreeClearCursor(pC->uc.pCursor);
004803    }
004804    break;
004805  }
004806  
004807  /* Opcode: SeekEnd P1 * * * *
004808  **
004809  ** Position cursor P1 at the end of the btree for the purpose of
004810  ** appending a new entry onto the btree.
004811  **
004812  ** It is assumed that the cursor is used only for appending and so
004813  ** if the cursor is valid, then the cursor must already be pointing
004814  ** at the end of the btree and so no changes are made to
004815  ** the cursor.
004816  */
004817  /* Opcode: Last P1 P2 * * *
004818  **
004819  ** The next use of the Rowid or Column or Prev instruction for P1 
004820  ** will refer to the last entry in the database table or index.
004821  ** If the table or index is empty and P2>0, then jump immediately to P2.
004822  ** If P2 is 0 or if the table or index is not empty, fall through
004823  ** to the following instruction.
004824  **
004825  ** This opcode leaves the cursor configured to move in reverse order,
004826  ** from the end toward the beginning.  In other words, the cursor is
004827  ** configured to use Prev, not Next.
004828  */
004829  case OP_SeekEnd:
004830  case OP_Last: {        /* jump */
004831    VdbeCursor *pC;
004832    BtCursor *pCrsr;
004833    int res;
004834  
004835    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004836    pC = p->apCsr[pOp->p1];
004837    assert( pC!=0 );
004838    assert( pC->eCurType==CURTYPE_BTREE );
004839    pCrsr = pC->uc.pCursor;
004840    res = 0;
004841    assert( pCrsr!=0 );
004842  #ifdef SQLITE_DEBUG
004843    pC->seekOp = pOp->opcode;
004844  #endif
004845    if( pOp->opcode==OP_SeekEnd ){
004846      assert( pOp->p2==0 );
004847      pC->seekResult = -1;
004848      if( sqlite3BtreeCursorIsValidNN(pCrsr) ){
004849        break;
004850      }
004851    }
004852    rc = sqlite3BtreeLast(pCrsr, &res);
004853    pC->nullRow = (u8)res;
004854    pC->deferredMoveto = 0;
004855    pC->cacheStatus = CACHE_STALE;
004856    if( rc ) goto abort_due_to_error;
004857    if( pOp->p2>0 ){
004858      VdbeBranchTaken(res!=0,2);
004859      if( res ) goto jump_to_p2;
004860    }
004861    break;
004862  }
004863  
004864  /* Opcode: IfSmaller P1 P2 P3 * *
004865  **
004866  ** Estimate the number of rows in the table P1.  Jump to P2 if that
004867  ** estimate is less than approximately 2**(0.1*P3).
004868  */
004869  case OP_IfSmaller: {        /* jump */
004870    VdbeCursor *pC;
004871    BtCursor *pCrsr;
004872    int res;
004873    i64 sz;
004874  
004875    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004876    pC = p->apCsr[pOp->p1];
004877    assert( pC!=0 );
004878    pCrsr = pC->uc.pCursor;
004879    assert( pCrsr );
004880    rc = sqlite3BtreeFirst(pCrsr, &res);
004881    if( rc ) goto abort_due_to_error;
004882    if( res==0 ){
004883      sz = sqlite3BtreeRowCountEst(pCrsr);
004884      if( ALWAYS(sz>=0) && sqlite3LogEst((u64)sz)<pOp->p3 ) res = 1;
004885    }
004886    VdbeBranchTaken(res!=0,2);
004887    if( res ) goto jump_to_p2;
004888    break;
004889  }
004890  
004891  
004892  /* Opcode: SorterSort P1 P2 * * *
004893  **
004894  ** After all records have been inserted into the Sorter object
004895  ** identified by P1, invoke this opcode to actually do the sorting.
004896  ** Jump to P2 if there are no records to be sorted.
004897  **
004898  ** This opcode is an alias for OP_Sort and OP_Rewind that is used
004899  ** for Sorter objects.
004900  */
004901  /* Opcode: Sort P1 P2 * * *
004902  **
004903  ** This opcode does exactly the same thing as OP_Rewind except that
004904  ** it increments an undocumented global variable used for testing.
004905  **
004906  ** Sorting is accomplished by writing records into a sorting index,
004907  ** then rewinding that index and playing it back from beginning to
004908  ** end.  We use the OP_Sort opcode instead of OP_Rewind to do the
004909  ** rewinding so that the global variable will be incremented and
004910  ** regression tests can determine whether or not the optimizer is
004911  ** correctly optimizing out sorts.
004912  */
004913  case OP_SorterSort:    /* jump */
004914  case OP_Sort: {        /* jump */
004915  #ifdef SQLITE_TEST
004916    sqlite3_sort_count++;
004917    sqlite3_search_count--;
004918  #endif
004919    p->aCounter[SQLITE_STMTSTATUS_SORT]++;
004920    /* Fall through into OP_Rewind */
004921  }
004922  /* Opcode: Rewind P1 P2 * * *
004923  **
004924  ** The next use of the Rowid or Column or Next instruction for P1 
004925  ** will refer to the first entry in the database table or index.
004926  ** If the table or index is empty, jump immediately to P2.
004927  ** If the table or index is not empty, fall through to the following 
004928  ** instruction.
004929  **
004930  ** This opcode leaves the cursor configured to move in forward order,
004931  ** from the beginning toward the end.  In other words, the cursor is
004932  ** configured to use Next, not Prev.
004933  */
004934  case OP_Rewind: {        /* jump */
004935    VdbeCursor *pC;
004936    BtCursor *pCrsr;
004937    int res;
004938  
004939    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
004940    pC = p->apCsr[pOp->p1];
004941    assert( pC!=0 );
004942    assert( isSorter(pC)==(pOp->opcode==OP_SorterSort) );
004943    res = 1;
004944  #ifdef SQLITE_DEBUG
004945    pC->seekOp = OP_Rewind;
004946  #endif
004947    if( isSorter(pC) ){
004948      rc = sqlite3VdbeSorterRewind(pC, &res);
004949    }else{
004950      assert( pC->eCurType==CURTYPE_BTREE );
004951      pCrsr = pC->uc.pCursor;
004952      assert( pCrsr );
004953      rc = sqlite3BtreeFirst(pCrsr, &res);
004954      pC->deferredMoveto = 0;
004955      pC->cacheStatus = CACHE_STALE;
004956    }
004957    if( rc ) goto abort_due_to_error;
004958    pC->nullRow = (u8)res;
004959    assert( pOp->p2>0 && pOp->p2<p->nOp );
004960    VdbeBranchTaken(res!=0,2);
004961    if( res ) goto jump_to_p2;
004962    break;
004963  }
004964  
004965  /* Opcode: Next P1 P2 P3 P4 P5
004966  **
004967  ** Advance cursor P1 so that it points to the next key/data pair in its
004968  ** table or index.  If there are no more key/value pairs then fall through
004969  ** to the following instruction.  But if the cursor advance was successful,
004970  ** jump immediately to P2.
004971  **
004972  ** The Next opcode is only valid following an SeekGT, SeekGE, or
004973  ** OP_Rewind opcode used to position the cursor.  Next is not allowed
004974  ** to follow SeekLT, SeekLE, or OP_Last.
004975  **
004976  ** The P1 cursor must be for a real table, not a pseudo-table.  P1 must have
004977  ** been opened prior to this opcode or the program will segfault.
004978  **
004979  ** The P3 value is a hint to the btree implementation. If P3==1, that
004980  ** means P1 is an SQL index and that this instruction could have been
004981  ** omitted if that index had been unique.  P3 is usually 0.  P3 is
004982  ** always either 0 or 1.
004983  **
004984  ** P4 is always of type P4_ADVANCE. The function pointer points to
004985  ** sqlite3BtreeNext().
004986  **
004987  ** If P5 is positive and the jump is taken, then event counter
004988  ** number P5-1 in the prepared statement is incremented.
004989  **
004990  ** See also: Prev, NextIfOpen
004991  */
004992  /* Opcode: NextIfOpen P1 P2 P3 P4 P5
004993  **
004994  ** This opcode works just like Next except that if cursor P1 is not
004995  ** open it behaves a no-op.
004996  */
004997  /* Opcode: Prev P1 P2 P3 P4 P5
004998  **
004999  ** Back up cursor P1 so that it points to the previous key/data pair in its
005000  ** table or index.  If there is no previous key/value pairs then fall through
005001  ** to the following instruction.  But if the cursor backup was successful,
005002  ** jump immediately to P2.
005003  **
005004  **
005005  ** The Prev opcode is only valid following an SeekLT, SeekLE, or
005006  ** OP_Last opcode used to position the cursor.  Prev is not allowed
005007  ** to follow SeekGT, SeekGE, or OP_Rewind.
005008  **
005009  ** The P1 cursor must be for a real table, not a pseudo-table.  If P1 is
005010  ** not open then the behavior is undefined.
005011  **
005012  ** The P3 value is a hint to the btree implementation. If P3==1, that
005013  ** means P1 is an SQL index and that this instruction could have been
005014  ** omitted if that index had been unique.  P3 is usually 0.  P3 is
005015  ** always either 0 or 1.
005016  **
005017  ** P4 is always of type P4_ADVANCE. The function pointer points to
005018  ** sqlite3BtreePrevious().
005019  **
005020  ** If P5 is positive and the jump is taken, then event counter
005021  ** number P5-1 in the prepared statement is incremented.
005022  */
005023  /* Opcode: PrevIfOpen P1 P2 P3 P4 P5
005024  **
005025  ** This opcode works just like Prev except that if cursor P1 is not
005026  ** open it behaves a no-op.
005027  */
005028  /* Opcode: SorterNext P1 P2 * * P5
005029  **
005030  ** This opcode works just like OP_Next except that P1 must be a
005031  ** sorter object for which the OP_SorterSort opcode has been
005032  ** invoked.  This opcode advances the cursor to the next sorted
005033  ** record, or jumps to P2 if there are no more sorted records.
005034  */
005035  case OP_SorterNext: {  /* jump */
005036    VdbeCursor *pC;
005037  
005038    pC = p->apCsr[pOp->p1];
005039    assert( isSorter(pC) );
005040    rc = sqlite3VdbeSorterNext(db, pC);
005041    goto next_tail;
005042  case OP_PrevIfOpen:    /* jump */
005043  case OP_NextIfOpen:    /* jump */
005044    if( p->apCsr[pOp->p1]==0 ) break;
005045    /* Fall through */
005046  case OP_Prev:          /* jump */
005047  case OP_Next:          /* jump */
005048    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
005049    assert( pOp->p5<ArraySize(p->aCounter) );
005050    pC = p->apCsr[pOp->p1];
005051    assert( pC!=0 );
005052    assert( pC->deferredMoveto==0 );
005053    assert( pC->eCurType==CURTYPE_BTREE );
005054    assert( pOp->opcode!=OP_Next || pOp->p4.xAdvance==sqlite3BtreeNext );
005055    assert( pOp->opcode!=OP_Prev || pOp->p4.xAdvance==sqlite3BtreePrevious );
005056    assert( pOp->opcode!=OP_NextIfOpen || pOp->p4.xAdvance==sqlite3BtreeNext );
005057    assert( pOp->opcode!=OP_PrevIfOpen || pOp->p4.xAdvance==sqlite3BtreePrevious);
005058  
005059    /* The Next opcode is only used after SeekGT, SeekGE, and Rewind.
005060    ** The Prev opcode is only used after SeekLT, SeekLE, and Last. */
005061    assert( pOp->opcode!=OP_Next || pOp->opcode!=OP_NextIfOpen
005062         || pC->seekOp==OP_SeekGT || pC->seekOp==OP_SeekGE
005063         || pC->seekOp==OP_Rewind || pC->seekOp==OP_Found);
005064    assert( pOp->opcode!=OP_Prev || pOp->opcode!=OP_PrevIfOpen
005065         || pC->seekOp==OP_SeekLT || pC->seekOp==OP_SeekLE
005066         || pC->seekOp==OP_Last );
005067  
005068    rc = pOp->p4.xAdvance(pC->uc.pCursor, pOp->p3);
005069  next_tail:
005070    pC->cacheStatus = CACHE_STALE;
005071    VdbeBranchTaken(rc==SQLITE_OK,2);
005072    if( rc==SQLITE_OK ){
005073      pC->nullRow = 0;
005074      p->aCounter[pOp->p5]++;
005075  #ifdef SQLITE_TEST
005076      sqlite3_search_count++;
005077  #endif
005078      goto jump_to_p2_and_check_for_interrupt;
005079    }
005080    if( rc!=SQLITE_DONE ) goto abort_due_to_error;
005081    rc = SQLITE_OK;
005082    pC->nullRow = 1;
005083    goto check_for_interrupt;
005084  }
005085  
005086  /* Opcode: IdxInsert P1 P2 P3 P4 P5
005087  ** Synopsis: key=r[P2]
005088  **
005089  ** Register P2 holds an SQL index key made using the
005090  ** MakeRecord instructions.  This opcode writes that key
005091  ** into the index P1.  Data for the entry is nil.
005092  **
005093  ** If P4 is not zero, then it is the number of values in the unpacked
005094  ** key of reg(P2).  In that case, P3 is the index of the first register
005095  ** for the unpacked key.  The availability of the unpacked key can sometimes
005096  ** be an optimization.
005097  **
005098  ** If P5 has the OPFLAG_APPEND bit set, that is a hint to the b-tree layer
005099  ** that this insert is likely to be an append.
005100  **
005101  ** If P5 has the OPFLAG_NCHANGE bit set, then the change counter is
005102  ** incremented by this instruction.  If the OPFLAG_NCHANGE bit is clear,
005103  ** then the change counter is unchanged.
005104  **
005105  ** If the OPFLAG_USESEEKRESULT flag of P5 is set, the implementation might
005106  ** run faster by avoiding an unnecessary seek on cursor P1.  However,
005107  ** the OPFLAG_USESEEKRESULT flag must only be set if there have been no prior
005108  ** seeks on the cursor or if the most recent seek used a key equivalent
005109  ** to P2. 
005110  **
005111  ** This instruction only works for indices.  The equivalent instruction
005112  ** for tables is OP_Insert.
005113  */
005114  /* Opcode: SorterInsert P1 P2 * * *
005115  ** Synopsis: key=r[P2]
005116  **
005117  ** Register P2 holds an SQL index key made using the
005118  ** MakeRecord instructions.  This opcode writes that key
005119  ** into the sorter P1.  Data for the entry is nil.
005120  */
005121  case OP_SorterInsert:       /* in2 */
005122  case OP_IdxInsert: {        /* in2 */
005123    VdbeCursor *pC;
005124    BtreePayload x;
005125  
005126    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
005127    pC = p->apCsr[pOp->p1];
005128    assert( pC!=0 );
005129    assert( isSorter(pC)==(pOp->opcode==OP_SorterInsert) );
005130    pIn2 = &aMem[pOp->p2];
005131    assert( pIn2->flags & MEM_Blob );
005132    if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
005133    assert( pC->eCurType==CURTYPE_BTREE || pOp->opcode==OP_SorterInsert );
005134    assert( pC->isTable==0 );
005135    rc = ExpandBlob(pIn2);
005136    if( rc ) goto abort_due_to_error;
005137    if( pOp->opcode==OP_SorterInsert ){
005138      rc = sqlite3VdbeSorterWrite(pC, pIn2);
005139    }else{
005140      x.nKey = pIn2->n;
005141      x.pKey = pIn2->z;
005142      x.aMem = aMem + pOp->p3;
005143      x.nMem = (u16)pOp->p4.i;
005144      rc = sqlite3BtreeInsert(pC->uc.pCursor, &x,
005145           (pOp->p5 & (OPFLAG_APPEND|OPFLAG_SAVEPOSITION)), 
005146          ((pOp->p5 & OPFLAG_USESEEKRESULT) ? pC->seekResult : 0)
005147          );
005148      assert( pC->deferredMoveto==0 );
005149      pC->cacheStatus = CACHE_STALE;
005150    }
005151    if( rc) goto abort_due_to_error;
005152    break;
005153  }
005154  
005155  /* Opcode: IdxDelete P1 P2 P3 * *
005156  ** Synopsis: key=r[P2@P3]
005157  **
005158  ** The content of P3 registers starting at register P2 form
005159  ** an unpacked index key. This opcode removes that entry from the 
005160  ** index opened by cursor P1.
005161  */
005162  case OP_IdxDelete: {
005163    VdbeCursor *pC;
005164    BtCursor *pCrsr;
005165    int res;
005166    UnpackedRecord r;
005167  
005168    assert( pOp->p3>0 );
005169    assert( pOp->p2>0 && pOp->p2+pOp->p3<=(p->nMem+1 - p->nCursor)+1 );
005170    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
005171    pC = p->apCsr[pOp->p1];
005172    assert( pC!=0 );
005173    assert( pC->eCurType==CURTYPE_BTREE );
005174    pCrsr = pC->uc.pCursor;
005175    assert( pCrsr!=0 );
005176    assert( pOp->p5==0 );
005177    r.pKeyInfo = pC->pKeyInfo;
005178    r.nField = (u16)pOp->p3;
005179    r.default_rc = 0;
005180    r.aMem = &aMem[pOp->p2];
005181    rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res);
005182    if( rc ) goto abort_due_to_error;
005183    if( res==0 ){
005184      rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE);
005185      if( rc ) goto abort_due_to_error;
005186    }
005187    assert( pC->deferredMoveto==0 );
005188    pC->cacheStatus = CACHE_STALE;
005189    pC->seekResult = 0;
005190    break;
005191  }
005192  
005193  /* Opcode: DeferredSeek P1 * P3 P4 *
005194  ** Synopsis: Move P3 to P1.rowid if needed
005195  **
005196  ** P1 is an open index cursor and P3 is a cursor on the corresponding
005197  ** table.  This opcode does a deferred seek of the P3 table cursor
005198  ** to the row that corresponds to the current row of P1.
005199  **
005200  ** This is a deferred seek.  Nothing actually happens until
005201  ** the cursor is used to read a record.  That way, if no reads
005202  ** occur, no unnecessary I/O happens.
005203  **
005204  ** P4 may be an array of integers (type P4_INTARRAY) containing
005205  ** one entry for each column in the P3 table.  If array entry a(i)
005206  ** is non-zero, then reading column a(i)-1 from cursor P3 is 
005207  ** equivalent to performing the deferred seek and then reading column i 
005208  ** from P1.  This information is stored in P3 and used to redirect
005209  ** reads against P3 over to P1, thus possibly avoiding the need to
005210  ** seek and read cursor P3.
005211  */
005212  /* Opcode: IdxRowid P1 P2 * * *
005213  ** Synopsis: r[P2]=rowid
005214  **
005215  ** Write into register P2 an integer which is the last entry in the record at
005216  ** the end of the index key pointed to by cursor P1.  This integer should be
005217  ** the rowid of the table entry to which this index entry points.
005218  **
005219  ** See also: Rowid, MakeRecord.
005220  */
005221  case OP_DeferredSeek:
005222  case OP_IdxRowid: {           /* out2 */
005223    VdbeCursor *pC;             /* The P1 index cursor */
005224    VdbeCursor *pTabCur;        /* The P2 table cursor (OP_DeferredSeek only) */
005225    i64 rowid;                  /* Rowid that P1 current points to */
005226  
005227    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
005228    pC = p->apCsr[pOp->p1];
005229    assert( pC!=0 );
005230    assert( pC->eCurType==CURTYPE_BTREE );
005231    assert( pC->uc.pCursor!=0 );
005232    assert( pC->isTable==0 );
005233    assert( pC->deferredMoveto==0 );
005234    assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
005235  
005236    /* The IdxRowid and Seek opcodes are combined because of the commonality
005237    ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */
005238    rc = sqlite3VdbeCursorRestore(pC);
005239  
005240    /* sqlite3VbeCursorRestore() can only fail if the record has been deleted
005241    ** out from under the cursor.  That will never happens for an IdxRowid
005242    ** or Seek opcode */
005243    if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
005244  
005245    if( !pC->nullRow ){
005246      rowid = 0;  /* Not needed.  Only used to silence a warning. */
005247      rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
005248      if( rc!=SQLITE_OK ){
005249        goto abort_due_to_error;
005250      }
005251      if( pOp->opcode==OP_DeferredSeek ){
005252        assert( pOp->p3>=0 && pOp->p3<p->nCursor );
005253        pTabCur = p->apCsr[pOp->p3];
005254        assert( pTabCur!=0 );
005255        assert( pTabCur->eCurType==CURTYPE_BTREE );
005256        assert( pTabCur->uc.pCursor!=0 );
005257        assert( pTabCur->isTable );
005258        pTabCur->nullRow = 0;
005259        pTabCur->movetoTarget = rowid;
005260        pTabCur->deferredMoveto = 1;
005261        assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
005262        pTabCur->aAltMap = pOp->p4.ai;
005263        pTabCur->pAltCursor = pC;
005264      }else{
005265        pOut = out2Prerelease(p, pOp);
005266        pOut->u.i = rowid;
005267      }
005268    }else{
005269      assert( pOp->opcode==OP_IdxRowid );
005270      sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
005271    }
005272    break;
005273  }
005274  
005275  /* Opcode: IdxGE P1 P2 P3 P4 P5
005276  ** Synopsis: key=r[P3@P4]
005277  **
005278  ** The P4 register values beginning with P3 form an unpacked index 
005279  ** key that omits the PRIMARY KEY.  Compare this key value against the index 
005280  ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID 
005281  ** fields at the end.
005282  **
005283  ** If the P1 index entry is greater than or equal to the key value
005284  ** then jump to P2.  Otherwise fall through to the next instruction.
005285  */
005286  /* Opcode: IdxGT P1 P2 P3 P4 P5
005287  ** Synopsis: key=r[P3@P4]
005288  **
005289  ** The P4 register values beginning with P3 form an unpacked index 
005290  ** key that omits the PRIMARY KEY.  Compare this key value against the index 
005291  ** that P1 is currently pointing to, ignoring the PRIMARY KEY or ROWID 
005292  ** fields at the end.
005293  **
005294  ** If the P1 index entry is greater than the key value
005295  ** then jump to P2.  Otherwise fall through to the next instruction.
005296  */
005297  /* Opcode: IdxLT P1 P2 P3 P4 P5
005298  ** Synopsis: key=r[P3@P4]
005299  **
005300  ** The P4 register values beginning with P3 form an unpacked index 
005301  ** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
005302  ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
005303  ** ROWID on the P1 index.
005304  **
005305  ** If the P1 index entry is less than the key value then jump to P2.
005306  ** Otherwise fall through to the next instruction.
005307  */
005308  /* Opcode: IdxLE P1 P2 P3 P4 P5
005309  ** Synopsis: key=r[P3@P4]
005310  **
005311  ** The P4 register values beginning with P3 form an unpacked index 
005312  ** key that omits the PRIMARY KEY or ROWID.  Compare this key value against
005313  ** the index that P1 is currently pointing to, ignoring the PRIMARY KEY or
005314  ** ROWID on the P1 index.
005315  **
005316  ** If the P1 index entry is less than or equal to the key value then jump
005317  ** to P2. Otherwise fall through to the next instruction.
005318  */
005319  case OP_IdxLE:          /* jump */
005320  case OP_IdxGT:          /* jump */
005321  case OP_IdxLT:          /* jump */
005322  case OP_IdxGE:  {       /* jump */
005323    VdbeCursor *pC;
005324    int res;
005325    UnpackedRecord r;
005326  
005327    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
005328    pC = p->apCsr[pOp->p1];
005329    assert( pC!=0 );
005330    assert( pC->isOrdered );
005331    assert( pC->eCurType==CURTYPE_BTREE );
005332    assert( pC->uc.pCursor!=0);
005333    assert( pC->deferredMoveto==0 );
005334    assert( pOp->p5==0 || pOp->p5==1 );
005335    assert( pOp->p4type==P4_INT32 );
005336    r.pKeyInfo = pC->pKeyInfo;
005337    r.nField = (u16)pOp->p4.i;
005338    if( pOp->opcode<OP_IdxLT ){
005339      assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxGT );
005340      r.default_rc = -1;
005341    }else{
005342      assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxLT );
005343      r.default_rc = 0;
005344    }
005345    r.aMem = &aMem[pOp->p3];
005346  #ifdef SQLITE_DEBUG
005347    { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
005348  #endif
005349    res = 0;  /* Not needed.  Only used to silence a warning. */
005350    rc = sqlite3VdbeIdxKeyCompare(db, pC, &r, &res);
005351    assert( (OP_IdxLE&1)==(OP_IdxLT&1) && (OP_IdxGE&1)==(OP_IdxGT&1) );
005352    if( (pOp->opcode&1)==(OP_IdxLT&1) ){
005353      assert( pOp->opcode==OP_IdxLE || pOp->opcode==OP_IdxLT );
005354      res = -res;
005355    }else{
005356      assert( pOp->opcode==OP_IdxGE || pOp->opcode==OP_IdxGT );
005357      res++;
005358    }
005359    VdbeBranchTaken(res>0,2);
005360    if( rc ) goto abort_due_to_error;
005361    if( res>0 ) goto jump_to_p2;
005362    break;
005363  }
005364  
005365  /* Opcode: Destroy P1 P2 P3 * *
005366  **
005367  ** Delete an entire database table or index whose root page in the database
005368  ** file is given by P1.
005369  **
005370  ** The table being destroyed is in the main database file if P3==0.  If
005371  ** P3==1 then the table to be clear is in the auxiliary database file
005372  ** that is used to store tables create using CREATE TEMPORARY TABLE.
005373  **
005374  ** If AUTOVACUUM is enabled then it is possible that another root page
005375  ** might be moved into the newly deleted root page in order to keep all
005376  ** root pages contiguous at the beginning of the database.  The former
005377  ** value of the root page that moved - its value before the move occurred -
005378  ** is stored in register P2. If no page movement was required (because the
005379  ** table being dropped was already the last one in the database) then a 
005380  ** zero is stored in register P2.  If AUTOVACUUM is disabled then a zero 
005381  ** is stored in register P2.
005382  **
005383  ** This opcode throws an error if there are any active reader VMs when
005384  ** it is invoked. This is done to avoid the difficulty associated with 
005385  ** updating existing cursors when a root page is moved in an AUTOVACUUM 
005386  ** database. This error is thrown even if the database is not an AUTOVACUUM 
005387  ** db in order to avoid introducing an incompatibility between autovacuum 
005388  ** and non-autovacuum modes.
005389  **
005390  ** See also: Clear
005391  */
005392  case OP_Destroy: {     /* out2 */
005393    int iMoved;
005394    int iDb;
005395  
005396    assert( p->readOnly==0 );
005397    assert( pOp->p1>1 );
005398    pOut = out2Prerelease(p, pOp);
005399    pOut->flags = MEM_Null;
005400    if( db->nVdbeRead > db->nVDestroy+1 ){
005401      rc = SQLITE_LOCKED;
005402      p->errorAction = OE_Abort;
005403      goto abort_due_to_error;
005404    }else{
005405      iDb = pOp->p3;
005406      assert( DbMaskTest(p->btreeMask, iDb) );
005407      iMoved = 0;  /* Not needed.  Only to silence a warning. */
005408      rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
005409      pOut->flags = MEM_Int;
005410      pOut->u.i = iMoved;
005411      if( rc ) goto abort_due_to_error;
005412  #ifndef SQLITE_OMIT_AUTOVACUUM
005413      if( iMoved!=0 ){
005414        sqlite3RootPageMoved(db, iDb, iMoved, pOp->p1);
005415        /* All OP_Destroy operations occur on the same btree */
005416        assert( resetSchemaOnFault==0 || resetSchemaOnFault==iDb+1 );
005417        resetSchemaOnFault = iDb+1;
005418      }
005419  #endif
005420    }
005421    break;
005422  }
005423  
005424  /* Opcode: Clear P1 P2 P3
005425  **
005426  ** Delete all contents of the database table or index whose root page
005427  ** in the database file is given by P1.  But, unlike Destroy, do not
005428  ** remove the table or index from the database file.
005429  **
005430  ** The table being clear is in the main database file if P2==0.  If
005431  ** P2==1 then the table to be clear is in the auxiliary database file
005432  ** that is used to store tables create using CREATE TEMPORARY TABLE.
005433  **
005434  ** If the P3 value is non-zero, then the table referred to must be an
005435  ** intkey table (an SQL table, not an index). In this case the row change 
005436  ** count is incremented by the number of rows in the table being cleared. 
005437  ** If P3 is greater than zero, then the value stored in register P3 is
005438  ** also incremented by the number of rows in the table being cleared.
005439  **
005440  ** See also: Destroy
005441  */
005442  case OP_Clear: {
005443    int nChange;
005444   
005445    nChange = 0;
005446    assert( p->readOnly==0 );
005447    assert( DbMaskTest(p->btreeMask, pOp->p2) );
005448    rc = sqlite3BtreeClearTable(
005449        db->aDb[pOp->p2].pBt, pOp->p1, (pOp->p3 ? &nChange : 0)
005450    );
005451    if( pOp->p3 ){
005452      p->nChange += nChange;
005453      if( pOp->p3>0 ){
005454        assert( memIsValid(&aMem[pOp->p3]) );
005455        memAboutToChange(p, &aMem[pOp->p3]);
005456        aMem[pOp->p3].u.i += nChange;
005457      }
005458    }
005459    if( rc ) goto abort_due_to_error;
005460    break;
005461  }
005462  
005463  /* Opcode: ResetSorter P1 * * * *
005464  **
005465  ** Delete all contents from the ephemeral table or sorter
005466  ** that is open on cursor P1.
005467  **
005468  ** This opcode only works for cursors used for sorting and
005469  ** opened with OP_OpenEphemeral or OP_SorterOpen.
005470  */
005471  case OP_ResetSorter: {
005472    VdbeCursor *pC;
005473   
005474    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
005475    pC = p->apCsr[pOp->p1];
005476    assert( pC!=0 );
005477    if( isSorter(pC) ){
005478      sqlite3VdbeSorterReset(db, pC->uc.pSorter);
005479    }else{
005480      assert( pC->eCurType==CURTYPE_BTREE );
005481      assert( pC->isEphemeral );
005482      rc = sqlite3BtreeClearTableOfCursor(pC->uc.pCursor);
005483      if( rc ) goto abort_due_to_error;
005484    }
005485    break;
005486  }
005487  
005488  /* Opcode: CreateBtree P1 P2 P3 * *
005489  ** Synopsis: r[P2]=root iDb=P1 flags=P3
005490  **
005491  ** Allocate a new b-tree in the main database file if P1==0 or in the
005492  ** TEMP database file if P1==1 or in an attached database if
005493  ** P1>1.  The P3 argument must be 1 (BTREE_INTKEY) for a rowid table
005494  ** it must be 2 (BTREE_BLOBKEY) for a index or WITHOUT ROWID table.
005495  ** The root page number of the new b-tree is stored in register P2.
005496  */
005497  case OP_CreateBtree: {          /* out2 */
005498    int pgno;
005499    Db *pDb;
005500  
005501    pOut = out2Prerelease(p, pOp);
005502    pgno = 0;
005503    assert( pOp->p3==BTREE_INTKEY || pOp->p3==BTREE_BLOBKEY );
005504    assert( pOp->p1>=0 && pOp->p1<db->nDb );
005505    assert( DbMaskTest(p->btreeMask, pOp->p1) );
005506    assert( p->readOnly==0 );
005507    pDb = &db->aDb[pOp->p1];
005508    assert( pDb->pBt!=0 );
005509    rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, pOp->p3);
005510    if( rc ) goto abort_due_to_error;
005511    pOut->u.i = pgno;
005512    break;
005513  }
005514  
005515  /* Opcode: SqlExec * * * P4 *
005516  **
005517  ** Run the SQL statement or statements specified in the P4 string.
005518  */
005519  case OP_SqlExec: {
005520    db->nSqlExec++;
005521    rc = sqlite3_exec(db, pOp->p4.z, 0, 0, 0);
005522    db->nSqlExec--;
005523    if( rc ) goto abort_due_to_error;
005524    break;
005525  }
005526  
005527  /* Opcode: ParseSchema P1 * * P4 *
005528  **
005529  ** Read and parse all entries from the SQLITE_MASTER table of database P1
005530  ** that match the WHERE clause P4. 
005531  **
005532  ** This opcode invokes the parser to create a new virtual machine,
005533  ** then runs the new virtual machine.  It is thus a re-entrant opcode.
005534  */
005535  case OP_ParseSchema: {
005536    int iDb;
005537    const char *zMaster;
005538    char *zSql;
005539    InitData initData;
005540  
005541    /* Any prepared statement that invokes this opcode will hold mutexes
005542    ** on every btree.  This is a prerequisite for invoking 
005543    ** sqlite3InitCallback().
005544    */
005545  #ifdef SQLITE_DEBUG
005546    for(iDb=0; iDb<db->nDb; iDb++){
005547      assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
005548    }
005549  #endif
005550  
005551    iDb = pOp->p1;
005552    assert( iDb>=0 && iDb<db->nDb );
005553    assert( DbHasProperty(db, iDb, DB_SchemaLoaded) );
005554    /* Used to be a conditional */ {
005555      zMaster = MASTER_NAME;
005556      initData.db = db;
005557      initData.iDb = pOp->p1;
005558      initData.pzErrMsg = &p->zErrMsg;
005559      zSql = sqlite3MPrintf(db,
005560         "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s ORDER BY rowid",
005561         db->aDb[iDb].zDbSName, zMaster, pOp->p4.z);
005562      if( zSql==0 ){
005563        rc = SQLITE_NOMEM_BKPT;
005564      }else{
005565        assert( db->init.busy==0 );
005566        db->init.busy = 1;
005567        initData.rc = SQLITE_OK;
005568        assert( !db->mallocFailed );
005569        rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
005570        if( rc==SQLITE_OK ) rc = initData.rc;
005571        sqlite3DbFreeNN(db, zSql);
005572        db->init.busy = 0;
005573      }
005574    }
005575    if( rc ){
005576      sqlite3ResetAllSchemasOfConnection(db);
005577      if( rc==SQLITE_NOMEM ){
005578        goto no_mem;
005579      }
005580      goto abort_due_to_error;
005581    }
005582    break;  
005583  }
005584  
005585  #if !defined(SQLITE_OMIT_ANALYZE)
005586  /* Opcode: LoadAnalysis P1 * * * *
005587  **
005588  ** Read the sqlite_stat1 table for database P1 and load the content
005589  ** of that table into the internal index hash table.  This will cause
005590  ** the analysis to be used when preparing all subsequent queries.
005591  */
005592  case OP_LoadAnalysis: {
005593    assert( pOp->p1>=0 && pOp->p1<db->nDb );
005594    rc = sqlite3AnalysisLoad(db, pOp->p1);
005595    if( rc ) goto abort_due_to_error;
005596    break;  
005597  }
005598  #endif /* !defined(SQLITE_OMIT_ANALYZE) */
005599  
005600  /* Opcode: DropTable P1 * * P4 *
005601  **
005602  ** Remove the internal (in-memory) data structures that describe
005603  ** the table named P4 in database P1.  This is called after a table
005604  ** is dropped from disk (using the Destroy opcode) in order to keep 
005605  ** the internal representation of the
005606  ** schema consistent with what is on disk.
005607  */
005608  case OP_DropTable: {
005609    sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
005610    break;
005611  }
005612  
005613  /* Opcode: DropIndex P1 * * P4 *
005614  **
005615  ** Remove the internal (in-memory) data structures that describe
005616  ** the index named P4 in database P1.  This is called after an index
005617  ** is dropped from disk (using the Destroy opcode)
005618  ** in order to keep the internal representation of the
005619  ** schema consistent with what is on disk.
005620  */
005621  case OP_DropIndex: {
005622    sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
005623    break;
005624  }
005625  
005626  /* Opcode: DropTrigger P1 * * P4 *
005627  **
005628  ** Remove the internal (in-memory) data structures that describe
005629  ** the trigger named P4 in database P1.  This is called after a trigger
005630  ** is dropped from disk (using the Destroy opcode) in order to keep 
005631  ** the internal representation of the
005632  ** schema consistent with what is on disk.
005633  */
005634  case OP_DropTrigger: {
005635    sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
005636    break;
005637  }
005638  
005639  
005640  #ifndef SQLITE_OMIT_INTEGRITY_CHECK
005641  /* Opcode: IntegrityCk P1 P2 P3 P4 P5
005642  **
005643  ** Do an analysis of the currently open database.  Store in
005644  ** register P1 the text of an error message describing any problems.
005645  ** If no problems are found, store a NULL in register P1.
005646  **
005647  ** The register P3 contains one less than the maximum number of allowed errors.
005648  ** At most reg(P3) errors will be reported.
005649  ** In other words, the analysis stops as soon as reg(P1) errors are 
005650  ** seen.  Reg(P1) is updated with the number of errors remaining.
005651  **
005652  ** The root page numbers of all tables in the database are integers
005653  ** stored in P4_INTARRAY argument.
005654  **
005655  ** If P5 is not zero, the check is done on the auxiliary database
005656  ** file, not the main database file.
005657  **
005658  ** This opcode is used to implement the integrity_check pragma.
005659  */
005660  case OP_IntegrityCk: {
005661    int nRoot;      /* Number of tables to check.  (Number of root pages.) */
005662    int *aRoot;     /* Array of rootpage numbers for tables to be checked */
005663    int nErr;       /* Number of errors reported */
005664    char *z;        /* Text of the error report */
005665    Mem *pnErr;     /* Register keeping track of errors remaining */
005666  
005667    assert( p->bIsReader );
005668    nRoot = pOp->p2;
005669    aRoot = pOp->p4.ai;
005670    assert( nRoot>0 );
005671    assert( aRoot[0]==nRoot );
005672    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
005673    pnErr = &aMem[pOp->p3];
005674    assert( (pnErr->flags & MEM_Int)!=0 );
005675    assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
005676    pIn1 = &aMem[pOp->p1];
005677    assert( pOp->p5<db->nDb );
005678    assert( DbMaskTest(p->btreeMask, pOp->p5) );
005679    z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, &aRoot[1], nRoot,
005680                                   (int)pnErr->u.i+1, &nErr);
005681    sqlite3VdbeMemSetNull(pIn1);
005682    if( nErr==0 ){
005683      assert( z==0 );
005684    }else if( z==0 ){
005685      goto no_mem;
005686    }else{
005687      pnErr->u.i -= nErr-1;
005688      sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
005689    }
005690    UPDATE_MAX_BLOBSIZE(pIn1);
005691    sqlite3VdbeChangeEncoding(pIn1, encoding);
005692    break;
005693  }
005694  #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
005695  
005696  /* Opcode: RowSetAdd P1 P2 * * *
005697  ** Synopsis: rowset(P1)=r[P2]
005698  **
005699  ** Insert the integer value held by register P2 into a RowSet object
005700  ** held in register P1.
005701  **
005702  ** An assertion fails if P2 is not an integer.
005703  */
005704  case OP_RowSetAdd: {       /* in1, in2 */
005705    pIn1 = &aMem[pOp->p1];
005706    pIn2 = &aMem[pOp->p2];
005707    assert( (pIn2->flags & MEM_Int)!=0 );
005708    if( (pIn1->flags & MEM_RowSet)==0 ){
005709      sqlite3VdbeMemSetRowSet(pIn1);
005710      if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
005711    }
005712    sqlite3RowSetInsert(pIn1->u.pRowSet, pIn2->u.i);
005713    break;
005714  }
005715  
005716  /* Opcode: RowSetRead P1 P2 P3 * *
005717  ** Synopsis: r[P3]=rowset(P1)
005718  **
005719  ** Extract the smallest value from the RowSet object in P1
005720  ** and put that value into register P3.
005721  ** Or, if RowSet object P1 is initially empty, leave P3
005722  ** unchanged and jump to instruction P2.
005723  */
005724  case OP_RowSetRead: {       /* jump, in1, out3 */
005725    i64 val;
005726  
005727    pIn1 = &aMem[pOp->p1];
005728    if( (pIn1->flags & MEM_RowSet)==0 
005729     || sqlite3RowSetNext(pIn1->u.pRowSet, &val)==0
005730    ){
005731      /* The boolean index is empty */
005732      sqlite3VdbeMemSetNull(pIn1);
005733      VdbeBranchTaken(1,2);
005734      goto jump_to_p2_and_check_for_interrupt;
005735    }else{
005736      /* A value was pulled from the index */
005737      VdbeBranchTaken(0,2);
005738      sqlite3VdbeMemSetInt64(&aMem[pOp->p3], val);
005739    }
005740    goto check_for_interrupt;
005741  }
005742  
005743  /* Opcode: RowSetTest P1 P2 P3 P4
005744  ** Synopsis: if r[P3] in rowset(P1) goto P2
005745  **
005746  ** Register P3 is assumed to hold a 64-bit integer value. If register P1
005747  ** contains a RowSet object and that RowSet object contains
005748  ** the value held in P3, jump to register P2. Otherwise, insert the
005749  ** integer in P3 into the RowSet and continue on to the
005750  ** next opcode.
005751  **
005752  ** The RowSet object is optimized for the case where sets of integers
005753  ** are inserted in distinct phases, which each set contains no duplicates.
005754  ** Each set is identified by a unique P4 value. The first set
005755  ** must have P4==0, the final set must have P4==-1, and for all other sets
005756  ** must have P4>0.
005757  **
005758  ** This allows optimizations: (a) when P4==0 there is no need to test
005759  ** the RowSet object for P3, as it is guaranteed not to contain it,
005760  ** (b) when P4==-1 there is no need to insert the value, as it will
005761  ** never be tested for, and (c) when a value that is part of set X is
005762  ** inserted, there is no need to search to see if the same value was
005763  ** previously inserted as part of set X (only if it was previously
005764  ** inserted as part of some other set).
005765  */
005766  case OP_RowSetTest: {                     /* jump, in1, in3 */
005767    int iSet;
005768    int exists;
005769  
005770    pIn1 = &aMem[pOp->p1];
005771    pIn3 = &aMem[pOp->p3];
005772    iSet = pOp->p4.i;
005773    assert( pIn3->flags&MEM_Int );
005774  
005775    /* If there is anything other than a rowset object in memory cell P1,
005776    ** delete it now and initialize P1 with an empty rowset
005777    */
005778    if( (pIn1->flags & MEM_RowSet)==0 ){
005779      sqlite3VdbeMemSetRowSet(pIn1);
005780      if( (pIn1->flags & MEM_RowSet)==0 ) goto no_mem;
005781    }
005782  
005783    assert( pOp->p4type==P4_INT32 );
005784    assert( iSet==-1 || iSet>=0 );
005785    if( iSet ){
005786      exists = sqlite3RowSetTest(pIn1->u.pRowSet, iSet, pIn3->u.i);
005787      VdbeBranchTaken(exists!=0,2);
005788      if( exists ) goto jump_to_p2;
005789    }
005790    if( iSet>=0 ){
005791      sqlite3RowSetInsert(pIn1->u.pRowSet, pIn3->u.i);
005792    }
005793    break;
005794  }
005795  
005796  
005797  #ifndef SQLITE_OMIT_TRIGGER
005798  
005799  /* Opcode: Program P1 P2 P3 P4 P5
005800  **
005801  ** Execute the trigger program passed as P4 (type P4_SUBPROGRAM). 
005802  **
005803  ** P1 contains the address of the memory cell that contains the first memory 
005804  ** cell in an array of values used as arguments to the sub-program. P2 
005805  ** contains the address to jump to if the sub-program throws an IGNORE 
005806  ** exception using the RAISE() function. Register P3 contains the address 
005807  ** of a memory cell in this (the parent) VM that is used to allocate the 
005808  ** memory required by the sub-vdbe at runtime.
005809  **
005810  ** P4 is a pointer to the VM containing the trigger program.
005811  **
005812  ** If P5 is non-zero, then recursive program invocation is enabled.
005813  */
005814  case OP_Program: {        /* jump */
005815    int nMem;               /* Number of memory registers for sub-program */
005816    int nByte;              /* Bytes of runtime space required for sub-program */
005817    Mem *pRt;               /* Register to allocate runtime space */
005818    Mem *pMem;              /* Used to iterate through memory cells */
005819    Mem *pEnd;              /* Last memory cell in new array */
005820    VdbeFrame *pFrame;      /* New vdbe frame to execute in */
005821    SubProgram *pProgram;   /* Sub-program to execute */
005822    void *t;                /* Token identifying trigger */
005823  
005824    pProgram = pOp->p4.pProgram;
005825    pRt = &aMem[pOp->p3];
005826    assert( pProgram->nOp>0 );
005827    
005828    /* If the p5 flag is clear, then recursive invocation of triggers is 
005829    ** disabled for backwards compatibility (p5 is set if this sub-program
005830    ** is really a trigger, not a foreign key action, and the flag set
005831    ** and cleared by the "PRAGMA recursive_triggers" command is clear).
005832    ** 
005833    ** It is recursive invocation of triggers, at the SQL level, that is 
005834    ** disabled. In some cases a single trigger may generate more than one 
005835    ** SubProgram (if the trigger may be executed with more than one different 
005836    ** ON CONFLICT algorithm). SubProgram structures associated with a
005837    ** single trigger all have the same value for the SubProgram.token 
005838    ** variable.  */
005839    if( pOp->p5 ){
005840      t = pProgram->token;
005841      for(pFrame=p->pFrame; pFrame && pFrame->token!=t; pFrame=pFrame->pParent);
005842      if( pFrame ) break;
005843    }
005844  
005845    if( p->nFrame>=db->aLimit[SQLITE_LIMIT_TRIGGER_DEPTH] ){
005846      rc = SQLITE_ERROR;
005847      sqlite3VdbeError(p, "too many levels of trigger recursion");
005848      goto abort_due_to_error;
005849    }
005850  
005851    /* Register pRt is used to store the memory required to save the state
005852    ** of the current program, and the memory required at runtime to execute
005853    ** the trigger program. If this trigger has been fired before, then pRt 
005854    ** is already allocated. Otherwise, it must be initialized.  */
005855    if( (pRt->flags&MEM_Frame)==0 ){
005856      /* SubProgram.nMem is set to the number of memory cells used by the 
005857      ** program stored in SubProgram.aOp. As well as these, one memory
005858      ** cell is required for each cursor used by the program. Set local
005859      ** variable nMem (and later, VdbeFrame.nChildMem) to this value.
005860      */
005861      nMem = pProgram->nMem + pProgram->nCsr;
005862      assert( nMem>0 );
005863      if( pProgram->nCsr==0 ) nMem++;
005864      nByte = ROUND8(sizeof(VdbeFrame))
005865                + nMem * sizeof(Mem)
005866                + pProgram->nCsr * sizeof(VdbeCursor*)
005867                + (pProgram->nOp + 7)/8;
005868      pFrame = sqlite3DbMallocZero(db, nByte);
005869      if( !pFrame ){
005870        goto no_mem;
005871      }
005872      sqlite3VdbeMemRelease(pRt);
005873      pRt->flags = MEM_Frame;
005874      pRt->u.pFrame = pFrame;
005875  
005876      pFrame->v = p;
005877      pFrame->nChildMem = nMem;
005878      pFrame->nChildCsr = pProgram->nCsr;
005879      pFrame->pc = (int)(pOp - aOp);
005880      pFrame->aMem = p->aMem;
005881      pFrame->nMem = p->nMem;
005882      pFrame->apCsr = p->apCsr;
005883      pFrame->nCursor = p->nCursor;
005884      pFrame->aOp = p->aOp;
005885      pFrame->nOp = p->nOp;
005886      pFrame->token = pProgram->token;
005887  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
005888      pFrame->anExec = p->anExec;
005889  #endif
005890  
005891      pEnd = &VdbeFrameMem(pFrame)[pFrame->nChildMem];
005892      for(pMem=VdbeFrameMem(pFrame); pMem!=pEnd; pMem++){
005893        pMem->flags = MEM_Undefined;
005894        pMem->db = db;
005895      }
005896    }else{
005897      pFrame = pRt->u.pFrame;
005898      assert( pProgram->nMem+pProgram->nCsr==pFrame->nChildMem 
005899          || (pProgram->nCsr==0 && pProgram->nMem+1==pFrame->nChildMem) );
005900      assert( pProgram->nCsr==pFrame->nChildCsr );
005901      assert( (int)(pOp - aOp)==pFrame->pc );
005902    }
005903  
005904    p->nFrame++;
005905    pFrame->pParent = p->pFrame;
005906    pFrame->lastRowid = db->lastRowid;
005907    pFrame->nChange = p->nChange;
005908    pFrame->nDbChange = p->db->nChange;
005909    assert( pFrame->pAuxData==0 );
005910    pFrame->pAuxData = p->pAuxData;
005911    p->pAuxData = 0;
005912    p->nChange = 0;
005913    p->pFrame = pFrame;
005914    p->aMem = aMem = VdbeFrameMem(pFrame);
005915    p->nMem = pFrame->nChildMem;
005916    p->nCursor = (u16)pFrame->nChildCsr;
005917    p->apCsr = (VdbeCursor **)&aMem[p->nMem];
005918    pFrame->aOnce = (u8*)&p->apCsr[pProgram->nCsr];
005919    memset(pFrame->aOnce, 0, (pProgram->nOp + 7)/8);
005920    p->aOp = aOp = pProgram->aOp;
005921    p->nOp = pProgram->nOp;
005922  #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
005923    p->anExec = 0;
005924  #endif
005925    pOp = &aOp[-1];
005926  
005927    break;
005928  }
005929  
005930  /* Opcode: Param P1 P2 * * *
005931  **
005932  ** This opcode is only ever present in sub-programs called via the 
005933  ** OP_Program instruction. Copy a value currently stored in a memory 
005934  ** cell of the calling (parent) frame to cell P2 in the current frames 
005935  ** address space. This is used by trigger programs to access the new.* 
005936  ** and old.* values.
005937  **
005938  ** The address of the cell in the parent frame is determined by adding
005939  ** the value of the P1 argument to the value of the P1 argument to the
005940  ** calling OP_Program instruction.
005941  */
005942  case OP_Param: {           /* out2 */
005943    VdbeFrame *pFrame;
005944    Mem *pIn;
005945    pOut = out2Prerelease(p, pOp);
005946    pFrame = p->pFrame;
005947    pIn = &pFrame->aMem[pOp->p1 + pFrame->aOp[pFrame->pc].p1];   
005948    sqlite3VdbeMemShallowCopy(pOut, pIn, MEM_Ephem);
005949    break;
005950  }
005951  
005952  #endif /* #ifndef SQLITE_OMIT_TRIGGER */
005953  
005954  #ifndef SQLITE_OMIT_FOREIGN_KEY
005955  /* Opcode: FkCounter P1 P2 * * *
005956  ** Synopsis: fkctr[P1]+=P2
005957  **
005958  ** Increment a "constraint counter" by P2 (P2 may be negative or positive).
005959  ** If P1 is non-zero, the database constraint counter is incremented 
005960  ** (deferred foreign key constraints). Otherwise, if P1 is zero, the 
005961  ** statement counter is incremented (immediate foreign key constraints).
005962  */
005963  case OP_FkCounter: {
005964    if( db->flags & SQLITE_DeferFKs ){
005965      db->nDeferredImmCons += pOp->p2;
005966    }else if( pOp->p1 ){
005967      db->nDeferredCons += pOp->p2;
005968    }else{
005969      p->nFkConstraint += pOp->p2;
005970    }
005971    break;
005972  }
005973  
005974  /* Opcode: FkIfZero P1 P2 * * *
005975  ** Synopsis: if fkctr[P1]==0 goto P2
005976  **
005977  ** This opcode tests if a foreign key constraint-counter is currently zero.
005978  ** If so, jump to instruction P2. Otherwise, fall through to the next 
005979  ** instruction.
005980  **
005981  ** If P1 is non-zero, then the jump is taken if the database constraint-counter
005982  ** is zero (the one that counts deferred constraint violations). If P1 is
005983  ** zero, the jump is taken if the statement constraint-counter is zero
005984  ** (immediate foreign key constraint violations).
005985  */
005986  case OP_FkIfZero: {         /* jump */
005987    if( pOp->p1 ){
005988      VdbeBranchTaken(db->nDeferredCons==0 && db->nDeferredImmCons==0, 2);
005989      if( db->nDeferredCons==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
005990    }else{
005991      VdbeBranchTaken(p->nFkConstraint==0 && db->nDeferredImmCons==0, 2);
005992      if( p->nFkConstraint==0 && db->nDeferredImmCons==0 ) goto jump_to_p2;
005993    }
005994    break;
005995  }
005996  #endif /* #ifndef SQLITE_OMIT_FOREIGN_KEY */
005997  
005998  #ifndef SQLITE_OMIT_AUTOINCREMENT
005999  /* Opcode: MemMax P1 P2 * * *
006000  ** Synopsis: r[P1]=max(r[P1],r[P2])
006001  **
006002  ** P1 is a register in the root frame of this VM (the root frame is
006003  ** different from the current frame if this instruction is being executed
006004  ** within a sub-program). Set the value of register P1 to the maximum of 
006005  ** its current value and the value in register P2.
006006  **
006007  ** This instruction throws an error if the memory cell is not initially
006008  ** an integer.
006009  */
006010  case OP_MemMax: {        /* in2 */
006011    VdbeFrame *pFrame;
006012    if( p->pFrame ){
006013      for(pFrame=p->pFrame; pFrame->pParent; pFrame=pFrame->pParent);
006014      pIn1 = &pFrame->aMem[pOp->p1];
006015    }else{
006016      pIn1 = &aMem[pOp->p1];
006017    }
006018    assert( memIsValid(pIn1) );
006019    sqlite3VdbeMemIntegerify(pIn1);
006020    pIn2 = &aMem[pOp->p2];
006021    sqlite3VdbeMemIntegerify(pIn2);
006022    if( pIn1->u.i<pIn2->u.i){
006023      pIn1->u.i = pIn2->u.i;
006024    }
006025    break;
006026  }
006027  #endif /* SQLITE_OMIT_AUTOINCREMENT */
006028  
006029  /* Opcode: IfPos P1 P2 P3 * *
006030  ** Synopsis: if r[P1]>0 then r[P1]-=P3, goto P2
006031  **
006032  ** Register P1 must contain an integer.
006033  ** If the value of register P1 is 1 or greater, subtract P3 from the
006034  ** value in P1 and jump to P2.
006035  **
006036  ** If the initial value of register P1 is less than 1, then the
006037  ** value is unchanged and control passes through to the next instruction.
006038  */
006039  case OP_IfPos: {        /* jump, in1 */
006040    pIn1 = &aMem[pOp->p1];
006041    assert( pIn1->flags&MEM_Int );
006042    VdbeBranchTaken( pIn1->u.i>0, 2);
006043    if( pIn1->u.i>0 ){
006044      pIn1->u.i -= pOp->p3;
006045      goto jump_to_p2;
006046    }
006047    break;
006048  }
006049  
006050  /* Opcode: OffsetLimit P1 P2 P3 * *
006051  ** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)
006052  **
006053  ** This opcode performs a commonly used computation associated with
006054  ** LIMIT and OFFSET process.  r[P1] holds the limit counter.  r[P3]
006055  ** holds the offset counter.  The opcode computes the combined value
006056  ** of the LIMIT and OFFSET and stores that value in r[P2].  The r[P2]
006057  ** value computed is the total number of rows that will need to be
006058  ** visited in order to complete the query.
006059  **
006060  ** If r[P3] is zero or negative, that means there is no OFFSET
006061  ** and r[P2] is set to be the value of the LIMIT, r[P1].
006062  **
006063  ** if r[P1] is zero or negative, that means there is no LIMIT
006064  ** and r[P2] is set to -1. 
006065  **
006066  ** Otherwise, r[P2] is set to the sum of r[P1] and r[P3].
006067  */
006068  case OP_OffsetLimit: {    /* in1, out2, in3 */
006069    i64 x;
006070    pIn1 = &aMem[pOp->p1];
006071    pIn3 = &aMem[pOp->p3];
006072    pOut = out2Prerelease(p, pOp);
006073    assert( pIn1->flags & MEM_Int );
006074    assert( pIn3->flags & MEM_Int );
006075    x = pIn1->u.i;
006076    if( x<=0 || sqlite3AddInt64(&x, pIn3->u.i>0?pIn3->u.i:0) ){
006077      /* If the LIMIT is less than or equal to zero, loop forever.  This
006078      ** is documented.  But also, if the LIMIT+OFFSET exceeds 2^63 then
006079      ** also loop forever.  This is undocumented.  In fact, one could argue
006080      ** that the loop should terminate.  But assuming 1 billion iterations
006081      ** per second (far exceeding the capabilities of any current hardware)
006082      ** it would take nearly 300 years to actually reach the limit.  So
006083      ** looping forever is a reasonable approximation. */
006084      pOut->u.i = -1;
006085    }else{
006086      pOut->u.i = x;
006087    }
006088    break;
006089  }
006090  
006091  /* Opcode: IfNotZero P1 P2 * * *
006092  ** Synopsis: if r[P1]!=0 then r[P1]--, goto P2
006093  **
006094  ** Register P1 must contain an integer.  If the content of register P1 is
006095  ** initially greater than zero, then decrement the value in register P1.
006096  ** If it is non-zero (negative or positive) and then also jump to P2.  
006097  ** If register P1 is initially zero, leave it unchanged and fall through.
006098  */
006099  case OP_IfNotZero: {        /* jump, in1 */
006100    pIn1 = &aMem[pOp->p1];
006101    assert( pIn1->flags&MEM_Int );
006102    VdbeBranchTaken(pIn1->u.i<0, 2);
006103    if( pIn1->u.i ){
006104       if( pIn1->u.i>0 ) pIn1->u.i--;
006105       goto jump_to_p2;
006106    }
006107    break;
006108  }
006109  
006110  /* Opcode: DecrJumpZero P1 P2 * * *
006111  ** Synopsis: if (--r[P1])==0 goto P2
006112  **
006113  ** Register P1 must hold an integer.  Decrement the value in P1
006114  ** and jump to P2 if the new value is exactly zero.
006115  */
006116  case OP_DecrJumpZero: {      /* jump, in1 */
006117    pIn1 = &aMem[pOp->p1];
006118    assert( pIn1->flags&MEM_Int );
006119    if( pIn1->u.i>SMALLEST_INT64 ) pIn1->u.i--;
006120    VdbeBranchTaken(pIn1->u.i==0, 2);
006121    if( pIn1->u.i==0 ) goto jump_to_p2;
006122    break;
006123  }
006124  
006125  
006126  /* Opcode: AggStep0 * P2 P3 P4 P5
006127  ** Synopsis: accum=r[P3] step(r[P2@P5])
006128  **
006129  ** Execute the step function for an aggregate.  The
006130  ** function has P5 arguments.   P4 is a pointer to the FuncDef
006131  ** structure that specifies the function.  Register P3 is the
006132  ** accumulator.
006133  **
006134  ** The P5 arguments are taken from register P2 and its
006135  ** successors.
006136  */
006137  /* Opcode: AggStep * P2 P3 P4 P5
006138  ** Synopsis: accum=r[P3] step(r[P2@P5])
006139  **
006140  ** Execute the step function for an aggregate.  The
006141  ** function has P5 arguments.   P4 is a pointer to an sqlite3_context
006142  ** object that is used to run the function.  Register P3 is
006143  ** as the accumulator.
006144  **
006145  ** The P5 arguments are taken from register P2 and its
006146  ** successors.
006147  **
006148  ** This opcode is initially coded as OP_AggStep0.  On first evaluation,
006149  ** the FuncDef stored in P4 is converted into an sqlite3_context and
006150  ** the opcode is changed.  In this way, the initialization of the
006151  ** sqlite3_context only happens once, instead of on each call to the
006152  ** step function.
006153  */
006154  case OP_AggStep0: {
006155    int n;
006156    sqlite3_context *pCtx;
006157  
006158    assert( pOp->p4type==P4_FUNCDEF );
006159    n = pOp->p5;
006160    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
006161    assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
006162    assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
006163    pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
006164    if( pCtx==0 ) goto no_mem;
006165    pCtx->pMem = 0;
006166    pCtx->pFunc = pOp->p4.pFunc;
006167    pCtx->iOp = (int)(pOp - aOp);
006168    pCtx->pVdbe = p;
006169    pCtx->argc = n;
006170    pOp->p4type = P4_FUNCCTX;
006171    pOp->p4.pCtx = pCtx;
006172    pOp->opcode = OP_AggStep;
006173    /* Fall through into OP_AggStep */
006174  }
006175  case OP_AggStep: {
006176    int i;
006177    sqlite3_context *pCtx;
006178    Mem *pMem;
006179    Mem t;
006180  
006181    assert( pOp->p4type==P4_FUNCCTX );
006182    pCtx = pOp->p4.pCtx;
006183    pMem = &aMem[pOp->p3];
006184  
006185    /* If this function is inside of a trigger, the register array in aMem[]
006186    ** might change from one evaluation to the next.  The next block of code
006187    ** checks to see if the register array has changed, and if so it
006188    ** reinitializes the relavant parts of the sqlite3_context object */
006189    if( pCtx->pMem != pMem ){
006190      pCtx->pMem = pMem;
006191      for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
006192    }
006193  
006194  #ifdef SQLITE_DEBUG
006195    for(i=0; i<pCtx->argc; i++){
006196      assert( memIsValid(pCtx->argv[i]) );
006197      REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
006198    }
006199  #endif
006200  
006201    pMem->n++;
006202    sqlite3VdbeMemInit(&t, db, MEM_Null);
006203    pCtx->pOut = &t;
006204    pCtx->fErrorOrAux = 0;
006205    pCtx->skipFlag = 0;
006206    (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
006207    if( pCtx->fErrorOrAux ){
006208      if( pCtx->isError ){
006209        sqlite3VdbeError(p, "%s", sqlite3_value_text(&t));
006210        rc = pCtx->isError;
006211      }
006212      sqlite3VdbeMemRelease(&t);
006213      if( rc ) goto abort_due_to_error;
006214    }else{
006215      assert( t.flags==MEM_Null );
006216    }
006217    if( pCtx->skipFlag ){
006218      assert( pOp[-1].opcode==OP_CollSeq );
006219      i = pOp[-1].p1;
006220      if( i ) sqlite3VdbeMemSetInt64(&aMem[i], 1);
006221    }
006222    break;
006223  }
006224  
006225  /* Opcode: AggFinal P1 P2 * P4 *
006226  ** Synopsis: accum=r[P1] N=P2
006227  **
006228  ** Execute the finalizer function for an aggregate.  P1 is
006229  ** the memory location that is the accumulator for the aggregate.
006230  **
006231  ** P2 is the number of arguments that the step function takes and
006232  ** P4 is a pointer to the FuncDef for this function.  The P2
006233  ** argument is not used by this opcode.  It is only there to disambiguate
006234  ** functions that can take varying numbers of arguments.  The
006235  ** P4 argument is only needed for the degenerate case where
006236  ** the step function was not previously called.
006237  */
006238  case OP_AggFinal: {
006239    Mem *pMem;
006240    assert( pOp->p1>0 && pOp->p1<=(p->nMem+1 - p->nCursor) );
006241    pMem = &aMem[pOp->p1];
006242    assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
006243    rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
006244    if( rc ){
006245      sqlite3VdbeError(p, "%s", sqlite3_value_text(pMem));
006246      goto abort_due_to_error;
006247    }
006248    sqlite3VdbeChangeEncoding(pMem, encoding);
006249    UPDATE_MAX_BLOBSIZE(pMem);
006250    if( sqlite3VdbeMemTooBig(pMem) ){
006251      goto too_big;
006252    }
006253    break;
006254  }
006255  
006256  #ifndef SQLITE_OMIT_WAL
006257  /* Opcode: Checkpoint P1 P2 P3 * *
006258  **
006259  ** Checkpoint database P1. This is a no-op if P1 is not currently in
006260  ** WAL mode. Parameter P2 is one of SQLITE_CHECKPOINT_PASSIVE, FULL,
006261  ** RESTART, or TRUNCATE.  Write 1 or 0 into mem[P3] if the checkpoint returns
006262  ** SQLITE_BUSY or not, respectively.  Write the number of pages in the
006263  ** WAL after the checkpoint into mem[P3+1] and the number of pages
006264  ** in the WAL that have been checkpointed after the checkpoint
006265  ** completes into mem[P3+2].  However on an error, mem[P3+1] and
006266  ** mem[P3+2] are initialized to -1.
006267  */
006268  case OP_Checkpoint: {
006269    int i;                          /* Loop counter */
006270    int aRes[3];                    /* Results */
006271    Mem *pMem;                      /* Write results here */
006272  
006273    assert( p->readOnly==0 );
006274    aRes[0] = 0;
006275    aRes[1] = aRes[2] = -1;
006276    assert( pOp->p2==SQLITE_CHECKPOINT_PASSIVE
006277         || pOp->p2==SQLITE_CHECKPOINT_FULL
006278         || pOp->p2==SQLITE_CHECKPOINT_RESTART
006279         || pOp->p2==SQLITE_CHECKPOINT_TRUNCATE
006280    );
006281    rc = sqlite3Checkpoint(db, pOp->p1, pOp->p2, &aRes[1], &aRes[2]);
006282    if( rc ){
006283      if( rc!=SQLITE_BUSY ) goto abort_due_to_error;
006284      rc = SQLITE_OK;
006285      aRes[0] = 1;
006286    }
006287    for(i=0, pMem = &aMem[pOp->p3]; i<3; i++, pMem++){
006288      sqlite3VdbeMemSetInt64(pMem, (i64)aRes[i]);
006289    }    
006290    break;
006291  };  
006292  #endif
006293  
006294  #ifndef SQLITE_OMIT_PRAGMA
006295  /* Opcode: JournalMode P1 P2 P3 * *
006296  **
006297  ** Change the journal mode of database P1 to P3. P3 must be one of the
006298  ** PAGER_JOURNALMODE_XXX values. If changing between the various rollback
006299  ** modes (delete, truncate, persist, off and memory), this is a simple
006300  ** operation. No IO is required.
006301  **
006302  ** If changing into or out of WAL mode the procedure is more complicated.
006303  **
006304  ** Write a string containing the final journal-mode to register P2.
006305  */
006306  case OP_JournalMode: {    /* out2 */
006307    Btree *pBt;                     /* Btree to change journal mode of */
006308    Pager *pPager;                  /* Pager associated with pBt */
006309    int eNew;                       /* New journal mode */
006310    int eOld;                       /* The old journal mode */
006311  #ifndef SQLITE_OMIT_WAL
006312    const char *zFilename;          /* Name of database file for pPager */
006313  #endif
006314  
006315    pOut = out2Prerelease(p, pOp);
006316    eNew = pOp->p3;
006317    assert( eNew==PAGER_JOURNALMODE_DELETE 
006318         || eNew==PAGER_JOURNALMODE_TRUNCATE 
006319         || eNew==PAGER_JOURNALMODE_PERSIST 
006320         || eNew==PAGER_JOURNALMODE_OFF
006321         || eNew==PAGER_JOURNALMODE_MEMORY
006322         || eNew==PAGER_JOURNALMODE_WAL
006323         || eNew==PAGER_JOURNALMODE_QUERY
006324    );
006325    assert( pOp->p1>=0 && pOp->p1<db->nDb );
006326    assert( p->readOnly==0 );
006327  
006328    pBt = db->aDb[pOp->p1].pBt;
006329    pPager = sqlite3BtreePager(pBt);
006330    eOld = sqlite3PagerGetJournalMode(pPager);
006331    if( eNew==PAGER_JOURNALMODE_QUERY ) eNew = eOld;
006332    if( !sqlite3PagerOkToChangeJournalMode(pPager) ) eNew = eOld;
006333  
006334  #ifndef SQLITE_OMIT_WAL
006335    zFilename = sqlite3PagerFilename(pPager, 1);
006336  
006337    /* Do not allow a transition to journal_mode=WAL for a database
006338    ** in temporary storage or if the VFS does not support shared memory 
006339    */
006340    if( eNew==PAGER_JOURNALMODE_WAL
006341     && (sqlite3Strlen30(zFilename)==0           /* Temp file */
006342         || !sqlite3PagerWalSupported(pPager))   /* No shared-memory support */
006343    ){
006344      eNew = eOld;
006345    }
006346  
006347    if( (eNew!=eOld)
006348     && (eOld==PAGER_JOURNALMODE_WAL || eNew==PAGER_JOURNALMODE_WAL)
006349    ){
006350      if( !db->autoCommit || db->nVdbeRead>1 ){
006351        rc = SQLITE_ERROR;
006352        sqlite3VdbeError(p,
006353            "cannot change %s wal mode from within a transaction",
006354            (eNew==PAGER_JOURNALMODE_WAL ? "into" : "out of")
006355        );
006356        goto abort_due_to_error;
006357      }else{
006358   
006359        if( eOld==PAGER_JOURNALMODE_WAL ){
006360          /* If leaving WAL mode, close the log file. If successful, the call
006361          ** to PagerCloseWal() checkpoints and deletes the write-ahead-log 
006362          ** file. An EXCLUSIVE lock may still be held on the database file 
006363          ** after a successful return. 
006364          */
006365          rc = sqlite3PagerCloseWal(pPager, db);
006366          if( rc==SQLITE_OK ){
006367            sqlite3PagerSetJournalMode(pPager, eNew);
006368          }
006369        }else if( eOld==PAGER_JOURNALMODE_MEMORY ){
006370          /* Cannot transition directly from MEMORY to WAL.  Use mode OFF
006371          ** as an intermediate */
006372          sqlite3PagerSetJournalMode(pPager, PAGER_JOURNALMODE_OFF);
006373        }
006374    
006375        /* Open a transaction on the database file. Regardless of the journal
006376        ** mode, this transaction always uses a rollback journal.
006377        */
006378        assert( sqlite3BtreeIsInTrans(pBt)==0 );
006379        if( rc==SQLITE_OK ){
006380          rc = sqlite3BtreeSetVersion(pBt, (eNew==PAGER_JOURNALMODE_WAL ? 2 : 1));
006381        }
006382      }
006383    }
006384  #endif /* ifndef SQLITE_OMIT_WAL */
006385  
006386    if( rc ) eNew = eOld;
006387    eNew = sqlite3PagerSetJournalMode(pPager, eNew);
006388  
006389    pOut->flags = MEM_Str|MEM_Static|MEM_Term;
006390    pOut->z = (char *)sqlite3JournalModename(eNew);
006391    pOut->n = sqlite3Strlen30(pOut->z);
006392    pOut->enc = SQLITE_UTF8;
006393    sqlite3VdbeChangeEncoding(pOut, encoding);
006394    if( rc ) goto abort_due_to_error;
006395    break;
006396  };
006397  #endif /* SQLITE_OMIT_PRAGMA */
006398  
006399  #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
006400  /* Opcode: Vacuum P1 * * * *
006401  **
006402  ** Vacuum the entire database P1.  P1 is 0 for "main", and 2 or more
006403  ** for an attached database.  The "temp" database may not be vacuumed.
006404  */
006405  case OP_Vacuum: {
006406    assert( p->readOnly==0 );
006407    rc = sqlite3RunVacuum(&p->zErrMsg, db, pOp->p1);
006408    if( rc ) goto abort_due_to_error;
006409    break;
006410  }
006411  #endif
006412  
006413  #if !defined(SQLITE_OMIT_AUTOVACUUM)
006414  /* Opcode: IncrVacuum P1 P2 * * *
006415  **
006416  ** Perform a single step of the incremental vacuum procedure on
006417  ** the P1 database. If the vacuum has finished, jump to instruction
006418  ** P2. Otherwise, fall through to the next instruction.
006419  */
006420  case OP_IncrVacuum: {        /* jump */
006421    Btree *pBt;
006422  
006423    assert( pOp->p1>=0 && pOp->p1<db->nDb );
006424    assert( DbMaskTest(p->btreeMask, pOp->p1) );
006425    assert( p->readOnly==0 );
006426    pBt = db->aDb[pOp->p1].pBt;
006427    rc = sqlite3BtreeIncrVacuum(pBt);
006428    VdbeBranchTaken(rc==SQLITE_DONE,2);
006429    if( rc ){
006430      if( rc!=SQLITE_DONE ) goto abort_due_to_error;
006431      rc = SQLITE_OK;
006432      goto jump_to_p2;
006433    }
006434    break;
006435  }
006436  #endif
006437  
006438  /* Opcode: Expire P1 * * * *
006439  **
006440  ** Cause precompiled statements to expire.  When an expired statement
006441  ** is executed using sqlite3_step() it will either automatically
006442  ** reprepare itself (if it was originally created using sqlite3_prepare_v2())
006443  ** or it will fail with SQLITE_SCHEMA.
006444  ** 
006445  ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
006446  ** then only the currently executing statement is expired.
006447  */
006448  case OP_Expire: {
006449    if( !pOp->p1 ){
006450      sqlite3ExpirePreparedStatements(db);
006451    }else{
006452      p->expired = 1;
006453    }
006454    break;
006455  }
006456  
006457  #ifndef SQLITE_OMIT_SHARED_CACHE
006458  /* Opcode: TableLock P1 P2 P3 P4 *
006459  ** Synopsis: iDb=P1 root=P2 write=P3
006460  **
006461  ** Obtain a lock on a particular table. This instruction is only used when
006462  ** the shared-cache feature is enabled. 
006463  **
006464  ** P1 is the index of the database in sqlite3.aDb[] of the database
006465  ** on which the lock is acquired.  A readlock is obtained if P3==0 or
006466  ** a write lock if P3==1.
006467  **
006468  ** P2 contains the root-page of the table to lock.
006469  **
006470  ** P4 contains a pointer to the name of the table being locked. This is only
006471  ** used to generate an error message if the lock cannot be obtained.
006472  */
006473  case OP_TableLock: {
006474    u8 isWriteLock = (u8)pOp->p3;
006475    if( isWriteLock || 0==(db->flags&SQLITE_ReadUncommit) ){
006476      int p1 = pOp->p1; 
006477      assert( p1>=0 && p1<db->nDb );
006478      assert( DbMaskTest(p->btreeMask, p1) );
006479      assert( isWriteLock==0 || isWriteLock==1 );
006480      rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
006481      if( rc ){
006482        if( (rc&0xFF)==SQLITE_LOCKED ){
006483          const char *z = pOp->p4.z;
006484          sqlite3VdbeError(p, "database table is locked: %s", z);
006485        }
006486        goto abort_due_to_error;
006487      }
006488    }
006489    break;
006490  }
006491  #endif /* SQLITE_OMIT_SHARED_CACHE */
006492  
006493  #ifndef SQLITE_OMIT_VIRTUALTABLE
006494  /* Opcode: VBegin * * * P4 *
006495  **
006496  ** P4 may be a pointer to an sqlite3_vtab structure. If so, call the 
006497  ** xBegin method for that table.
006498  **
006499  ** Also, whether or not P4 is set, check that this is not being called from
006500  ** within a callback to a virtual table xSync() method. If it is, the error
006501  ** code will be set to SQLITE_LOCKED.
006502  */
006503  case OP_VBegin: {
006504    VTable *pVTab;
006505    pVTab = pOp->p4.pVtab;
006506    rc = sqlite3VtabBegin(db, pVTab);
006507    if( pVTab ) sqlite3VtabImportErrmsg(p, pVTab->pVtab);
006508    if( rc ) goto abort_due_to_error;
006509    break;
006510  }
006511  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006512  
006513  #ifndef SQLITE_OMIT_VIRTUALTABLE
006514  /* Opcode: VCreate P1 P2 * * *
006515  **
006516  ** P2 is a register that holds the name of a virtual table in database 
006517  ** P1. Call the xCreate method for that table.
006518  */
006519  case OP_VCreate: {
006520    Mem sMem;          /* For storing the record being decoded */
006521    const char *zTab;  /* Name of the virtual table */
006522  
006523    memset(&sMem, 0, sizeof(sMem));
006524    sMem.db = db;
006525    /* Because P2 is always a static string, it is impossible for the
006526    ** sqlite3VdbeMemCopy() to fail */
006527    assert( (aMem[pOp->p2].flags & MEM_Str)!=0 );
006528    assert( (aMem[pOp->p2].flags & MEM_Static)!=0 );
006529    rc = sqlite3VdbeMemCopy(&sMem, &aMem[pOp->p2]);
006530    assert( rc==SQLITE_OK );
006531    zTab = (const char*)sqlite3_value_text(&sMem);
006532    assert( zTab || db->mallocFailed );
006533    if( zTab ){
006534      rc = sqlite3VtabCallCreate(db, pOp->p1, zTab, &p->zErrMsg);
006535    }
006536    sqlite3VdbeMemRelease(&sMem);
006537    if( rc ) goto abort_due_to_error;
006538    break;
006539  }
006540  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006541  
006542  #ifndef SQLITE_OMIT_VIRTUALTABLE
006543  /* Opcode: VDestroy P1 * * P4 *
006544  **
006545  ** P4 is the name of a virtual table in database P1.  Call the xDestroy method
006546  ** of that table.
006547  */
006548  case OP_VDestroy: {
006549    db->nVDestroy++;
006550    rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
006551    db->nVDestroy--;
006552    if( rc ) goto abort_due_to_error;
006553    break;
006554  }
006555  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006556  
006557  #ifndef SQLITE_OMIT_VIRTUALTABLE
006558  /* Opcode: VOpen P1 * * P4 *
006559  **
006560  ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
006561  ** P1 is a cursor number.  This opcode opens a cursor to the virtual
006562  ** table and stores that cursor in P1.
006563  */
006564  case OP_VOpen: {
006565    VdbeCursor *pCur;
006566    sqlite3_vtab_cursor *pVCur;
006567    sqlite3_vtab *pVtab;
006568    const sqlite3_module *pModule;
006569  
006570    assert( p->bIsReader );
006571    pCur = 0;
006572    pVCur = 0;
006573    pVtab = pOp->p4.pVtab->pVtab;
006574    if( pVtab==0 || NEVER(pVtab->pModule==0) ){
006575      rc = SQLITE_LOCKED;
006576      goto abort_due_to_error;
006577    }
006578    pModule = pVtab->pModule;
006579    rc = pModule->xOpen(pVtab, &pVCur);
006580    sqlite3VtabImportErrmsg(p, pVtab);
006581    if( rc ) goto abort_due_to_error;
006582  
006583    /* Initialize sqlite3_vtab_cursor base class */
006584    pVCur->pVtab = pVtab;
006585  
006586    /* Initialize vdbe cursor object */
006587    pCur = allocateCursor(p, pOp->p1, 0, -1, CURTYPE_VTAB);
006588    if( pCur ){
006589      pCur->uc.pVCur = pVCur;
006590      pVtab->nRef++;
006591    }else{
006592      assert( db->mallocFailed );
006593      pModule->xClose(pVCur);
006594      goto no_mem;
006595    }
006596    break;
006597  }
006598  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006599  
006600  #ifndef SQLITE_OMIT_VIRTUALTABLE
006601  /* Opcode: VFilter P1 P2 P3 P4 *
006602  ** Synopsis: iplan=r[P3] zplan='P4'
006603  **
006604  ** P1 is a cursor opened using VOpen.  P2 is an address to jump to if
006605  ** the filtered result set is empty.
006606  **
006607  ** P4 is either NULL or a string that was generated by the xBestIndex
006608  ** method of the module.  The interpretation of the P4 string is left
006609  ** to the module implementation.
006610  **
006611  ** This opcode invokes the xFilter method on the virtual table specified
006612  ** by P1.  The integer query plan parameter to xFilter is stored in register
006613  ** P3. Register P3+1 stores the argc parameter to be passed to the
006614  ** xFilter method. Registers P3+2..P3+1+argc are the argc
006615  ** additional parameters which are passed to
006616  ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
006617  **
006618  ** A jump is made to P2 if the result set after filtering would be empty.
006619  */
006620  case OP_VFilter: {   /* jump */
006621    int nArg;
006622    int iQuery;
006623    const sqlite3_module *pModule;
006624    Mem *pQuery;
006625    Mem *pArgc;
006626    sqlite3_vtab_cursor *pVCur;
006627    sqlite3_vtab *pVtab;
006628    VdbeCursor *pCur;
006629    int res;
006630    int i;
006631    Mem **apArg;
006632  
006633    pQuery = &aMem[pOp->p3];
006634    pArgc = &pQuery[1];
006635    pCur = p->apCsr[pOp->p1];
006636    assert( memIsValid(pQuery) );
006637    REGISTER_TRACE(pOp->p3, pQuery);
006638    assert( pCur->eCurType==CURTYPE_VTAB );
006639    pVCur = pCur->uc.pVCur;
006640    pVtab = pVCur->pVtab;
006641    pModule = pVtab->pModule;
006642  
006643    /* Grab the index number and argc parameters */
006644    assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
006645    nArg = (int)pArgc->u.i;
006646    iQuery = (int)pQuery->u.i;
006647  
006648    /* Invoke the xFilter method */
006649    res = 0;
006650    apArg = p->apArg;
006651    for(i = 0; i<nArg; i++){
006652      apArg[i] = &pArgc[i+1];
006653    }
006654    rc = pModule->xFilter(pVCur, iQuery, pOp->p4.z, nArg, apArg);
006655    sqlite3VtabImportErrmsg(p, pVtab);
006656    if( rc ) goto abort_due_to_error;
006657    res = pModule->xEof(pVCur);
006658    pCur->nullRow = 0;
006659    VdbeBranchTaken(res!=0,2);
006660    if( res ) goto jump_to_p2;
006661    break;
006662  }
006663  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006664  
006665  #ifndef SQLITE_OMIT_VIRTUALTABLE
006666  /* Opcode: VColumn P1 P2 P3 * *
006667  ** Synopsis: r[P3]=vcolumn(P2)
006668  **
006669  ** Store the value of the P2-th column of
006670  ** the row of the virtual-table that the 
006671  ** P1 cursor is pointing to into register P3.
006672  */
006673  case OP_VColumn: {
006674    sqlite3_vtab *pVtab;
006675    const sqlite3_module *pModule;
006676    Mem *pDest;
006677    sqlite3_context sContext;
006678  
006679    VdbeCursor *pCur = p->apCsr[pOp->p1];
006680    assert( pCur->eCurType==CURTYPE_VTAB );
006681    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
006682    pDest = &aMem[pOp->p3];
006683    memAboutToChange(p, pDest);
006684    if( pCur->nullRow ){
006685      sqlite3VdbeMemSetNull(pDest);
006686      break;
006687    }
006688    pVtab = pCur->uc.pVCur->pVtab;
006689    pModule = pVtab->pModule;
006690    assert( pModule->xColumn );
006691    memset(&sContext, 0, sizeof(sContext));
006692    sContext.pOut = pDest;
006693    MemSetTypeFlag(pDest, MEM_Null);
006694    rc = pModule->xColumn(pCur->uc.pVCur, &sContext, pOp->p2);
006695    sqlite3VtabImportErrmsg(p, pVtab);
006696    if( sContext.isError ){
006697      rc = sContext.isError;
006698    }
006699    sqlite3VdbeChangeEncoding(pDest, encoding);
006700    REGISTER_TRACE(pOp->p3, pDest);
006701    UPDATE_MAX_BLOBSIZE(pDest);
006702  
006703    if( sqlite3VdbeMemTooBig(pDest) ){
006704      goto too_big;
006705    }
006706    if( rc ) goto abort_due_to_error;
006707    break;
006708  }
006709  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006710  
006711  #ifndef SQLITE_OMIT_VIRTUALTABLE
006712  /* Opcode: VNext P1 P2 * * *
006713  **
006714  ** Advance virtual table P1 to the next row in its result set and
006715  ** jump to instruction P2.  Or, if the virtual table has reached
006716  ** the end of its result set, then fall through to the next instruction.
006717  */
006718  case OP_VNext: {   /* jump */
006719    sqlite3_vtab *pVtab;
006720    const sqlite3_module *pModule;
006721    int res;
006722    VdbeCursor *pCur;
006723  
006724    res = 0;
006725    pCur = p->apCsr[pOp->p1];
006726    assert( pCur->eCurType==CURTYPE_VTAB );
006727    if( pCur->nullRow ){
006728      break;
006729    }
006730    pVtab = pCur->uc.pVCur->pVtab;
006731    pModule = pVtab->pModule;
006732    assert( pModule->xNext );
006733  
006734    /* Invoke the xNext() method of the module. There is no way for the
006735    ** underlying implementation to return an error if one occurs during
006736    ** xNext(). Instead, if an error occurs, true is returned (indicating that 
006737    ** data is available) and the error code returned when xColumn or
006738    ** some other method is next invoked on the save virtual table cursor.
006739    */
006740    rc = pModule->xNext(pCur->uc.pVCur);
006741    sqlite3VtabImportErrmsg(p, pVtab);
006742    if( rc ) goto abort_due_to_error;
006743    res = pModule->xEof(pCur->uc.pVCur);
006744    VdbeBranchTaken(!res,2);
006745    if( !res ){
006746      /* If there is data, jump to P2 */
006747      goto jump_to_p2_and_check_for_interrupt;
006748    }
006749    goto check_for_interrupt;
006750  }
006751  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006752  
006753  #ifndef SQLITE_OMIT_VIRTUALTABLE
006754  /* Opcode: VRename P1 * * P4 *
006755  **
006756  ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
006757  ** This opcode invokes the corresponding xRename method. The value
006758  ** in register P1 is passed as the zName argument to the xRename method.
006759  */
006760  case OP_VRename: {
006761    sqlite3_vtab *pVtab;
006762    Mem *pName;
006763  
006764    pVtab = pOp->p4.pVtab->pVtab;
006765    pName = &aMem[pOp->p1];
006766    assert( pVtab->pModule->xRename );
006767    assert( memIsValid(pName) );
006768    assert( p->readOnly==0 );
006769    REGISTER_TRACE(pOp->p1, pName);
006770    assert( pName->flags & MEM_Str );
006771    testcase( pName->enc==SQLITE_UTF8 );
006772    testcase( pName->enc==SQLITE_UTF16BE );
006773    testcase( pName->enc==SQLITE_UTF16LE );
006774    rc = sqlite3VdbeChangeEncoding(pName, SQLITE_UTF8);
006775    if( rc ) goto abort_due_to_error;
006776    rc = pVtab->pModule->xRename(pVtab, pName->z);
006777    sqlite3VtabImportErrmsg(p, pVtab);
006778    p->expired = 0;
006779    if( rc ) goto abort_due_to_error;
006780    break;
006781  }
006782  #endif
006783  
006784  #ifndef SQLITE_OMIT_VIRTUALTABLE
006785  /* Opcode: VUpdate P1 P2 P3 P4 P5
006786  ** Synopsis: data=r[P3@P2]
006787  **
006788  ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
006789  ** This opcode invokes the corresponding xUpdate method. P2 values
006790  ** are contiguous memory cells starting at P3 to pass to the xUpdate 
006791  ** invocation. The value in register (P3+P2-1) corresponds to the 
006792  ** p2th element of the argv array passed to xUpdate.
006793  **
006794  ** The xUpdate method will do a DELETE or an INSERT or both.
006795  ** The argv[0] element (which corresponds to memory cell P3)
006796  ** is the rowid of a row to delete.  If argv[0] is NULL then no 
006797  ** deletion occurs.  The argv[1] element is the rowid of the new 
006798  ** row.  This can be NULL to have the virtual table select the new 
006799  ** rowid for itself.  The subsequent elements in the array are 
006800  ** the values of columns in the new row.
006801  **
006802  ** If P2==1 then no insert is performed.  argv[0] is the rowid of
006803  ** a row to delete.
006804  **
006805  ** P1 is a boolean flag. If it is set to true and the xUpdate call
006806  ** is successful, then the value returned by sqlite3_last_insert_rowid() 
006807  ** is set to the value of the rowid for the row just inserted.
006808  **
006809  ** P5 is the error actions (OE_Replace, OE_Fail, OE_Ignore, etc) to
006810  ** apply in the case of a constraint failure on an insert or update.
006811  */
006812  case OP_VUpdate: {
006813    sqlite3_vtab *pVtab;
006814    const sqlite3_module *pModule;
006815    int nArg;
006816    int i;
006817    sqlite_int64 rowid;
006818    Mem **apArg;
006819    Mem *pX;
006820  
006821    assert( pOp->p2==1        || pOp->p5==OE_Fail   || pOp->p5==OE_Rollback 
006822         || pOp->p5==OE_Abort || pOp->p5==OE_Ignore || pOp->p5==OE_Replace
006823    );
006824    assert( p->readOnly==0 );
006825    pVtab = pOp->p4.pVtab->pVtab;
006826    if( pVtab==0 || NEVER(pVtab->pModule==0) ){
006827      rc = SQLITE_LOCKED;
006828      goto abort_due_to_error;
006829    }
006830    pModule = pVtab->pModule;
006831    nArg = pOp->p2;
006832    assert( pOp->p4type==P4_VTAB );
006833    if( ALWAYS(pModule->xUpdate) ){
006834      u8 vtabOnConflict = db->vtabOnConflict;
006835      apArg = p->apArg;
006836      pX = &aMem[pOp->p3];
006837      for(i=0; i<nArg; i++){
006838        assert( memIsValid(pX) );
006839        memAboutToChange(p, pX);
006840        apArg[i] = pX;
006841        pX++;
006842      }
006843      db->vtabOnConflict = pOp->p5;
006844      rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
006845      db->vtabOnConflict = vtabOnConflict;
006846      sqlite3VtabImportErrmsg(p, pVtab);
006847      if( rc==SQLITE_OK && pOp->p1 ){
006848        assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
006849        db->lastRowid = rowid;
006850      }
006851      if( (rc&0xff)==SQLITE_CONSTRAINT && pOp->p4.pVtab->bConstraint ){
006852        if( pOp->p5==OE_Ignore ){
006853          rc = SQLITE_OK;
006854        }else{
006855          p->errorAction = ((pOp->p5==OE_Replace) ? OE_Abort : pOp->p5);
006856        }
006857      }else{
006858        p->nChange++;
006859      }
006860      if( rc ) goto abort_due_to_error;
006861    }
006862    break;
006863  }
006864  #endif /* SQLITE_OMIT_VIRTUALTABLE */
006865  
006866  #ifndef  SQLITE_OMIT_PAGER_PRAGMAS
006867  /* Opcode: Pagecount P1 P2 * * *
006868  **
006869  ** Write the current number of pages in database P1 to memory cell P2.
006870  */
006871  case OP_Pagecount: {            /* out2 */
006872    pOut = out2Prerelease(p, pOp);
006873    pOut->u.i = sqlite3BtreeLastPage(db->aDb[pOp->p1].pBt);
006874    break;
006875  }
006876  #endif
006877  
006878  
006879  #ifndef  SQLITE_OMIT_PAGER_PRAGMAS
006880  /* Opcode: MaxPgcnt P1 P2 P3 * *
006881  **
006882  ** Try to set the maximum page count for database P1 to the value in P3.
006883  ** Do not let the maximum page count fall below the current page count and
006884  ** do not change the maximum page count value if P3==0.
006885  **
006886  ** Store the maximum page count after the change in register P2.
006887  */
006888  case OP_MaxPgcnt: {            /* out2 */
006889    unsigned int newMax;
006890    Btree *pBt;
006891  
006892    pOut = out2Prerelease(p, pOp);
006893    pBt = db->aDb[pOp->p1].pBt;
006894    newMax = 0;
006895    if( pOp->p3 ){
006896      newMax = sqlite3BtreeLastPage(pBt);
006897      if( newMax < (unsigned)pOp->p3 ) newMax = (unsigned)pOp->p3;
006898    }
006899    pOut->u.i = sqlite3BtreeMaxPageCount(pBt, newMax);
006900    break;
006901  }
006902  #endif
006903  
006904  /* Opcode: Function0 P1 P2 P3 P4 P5
006905  ** Synopsis: r[P3]=func(r[P2@P5])
006906  **
006907  ** Invoke a user function (P4 is a pointer to a FuncDef object that
006908  ** defines the function) with P5 arguments taken from register P2 and
006909  ** successors.  The result of the function is stored in register P3.
006910  ** Register P3 must not be one of the function inputs.
006911  **
006912  ** P1 is a 32-bit bitmask indicating whether or not each argument to the 
006913  ** function was determined to be constant at compile time. If the first
006914  ** argument was constant then bit 0 of P1 is set. This is used to determine
006915  ** whether meta data associated with a user function argument using the
006916  ** sqlite3_set_auxdata() API may be safely retained until the next
006917  ** invocation of this opcode.
006918  **
006919  ** See also: Function, AggStep, AggFinal
006920  */
006921  /* Opcode: Function P1 P2 P3 P4 P5
006922  ** Synopsis: r[P3]=func(r[P2@P5])
006923  **
006924  ** Invoke a user function (P4 is a pointer to an sqlite3_context object that
006925  ** contains a pointer to the function to be run) with P5 arguments taken
006926  ** from register P2 and successors.  The result of the function is stored
006927  ** in register P3.  Register P3 must not be one of the function inputs.
006928  **
006929  ** P1 is a 32-bit bitmask indicating whether or not each argument to the 
006930  ** function was determined to be constant at compile time. If the first
006931  ** argument was constant then bit 0 of P1 is set. This is used to determine
006932  ** whether meta data associated with a user function argument using the
006933  ** sqlite3_set_auxdata() API may be safely retained until the next
006934  ** invocation of this opcode.
006935  **
006936  ** SQL functions are initially coded as OP_Function0 with P4 pointing
006937  ** to a FuncDef object.  But on first evaluation, the P4 operand is
006938  ** automatically converted into an sqlite3_context object and the operation
006939  ** changed to this OP_Function opcode.  In this way, the initialization of
006940  ** the sqlite3_context object occurs only once, rather than once for each
006941  ** evaluation of the function.
006942  **
006943  ** See also: Function0, AggStep, AggFinal
006944  */
006945  case OP_PureFunc0:
006946  case OP_Function0: {
006947    int n;
006948    sqlite3_context *pCtx;
006949  
006950    assert( pOp->p4type==P4_FUNCDEF );
006951    n = pOp->p5;
006952    assert( pOp->p3>0 && pOp->p3<=(p->nMem+1 - p->nCursor) );
006953    assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem+1 - p->nCursor)+1) );
006954    assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
006955    pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
006956    if( pCtx==0 ) goto no_mem;
006957    pCtx->pOut = 0;
006958    pCtx->pFunc = pOp->p4.pFunc;
006959    pCtx->iOp = (int)(pOp - aOp);
006960    pCtx->pVdbe = p;
006961    pCtx->argc = n;
006962    pOp->p4type = P4_FUNCCTX;
006963    pOp->p4.pCtx = pCtx;
006964    assert( OP_PureFunc == OP_PureFunc0+2 );
006965    assert( OP_Function == OP_Function0+2 );
006966    pOp->opcode += 2;
006967    /* Fall through into OP_Function */
006968  }
006969  case OP_PureFunc:
006970  case OP_Function: {
006971    int i;
006972    sqlite3_context *pCtx;
006973  
006974    assert( pOp->p4type==P4_FUNCCTX );
006975    pCtx = pOp->p4.pCtx;
006976  
006977    /* If this function is inside of a trigger, the register array in aMem[]
006978    ** might change from one evaluation to the next.  The next block of code
006979    ** checks to see if the register array has changed, and if so it
006980    ** reinitializes the relavant parts of the sqlite3_context object */
006981    pOut = &aMem[pOp->p3];
006982    if( pCtx->pOut != pOut ){
006983      pCtx->pOut = pOut;
006984      for(i=pCtx->argc-1; i>=0; i--) pCtx->argv[i] = &aMem[pOp->p2+i];
006985    }
006986  
006987    memAboutToChange(p, pOut);
006988  #ifdef SQLITE_DEBUG
006989    for(i=0; i<pCtx->argc; i++){
006990      assert( memIsValid(pCtx->argv[i]) );
006991      REGISTER_TRACE(pOp->p2+i, pCtx->argv[i]);
006992    }
006993  #endif
006994    MemSetTypeFlag(pOut, MEM_Null);
006995    pCtx->fErrorOrAux = 0;
006996    (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
006997  
006998    /* If the function returned an error, throw an exception */
006999    if( pCtx->fErrorOrAux ){
007000      if( pCtx->isError ){
007001        sqlite3VdbeError(p, "%s", sqlite3_value_text(pOut));
007002        rc = pCtx->isError;
007003      }
007004      sqlite3VdbeDeleteAuxData(db, &p->pAuxData, pCtx->iOp, pOp->p1);
007005      if( rc ) goto abort_due_to_error;
007006    }
007007  
007008    /* Copy the result of the function into register P3 */
007009    if( pOut->flags & (MEM_Str|MEM_Blob) ){
007010      sqlite3VdbeChangeEncoding(pOut, encoding);
007011      if( sqlite3VdbeMemTooBig(pOut) ) goto too_big;
007012    }
007013  
007014    REGISTER_TRACE(pOp->p3, pOut);
007015    UPDATE_MAX_BLOBSIZE(pOut);
007016    break;
007017  }
007018  
007019  
007020  /* Opcode: Init P1 P2 P3 P4 *
007021  ** Synopsis: Start at P2
007022  **
007023  ** Programs contain a single instance of this opcode as the very first
007024  ** opcode.
007025  **
007026  ** If tracing is enabled (by the sqlite3_trace()) interface, then
007027  ** the UTF-8 string contained in P4 is emitted on the trace callback.
007028  ** Or if P4 is blank, use the string returned by sqlite3_sql().
007029  **
007030  ** If P2 is not zero, jump to instruction P2.
007031  **
007032  ** Increment the value of P1 so that OP_Once opcodes will jump the
007033  ** first time they are evaluated for this run.
007034  **
007035  ** If P3 is not zero, then it is an address to jump to if an SQLITE_CORRUPT
007036  ** error is encountered.
007037  */
007038  case OP_Init: {          /* jump */
007039    char *zTrace;
007040    int i;
007041  
007042    /* If the P4 argument is not NULL, then it must be an SQL comment string.
007043    ** The "--" string is broken up to prevent false-positives with srcck1.c.
007044    **
007045    ** This assert() provides evidence for:
007046    ** EVIDENCE-OF: R-50676-09860 The callback can compute the same text that
007047    ** would have been returned by the legacy sqlite3_trace() interface by
007048    ** using the X argument when X begins with "--" and invoking
007049    ** sqlite3_expanded_sql(P) otherwise.
007050    */
007051    assert( pOp->p4.z==0 || strncmp(pOp->p4.z, "-" "- ", 3)==0 );
007052    assert( pOp==p->aOp );  /* Always instruction 0 */
007053  
007054  #ifndef SQLITE_OMIT_TRACE
007055    if( (db->mTrace & (SQLITE_TRACE_STMT|SQLITE_TRACE_LEGACY))!=0
007056     && !p->doingRerun
007057     && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
007058    ){
007059  #ifndef SQLITE_OMIT_DEPRECATED
007060      if( db->mTrace & SQLITE_TRACE_LEGACY ){
007061        void (*x)(void*,const char*) = (void(*)(void*,const char*))db->xTrace;
007062        char *z = sqlite3VdbeExpandSql(p, zTrace);
007063        x(db->pTraceArg, z);
007064        sqlite3_free(z);
007065      }else
007066  #endif
007067      if( db->nVdbeExec>1 ){
007068        char *z = sqlite3MPrintf(db, "-- %s", zTrace);
007069        (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, z);
007070        sqlite3DbFree(db, z);
007071      }else{
007072        (void)db->xTrace(SQLITE_TRACE_STMT, db->pTraceArg, p, zTrace);
007073      }
007074    }
007075  #ifdef SQLITE_USE_FCNTL_TRACE
007076    zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql);
007077    if( zTrace ){
007078      int j;
007079      for(j=0; j<db->nDb; j++){
007080        if( DbMaskTest(p->btreeMask, j)==0 ) continue;
007081        sqlite3_file_control(db, db->aDb[j].zDbSName, SQLITE_FCNTL_TRACE, zTrace);
007082      }
007083    }
007084  #endif /* SQLITE_USE_FCNTL_TRACE */
007085  #ifdef SQLITE_DEBUG
007086    if( (db->flags & SQLITE_SqlTrace)!=0
007087     && (zTrace = (pOp->p4.z ? pOp->p4.z : p->zSql))!=0
007088    ){
007089      sqlite3DebugPrintf("SQL-trace: %s\n", zTrace);
007090    }
007091  #endif /* SQLITE_DEBUG */
007092  #endif /* SQLITE_OMIT_TRACE */
007093    assert( pOp->p2>0 );
007094    if( pOp->p1>=sqlite3GlobalConfig.iOnceResetThreshold ){
007095      for(i=1; i<p->nOp; i++){
007096        if( p->aOp[i].opcode==OP_Once ) p->aOp[i].p1 = 0;
007097      }
007098      pOp->p1 = 0;
007099    }
007100    pOp->p1++;
007101    p->aCounter[SQLITE_STMTSTATUS_RUN]++;
007102    goto jump_to_p2;
007103  }
007104  
007105  #ifdef SQLITE_ENABLE_CURSOR_HINTS
007106  /* Opcode: CursorHint P1 * * P4 *
007107  **
007108  ** Provide a hint to cursor P1 that it only needs to return rows that
007109  ** satisfy the Expr in P4.  TK_REGISTER terms in the P4 expression refer
007110  ** to values currently held in registers.  TK_COLUMN terms in the P4
007111  ** expression refer to columns in the b-tree to which cursor P1 is pointing.
007112  */
007113  case OP_CursorHint: {
007114    VdbeCursor *pC;
007115  
007116    assert( pOp->p1>=0 && pOp->p1<p->nCursor );
007117    assert( pOp->p4type==P4_EXPR );
007118    pC = p->apCsr[pOp->p1];
007119    if( pC ){
007120      assert( pC->eCurType==CURTYPE_BTREE );
007121      sqlite3BtreeCursorHint(pC->uc.pCursor, BTREE_HINT_RANGE,
007122                             pOp->p4.pExpr, aMem);
007123    }
007124    break;
007125  }
007126  #endif /* SQLITE_ENABLE_CURSOR_HINTS */
007127  
007128  /* Opcode: Noop * * * * *
007129  **
007130  ** Do nothing.  This instruction is often useful as a jump
007131  ** destination.
007132  */
007133  /*
007134  ** The magic Explain opcode are only inserted when explain==2 (which
007135  ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
007136  ** This opcode records information from the optimizer.  It is the
007137  ** the same as a no-op.  This opcodesnever appears in a real VM program.
007138  */
007139  default: {          /* This is really OP_Noop and OP_Explain */
007140    assert( pOp->opcode==OP_Noop || pOp->opcode==OP_Explain );
007141    break;
007142  }
007143  
007144  /*****************************************************************************
007145  ** The cases of the switch statement above this line should all be indented
007146  ** by 6 spaces.  But the left-most 6 spaces have been removed to improve the
007147  ** readability.  From this point on down, the normal indentation rules are
007148  ** restored.
007149  *****************************************************************************/
007150      }
007151  
007152  #ifdef VDBE_PROFILE
007153      {
007154        u64 endTime = sqlite3Hwtime();
007155        if( endTime>start ) pOrigOp->cycles += endTime - start;
007156        pOrigOp->cnt++;
007157      }
007158  #endif
007159  
007160      /* The following code adds nothing to the actual functionality
007161      ** of the program.  It is only here for testing and debugging.
007162      ** On the other hand, it does burn CPU cycles every time through
007163      ** the evaluator loop.  So we can leave it out when NDEBUG is defined.
007164      */
007165  #ifndef NDEBUG
007166      assert( pOp>=&aOp[-1] && pOp<&aOp[p->nOp-1] );
007167  
007168  #ifdef SQLITE_DEBUG
007169      if( db->flags & SQLITE_VdbeTrace ){
007170        u8 opProperty = sqlite3OpcodeProperty[pOrigOp->opcode];
007171        if( rc!=0 ) printf("rc=%d\n",rc);
007172        if( opProperty & (OPFLG_OUT2) ){
007173          registerTrace(pOrigOp->p2, &aMem[pOrigOp->p2]);
007174        }
007175        if( opProperty & OPFLG_OUT3 ){
007176          registerTrace(pOrigOp->p3, &aMem[pOrigOp->p3]);
007177        }
007178      }
007179  #endif  /* SQLITE_DEBUG */
007180  #endif  /* NDEBUG */
007181    }  /* The end of the for(;;) loop the loops through opcodes */
007182  
007183    /* If we reach this point, it means that execution is finished with
007184    ** an error of some kind.
007185    */
007186  abort_due_to_error:
007187    if( db->mallocFailed ) rc = SQLITE_NOMEM_BKPT;
007188    assert( rc );
007189    if( p->zErrMsg==0 && rc!=SQLITE_IOERR_NOMEM ){
007190      sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
007191    }
007192    p->rc = rc;
007193    sqlite3SystemError(db, rc);
007194    testcase( sqlite3GlobalConfig.xLog!=0 );
007195    sqlite3_log(rc, "statement aborts at %d: [%s] %s", 
007196                     (int)(pOp - aOp), p->zSql, p->zErrMsg);
007197    sqlite3VdbeHalt(p);
007198    if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
007199    rc = SQLITE_ERROR;
007200    if( resetSchemaOnFault>0 ){
007201      sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
007202    }
007203  
007204    /* This is the only way out of this procedure.  We have to
007205    ** release the mutexes on btrees that were acquired at the
007206    ** top. */
007207  vdbe_return:
007208    testcase( nVmStep>0 );
007209    p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
007210    sqlite3VdbeLeave(p);
007211    assert( rc!=SQLITE_OK || nExtraDelete==0 
007212         || sqlite3_strlike("DELETE%",p->zSql,0)!=0 
007213    );
007214    return rc;
007215  
007216    /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
007217    ** is encountered.
007218    */
007219  too_big:
007220    sqlite3VdbeError(p, "string or blob too big");
007221    rc = SQLITE_TOOBIG;
007222    goto abort_due_to_error;
007223  
007224    /* Jump to here if a malloc() fails.
007225    */
007226  no_mem:
007227    sqlite3OomFault(db);
007228    sqlite3VdbeError(p, "out of memory");
007229    rc = SQLITE_NOMEM_BKPT;
007230    goto abort_due_to_error;
007231  
007232    /* Jump to here if the sqlite3_interrupt() API sets the interrupt
007233    ** flag.
007234    */
007235  abort_due_to_interrupt:
007236    assert( db->u1.isInterrupted );
007237    rc = db->mallocFailed ? SQLITE_NOMEM_BKPT : SQLITE_INTERRUPT;
007238    p->rc = rc;
007239    sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
007240    goto abort_due_to_error;
007241  }