/*

 ** 2001 September 15

 **

 ** The author disclaims copyright to this source code.  In place of

 ** a legal notice, here is a blessing:

 **

 **    May you do good and not evil.

 **    May you find forgiveness for yourself and forgive others.

 **    May you share freely, never taking more than you give.

 **

 *************************************************************************

 ** The code in this file implements execution method of the 

 ** Virtual Database Engine (VDBE).  A separate file ("vdbeaux.c")

 ** handles housekeeping details such as creating and deleting

 ** VDBE instances.  This file is solely interested in executing

 ** the VDBE program.

 **

 ** In the external interface, an "sqlite3_stmt*" is an opaque pointer

 ** to a VDBE.

 **

 ** The SQL parser generates a program which is then executed by

 ** the VDBE to do the work of the SQL statement.  VDBE programs are 

 ** similar in form to assembly language.  The program consists of

 ** a linear sequence of operations.  Each operation has an opcode 

 ** and 5 operands.  Operands P1, P2, and P3 are integers.  Operand P4 

 ** is a null-terminated string.  Operand P5 is an unsigned character.

 ** Few opcodes use all 5 operands.

 **

 ** Computation results are stored on a set of registers numbered beginning

 ** with 1 and going up to Vdbe.nMem.  Each register can store

 ** either an integer, a null-terminated string, a floating point

 ** number, or the SQL "NULL" value.  An implicit conversion from one

 ** type to the other occurs as necessary.

 ** 

 ** Most of the code in this file is taken up by the sqlite3VdbeExec()

 ** function which does the work of interpreting a VDBE program.

 ** But other routines are also provided to help in building up

 ** a program instruction by instruction.

 **

 ** Various scripts scan this source file in order to generate HTML

 ** documentation, headers files, or other derived files.  The formatting

 ** of the code in this file is, therefore, important.  See other comments

 ** in this file for details.  If in doubt, do not deviate from existing

 ** commenting and indentation practices when changing or adding code.

 **

 ** $Id: vdbe.c,v 1.782 2008/10/08 17:58:49 danielk1977 Exp $

 */

 #include "sqliteInt.h"

 #include <ctype.h>

 #include "vdbeInt.h"

 /*

 ** The following global variable is incremented every time a cursor

 ** moves, either by the OP_MoveXX, OP_Next, or OP_Prev opcodes.  The test

 ** procedures use this information to make sure that indices are

 ** working correctly.  This variable has no function other than to

 ** help verify the correct operation of the library.

 */

 #ifdef SQLITE_TEST

 int sqlite3_search_count = 0;

 #endif

 /*

 ** When this global variable is positive, it gets decremented once before

 ** each instruction in the VDBE.  When reaches zero, the u1.isInterrupted

 ** field of the sqlite3 structure is set in order to simulate and interrupt.

 **

 ** This facility is used for testing purposes only.  It does not function

 ** in an ordinary build.

 */

 #ifdef SQLITE_TEST

 int sqlite3_interrupt_count = 0;

 #endif

 /*

 ** The next global variable is incremented each type the OP_Sort opcode

 ** is executed.  The test procedures use this information to make sure that

 ** sorting is occurring or not occurring at appropriate times.   This variable

 ** has no function other than to help verify the correct operation of the

 ** library.

 */

 #ifdef SQLITE_TEST

 int sqlite3_sort_count = 0;

 #endif

 /*

 ** The next global variable records the size of the largest MEM_Blob

 ** or MEM_Str that has been used by a VDBE opcode.  The test procedures

 ** use this information to make sure that the zero-blob functionality

 ** is working correctly.   This variable has no function other than to

 ** help verify the correct operation of the library.

 */

 #ifdef SQLITE_TEST

 int sqlite3_max_blobsize = 0;

 static void updateMaxBlobsize(Mem *p){

   if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){

     sqlite3_max_blobsize = p->n;

   }

 }

 #endif

 /*

 ** Test a register to see if it exceeds the current maximum blob size.

 ** If it does, record the new maximum blob size.

 */

 #if defined(SQLITE_TEST) && !defined(SQLITE_OMIT_BUILTIN_TEST)

 # define UPDATE_MAX_BLOBSIZE(P)  updateMaxBlobsize(P)

 #else

 # define UPDATE_MAX_BLOBSIZE(P)

 #endif

 /*

 ** Convert the given register into a string if it isn't one

 ** already. Return non-zero if a malloc() fails.

 */

 #define Stringify(P, enc) \

    if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc)) \

      { goto no_mem; }

 /*

 ** An ephemeral string value (signified by the MEM_Ephem flag) contains

 ** a pointer to a dynamically allocated string where some other entity

 ** is responsible for deallocating that string.  Because the register

 ** does not control the string, it might be deleted without the register

 ** knowing it.

 **

 ** This routine converts an ephemeral string into a dynamically allocated

 ** string that the register itself controls.  In other words, it

 ** converts an MEM_Ephem string into an MEM_Dyn string.

 */

 #define Deephemeralize(P) \

    if( ((P)->flags&MEM_Ephem)!=0 \

        && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}

 /*

 ** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)

 ** P if required.

 */

 #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)

 /*

 ** Argument pMem points at a register that will be passed to a

 ** user-defined function or returned to the user as the result of a query.

 ** The second argument, 'db_enc' is the text encoding used by the vdbe for

 ** register variables.  This routine sets the pMem->enc and pMem->type

 ** variables used by the sqlite3_value_*() routines.

 */

 #define storeTypeInfo(A,B) _storeTypeInfo(A)

 static void _storeTypeInfo(Mem *pMem){

   int flags = pMem->flags;

   if( flags & MEM_Null ){

     pMem->type = SQLITE_NULL;

   }

   else if( flags & MEM_Int ){

     pMem->type = SQLITE_INTEGER;

   }

   else if( flags & MEM_Real ){

     pMem->type = SQLITE_FLOAT;

   }

   else if( flags & MEM_Str ){

     pMem->type = SQLITE_TEXT;

   }else{

     pMem->type = SQLITE_BLOB;

   }

 }

 /*

 ** Properties of opcodes.  The OPFLG_INITIALIZER macro is

 ** created by mkopcodeh.awk during compilation.  Data is obtained

 ** from the comments following the "case OP_xxxx:" statements in

 ** this file.  

 */

 static const unsigned char opcodeProperty[] = OPFLG_INITIALIZER;

 /*

 ** Return true if an opcode has any of the OPFLG_xxx properties

 ** specified by mask.

 */

 int sqlite3VdbeOpcodeHasProperty(int opcode, int mask){

   assert( opcode>0 && opcode<sizeof(opcodeProperty) );

   return (opcodeProperty[opcode]&mask)!=0;

 }

 /*

 ** Allocate cursor number iCur.  Return a pointer to it.  Return NULL

 ** if we run out of memory.

 */

 static Cursor *allocateCursor(

   Vdbe *p, 

   int iCur, 

   Op *pOp,

   int iDb, 

   int isBtreeCursor

 ){

   /* Find the memory cell that will be used to store the blob of memory

   ** required for this Cursor structure. It is convenient to use a 

   ** vdbe memory cell to manage the memory allocation required for a

   ** Cursor structure for the following reasons:

   **

   **   * Sometimes cursor numbers are used for a couple of different

   **     purposes in a vdbe program. The different uses might require

   **     different sized allocations. Memory cells provide growable

   **     allocations.

   **

   **   * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can

   **     be freed lazily via the sqlite3_release_memory() API. This

   **     minimizes the number of malloc calls made by the system.

   **

   ** Memory cells for cursors are allocated at the top of the address

   ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for

   ** cursor 1 is managed by memory cell (p->nMem-1), etc.

   */

   Mem *pMem = &p->aMem[p->nMem-iCur];

   int nByte;

   Cursor *pCx = 0;

   /* If the opcode of pOp is OP_SetNumColumns, then pOp->p2 contains

   ** the number of fields in the records contained in the table or

   ** index being opened. Use this to reserve space for the 

   ** Cursor.aType[] array.

   */

   int nField = 0;

   if( pOp->opcode==OP_SetNumColumns || pOp->opcode==OP_OpenEphemeral ){

     nField = pOp->p2;

   }

   nByte = 

       sizeof(Cursor) + 

       (isBtreeCursor?sqlite3BtreeCursorSize():0) + 

       2*nField*sizeof(u32);

   assert( iCur<p->nCursor );

   if( p->apCsr[iCur] ){

     sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);

     p->apCsr[iCur] = 0;

   }

   if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){

     p->apCsr[iCur] = pCx = (Cursor *)pMem->z;

     memset(pMem->z, 0, nByte);

     pCx->iDb = iDb;

     pCx->nField = nField;

     if( nField ){

       pCx->aType = (u32 *)&pMem->z[sizeof(Cursor)];

     }

     if( isBtreeCursor ){

       pCx->pCursor = (BtCursor *)&pMem->z[sizeof(Cursor)+2*nField*sizeof(u32)];

     }

   }

   return pCx;

 }

 /*

 ** Try to convert a value into a numeric representation if we can

 ** do so without loss of information.  In other words, if the string

 ** looks like a number, convert it into a number.  If it does not

 ** look like a number, leave it alone.

 */

 static void applyNumericAffinity(Mem *pRec){

   if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){

     int realnum;

     sqlite3VdbeMemNulTerminate(pRec);

     if( (pRec->flags&MEM_Str)

          && sqlite3IsNumber(pRec->z, &realnum, pRec->enc) ){

       i64 value;

       sqlite3VdbeChangeEncoding(pRec, SQLITE_UTF8);

       if( !realnum && sqlite3Atoi64(pRec->z, &value) ){

         pRec->u.i = value;

         MemSetTypeFlag(pRec, MEM_Int);

       }else{

         sqlite3VdbeMemRealify(pRec);

       }

     }

   }

 }

 /*

 ** Processing is determine by the affinity parameter:

 **

 ** SQLITE_AFF_INTEGER:

 ** SQLITE_AFF_REAL:

 ** SQLITE_AFF_NUMERIC:

 **    Try to convert pRec to an integer representation or a 

 **    floating-point representation if an integer representation

 **    is not possible.  Note that the integer representation is

 **    always preferred, even if the affinity is REAL, because

 **    an integer representation is more space efficient on disk.

 **

 ** SQLITE_AFF_TEXT:

 **    Convert pRec to a text representation.

 **

 ** SQLITE_AFF_NONE:

 **    No-op.  pRec is unchanged.

 */

 static void applyAffinity(

   Mem *pRec,          /* The value to apply affinity to */

   char affinity,      /* The affinity to be applied */

   u8 enc              /* Use this text encoding */

 ){

   if( affinity==SQLITE_AFF_TEXT ){

     /* Only attempt the conversion to TEXT if there is an integer or real

     ** representation (blob and NULL do not get converted) but no string

     ** representation.

     */

     if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){

       sqlite3VdbeMemStringify(pRec, enc);

     }

     pRec->flags &= ~(MEM_Real|MEM_Int);

   }else if( affinity!=SQLITE_AFF_NONE ){

     assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL

              || affinity==SQLITE_AFF_NUMERIC );

     applyNumericAffinity(pRec);

     if( pRec->flags & MEM_Real ){

       sqlite3VdbeIntegerAffinity(pRec);

     }

   }

 }

 /*

 ** Try to convert the type of a function argument or a result column

 ** into a numeric representation.  Use either INTEGER or REAL whichever

 ** is appropriate.  But only do the conversion if it is possible without

 ** loss of information and return the revised type of the argument.

 **

 ** This is an EXPERIMENTAL api and is subject to change or removal.

 */

 int sqlite3_value_numeric_type(sqlite3_value *pVal){

   Mem *pMem = (Mem*)pVal;

   applyNumericAffinity(pMem);

   storeTypeInfo(pMem, 0);

   return pMem->type;

 }

 /*

 ** Exported version of applyAffinity(). This one works on sqlite3_value*, 

 ** not the internal Mem* type.

 */

 void sqlite3ValueApplyAffinity(

   sqlite3_value *pVal, 

   u8 affinity, 

   u8 enc

 ){

   applyAffinity((Mem *)pVal, affinity, enc);

 }

 #ifdef SQLITE_DEBUG

 /*

 ** Write a nice string representation of the contents of cell pMem

 ** into buffer zBuf, length nBuf.

 */

 void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){

   char *zCsr = zBuf;

   int f = pMem->flags;

   static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};

   if( f&MEM_Blob ){

     int i;

     char c;

     if( f & MEM_Dyn ){

       c = 'z';

       assert( (f & (MEM_Static|MEM_Ephem))==0 );

     }else if( f & MEM_Static ){

       c = 't';

       assert( (f & (MEM_Dyn|MEM_Ephem))==0 );

     }else if( f & MEM_Ephem ){

       c = 'e';

       assert( (f & (MEM_Static|MEM_Dyn))==0 );

     }else{

       c = 's';

     }

     sqlite3_snprintf(100, zCsr, "%c", c);

     zCsr += strlen(zCsr);

     sqlite3_snprintf(100, zCsr, "%d[", pMem->n);

     zCsr += strlen(zCsr);

     for(i=0; i<16 && i<pMem->n; i++){

       sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));

       zCsr += strlen(zCsr);

     }

     for(i=0; i<16 && i<pMem->n; i++){

       char z = pMem->z[i];

       if( z<32 || z>126 ) *zCsr++ = '.';

       else *zCsr++ = z;

     }

     sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);

     zCsr += strlen(zCsr);

     if( f & MEM_Zero ){

       sqlite3_snprintf(100, zCsr,"+%lldz",pMem->u.i);

       zCsr += strlen(zCsr);

     }

     *zCsr = '\0';

   }else if( f & MEM_Str ){

     int j, k;

     zBuf[0] = ' ';

     if( f & MEM_Dyn ){

       zBuf[1] = 'z';

       assert( (f & (MEM_Static|MEM_Ephem))==0 );

     }else if( f & MEM_Static ){

       zBuf[1] = 't';

       assert( (f & (MEM_Dyn|MEM_Ephem))==0 );

     }else if( f & MEM_Ephem ){

       zBuf[1] = 'e';

       assert( (f & (MEM_Static|MEM_Dyn))==0 );

     }else{

       zBuf[1] = 's';

     }

     k = 2;

     sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n);

     k += strlen(&zBuf[k]);

     zBuf[k++] = '[';

     for(j=0; j<15 && j<pMem->n; j++){

       u8 c = pMem->z[j];

       if( c>=0x20 && c<0x7f ){

         zBuf[k++] = c;

       }else{

         zBuf[k++] = '.';

       }

     }

     zBuf[k++] = ']';

     sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]);

     k += strlen(&zBuf[k]);

     zBuf[k++] = 0;

   }

 }

 #endif

 #ifdef SQLITE_DEBUG

 /*

 ** Print the value of a register for tracing purposes:

 */

 static void memTracePrint(FILE *out, Mem *p){

   if( p->flags & MEM_Null ){

     fprintf(out, " NULL");

   }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){

     fprintf(out, " si:%lld", p->u.i);

   }else if( p->flags & MEM_Int ){

     fprintf(out, " i:%lld", p->u.i);

   }else if( p->flags & MEM_Real ){

     fprintf(out, " r:%g", p->r);

   }else{

     char zBuf[200];

     sqlite3VdbeMemPrettyPrint(p, zBuf);

     fprintf(out, " ");

     fprintf(out, "%s", zBuf);

   }

 }

 static void registerTrace(FILE *out, int iReg, Mem *p){

   fprintf(out, "REG[%d] = ", iReg);

   memTracePrint(out, p);

   fprintf(out, "\n");

 }

 #endif

 #ifdef SQLITE_DEBUG

 #  define REGISTER_TRACE(R,M) if(p->trace)registerTrace(p->trace,R,M)

 #else

 #  define REGISTER_TRACE(R,M)

 #endif

 #ifdef VDBE_PROFILE

 /* 

 ** hwtime.h contains inline assembler code for implementing 

 ** high-performance timing routines.

 */

 #include "hwtime.h"

 #endif

 /*

 ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the

 ** sqlite3_interrupt() routine has been called.  If it has been, then

 ** processing of the VDBE program is interrupted.

 **

 ** This macro added to every instruction that does a jump in order to

 ** implement a loop.  This test used to be on every single instruction,

 ** but that meant we more testing that we needed.  By only testing the

 ** flag on jump instructions, we get a (small) speed improvement.

 */

 #define CHECK_FOR_INTERRUPT \

    if( db->u1.isInterrupted ) goto abort_due_to_interrupt;

 #ifdef SQLITE_DEBUG

 static int fileExists(sqlite3 *db, const char *zFile){

   int res = 0;

   int rc = SQLITE_OK;

 #ifdef SQLITE_TEST

   /* If we are currently testing IO errors, then do not call OsAccess() to

   ** test for the presence of zFile. This is because any IO error that

   ** occurs here will not be reported, causing the test to fail.

   */

   extern int sqlite3_io_error_pending;

   if( sqlite3_io_error_pending<=0 )

 #endif

     rc = sqlite3OsAccess(db->pVfs, zFile, SQLITE_ACCESS_EXISTS, &res);

   return (res && rc==SQLITE_OK);

 }

 #endif

 /*

 ** Execute as much of a VDBE program as we can then return.

 **

 ** sqlite3VdbeMakeReady() must be called before this routine in order to

 ** close the program with a final OP_Halt and to set up the callbacks

 ** and the error message pointer.

 **

 ** Whenever a row or result data is available, this routine will either

 ** invoke the result callback (if there is one) or return with

 ** SQLITE_ROW.

 **

 ** If an attempt is made to open a locked database, then this routine

 ** will either invoke the busy callback (if there is one) or it will

 ** return SQLITE_BUSY.

 **

 ** If an error occurs, an error message is written to memory obtained

 ** from sqlite3_malloc() and p->zErrMsg is made to point to that memory.

 ** The error code is stored in p->rc and this routine returns SQLITE_ERROR.

 **

 ** If the callback ever returns non-zero, then the program exits

 ** immediately.  There will be no error message but the p->rc field is

 ** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.

 **

 ** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this

 ** routine to return SQLITE_ERROR.

 **

 ** Other fatal errors return SQLITE_ERROR.

 **

 ** After this routine has finished, sqlite3VdbeFinalize() should be

 ** used to clean up the mess that was left behind.

 */

 int sqlite3VdbeExec(

   Vdbe *p                    /* The VDBE */

 ){

   int pc;                    /* The program counter */

   Op *pOp;                   /* Current operation */

   int rc = SQLITE_OK;        /* Value to return */

   sqlite3 *db = p->db;       /* The database */

   u8 encoding = ENC(db);     /* The database encoding */

   Mem *pIn1, *pIn2, *pIn3;   /* Input operands */

   Mem *pOut;                 /* Output operand */

   u8 opProperty;

   int iCompare = 0;          /* Result of last OP_Compare operation */

   int *aPermute = 0;         /* Permuation of columns for OP_Compare */

 #ifdef VDBE_PROFILE

   u64 start;                 /* CPU clock count at start of opcode */

   int origPc;                /* Program counter at start of opcode */

 #endif

 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK

   int nProgressOps = 0;      /* Opcodes executed since progress callback. */

 #endif

   UnpackedRecord aTempRec[16]; /* Space to hold a transient UnpackedRecord */

   assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */

   assert( db->magic==SQLITE_MAGIC_BUSY );

   sqlite3BtreeMutexArrayEnter(&p->aMutex);

   if( p->rc==SQLITE_NOMEM ){

     /* This happens if a malloc() inside a call to sqlite3_column_text() or

     ** sqlite3_column_text16() failed.  */

     goto no_mem;

   }

   assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );

   p->rc = SQLITE_OK;

   assert( p->explain==0 );

   p->pResultSet = 0;

   db->busyHandler.nBusy = 0;

   CHECK_FOR_INTERRUPT;

   sqlite3VdbeIOTraceSql(p);

 #ifdef SQLITE_DEBUG

   sqlite3BeginBenignMalloc();

   if( p->pc==0 

    && ((p->db->flags & SQLITE_VdbeListing) || fileExists(db, "vdbe_explain"))

   ){

     int i;

     printf("VDBE Program Listing:\n");

     sqlite3VdbePrintSql(p);

     for(i=0; i<p->nOp; i++){

       sqlite3VdbePrintOp(stdout, i, &p->aOp[i]);

     }

   }

   if( fileExists(db, "vdbe_trace") ){

     p->trace = stdout;

   }

   sqlite3EndBenignMalloc();

 #endif

   for(pc=p->pc; rc==SQLITE_OK; pc++){

     assert( pc>=0 && pc<p->nOp );

     if( db->mallocFailed ) goto no_mem;

 #ifdef VDBE_PROFILE

     origPc = pc;

     start = sqlite3Hwtime();

 #endif

     pOp = &p->aOp[pc];

     /* Only allow tracing if SQLITE_DEBUG is defined.

     */

 #ifdef SQLITE_DEBUG

     if( p->trace ){

       if( pc==0 ){

         printf("VDBE Execution Trace:\n");

         sqlite3VdbePrintSql(p);

       }

       sqlite3VdbePrintOp(p->trace, pc, pOp);

     }

     if( p->trace==0 && pc==0 ){

       sqlite3BeginBenignMalloc();

       if( fileExists(db, "vdbe_sqltrace") ){

         sqlite3VdbePrintSql(p);

       }

       sqlite3EndBenignMalloc();

     }

 #endif

     /* Check to see if we need to simulate an interrupt.  This only happens

     ** if we have a special test build.

     */

 #ifdef SQLITE_TEST

     if( sqlite3_interrupt_count>0 ){

       sqlite3_interrupt_count--;

       if( sqlite3_interrupt_count==0 ){

         sqlite3_interrupt(db);

       }

     }

 #endif

 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK

     /* Call the progress callback if it is configured and the required number

     ** of VDBE ops have been executed (either since this invocation of

     ** sqlite3VdbeExec() or since last time the progress callback was called).

     ** If the progress callback returns non-zero, exit the virtual machine with

     ** a return code SQLITE_ABORT.

     */

     if( db->xProgress ){

       if( db->nProgressOps==nProgressOps ){

         int prc;

         if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;

         prc =db->xProgress(db->pProgressArg);

         if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;

         if( prc!=0 ){

           rc = SQLITE_INTERRUPT;

           goto vdbe_error_halt;

         }

         nProgressOps = 0;

       }

       nProgressOps++;

     }

 #endif

     /* Do common setup processing for any opcode that is marked

     ** with the "out2-prerelease" tag.  Such opcodes have a single

     ** output which is specified by the P2 parameter.  The P2 register

     ** is initialized to a NULL.

     */

     opProperty = opcodeProperty[pOp->opcode];

     if( (opProperty & OPFLG_OUT2_PRERELEASE)!=0 ){

       assert( pOp->p2>0 );

       assert( pOp->p2<=p->nMem );

       pOut = &p->aMem[pOp->p2];

       sqlite3VdbeMemReleaseExternal(pOut);

       pOut->flags = MEM_Null;

     }else

     /* Do common setup for opcodes marked with one of the following

     ** combinations of properties.

     **

     **           in1

     **           in1 in2

     **           in1 in2 out3

     **           in1 in3

     **

     ** Variables pIn1, pIn2, and pIn3 are made to point to appropriate

     ** registers for inputs.  Variable pOut points to the output register.

     */

     if( (opProperty & OPFLG_IN1)!=0 ){

       assert( pOp->p1>0 );

       assert( pOp->p1<=p->nMem );

       pIn1 = &p->aMem[pOp->p1];

       REGISTER_TRACE(pOp->p1, pIn1);

       if( (opProperty & OPFLG_IN2)!=0 ){

         assert( pOp->p2>0 );

         assert( pOp->p2<=p->nMem );

         pIn2 = &p->aMem[pOp->p2];

         REGISTER_TRACE(pOp->p2, pIn2);

         if( (opProperty & OPFLG_OUT3)!=0 ){

           assert( pOp->p3>0 );

           assert( pOp->p3<=p->nMem );

           pOut = &p->aMem[pOp->p3];

         }

       }else if( (opProperty & OPFLG_IN3)!=0 ){

         assert( pOp->p3>0 );

         assert( pOp->p3<=p->nMem );

         pIn3 = &p->aMem[pOp->p3];

         REGISTER_TRACE(pOp->p3, pIn3);

       }

     }else if( (opProperty & OPFLG_IN2)!=0 ){

       assert( pOp->p2>0 );

       assert( pOp->p2<=p->nMem );

       pIn2 = &p->aMem[pOp->p2];

       REGISTER_TRACE(pOp->p2, pIn2);

     }else if( (opProperty & OPFLG_IN3)!=0 ){

       assert( pOp->p3>0 );

       assert( pOp->p3<=p->nMem );

       pIn3 = &p->aMem[pOp->p3];

       REGISTER_TRACE(pOp->p3, pIn3);

     }

     switch( pOp->opcode ){

 /*****************************************************************************

 ** What follows is a massive switch statement where each case implements a

 ** separate instruction in the virtual machine.  If we follow the usual

 ** indentation conventions, each case should be indented by 6 spaces.  But

 ** that is a lot of wasted space on the left margin.  So the code within

 ** the switch statement will break with convention and be flush-left. Another

 ** big comment (similar to this one) will mark the point in the code where

 ** we transition back to normal indentation.

 **

 ** The formatting of each case is important.  The makefile for SQLite

 ** generates two C files "opcodes.h" and "opcodes.c" by scanning this

 ** file looking for lines that begin with "case OP_".  The opcodes.h files

 ** will be filled with #defines that give unique integer values to each

 ** opcode and the opcodes.c file is filled with an array of strings where

 ** each string is the symbolic name for the corresponding opcode.  If the

 ** case statement is followed by a comment of the form "/# same as ... #/"

 ** that comment is used to determine the particular value of the opcode.

 **

 ** Other keywords in the comment that follows each case are used to

 ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].

 ** Keywords include: in1, in2, in3, out2_prerelease, out2, out3.  See

 ** the mkopcodeh.awk script for additional information.

 **

 ** Documentation about VDBE opcodes is generated by scanning this file

 ** for lines of that contain "Opcode:".  That line and all subsequent

 ** comment lines are used in the generation of the opcode.html documentation

 ** file.

 **

 ** SUMMARY:

 **

 **     Formatting is important to scripts that scan this file.

 **     Do not deviate from the formatting style currently in use.

 **

 *****************************************************************************/

 /* Opcode:  Goto * P2 * * *

 **

 ** An unconditional jump to address P2.

 ** The next instruction executed will be 

 ** the one at index P2 from the beginning of

 ** the program.

 */

 case OP_Goto: {             /* jump */

   CHECK_FOR_INTERRUPT;

   pc = pOp->p2 - 1;

   break;

 }

 /* Opcode:  Gosub P1 P2 * * *

 **

 ** Write the current address onto register P1

 ** and then jump to address P2.

 */

 case OP_Gosub: {            /* jump */

   assert( pOp->p1>0 );

   assert( pOp->p1<=p->nMem );

   pIn1 = &p->aMem[pOp->p1];

   assert( (pIn1->flags & MEM_Dyn)==0 );

   pIn1->flags = MEM_Int;

   pIn1->u.i = pc;

   REGISTER_TRACE(pOp->p1, pIn1);

   pc = pOp->p2 - 1;

   break;

 }

 /* Opcode:  Return P1 * * * *

 **

 ** Jump to the next instruction after the address in register P1.

 */

 case OP_Return: {           /* in1 */

   assert( pIn1->flags & MEM_Int );

   pc = pIn1->u.i;

   break;

 }

 /* Opcode:  Yield P1 * * * *

 **

 ** Swap the program counter with the value in register P1.

 */

 case OP_Yield: {

   int pcDest;

   assert( pOp->p1>0 );

   assert( pOp->p1<=p->nMem );

   pIn1 = &p->aMem[pOp->p1];

   assert( (pIn1->flags & MEM_Dyn)==0 );

   pIn1->flags = MEM_Int;

   pcDest = pIn1->u.i;

   pIn1->u.i = pc;

   REGISTER_TRACE(pOp->p1, pIn1);

   pc = pcDest;

   break;

 }

 /* Opcode:  Halt P1 P2 * P4 *

 **

 ** Exit immediately.  All open cursors, Fifos, etc are closed

 ** automatically.

 **

 ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),

 ** or sqlite3_finalize().  For a normal halt, this should be SQLITE_OK (0).

 ** For errors, it can be some other value.  If P1!=0 then P2 will determine

 ** whether or not to rollback the current transaction.  Do not rollback

 ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback.  If P2==OE_Abort,

 ** then back out all changes that have occurred during this execution of the

 ** VDBE, but do not rollback the transaction. 

 **

 ** If P4 is not null then it is an error message string.

 **

 ** There is an implied "Halt 0 0 0" instruction inserted at the very end of

 ** every program.  So a jump past the last instruction of the program

 ** is the same as executing Halt.

 */

 case OP_Halt: {

   p->rc = pOp->p1;

   p->pc = pc;

   p->errorAction = pOp->p2;

   if( pOp->p4.z ){

     sqlite3SetString(&p->zErrMsg, db, "%s", pOp->p4.z);

   }

   rc = sqlite3VdbeHalt(p);

   assert( rc==SQLITE_BUSY || rc==SQLITE_OK );

   if( rc==SQLITE_BUSY ){

     p->rc = rc = SQLITE_BUSY;

   }else{

     rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;

   }

   goto vdbe_return;

 }

 /* Opcode: Integer P1 P2 * * *

 **

 ** The 32-bit integer value P1 is written into register P2.

 */

 case OP_Integer: {         /* out2-prerelease */

   pOut->flags = MEM_Int;

   pOut->u.i = pOp->p1;

   break;

 }

 /* Opcode: Int64 * P2 * P4 *

 **

 ** P4 is a pointer to a 64-bit integer value.

 ** Write that value into register P2.

 */

 case OP_Int64: {           /* out2-prerelease */

   assert( pOp->p4.pI64!=0 );

   pOut->flags = MEM_Int;

   pOut->u.i = *pOp->p4.pI64;

   break;

 }

 /* Opcode: Real * P2 * P4 *

 **

 ** P4 is a pointer to a 64-bit floating point value.

 ** Write that value into register P2.

 */

 case OP_Real: {            /* same as TK_FLOAT, out2-prerelease */

   pOut->flags = MEM_Real;

   assert( !sqlite3IsNaN(*pOp->p4.pReal) );

   pOut->r = *pOp->p4.pReal;

   break;

 }

 /* Opcode: String8 * P2 * P4 *

 **

 ** P4 points to a nul terminated UTF-8 string. This opcode is transformed 

 ** into an OP_String before it is executed for the first time.

 */

 case OP_String8: {         /* same as TK_STRING, out2-prerelease */

   assert( pOp->p4.z!=0 );

   pOp->opcode = OP_String;

   pOp->p1 = strlen(pOp->p4.z);

 #ifndef SQLITE_OMIT_UTF16

   if( encoding!=SQLITE_UTF8 ){

     sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);

     if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;

     if( SQLITE_OK!=sqlite3VdbeMemMakeWriteable(pOut) ) goto no_mem;

     pOut->zMalloc = 0;

     pOut->flags |= MEM_Static;

     pOut->flags &= ~MEM_Dyn;

     if( pOp->p4type==P4_DYNAMIC ){

       sqlite3DbFree(db, pOp->p4.z);

     }

     pOp->p4type = P4_DYNAMIC;

     pOp->p4.z = pOut->z;

     pOp->p1 = pOut->n;

     if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){

       goto too_big;

     }

     UPDATE_MAX_BLOBSIZE(pOut);

     break;

   }

 #endif

   if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){

     goto too_big;

   }

   /* Fall through to the next case, OP_String */

 }

 /* Opcode: String P1 P2 * P4 *

 **

 ** The string value P4 of length P1 (bytes) is stored in register P2.

 */

 case OP_String: {          /* out2-prerelease */

   assert( pOp->p4.z!=0 );

   pOut->flags = MEM_Str|MEM_Static|MEM_Term;

   pOut->z = pOp->p4.z;

   pOut->n = pOp->p1;

   pOut->enc = encoding;

   UPDATE_MAX_BLOBSIZE(pOut);

   break;

 }

 /* Opcode: Null * P2 * * *

 **

 ** Write a NULL into register P2.

 */

 case OP_Null: {           /* out2-prerelease */

   break;

 }

 #ifndef SQLITE_OMIT_BLOB_LITERAL

 /* Opcode: Blob P1 P2 * P4

 **

 ** P4 points to a blob of data P1 bytes long.  Store this

 ** blob in register P2. This instruction is not coded directly

 ** by the compiler. Instead, the compiler layer specifies

 ** an OP_HexBlob opcode, with the hex string representation of

 ** the blob as P4. This opcode is transformed to an OP_Blob

 ** the first time it is executed.

 */

 case OP_Blob: {                /* out2-prerelease */

   assert( pOp->p1 <= SQLITE_MAX_LENGTH );

   sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);

   pOut->enc = encoding;

   UPDATE_MAX_BLOBSIZE(pOut);

   break;

 }

 #endif /* SQLITE_OMIT_BLOB_LITERAL */

 /* Opcode: Variable P1 P2 * * *

 **

 ** The value of variable P1 is written into register P2. A variable is

 ** an unknown in the original SQL string as handed to sqlite3_compile().

 ** Any occurrence of the '?' character in the original SQL is considered

 ** a variable.  Variables in the SQL string are number from left to

 ** right beginning with 1.  The values of variables are set using the

 ** sqlite3_bind() API.

 */

 case OP_Variable: {           /* out2-prerelease */

   int j = pOp->p1 - 1;

   Mem *pVar;

   assert( j>=0 && j<p->nVar );

   pVar = &p->aVar[j];

   if( sqlite3VdbeMemTooBig(pVar) ){

     goto too_big;

   }

   sqlite3VdbeMemShallowCopy(pOut, &p->aVar[j], MEM_Static);

   UPDATE_MAX_BLOBSIZE(pOut);

   break;

 }

 /* Opcode: Move P1 P2 P3 * *

 **

 ** Move the values in register P1..P1+P3-1 over into

 ** registers P2..P2+P3-1.  Registers P1..P1+P1-1 are

 ** left holding a NULL.  It is an error for register ranges

 ** P1..P1+P3-1 and P2..P2+P3-1 to overlap.

 */

 case OP_Move: {

   char *zMalloc;

   int n = pOp->p3;

   int p1 = pOp->p1;

   int p2 = pOp->p2;

   assert( n>0 );

   assert( p1>0 );

   assert( p1+n<p->nMem );

   pIn1 = &p->aMem[p1];

   assert( p2>0 );

   assert( p2+n<p->nMem );

   pOut = &p->aMem[p2];

   assert( p1+n<=p2 || p2+n<=p1 );

   while( n-- ){

     zMalloc = pOut->zMalloc;

     pOut->zMalloc = 0;

     sqlite3VdbeMemMove(pOut, pIn1);

     pIn1->zMalloc = zMalloc;

     REGISTER_TRACE(p2++, pOut);

     pIn1++;

     pOut++;

   }

   break;

 }

 /* Opcode: Copy P1 P2 * * *

 **

 ** Make a copy of register P1 into register P2.

 **

 ** This instruction makes a deep copy of the value.  A duplicate

 ** is made of any string or blob constant.  See also OP_SCopy.

 */

 case OP_Copy: {

   assert( pOp->p1>0 );

   assert( pOp->p1<=p->nMem );

   pIn1 = &p->aMem[pOp->p1];

   assert( pOp->p2>0 );

   assert( pOp->p2<=p->nMem );

   pOut = &p->aMem[pOp->p2];

   assert( pOut!=pIn1 );

   sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);

   Deephemeralize(pOut);

   REGISTER_TRACE(pOp->p2, pOut);

   break;

 }

 /* Opcode: SCopy P1 P2 * * *

 **

 ** Make a shallow copy of register P1 into register P2.

 **

 ** This instruction makes a shallow copy of the value.  If the value

 ** is a string or blob, then the copy is only a pointer to the

 ** original and hence if the original changes so will the copy.

 ** Worse, if the original is deallocated, the copy becomes invalid.

 ** Thus the program must guarantee that the original will not change

 ** during the lifetime of the copy.  Use OP_Copy to make a complete

 ** copy.

 */

 case OP_SCopy: {

   assert( pOp->p1>0 );

   assert( pOp->p1<=p->nMem );

   pIn1 = &p->aMem[pOp->p1];

   REGISTER_TRACE(pOp->p1, pIn1);

   assert( pOp->p2>0 );

   assert( pOp->p2<=p->nMem );

   pOut = &p->aMem[pOp->p2];

   assert( pOut!=pIn1 );

   sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);

   REGISTER_TRACE(pOp->p2, pOut);

   break;

 }

 /* Opcode: ResultRow P1 P2 * * *

 **

 ** The registers P1 through P1+P2-1 contain a single row of

 ** results. This opcode causes the sqlite3_step() call to terminate

 ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt

 ** structure to provide access to the top P1 values as the result

 ** row.

 */

 case OP_ResultRow: {

   Mem *pMem;

   int i;

   assert( p->nResColumn==pOp->p2 );

   assert( pOp->p1>0 );

   assert( pOp->p1+pOp->p2<=p->nMem );

   /* Invalidate all ephemeral cursor row caches */

   p->cacheCtr = (p->cacheCtr + 2)|1;

   /* Make sure the results of the current row are \000 terminated

   ** and have an assigned type.  The results are de-ephemeralized as

   ** as side effect.

   */

   pMem = p->pResultSet = &p->aMem[pOp->p1];

   for(i=0; i<pOp->p2; i++){

     sqlite3VdbeMemNulTerminate(&pMem[i]);

     storeTypeInfo(&pMem[i], encoding);

     REGISTER_TRACE(pOp->p1+i, &pMem[i]);

   }

   if( db->mallocFailed ) goto no_mem;

   /* Return SQLITE_ROW

   */

   p->nCallback++;

   p->pc = pc + 1;

   rc = SQLITE_ROW;

   goto vdbe_return;

 }

 /* Opcode: Concat P1 P2 P3 * *

 **

 ** Add the text in register P1 onto the end of the text in

 ** register P2 and store the result in register P3.

 ** If either the P1 or P2 text are NULL then store NULL in P3.

 **

 **   P3 = P2 || P1

 **

 ** It is illegal for P1 and P3 to be the same register. Sometimes,

 ** if P3 is the same register as P2, the implementation is able

 ** to avoid a memcpy().

 */

 case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */

   i64 nByte;

   assert( pIn1!=pOut );

   if( (pIn1->flags | pIn2->flags) & MEM_Null ){

     sqlite3VdbeMemSetNull(pOut);

     break;

   }

   ExpandBlob(pIn1);

   Stringify(pIn1, encoding);

   ExpandBlob(pIn2);

   Stringify(pIn2, encoding);

   nByte = pIn1->n + pIn2->n;

   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){

     goto too_big;

   }

   MemSetTypeFlag(pOut, MEM_Str);

   if( sqlite3VdbeMemGrow(pOut, nByte+2, pOut==pIn2) ){

     goto no_mem;

   }

   if( pOut!=pIn2 ){

     memcpy(pOut->z, pIn2->z, pIn2->n);

   }

   memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);

   pOut->z[nByte] = 0;

   pOut->z[nByte+1] = 0;

   pOut->flags |= MEM_Term;

   pOut->n = nByte;

   pOut->enc = encoding;

   UPDATE_MAX_BLOBSIZE(pOut);

   break;

 }

 /* Opcode: Add P1 P2 P3 * *

 **

 ** Add the value in register P1 to the value in register P2

 ** and store the result in register P3.

 ** If either input is NULL, the result is NULL.

 */

 /* Opcode: Multiply P1 P2 P3 * *

 **

 **

 ** Multiply the value in register P1 by the value in register P2

 ** and store the result in register P3.

 ** If either input is NULL, the result is NULL.

 */

 /* Opcode: Subtract P1 P2 P3 * *

 **

 ** Subtract the value in register P1 from the value in register P2

 ** and store the result in register P3.

 ** If either input is NULL, the result is NULL.

 */

 /* Opcode: Divide P1 P2 P3 * *

 **

 ** Divide the value in register P1 by the value in register P2

 ** and store the result in register P3.  If the value in register P2

 ** is zero, then the result is NULL.

 ** If either input is NULL, the result is NULL.

 */

 /* Opcode: Remainder P1 P2 P3 * *

 **

 ** Compute the remainder after integer division of the value in

 ** register P1 by the value in register P2 and store the result in P3. 

 ** If the value in register P2 is zero the result is NULL.

 ** If either operand is NULL, the result is NULL.

 */

 case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */

 case OP_Subtract:              /* same as TK_MINUS, in1, in2, out3 */

 case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */

 case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */

 case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */

   int flags;

   applyNumericAffinity(pIn1);

   applyNumericAffinity(pIn2);

   flags = pIn1->flags | pIn2->flags;

   if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;

   if( (pIn1->flags & pIn2->flags & MEM_Int)==MEM_Int ){

     i64 a, b;

     a = pIn1->u.i;

     b = pIn2->u.i;

     switch( pOp->opcode ){

       case OP_Add:         b += a;       break;

       case OP_Subtract:    b -= a;       break;

       case OP_Multiply:    b *= a;       break;

       case OP_Divide: {

         if( a==0 ) goto arithmetic_result_is_null;

         /* Dividing the largest possible negative 64-bit integer (1<<63) by 

         ** -1 returns an integer too large to store in a 64-bit data-type. On

         ** some architectures, the value overflows to (1<<63). On others,

         ** a SIGFPE is issued. The following statement normalizes this

         ** behavior so that all architectures behave as if integer 

         ** overflow occurred.

         */

         if( a==-1 && b==SMALLEST_INT64 ) a = 1;

         b /= a;

         break;

       }

       default: {

         if( a==0 ) goto arithmetic_result_is_null;

         if( a==-1 ) a = 1;

         b %= a;

         break;

       }

     }

     pOut->u.i = b;

     MemSetTypeFlag(pOut, MEM_Int);

   }else{

     double a, b;

     a = sqlite3VdbeRealValue(pIn1);

     b = sqlite3VdbeRealValue(pIn2);

     switch( pOp->opcode ){

       case OP_Add:         b += a;       break;

       case OP_Subtract:    b -= a;       break;

       case OP_Multiply:    b *= a;       break;

       case OP_Divide: {

         if( a==0.0 ) goto arithmetic_result_is_null;

         b /= a;

         break;

       }

       default: {

         i64 ia = (i64)a;

         i64 ib = (i64)b;

         if( ia==0 ) goto arithmetic_result_is_null;

         if( ia==-1 ) ia = 1;

         b = ib % ia;

         break;

       }

     }

     if( sqlite3IsNaN(b) ){

       goto arithmetic_result_is_null;

     }

     pOut->r = b;

     MemSetTypeFlag(pOut, MEM_Real);

     if( (flags & MEM_Real)==0 ){

       sqlite3VdbeIntegerAffinity(pOut);

     }

   }

   break;

 arithmetic_result_is_null:

   sqlite3VdbeMemSetNull(pOut);

   break;

 }

 /* Opcode: CollSeq * * P4

 **

 ** P4 is a pointer to a CollSeq struct. If the next call to a user function

 ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will

 ** be returned. This is used by the built-in min(), max() and nullif()

 ** functions.

 **

 ** The interface used by the implementation of the aforementioned functions

 ** to retrieve the collation sequence set by this opcode is not available

 ** publicly, only to user functions defined in func.c.

 */

 case OP_CollSeq: {

   assert( pOp->p4type==P4_COLLSEQ );

   break;

 }

 /* Opcode: Function P1 P2 P3 P4 P5

 **

 ** Invoke a user function (P4 is a pointer to a Function structure that

 ** defines the function) with P5 arguments taken from register P2 and

 ** successors.  The result of the function is stored in register P3.

 ** Register P3 must not be one of the function inputs.

 **

 ** P1 is a 32-bit bitmask indicating whether or not each argument to the 

 ** function was determined to be constant at compile time. If the first

 ** argument was constant then bit 0 of P1 is set. This is used to determine

 ** whether meta data associated with a user function argument using the

 ** sqlite3_set_auxdata() API may be safely retained until the next

 ** invocation of this opcode.

 **

 ** See also: AggStep and AggFinal

 */

 case OP_Function: {

   int i;

   Mem *pArg;

   sqlite3_context ctx;

   sqlite3_value **apVal;

   int n = pOp->p5;

   apVal = p->apArg;

   assert( apVal || n==0 );

   assert( n==0 || (pOp->p2>0 && pOp->p2+n<=p->nMem) );

   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );

   pArg = &p->aMem[pOp->p2];

   for(i=0; i<n; i++, pArg++){

     apVal[i] = pArg;

     storeTypeInfo(pArg, encoding);

     REGISTER_TRACE(pOp->p2, pArg);

   }

   assert( pOp->p4type==P4_FUNCDEF || pOp->p4type==P4_VDBEFUNC );

   if( pOp->p4type==P4_FUNCDEF ){

     ctx.pFunc = pOp->p4.pFunc;

     ctx.pVdbeFunc = 0;

   }else{

     ctx.pVdbeFunc = (VdbeFunc*)pOp->p4.pVdbeFunc;

     ctx.pFunc = ctx.pVdbeFunc->pFunc;

   }

   assert( pOp->p3>0 && pOp->p3<=p->nMem );

   pOut = &p->aMem[pOp->p3];

   ctx.s.flags = MEM_Null;

   ctx.s.db = db;

   ctx.s.xDel = 0;

   ctx.s.zMalloc = 0;

   /* The output cell may already have a buffer allocated. Move

   ** the pointer to ctx.s so in case the user-function can use

   ** the already allocated buffer instead of allocating a new one.

   */

   sqlite3VdbeMemMove(&ctx.s, pOut);

   MemSetTypeFlag(&ctx.s, MEM_Null);

   ctx.isError = 0;

   if( ctx.pFunc->flags & SQLITE_FUNC_NEEDCOLL ){

     assert( pOp>p->aOp );

     assert( pOp[-1].p4type==P4_COLLSEQ );

     assert( pOp[-1].opcode==OP_CollSeq );

     ctx.pColl = pOp[-1].p4.pColl;

   }

   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;

   (*ctx.pFunc->xFunc)(&ctx, n, apVal);

   if( sqlite3SafetyOn(db) ){

     sqlite3VdbeMemRelease(&ctx.s);

     goto abort_due_to_misuse;

   }

   if( db->mallocFailed ){

     /* Even though a malloc() has failed, the implementation of the

     ** user function may have called an sqlite3_result_XXX() function

     ** to return a value. The following call releases any resources

     ** associated with such a value.

     **

     ** Note: Maybe MemRelease() should be called if sqlite3SafetyOn()

     ** fails also (the if(...) statement above). But if people are

     ** misusing sqlite, they have bigger problems than a leaked value.

     */

     sqlite3VdbeMemRelease(&ctx.s);

     goto no_mem;

   }

   /* If any auxiliary data functions have been called by this user function,

   ** immediately call the destructor for any non-static values.

   */

   if( ctx.pVdbeFunc ){

     sqlite3VdbeDeleteAuxData(ctx.pVdbeFunc, pOp->p1);

     pOp->p4.pVdbeFunc = ctx.pVdbeFunc;

     pOp->p4type = P4_VDBEFUNC;

   }

   /* If the function returned an error, throw an exception */

   if( ctx.isError ){

     sqlite3SetString(&p->zErrMsg, db, "%s", sqlite3_value_text(&ctx.s));

     rc = ctx.isError;

   }

   /* Copy the result of the function into register P3 */

   sqlite3VdbeChangeEncoding(&ctx.s, encoding);

   sqlite3VdbeMemMove(pOut, &ctx.s);

   if( sqlite3VdbeMemTooBig(pOut) ){

     goto too_big;

   }

   REGISTER_TRACE(pOp->p3, pOut);

   UPDATE_MAX_BLOBSIZE(pOut);

   break;

 }

 /* Opcode: BitAnd P1 P2 P3 * *

 **

 ** Take the bit-wise AND of the values in register P1 and P2 and

 ** store the result in register P3.

 ** If either input is NULL, the result is NULL.

 */

 /* Opcode: BitOr P1 P2 P3 * *

 **

 ** Take the bit-wise OR of the values in register P1 and P2 and

 ** store the result in register P3.

 ** If either input is NULL, the result is NULL.

 */

 /* Opcode: ShiftLeft P1 P2 P3 * *

 **

 ** Shift the integer value in register P2 to the left by the

 ** number of bits specified by the integer in regiser P1.

 ** Store the result in register P3.

 ** If either input is NULL, the result is NULL.

 */

 /* Opcode: ShiftRight P1 P2 P3 * *

 **

 ** Shift the integer value in register P2 to the right by the

 ** number of bits specified by the integer in register P1.

 ** Store the result in register P3.

 ** If either input is NULL, the result is NULL.

 */

 case OP_BitAnd:                 /* same as TK_BITAND, in1, in2, out3 */

 case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */

 case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */

 case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */

   i64 a, b;

   if( (pIn1->flags | pIn2->flags) & MEM_Null ){

     sqlite3VdbeMemSetNull(pOut);

     break;

   }

   a = sqlite3VdbeIntValue(pIn2);

   b = sqlite3VdbeIntValue(pIn1);

   switch( pOp->opcode ){

     case OP_BitAnd:      a &= b;     break;

     case OP_BitOr:       a |= b;     break;

     case OP_ShiftLeft:   a <<= b;    break;

     default:  assert( pOp->opcode==OP_ShiftRight );

                          a >>= b;    break;

   }

   pOut->u.i = a;

   MemSetTypeFlag(pOut, MEM_Int);

   break;

 }

 /* Opcode: AddImm  P1 P2 * * *

 ** 

 ** Add the constant P2 to the value in register P1.

 ** The result is always an integer.

 **

 ** To force any register to be an integer, just add 0.

 */

 case OP_AddImm: {            /* in1 */

   sqlite3VdbeMemIntegerify(pIn1);

   pIn1->u.i += pOp->p2;

   break;

 }

 /* Opcode: ForceInt P1 P2 P3 * *

 **

 ** Convert value in register P1 into an integer.  If the value 

 ** in P1 is not numeric (meaning that is is a NULL or a string that

 ** does not look like an integer or floating point number) then

 ** jump to P2.  If the value in P1 is numeric then

 ** convert it into the least integer that is greater than or equal to its

 ** current value if P3==0, or to the least integer that is strictly

 ** greater than its current value if P3==1.

 */

 case OP_ForceInt: {            /* jump, in1 */

   i64 v;

   applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);

   if( (pIn1->flags & (MEM_Int|MEM_Real))==0 ){

     pc = pOp->p2 - 1;

     break;

   }

   if( pIn1->flags & MEM_Int ){

     v = pIn1->u.i + (pOp->p3!=0);

   }else{

     assert( pIn1->flags & MEM_Real );

     v = (sqlite3_int64)pIn1->r;

     if( pIn1->r>(double)v ) v++;

     if( pOp->p3 && pIn1->r==(double)v ) v++;

   }

   pIn1->u.i = v;

   MemSetTypeFlag(pIn1, MEM_Int);

   break;

 }

 /* Opcode: MustBeInt P1 P2 * * *

 ** 

 ** Force the value in register P1 to be an integer.  If the value

 ** in P1 is not an integer and cannot be converted into an integer

 ** without data loss, then jump immediately to P2, or if P2==0

 ** raise an SQLITE_MISMATCH exception.

 */

 case OP_MustBeInt: {            /* jump, in1 */

   applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);

   if( (pIn1->flags & MEM_Int)==0 ){

     if( pOp->p2==0 ){

       rc = SQLITE_MISMATCH;

       goto abort_due_to_error;

     }else{

       pc = pOp->p2 - 1;

     }

   }else{

     MemSetTypeFlag(pIn1, MEM_Int);

   }

   break;

 }

 /* Opcode: RealAffinity P1 * * * *

 **

 ** If register P1 holds an integer convert it to a real value.

 **

 ** This opcode is used when extracting information from a column that

 ** has REAL affinity.  Such column values may still be stored as

 ** integers, for space efficiency, but after extraction we want them

 ** to have only a real value.

 */

 case OP_RealAffinity: {                  /* in1 */

   if( pIn1->flags & MEM_Int ){

     sqlite3VdbeMemRealify(pIn1);

   }

   break;

 }

 #ifndef SQLITE_OMIT_CAST

 /* Opcode: ToText P1 * * * *

 **

 ** Force the value in register P1 to be text.

 ** If the value is numeric, convert it to a string using the

 ** equivalent of printf().  Blob values are unchanged and

 ** are afterwards simply interpreted as text.

 **

 ** A NULL value is not changed by this routine.  It remains NULL.

 */

 case OP_ToText: {                  /* same as TK_TO_TEXT, in1 */

   if( pIn1->flags & MEM_Null ) break;

   assert( MEM_Str==(MEM_Blob>>3) );

   pIn1->flags |= (pIn1->flags&MEM_Blob)>>3;

   applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);

   rc = ExpandBlob(pIn1);

   assert( pIn1->flags & MEM_Str || db->mallocFailed );

   pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Blob);

   UPDATE_MAX_BLOBSIZE(pIn1);

   break;

 }

 /* Opcode: ToBlob P1 * * * *

 **

 ** Force the value in register P1 to be a BLOB.

 ** If the value is numeric, convert it to a string first.

 ** Strings are simply reinterpreted as blobs with no change

 ** to the underlying data.

 **

 ** A NULL value is not changed by this routine.  It remains NULL.

 */

 case OP_ToBlob: {                  /* same as TK_TO_BLOB, in1 */

   if( pIn1->flags & MEM_Null ) break;

   if( (pIn1->flags & MEM_Blob)==0 ){

     applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);

     assert( pIn1->flags & MEM_Str || db->mallocFailed );

   }

   MemSetTypeFlag(pIn1, MEM_Blob);

   UPDATE_MAX_BLOBSIZE(pIn1);

   break;

 }

 /* Opcode: ToNumeric P1 * * * *

 **

 ** Force the value in register P1 to be numeric (either an

 ** integer or a floating-point number.)

 ** If the value is text or blob, try to convert it to an using the

 ** equivalent of atoi() or atof() and store 0 if no such conversion 

 ** is possible.

 **

 ** A NULL value is not changed by this routine.  It remains NULL.

 */

 case OP_ToNumeric: {                  /* same as TK_TO_NUMERIC, in1 */

   if( (pIn1->flags & (MEM_Null|MEM_Int|MEM_Real))==0 ){

     sqlite3VdbeMemNumerify(pIn1);

   }

   break;

 }

 #endif /* SQLITE_OMIT_CAST */

 /* Opcode: ToInt P1 * * * *

 **

 ** Force the value in register P1 be an integer.  If

 ** The value is currently a real number, drop its fractional part.

 ** If the value is text or blob, try to convert it to an integer using the

 ** equivalent of atoi() and store 0 if no such conversion is possible.

 **

 ** A NULL value is not changed by this routine.  It remains NULL.

 */

 case OP_ToInt: {                  /* same as TK_TO_INT, in1 */

   if( (pIn1->flags & MEM_Null)==0 ){

     sqlite3VdbeMemIntegerify(pIn1);

   }

   break;

 }

 #ifndef SQLITE_OMIT_CAST

 /* Opcode: ToReal P1 * * * *

 **

 ** Force the value in register P1 to be a floating point number.

 ** If The value is currently an integer, convert it.

 ** If the value is text or blob, try to convert it to an integer using the

 ** equivalent of atoi() and store 0.0 if no such conversion is possible.

 **

 ** A NULL value is not changed by this routine.  It remains NULL.

 */

 case OP_ToReal: {                  /* same as TK_TO_REAL, in1 */

   if( (pIn1->flags & MEM_Null)==0 ){

     sqlite3VdbeMemRealify(pIn1);

   }

   break;

 }

 #endif /* SQLITE_OMIT_CAST */

 /* Opcode: Lt P1 P2 P3 P4 P5

 **

 ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then

 ** jump to address P2.  

 **

 ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or

 ** reg(P3) is NULL then take the jump.  If the SQLITE_JUMPIFNULL 

 ** bit is clear then fall thru if either operand is NULL.

 **

 ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -

 ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made 

 ** to coerce both inputs according to this affinity before the

 ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric

 ** affinity is used. Note that the affinity conversions are stored

 ** back into the input registers P1 and P3.  So this opcode can cause

 ** persistent changes to registers P1 and P3.

 **

 ** Once any conversions have taken place, and neither value is NULL, 

 ** the values are compared. If both values are blobs then memcmp() is

 ** used to determine the results of the comparison.  If both values

 ** are text, then the appropriate collating function specified in

 ** P4 is  used to do the comparison.  If P4 is not specified then

 ** memcmp() is used to compare text string.  If both values are

 ** numeric, then a numeric comparison is used. If the two values

 ** are of different types, then numbers are considered less than

 ** strings and strings are considered less than blobs.

 **

 ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump.  Instead,

 ** store a boolean result (either 0, or 1, or NULL) in register P2.

 */

 /* Opcode: Ne P1 P2 P3 P4 P5

 **

 ** This works just like the Lt opcode except that the jump is taken if

 ** the operands in registers P1 and P3 are not equal.  See the Lt opcode for

 ** additional information.

 */

 /* Opcode: Eq P1 P2 P3 P4 P5

 **

 ** This works just like the Lt opcode except that the jump is taken if

 ** the operands in registers P1 and P3 are equal.

 ** See the Lt opcode for additional information.

 */

 /* Opcode: Le P1 P2 P3 P4 P5

 **

 ** This works just like the Lt opcode except that the jump is taken if

 ** the content of register P3 is less than or equal to the content of

 ** register P1.  See the Lt opcode for additional information.

 */

 /* Opcode: Gt P1 P2 P3 P4 P5

 **

 ** This works just like the Lt opcode except that the jump is taken if

 ** the content of register P3 is greater than the content of

 ** register P1.  See the Lt opcode for additional information.

 */

 /* Opcode: Ge P1 P2 P3 P4 P5

 **

 ** This works just like the Lt opcode except that the jump is taken if

 ** the content of register P3 is greater than or equal to the content of

 ** register P1.  See the Lt opcode for additional information.

 */

 case OP_Eq:               /* same as TK_EQ, jump, in1, in3 */

 case OP_Ne:               /* same as TK_NE, jump, in1, in3 */

 case OP_Lt:               /* same as TK_LT, jump, in1, in3 */

 case OP_Le:               /* same as TK_LE, jump, in1, in3 */

 case OP_Gt:               /* same as TK_GT, jump, in1, in3 */

 case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */

   int flags;

   int res;

   char affinity;

   flags = pIn1->flags|pIn3->flags;

   if( flags&MEM_Null ){

     /* If either operand is NULL then the result is always NULL.

     ** The jump is taken if the SQLITE_JUMPIFNULL bit is set.

     */

     if( pOp->p5 & SQLITE_STOREP2 ){

       pOut = &p->aMem[pOp->p2];

       MemSetTypeFlag(pOut, MEM_Null);

       REGISTER_TRACE(pOp->p2, pOut);

     }else if( pOp->p5 & SQLITE_JUMPIFNULL ){

       pc = pOp->p2-1;

     }

     break;

   }

   affinity = pOp->p5 & SQLITE_AFF_MASK;

   if( affinity ){

     applyAffinity(pIn1, affinity, encoding);

     applyAffinity(pIn3, affinity, encoding);

   }

   assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );

   ExpandBlob(pIn1);

   ExpandBlob(pIn3);

   res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);

   switch( pOp->opcode ){

     case OP_Eq:    res = res==0;     break;

     case OP_Ne:    res = res!=0;     break;

     case OP_Lt:    res = res<0;      break;

     case OP_Le:    res = res<=0;     break;

     case OP_Gt:    res = res>0;      break;

     default:       res = res>=0;     break;

   }

   if( pOp->p5 & SQLITE_STOREP2 ){

     pOut = &p->aMem[pOp->p2];

     MemSetTypeFlag(pOut, MEM_Int);

     pOut->u.i = res;

     REGISTER_TRACE(pOp->p2, pOut);

   }else if( res ){

     pc = pOp->p2-1;

   }

   break;

 }

 /* Opcode: Permutation * * * P4 *

 **

 ** Set the permuation used by the OP_Compare operator to be the array

 ** of integers in P4.

 **

 ** The permutation is only valid until the next OP_Permutation, OP_Compare,

 ** OP_Halt, or OP_ResultRow.  Typically the OP_Permutation should occur

 ** immediately prior to the OP_Compare.

 */

 case OP_Permutation: {

   assert( pOp->p4type==P4_INTARRAY );

   assert( pOp->p4.ai );

   aPermute = pOp->p4.ai;

   break;

 }

 /* Opcode: Compare P1 P2 P3 P4 *

 **

 ** Compare to vectors of registers in reg(P1)..reg(P1+P3-1) (all this

 ** one "A") and in reg(P2)..reg(P2+P3-1) ("B").  Save the result of

 ** the comparison for use by the next OP_Jump instruct.

 **

 ** P4 is a KeyInfo structure that defines collating sequences and sort

 ** orders for the comparison.  The permutation applies to registers

 ** only.  The KeyInfo elements are used sequentially.

 **

 ** The comparison is a sort comparison, so NULLs compare equal,

 ** NULLs are less than numbers, numbers are less than strings,

 ** and strings are less than blobs.

 */

 case OP_Compare: {

   int n = pOp->p3;

   int i, p1, p2;

   const KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;

   assert( n>0 );

   assert( pKeyInfo!=0 );

   p1 = pOp->p1;

   assert( p1>0 && p1+n-1<p->nMem );

   p2 = pOp->p2;

   assert( p2>0 && p2+n-1<p->nMem );

   for(i=0; i<n; i++){

     int idx = aPermute ? aPermute[i] : i;

     CollSeq *pColl;    /* Collating sequence to use on this term */

     int bRev;          /* True for DESCENDING sort order */

     REGISTER_TRACE(p1+idx, &p->aMem[p1+idx]);

     REGISTER_TRACE(p2+idx, &p->aMem[p2+idx]);

     assert( i<pKeyInfo->nField );

     pColl = pKeyInfo->aColl[i];

     bRev = pKeyInfo->aSortOrder[i];

     iCompare = sqlite3MemCompare(&p->aMem[p1+idx], &p->aMem[p2+idx], pColl);

     if( iCompare ){

       if( bRev ) iCompare = -iCompare;

       break;

     }

   }

   aPermute = 0;

   break;

 }

 /* Opcode: Jump P1 P2 P3 * *

 **

 ** Jump to the instruction at address P1, P2, or P3 depending on whether

 ** in the most recent OP_Compare instruction the P1 vector was less than

 ** equal to, or greater than the P2 vector, respectively.

 */

 case OP_Jump: {             /* jump */

   if( iCompare<0 ){

     pc = pOp->p1 - 1;

   }else if( iCompare==0 ){

     pc = pOp->p2 - 1;

   }else{

     pc = pOp->p3 - 1;

   }

   break;

 }

 /* Opcode: And P1 P2 P3 * *

 **

 ** Take the logical AND of the values in registers P1 and P2 and

 ** write the result into register P3.

 **

 ** If either P1 or P2 is 0 (false) then the result is 0 even if

 ** the other input is NULL.  A NULL and true or two NULLs give

 ** a NULL output.

 */

 /* Opcode: Or P1 P2 P3 * *

 **

 ** Take the logical OR of the values in register P1 and P2 and

 ** store the answer in register P3.

 **

 ** If either P1 or P2 is nonzero (true) then the result is 1 (true)

 ** even if the other input is NULL.  A NULL and false or two NULLs

 ** give a NULL output.

 */

 case OP_And:              /* same as TK_AND, in1, in2, out3 */

 case OP_Or: {             /* same as TK_OR, in1, in2, out3 */

   int v1, v2;    /* 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */

   if( pIn1->flags & MEM_Null ){

     v1 = 2;

   }else{

     v1 = sqlite3VdbeIntValue(pIn1)!=0;

   }

   if( pIn2->flags & MEM_Null ){

     v2 = 2;

   }else{

     v2 = sqlite3VdbeIntValue(pIn2)!=0;

   }

   if( pOp->opcode==OP_And ){

     static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };

     v1 = and_logic[v1*3+v2];

   }else{

     static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };

     v1 = or_logic[v1*3+v2];

   }

   if( v1==2 ){

     MemSetTypeFlag(pOut, MEM_Null);

   }else{

     pOut->u.i = v1;

     MemSetTypeFlag(pOut, MEM_Int);

   }

   break;

 }

 /* Opcode: Not P1 P2 * * *

 **

 ** Interpret the value in register P1 as a boolean value.  Store the

 ** boolean complement in register P2.  If the value in register P1 is 

 ** NULL, then a NULL is stored in P2.

 */

 case OP_Not: {                /* same as TK_NOT, in1 */

   pOut = &p->aMem[pOp->p2];

   if( pIn1->flags & MEM_Null ){

     sqlite3VdbeMemSetNull(pOut);

   }else{

     sqlite3VdbeMemSetInt64(pOut, !sqlite3VdbeIntValue(pIn1));

   }

   break;

 }

 /* Opcode: BitNot P1 P2 * * *

 **

 ** Interpret the content of register P1 as an integer.  Store the

 ** ones-complement of the P1 value into register P2.  If P1 holds

 ** a NULL then store a NULL in P2.

 */

 case OP_BitNot: {             /* same as TK_BITNOT, in1 */

   pOut = &p->aMem[pOp->p2];

   if( pIn1->flags & MEM_Null ){

     sqlite3VdbeMemSetNull(pOut);

   }else{

     sqlite3VdbeMemSetInt64(pOut, ~sqlite3VdbeIntValue(pIn1));

   }

   break;

 }

 /* Opcode: If P1 P2 P3 * *

 **

 ** Jump to P2 if the value in register P1 is true.  The value is

 ** is considered true if it is numeric and non-zero.  If the value

 ** in P1 is NULL then take the jump if P3 is true.

 */

 /* Opcode: IfNot P1 P2 P3 * *

 **

 ** Jump to P2 if the value in register P1 is False.  The value is

 ** is considered true if it has a numeric value of zero.  If the value

 ** in P1 is NULL then take the jump if P3 is true.

 */

 case OP_If:                 /* jump, in1 */

 case OP_IfNot: {            /* jump, in1 */

   int c;

   if( pIn1->flags & MEM_Null ){

     c = pOp->p3;

   }else{

 #ifdef SQLITE_OMIT_FLOATING_POINT

     c = sqlite3VdbeIntValue(pIn1);

 #else

     c = sqlite3VdbeRealValue(pIn1)!=0.0;

 #endif

     if( pOp->opcode==OP_IfNot ) c = !c;

   }

   if( c ){

     pc = pOp->p2-1;

   }

   break;

 }

 /* Opcode: IsNull P1 P2 P3 * *

 **

 ** Jump to P2 if the value in register P1 is NULL.  If P3 is greater

 ** than zero, then check all values reg(P1), reg(P1+1), 

 ** reg(P1+2), ..., reg(P1+P3-1).

 */

 case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */

   int n = pOp->p3;

   assert( pOp->p3==0 || pOp->p1>0 );

   do{

     if( (pIn1->flags & MEM_Null)!=0 ){

       pc = pOp->p2 - 1;

       break;

     }

     pIn1++;

   }while( --n > 0 );

   break;

 }

 /* Opcode: NotNull P1 P2 * * *

 **

 ** Jump to P2 if the value in register P1 is not NULL.  

 */

 case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */

   if( (pIn1->flags & MEM_Null)==0 ){

     pc = pOp->p2 - 1;

   }

   break;

 }

 /* Opcode: SetNumColumns * P2 * * *

 **

 ** This opcode sets the number of columns for the cursor opened by the

 ** following instruction to P2.

 **

 ** An OP_SetNumColumns is only useful if it occurs immediately before 

 ** one of the following opcodes:

 **

 **     OpenRead

 **     OpenWrite

 **     OpenPseudo

 **

 ** If the OP_Column opcode is to be executed on a cursor, then

 ** this opcode must be present immediately before the opcode that

 ** opens the cursor.

 */

 case OP_SetNumColumns: {

   break;

 }

 /* Opcode: Column P1 P2 P3 P4 *

 **

 ** Interpret the data that cursor P1 points to as a structure built using

 ** the MakeRecord instruction.  (See the MakeRecord opcode for additional

 ** information about the format of the data.)  Extract the P2-th column

 ** from this record.  If there are less that (P2+1) 

 ** values in the record, extract a NULL.

 **

 ** The value extracted is stored in register P3.

 **

 ** If the KeyAsData opcode has previously executed on this cursor, then the

 ** field might be extracted from the key rather than the data.

 **

 ** If the column contains fewer than P2 fields, then extract a NULL.  Or,

 ** if the P4 argument is a P4_MEM use the value of the P4 argument as

 ** the result.

 */

 case OP_Column: {

   u32 payloadSize;   /* Number of bytes in the record */

   int p1 = pOp->p1;  /* P1 value of the opcode */

   int p2 = pOp->p2;  /* column number to retrieve */

   Cursor *pC = 0;    /* The VDBE cursor */

   char *zRec;        /* Pointer to complete record-data */

   BtCursor *pCrsr;   /* The BTree cursor */

   u32 *aType;        /* aType[i] holds the numeric type of the i-th column */

   u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */

   u32 nField;        /* number of fields in the record */

   int len;           /* The length of the serialized data for the column */

   int i;             /* Loop counter */

   char *zData;       /* Part of the record being decoded */

   Mem *pDest;        /* Where to write the extracted value */

   Mem sMem;          /* For storing the record being decoded */

   sMem.flags = 0;

   sMem.db = 0;

   sMem.zMalloc = 0;

   assert( p1<p->nCursor );

   assert( pOp->p3>0 && pOp->p3<=p->nMem );

   pDest = &p->aMem[pOp->p3];

   MemSetTypeFlag(pDest, MEM_Null);

   /* This block sets the variable payloadSize to be the total number of

   ** bytes in the record.

   **

   ** zRec is set to be the complete text of the record if it is available.

   ** The complete record text is always available for pseudo-tables

   ** If the record is stored in a cursor, the complete record text

   ** might be available in the  pC->aRow cache.  Or it might not be.

   ** If the data is unavailable,  zRec is set to NULL.

   **

   ** We also compute the number of columns in the record.  For cursors,

   ** the number of columns is stored in the Cursor.nField element.

   */

   pC = p->apCsr[p1];

   assert( pC!=0 );

 #ifndef SQLITE_OMIT_VIRTUALTABLE

   assert( pC->pVtabCursor==0 );

 #endif

   if( pC->pCursor!=0 ){

     /* The record is stored in a B-Tree */

     rc = sqlite3VdbeCursorMoveto(pC);

     if( rc ) goto abort_due_to_error;

     zRec = 0;

     pCrsr = pC->pCursor;

     if( pC->nullRow ){

       payloadSize = 0;

     }else if( pC->cacheStatus==p->cacheCtr ){

       payloadSize = pC->payloadSize;

       zRec = (char*)pC->aRow;

     }else if( pC->isIndex ){

       i64 payloadSize64;

       sqlite3BtreeKeySize(pCrsr, &payloadSize64);

       payloadSize = payloadSize64;

     }else{

       sqlite3BtreeDataSize(pCrsr, &payloadSize);

     }

     nField = pC->nField;

   }else{

     assert( pC->pseudoTable );

     /* The record is the sole entry of a pseudo-table */

     payloadSize = pC->nData;

     zRec = pC->pData;

     pC->cacheStatus = CACHE_STALE;

     assert( payloadSize==0 || zRec!=0 );

     nField = pC->nField;

     pCrsr = 0;

   }

   /* If payloadSize is 0, then just store a NULL */

   if( payloadSize==0 ){

     assert( pDest->flags&MEM_Null );

     goto op_column_out;

   }

   if( payloadSize>db->aLimit[SQLITE_LIMIT_LENGTH] ){

     goto too_big;

   }

   assert( p2<nField );

   /* Read and parse the table header.  Store the results of the parse

   ** into the record header cache fields of the cursor.

   */

   aType = pC->aType;

   if( pC->cacheStatus==p->cacheCtr ){

     aOffset = pC->aOffset;

   }else{

     u8 *zIdx;        /* Index into header */

     u8 *zEndHdr;     /* Pointer to first byte after the header */

     u32 offset;      /* Offset into the data */

     int szHdrSz;     /* Size of the header size field at start of record */

     int avail;       /* Number of bytes of available data */

     assert(aType);

     pC->aOffset = aOffset = &aType[nField];

     pC->payloadSize = payloadSize;

     pC->cacheStatus = p->cacheCtr;

     /* Figure out how many bytes are in the header */

     if( zRec ){

       zData = zRec;

     }else{

       if( pC->isIndex ){

         zData = (char*)sqlite3BtreeKeyFetch(pCrsr, &avail);

       }else{

         zData = (char*)sqlite3BtreeDataFetch(pCrsr, &avail);

       }

       /* If KeyFetch()/DataFetch() managed to get the entire payload,

       ** save the payload in the pC->aRow cache.  That will save us from

       ** having to make additional calls to fetch the content portion of

       ** the record.

       */

       if( avail>=payloadSize ){

         zRec = zData;

         pC->aRow = (u8*)zData;

       }else{

         pC->aRow = 0;

       }

     }

     /* The following assert is true in all cases accept when

     ** the database file has been corrupted externally.

     **    assert( zRec!=0 || avail>=payloadSize || avail>=9 ); */

     szHdrSz = getVarint32((u8*)zData, offset);

     /* The KeyFetch() or DataFetch() above are fast and will get the entire

     ** record header in most cases.  But they will fail to get the complete

     ** record header if the record header does not fit on a single page

     ** in the B-Tree.  When that happens, use sqlite3VdbeMemFromBtree() to

     ** acquire the complete header text.

     */

     if( !zRec && avail<offset ){

       sMem.flags = 0;

       sMem.db = 0;

       rc = sqlite3VdbeMemFromBtree(pCrsr, 0, offset, pC->isIndex, &sMem);

       if( rc!=SQLITE_OK ){

         goto op_column_out;

       }

       zData = sMem.z;

     }

     zEndHdr = (u8 *)&zData[offset];

     zIdx = (u8 *)&zData[szHdrSz];

     /* Scan the header and use it to fill in the aType[] and aOffset[]

     ** arrays.  aType[i] will contain the type integer for the i-th

     ** column and aOffset[i] will contain the offset from the beginning

     ** of the record to the start of the data for the i-th column

     */

     for(i=0; i<nField; i++){

       if( zIdx<zEndHdr ){

         aOffset[i] = offset;

         zIdx += getVarint32(zIdx, aType[i]);

         offset += sqlite3VdbeSerialTypeLen(aType[i]);

       }else{

         /* If i is less that nField, then there are less fields in this

         ** record than SetNumColumns indicated there are columns in the

         ** table. Set the offset for any extra columns not present in

         ** the record to 0. This tells code below to store a NULL

         ** instead of deserializing a value from the record.

         */

         aOffset[i] = 0;

       }

     }

     sqlite3VdbeMemRelease(&sMem);

     sMem.flags = MEM_Null;

     /* If we have read more header data than was contained in the header,

     ** or if the end of the last field appears to be past the end of the

     ** record, or if the end of the last field appears to be before the end

     ** of the record (when all fields present), then we must be dealing 

     ** with a corrupt database.

     */

     if( zIdx>zEndHdr || offset>payloadSize 

      || (zIdx==zEndHdr && offset!=payloadSize) ){

       rc = SQLITE_CORRUPT_BKPT;

       goto op_column_out;

     }

   }

   /* Get the column information. If aOffset[p2] is non-zero, then 

   ** deserialize the value from the record. If aOffset[p2] is zero,

   ** then there are not enough fields in the record to satisfy the

   ** request.  In this case, set the value NULL or to P4 if P4 is

   ** a pointer to a Mem object.

   */

   if( aOffset[p2] ){

     assert( rc==SQLITE_OK );

     if( zRec ){

       sqlite3VdbeMemReleaseExternal(pDest);

       sqlite3VdbeSerialGet((u8 *)&zRec[aOffset[p2]], aType[p2], pDest);

     }else{

       len = sqlite3VdbeSerialTypeLen(aType[p2]);

       sqlite3VdbeMemMove(&sMem, pDest);

       rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, pC->isIndex, &sMem);

       if( rc!=SQLITE_OK ){

         goto op_column_out;

       }

       zData = sMem.z;

       sqlite3VdbeSerialGet((u8*)zData, aType[p2], pDest);

     }

     pDest->enc = encoding;

   }else{

     if( pOp->p4type==P4_MEM ){

       sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);

     }else{

       assert( pDest->flags&MEM_Null );

     }

   }

   /* If we dynamically allocated space to hold the data (in the

   ** sqlite3VdbeMemFromBtree() call above) then transfer control of that

   ** dynamically allocated space over to the pDest structure.

   ** This prevents a memory copy.

   */

   if( sMem.zMalloc ){

     assert( sMem.z==sMem.zMalloc );

     assert( !(pDest->flags & MEM_Dyn) );

     assert( !(pDest->flags & (MEM_Blob|MEM_Str)) || pDest->z==sMem.z );

     pDest->flags &= ~(MEM_Ephem|MEM_Static);

     pDest->flags |= MEM_Term;

     pDest->z = sMem.z;

     pDest->zMalloc = sMem.zMalloc;

   }

   rc = sqlite3VdbeMemMakeWriteable(pDest);

 op_column_out:

   UPDATE_MAX_BLOBSIZE(pDest);

   REGISTER_TRACE(pOp->p3, pDest);

   break;

 }

 /* Opcode: Affinity P1 P2 * P4 *

 **

 ** Apply affinities to a range of P2 registers starting with P1.

 **

 ** P4 is a string that is P2 characters long. The nth character of the

 ** string indicates the column affinity that should be used for the nth

 ** memory cell in the range.

 */

 case OP_Affinity: {

   char *zAffinity = pOp->p4.z;

   Mem *pData0 = &p->aMem[pOp->p1];

   Mem *pLast = &pData0[pOp->p2-1];

   Mem *pRec;

   for(pRec=pData0; pRec<=pLast; pRec++){

     ExpandBlob(pRec);

     applyAffinity(pRec, zAffinity[pRec-pData0], encoding);

   }

   break;

 }

 /* Opcode: MakeRecord P1 P2 P3 P4 *

 **

 ** Convert P2 registers beginning with P1 into a single entry

 ** suitable for use as a data record in a database table or as a key

 ** in an index.  The details of the format are irrelevant as long as

 ** the OP_Column opcode can decode the record later.

 ** Refer to source code comments for the details of the record

 ** format.

 **

 ** P4 may be a string that is P2 characters long.  The nth character of the

 ** string indicates the column affinity that should be used for the nth

 ** field of the index key.

 **

 ** The mapping from character to affinity is given by the SQLITE_AFF_

 ** macros defined in sqliteInt.h.

 **

 ** If P4 is NULL then all index fields have the affinity NONE.

 */

 case OP_MakeRecord: {

   /* Assuming the record contains N fields, the record format looks

   ** like this:

   **

   ** ------------------------------------------------------------------------

   ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | 

   ** ------------------------------------------------------------------------

   **

   ** Data(0) is taken from register P1.  Data(1) comes from register P1+1

   ** and so froth.

   **

   ** Each type field is a varint representing the serial type of the 

   ** corresponding data element (see sqlite3VdbeSerialType()). The

   ** hdr-size field is also a varint which is the offset from the beginning

   ** of the record to data0.

   */

   u8 *zNewRecord;        /* A buffer to hold the data for the new record */

   Mem *pRec;             /* The new record */

   u64 nData = 0;         /* Number of bytes of data space */

   int nHdr = 0;          /* Number of bytes of header space */

   u64 nByte = 0;         /* Data space required for this record */

   int nZero = 0;         /* Number of zero bytes at the end of the record */

   int nVarint;           /* Number of bytes in a varint */

   u32 serial_type;       /* Type field */

   Mem *pData0;           /* First field to be combined into the record */

   Mem *pLast;            /* Last field of the record */

   int nField;            /* Number of fields in the record */

   char *zAffinity;       /* The affinity string for the record */

   int file_format;       /* File format to use for encoding */

   int i;                 /* Space used in zNewRecord[] */

   nField = pOp->p1;

   zAffinity = pOp->p4.z;

   assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=p->nMem );

   pData0 = &p->aMem[nField];

   nField = pOp->p2;

   pLast = &pData0[nField-1];

   file_format = p->minWriteFileFormat;

   /* Loop through the elements that will make up the record to figure

   ** out how much space is required for the new record.

   */

   for(pRec=pData0; pRec<=pLast; pRec++){

     int len;

     if( zAffinity ){

       applyAffinity(pRec, zAffinity[pRec-pData0], encoding);

     }

     if( pRec->flags&MEM_Zero && pRec->n>0 ){

       sqlite3VdbeMemExpandBlob(pRec);

     }

     serial_type = sqlite3VdbeSerialType(pRec, file_format);

     len = sqlite3VdbeSerialTypeLen(serial_type);

     nData += len;

     nHdr += sqlite3VarintLen(serial_type);

     if( pRec->flags & MEM_Zero ){

       /* Only pure zero-filled BLOBs can be input to this Opcode.

       ** We do not allow blobs with a prefix and a zero-filled tail. */

       nZero += pRec->u.i;

     }else if( len ){

       nZero = 0;

     }

   }

   /* Add the initial header varint and total the size */

   nHdr += nVarint = sqlite3VarintLen(nHdr);

   if( nVarint<sqlite3VarintLen(nHdr) ){

     nHdr++;

   }

   nByte = nHdr+nData-nZero;

   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){

     goto too_big;

   }

   /* Make sure the output register has a buffer large enough to store 

   ** the new record. The output register (pOp->p3) is not allowed to

   ** be one of the input registers (because the following call to

   ** sqlite3VdbeMemGrow() could clobber the value before it is used).

   */

   assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );

   pOut = &p->aMem[pOp->p3];

   if( sqlite3VdbeMemGrow(pOut, nByte, 0) ){

     goto no_mem;

   }

   zNewRecord = (u8 *)pOut->z;

   /* Write the record */

   i = putVarint32(zNewRecord, nHdr);

   for(pRec=pData0; pRec<=pLast; pRec++){

     serial_type = sqlite3VdbeSerialType(pRec, file_format);

     i += putVarint32(&zNewRecord[i], serial_type);      /* serial type */

   }

   for(pRec=pData0; pRec<=pLast; pRec++){  /* serial data */

     i += sqlite3VdbeSerialPut(&zNewRecord[i], nByte-i, pRec, file_format);

   }

   assert( i==nByte );

   assert( pOp->p3>0 && pOp->p3<=p->nMem );

   pOut->n = nByte;

   pOut->flags = MEM_Blob | MEM_Dyn;

   pOut->xDel = 0;

   if( nZero ){

     pOut->u.i = nZero;

     pOut->flags |= MEM_Zero;

   }

   pOut->enc = SQLITE_UTF8;  /* In case the blob is ever converted to text */

   REGISTER_TRACE(pOp->p3, pOut);

   UPDATE_MAX_BLOBSIZE(pOut);

   break;

 }

 /* Opcode: Statement P1 * * * *

 **

 ** Begin an individual statement transaction which is part of a larger

 ** transaction.  This is needed so that the statement

 ** can be rolled back after an error without having to roll back the

 ** entire transaction.  The statement transaction will automatically

 ** commit when the VDBE halts.

 **

 ** If the database connection is currently in autocommit mode (that 

 ** is to say, if it is in between BEGIN and COMMIT)

 ** and if there are no other active statements on the same database

 ** connection, then this operation is a no-op.  No statement transaction

 ** is needed since any error can use the normal ROLLBACK process to

 ** undo changes.

 **

 ** If a statement transaction is started, then a statement journal file

 ** will be allocated and initialized.

 **

 ** The statement is begun on the database file with index P1.  The main

 ** database file has an index of 0 and the file used for temporary tables

 ** has an index of 1.

 */

 case OP_Statement: {

   if( db->autoCommit==0 || db->activeVdbeCnt>1 ){

     int i = pOp->p1;

     Btree *pBt;

     assert( i>=0 && i<db->nDb );

     assert( db->aDb[i].pBt!=0 );

     pBt = db->aDb[i].pBt;

     assert( sqlite3BtreeIsInTrans(pBt) );

     assert( (p->btreeMask & (1<<i))!=0 );

     if( !sqlite3BtreeIsInStmt(pBt) ){

       rc = sqlite3BtreeBeginStmt(pBt);

       p->openedStatement = 1;

     }

   }

   break;

 }

 /* Opcode: AutoCommit P1 P2 * * *

 **

 ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll

 ** back any currently active btree transactions. If there are any active

 ** VMs (apart from this one), then the COMMIT or ROLLBACK statement fails.

 **

 ** This instruction causes the VM to halt.

 */

 case OP_AutoCommit: {

   u8 i = pOp->p1;

   u8 rollback = pOp->p2;

   assert( i==1 || i==0 );

   assert( i==1 || rollback==0 );

   assert( db->activeVdbeCnt>0 );  /* At least this one VM is active */

   if( db->activeVdbeCnt>1 && i && !db->autoCommit ){

     /* If this instruction implements a COMMIT or ROLLBACK, other VMs are

     ** still running, and a transaction is active, return an error indicating

     ** that the other VMs must complete first. 

     */

     sqlite3SetString(&p->zErrMsg, db, "cannot %s transaction - "

         "SQL statements in progress",

         rollback ? "rollback" : "commit");

     rc = SQLITE_ERROR;

   }else if( i!=db->autoCommit ){

     if( pOp->p2 ){

       assert( i==1 );

       sqlite3RollbackAll(db);

       db->autoCommit = 1;

     }else{

       db->autoCommit = i;

       if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){

         p->pc = pc;

         db->autoCommit = 1-i;

         p->rc = rc = SQLITE_BUSY;

         goto vdbe_return;

       }

     }

     if( p->rc==SQLITE_OK ){

       rc = SQLITE_DONE;

     }else{

       rc = SQLITE_ERROR;

     }

     goto vdbe_return;

   }else{

     sqlite3SetString(&p->zErrMsg, db,

         (!i)?"cannot start a transaction within a transaction":(

         (rollback)?"cannot rollback - no transaction is active":

                    "cannot commit - no transaction is active"));

     rc = SQLITE_ERROR;

   }

   break;

 }

 /* Opcode: Transaction P1 P2 * * *

 **

 ** Begin a transaction.  The transaction ends when a Commit or Rollback

 ** opcode is encountered.  Depending on the ON CONFLICT setting, the

 ** transaction might also be rolled back if an error is encountered.

 **

 ** P1 is the index of the database file on which the transaction is

 ** started.  Index 0 is the main database file and index 1 is the

 ** file used for temporary tables.  Indices of 2 or more are used for

 ** attached databases.

 **

 ** If P2 is non-zero, then a write-transaction is started.  A RESERVED lock is

 ** obtained on the database file when a write-transaction is started.  No

 ** other process can start another write transaction while this transaction is

 ** underway.  Starting a write transaction also creates a rollback journal. A

 ** write transaction must be started before any changes can be made to the

 ** database.  If P2 is 2 or greater then an EXCLUSIVE lock is also obtained

 ** on the file.

 **

 ** If P2 is zero, then a read-lock is obtained on the database file.

 */

 case OP_Transaction: {

   int i = pOp->p1;

   Btree *pBt;

   assert( i>=0 && i<db->nDb );

   assert( (p->btreeMask & (1<<i))!=0 );

   pBt = db->aDb[i].pBt;

   if( pBt ){

     rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);

     if( rc==SQLITE_BUSY ){

       p->pc = pc;

       p->rc = rc = SQLITE_BUSY;

       goto vdbe_return;

     }

     if( rc!=SQLITE_OK && rc!=SQLITE_READONLY /* && rc!=SQLITE_BUSY */ ){

       goto abort_due_to_error;

     }

   }

   break;

 }

 /* Opcode: ReadCookie P1 P2 P3 * *

 **

 ** Read cookie number P3 from database P1 and write it into register P2.

 ** P3==0 is the schema version.  P3==1 is the database format.

 ** P3==2 is the recommended pager cache size, and so forth.  P1==0 is

 ** the main database file and P1==1 is the database file used to store

 ** temporary tables.

 **

 ** If P1 is negative, then this is a request to read the size of a

 ** databases free-list. P3 must be set to 1 in this case. The actual

 ** database accessed is ((P1+1)*-1). For example, a P1 parameter of -1

 ** corresponds to database 0 ("main"), a P1 of -2 is database 1 ("temp").

 **

 ** There must be a read-lock on the database (either a transaction

 ** must be started or there must be an open cursor) before

 ** executing this instruction.

 */

 case OP_ReadCookie: {               /* out2-prerelease */

   int iMeta;

   int iDb = pOp->p1;

   int iCookie = pOp->p3;

   assert( pOp->p3<SQLITE_N_BTREE_META );

   if( iDb<0 ){

     iDb = (-1*(iDb+1));

     iCookie *= -1;

   }

   assert( iDb>=0 && iDb<db->nDb );

   assert( db->aDb[iDb].pBt!=0 );

   assert( (p->btreeMask & (1<<iDb))!=0 );

   /* The indexing of meta values at the schema layer is off by one from

   ** the indexing in the btree layer.  The btree considers meta[0] to

   ** be the number of free pages in the database (a read-only value)

   ** and meta[1] to be the schema cookie.  The schema layer considers

   ** meta[1] to be the schema cookie.  So we have to shift the index

   ** by one in the following statement.

   */

   rc = sqlite3BtreeGetMeta(db->aDb[iDb].pBt, 1 + iCookie, (u32 *)&iMeta);

   pOut->u.i = iMeta;

   MemSetTypeFlag(pOut, MEM_Int);

   break;

 }

 /* Opcode: SetCookie P1 P2 P3 * *

 **

 ** Write the content of register P3 (interpreted as an integer)

 ** into cookie number P2 of database P1.

 ** P2==0 is the schema version.  P2==1 is the database format.

 ** P2==2 is the recommended pager cache size, and so forth.  P1==0 is

 ** the main database file and P1==1 is the database file used to store

 ** temporary tables.

 **

 ** A transaction must be started before executing this opcode.

 */

 case OP_SetCookie: {       /* in3 */

   Db *pDb;

   assert( pOp->p2<SQLITE_N_BTREE_META );

   assert( pOp->p1>=0 && pOp->p1<db->nDb );

   assert( (p->btreeMask & (1<<pOp->p1))!=0 );

   pDb = &db->aDb[pOp->p1];

   assert( pDb->pBt!=0 );

   sqlite3VdbeMemIntegerify(pIn3);

   /* See note about index shifting on OP_ReadCookie */

   rc = sqlite3BtreeUpdateMeta(pDb->pBt, 1+pOp->p2, (int)pIn3->u.i);

   if( pOp->p2==0 ){

     /* When the schema cookie changes, record the new cookie internally */

     pDb->pSchema->schema_cookie = pIn3->u.i;

     db->flags |= SQLITE_InternChanges;

   }else if( pOp->p2==1 ){

     /* Record changes in the file format */

     pDb->pSchema->file_format = pIn3->u.i;

   }

   if( pOp->p1==1 ){

     /* Invalidate all prepared statements whenever the TEMP database

     ** schema is changed.  Ticket #1644 */

     sqlite3ExpirePreparedStatements(db);

   }

   break;

 }

 /* Opcode: VerifyCookie P1 P2 *

 **

 ** Check the value of global database parameter number 0 (the

 ** schema version) and make sure it is equal to P2.  

 ** P1 is the database number which is 0 for the main database file

 ** and 1 for the file holding temporary tables and some higher number

 ** for auxiliary databases.

 **

 ** The cookie changes its value whenever the database schema changes.

 ** This operation is used to detect when that the cookie has changed

 ** and that the current process needs to reread the schema.

 **

 ** Either a transaction needs to have been started or an OP_Open needs

 ** to be executed (to establish a read lock) before this opcode is

 ** invoked.

 */

 case OP_VerifyCookie: {

   int iMeta;

   Btree *pBt;

   assert( pOp->p1>=0 && pOp->p1<db->nDb );

   assert( (p->btreeMask & (1<<pOp->p1))!=0 );

   pBt = db->aDb[pOp->p1].pBt;

   if( pBt ){

     rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&iMeta);

   }else{

     rc = SQLITE_OK;

     iMeta = 0;

   }

   if( rc==SQLITE_OK && iMeta!=pOp->p2 ){

     sqlite3DbFree(db, p->zErrMsg);

     p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");

     /* If the schema-cookie from the database file matches the cookie 

     ** stored with the in-memory representation of the schema, do

     ** not reload the schema from the database file.

     **

     ** If virtual-tables are in use, this is not just an optimization.

     ** Often, v-tables store their data in other SQLite tables, which

     ** are queried from within xNext() and other v-table methods using

     ** prepared queries. If such a query is out-of-date, we do not want to

     ** discard the database schema, as the user code implementing the

     ** v-table would have to be ready for the sqlite3_vtab structure itself

     ** to be invalidated whenever sqlite3_step() is called from within 

     ** a v-table method.

     */

     if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){

       sqlite3ResetInternalSchema(db, pOp->p1);

     }

     sqlite3ExpirePreparedStatements(db);

     rc = SQLITE_SCHEMA;

   }

   break;

 }

 /* Opcode: OpenRead P1 P2 P3 P4 P5

 **

 ** Open a read-only cursor for the database table whose root page is

 ** P2 in a database file.  The database file is determined by P3. 

 ** P3==0 means the main database, P3==1 means the database used for 

 ** temporary tables, and P3>1 means used the corresponding attached

 ** database.  Give the new cursor an identifier of P1.  The P1

 ** values need not be contiguous but all P1 values should be small integers.

 ** It is an error for P1 to be negative.

 **

 ** If P5!=0 then use the content of register P2 as the root page, not

 ** the value of P2 itself.

 **

 ** There will be a read lock on the database whenever there is an

 ** open cursor.  If the database was unlocked prior to this instruction

 ** then a read lock is acquired as part of this instruction.  A read

 ** lock allows other processes to read the database but prohibits

 ** any other process from modifying the database.  The read lock is

 ** released when all cursors are closed.  If this instruction attempts

 ** to get a read lock but fails, the script terminates with an

 ** SQLITE_BUSY error code.

 **

 ** The P4 value is a pointer to a KeyInfo structure that defines the

 ** content and collating sequence of indices.  P4 is NULL for cursors

 ** that are not pointing to indices.

 **