vdbe.c
上传用户:sunhongbo
上传日期:2022-01-25
资源大小:3010k
文件大小:151k
源码类别:

数据库系统

开发平台:

C/C++

  1. /*
  2. ** 2001 September 15
  3. **
  4. ** The author disclaims copyright to this source code.  In place of
  5. ** a legal notice, here is a blessing:
  6. **
  7. **    May you do good and not evil.
  8. **    May you find forgiveness for yourself and forgive others.
  9. **    May you share freely, never taking more than you give.
  10. **
  11. *************************************************************************
  12. ** The code in this file implements execution method of the 
  13. ** Virtual Database Engine (VDBE).  A separate file ("vdbeaux.c")
  14. ** handles housekeeping details such as creating and deleting
  15. ** VDBE instances.  This file is solely interested in executing
  16. ** the VDBE program.
  17. **
  18. ** In the external interface, an "sqlite3_stmt*" is an opaque pointer
  19. ** to a VDBE.
  20. **
  21. ** The SQL parser generates a program which is then executed by
  22. ** the VDBE to do the work of the SQL statement.  VDBE programs are 
  23. ** similar in form to assembly language.  The program consists of
  24. ** a linear sequence of operations.  Each operation has an opcode 
  25. ** and 5 operands.  Operands P1, P2, and P3 are integers.  Operand P4 
  26. ** is a null-terminated string.  Operand P5 is an unsigned character.
  27. ** Few opcodes use all 5 operands.
  28. **
  29. ** Computation results are stored on a set of registers numbered beginning
  30. ** with 1 and going up to Vdbe.nMem.  Each register can store
  31. ** either an integer, a null-terminated string, a floating point
  32. ** number, or the SQL "NULL" value.  An inplicit conversion from one
  33. ** type to the other occurs as necessary.
  34. ** 
  35. ** Most of the code in this file is taken up by the sqlite3VdbeExec()
  36. ** function which does the work of interpreting a VDBE program.
  37. ** But other routines are also provided to help in building up
  38. ** a program instruction by instruction.
  39. **
  40. ** Various scripts scan this source file in order to generate HTML
  41. ** documentation, headers files, or other derived files.  The formatting
  42. ** of the code in this file is, therefore, important.  See other comments
  43. ** in this file for details.  If in doubt, do not deviate from existing
  44. ** commenting and indentation practices when changing or adding code.
  45. **
  46. ** $Id: vdbe.c,v 1.730 2008/04/15 12:14:22 drh Exp $
  47. */
  48. #include "sqliteInt.h"
  49. #include <ctype.h>
  50. #include "vdbeInt.h"
  51. /*
  52. ** The following global variable is incremented every time a cursor
  53. ** moves, either by the OP_MoveXX, OP_Next, or OP_Prev opcodes.  The test
  54. ** procedures use this information to make sure that indices are
  55. ** working correctly.  This variable has no function other than to
  56. ** help verify the correct operation of the library.
  57. */
  58. #ifdef SQLITE_TEST
  59. int sqlite3_search_count = 0;
  60. #endif
  61. /*
  62. ** When this global variable is positive, it gets decremented once before
  63. ** each instruction in the VDBE.  When reaches zero, the u1.isInterrupted
  64. ** field of the sqlite3 structure is set in order to simulate and interrupt.
  65. **
  66. ** This facility is used for testing purposes only.  It does not function
  67. ** in an ordinary build.
  68. */
  69. #ifdef SQLITE_TEST
  70. int sqlite3_interrupt_count = 0;
  71. #endif
  72. /*
  73. ** The next global variable is incremented each type the OP_Sort opcode
  74. ** is executed.  The test procedures use this information to make sure that
  75. ** sorting is occurring or not occuring at appropriate times.   This variable
  76. ** has no function other than to help verify the correct operation of the
  77. ** library.
  78. */
  79. #ifdef SQLITE_TEST
  80. int sqlite3_sort_count = 0;
  81. #endif
  82. /*
  83. ** The next global variable records the size of the largest MEM_Blob
  84. ** or MEM_Str that has been used by a VDBE opcode.  The test procedures
  85. ** use this information to make sure that the zero-blob functionality
  86. ** is working correctly.   This variable has no function other than to
  87. ** help verify the correct operation of the library.
  88. */
  89. #ifdef SQLITE_TEST
  90. int sqlite3_max_blobsize = 0;
  91. static void updateMaxBlobsize(Mem *p){
  92.   if( (p->flags & (MEM_Str|MEM_Blob))!=0 && p->n>sqlite3_max_blobsize ){
  93.     sqlite3_max_blobsize = p->n;
  94.   }
  95. }
  96. #endif
  97. /*
  98. ** Test a register to see if it exceeds the current maximum blob size.
  99. ** If it does, record the new maximum blob size.
  100. */
  101. #if defined(SQLITE_TEST) && !defined(SQLITE_OMIT_BUILTIN_TEST)
  102. # define UPDATE_MAX_BLOBSIZE(P)  updateMaxBlobsize(P)
  103. #else
  104. # define UPDATE_MAX_BLOBSIZE(P)
  105. #endif
  106. /*
  107. ** Release the memory associated with a register.  This
  108. ** leaves the Mem.flags field in an inconsistent state.
  109. */
  110. #define Release(P) if((P)->flags&MEM_Dyn){ sqlite3VdbeMemRelease(P); }
  111. /*
  112. ** Convert the given register into a string if it isn't one
  113. ** already. Return non-zero if a malloc() fails.
  114. */
  115. #define Stringify(P, enc) 
  116.    if(((P)->flags&(MEM_Str|MEM_Blob))==0 && sqlite3VdbeMemStringify(P,enc)) 
  117.      { goto no_mem; }
  118. /*
  119. ** The header of a record consists of a sequence variable-length integers.
  120. ** These integers are almost always small and are encoded as a single byte.
  121. ** The following macro takes advantage this fact to provide a fast decode
  122. ** of the integers in a record header.  It is faster for the common case
  123. ** where the integer is a single byte.  It is a little slower when the
  124. ** integer is two or more bytes.  But overall it is faster.
  125. **
  126. ** The following expressions are equivalent:
  127. **
  128. **     x = sqlite3GetVarint32( A, &B );
  129. **
  130. **     x = GetVarint( A, B );
  131. **
  132. */
  133. #define GetVarint(A,B)  ((B = *(A))<=0x7f ? 1 : sqlite3GetVarint32(A, &B))
  134. /*
  135. ** An ephemeral string value (signified by the MEM_Ephem flag) contains
  136. ** a pointer to a dynamically allocated string where some other entity
  137. ** is responsible for deallocating that string.  Because the register
  138. ** does not control the string, it might be deleted without the register
  139. ** knowing it.
  140. **
  141. ** This routine converts an ephemeral string into a dynamically allocated
  142. ** string that the register itself controls.  In other words, it
  143. ** converts an MEM_Ephem string into an MEM_Dyn string.
  144. */
  145. #define Deephemeralize(P) 
  146.    if( ((P)->flags&MEM_Ephem)!=0 
  147.        && sqlite3VdbeMemMakeWriteable(P) ){ goto no_mem;}
  148. /*
  149. ** Call sqlite3VdbeMemExpandBlob() on the supplied value (type Mem*)
  150. ** P if required.
  151. */
  152. #define ExpandBlob(P) (((P)->flags&MEM_Zero)?sqlite3VdbeMemExpandBlob(P):0)
  153. /*
  154. ** Argument pMem points at a regiser that will be passed to a
  155. ** user-defined function or returned to the user as the result of a query.
  156. ** The second argument, 'db_enc' is the text encoding used by the vdbe for
  157. ** register variables.  This routine sets the pMem->enc and pMem->type
  158. ** variables used by the sqlite3_value_*() routines.
  159. */
  160. #define storeTypeInfo(A,B) _storeTypeInfo(A)
  161. static void _storeTypeInfo(Mem *pMem){
  162.   int flags = pMem->flags;
  163.   if( flags & MEM_Null ){
  164.     pMem->type = SQLITE_NULL;
  165.   }
  166.   else if( flags & MEM_Int ){
  167.     pMem->type = SQLITE_INTEGER;
  168.   }
  169.   else if( flags & MEM_Real ){
  170.     pMem->type = SQLITE_FLOAT;
  171.   }
  172.   else if( flags & MEM_Str ){
  173.     pMem->type = SQLITE_TEXT;
  174.   }else{
  175.     pMem->type = SQLITE_BLOB;
  176.   }
  177. }
  178. /*
  179. ** Properties of opcodes.  The OPFLG_INITIALIZER macro is
  180. ** created by mkopcodeh.awk during compilation.  Data is obtained
  181. ** from the comments following the "case OP_xxxx:" statements in
  182. ** this file.  
  183. */
  184. static unsigned char opcodeProperty[] = OPFLG_INITIALIZER;
  185. /*
  186. ** Return true if an opcode has any of the OPFLG_xxx properties
  187. ** specified by mask.
  188. */
  189. int sqlite3VdbeOpcodeHasProperty(int opcode, int mask){
  190.   assert( opcode>0 && opcode<sizeof(opcodeProperty) );
  191.   return (opcodeProperty[opcode]&mask)!=0;
  192. }
  193. /*
  194. ** Allocate cursor number iCur.  Return a pointer to it.  Return NULL
  195. ** if we run out of memory.
  196. */
  197. static Cursor *allocateCursor(
  198.   Vdbe *p, 
  199.   int iCur, 
  200.   Op *pOp,
  201.   int iDb, 
  202.   int isBtreeCursor
  203. ){
  204.   /* Find the memory cell that will be used to store the blob of memory
  205.   ** required for this Cursor structure. It is convenient to use a 
  206.   ** vdbe memory cell to manage the memory allocation required for a
  207.   ** Cursor structure for the following reasons:
  208.   **
  209.   **   * Sometimes cursor numbers are used for a couple of different
  210.   **     purposes in a vdbe program. The different uses might require
  211.   **     different sized allocations. Memory cells provide growable
  212.   **     allocations.
  213.   **
  214.   **   * When using ENABLE_MEMORY_MANAGEMENT, memory cell buffers can
  215.   **     be freed lazily via the sqlite3_release_memory() API. This
  216.   **     minimizes the number of malloc calls made by the system.
  217.   **
  218.   ** Memory cells for cursors are allocated at the top of the address
  219.   ** space. Memory cell (p->nMem) corresponds to cursor 0. Space for
  220.   ** cursor 1 is managed by memory cell (p->nMem-1), etc.
  221.   */
  222.   Mem *pMem = &p->aMem[p->nMem-iCur];
  223.   int nByte;
  224.   Cursor *pCx = 0;
  225.   /* If the opcode of pOp is OP_SetNumColumns, then pOp->p2 contains
  226.   ** the number of fields in the records contained in the table or
  227.   ** index being opened. Use this to reserve space for the 
  228.   ** Cursor.aType[] array.
  229.   */
  230.   int nField = 0;
  231.   if( pOp->opcode==OP_SetNumColumns || pOp->opcode==OP_OpenEphemeral ){
  232.     nField = pOp->p2;
  233.   }
  234.   nByte = 
  235.       sizeof(Cursor) + 
  236.       (isBtreeCursor?sqlite3BtreeCursorSize():0) + 
  237.       2*nField*sizeof(u32);
  238.   assert( iCur<p->nCursor );
  239.   if( p->apCsr[iCur] ){
  240.     sqlite3VdbeFreeCursor(p, p->apCsr[iCur]);
  241.     p->apCsr[iCur] = 0;
  242.   }
  243.   if( SQLITE_OK==sqlite3VdbeMemGrow(pMem, nByte, 0) ){
  244.     p->apCsr[iCur] = pCx = (Cursor *)pMem->z;
  245.     memset(pMem->z, 0, nByte);
  246.     pCx->iDb = iDb;
  247.     pCx->nField = nField;
  248.     if( nField ){
  249.       pCx->aType = (u32 *)&pMem->z[sizeof(Cursor)];
  250.     }
  251.     if( isBtreeCursor ){
  252.       pCx->pCursor = (BtCursor *)&pMem->z[sizeof(Cursor)+2*nField*sizeof(u32)];
  253.     }
  254.   }
  255.   return pCx;
  256. }
  257. /*
  258. ** Try to convert a value into a numeric representation if we can
  259. ** do so without loss of information.  In other words, if the string
  260. ** looks like a number, convert it into a number.  If it does not
  261. ** look like a number, leave it alone.
  262. */
  263. static void applyNumericAffinity(Mem *pRec){
  264.   if( (pRec->flags & (MEM_Real|MEM_Int))==0 ){
  265.     int realnum;
  266.     sqlite3VdbeMemNulTerminate(pRec);
  267.     if( (pRec->flags&MEM_Str)
  268.          && sqlite3IsNumber(pRec->z, &realnum, pRec->enc) ){
  269.       i64 value;
  270.       sqlite3VdbeChangeEncoding(pRec, SQLITE_UTF8);
  271.       if( !realnum && sqlite3Atoi64(pRec->z, &value) ){
  272.         pRec->u.i = value;
  273.         MemSetTypeFlag(pRec, MEM_Int);
  274.       }else{
  275.         sqlite3VdbeMemRealify(pRec);
  276.       }
  277.     }
  278.   }
  279. }
  280. /*
  281. ** Processing is determine by the affinity parameter:
  282. **
  283. ** SQLITE_AFF_INTEGER:
  284. ** SQLITE_AFF_REAL:
  285. ** SQLITE_AFF_NUMERIC:
  286. **    Try to convert pRec to an integer representation or a 
  287. **    floating-point representation if an integer representation
  288. **    is not possible.  Note that the integer representation is
  289. **    always preferred, even if the affinity is REAL, because
  290. **    an integer representation is more space efficient on disk.
  291. **
  292. ** SQLITE_AFF_TEXT:
  293. **    Convert pRec to a text representation.
  294. **
  295. ** SQLITE_AFF_NONE:
  296. **    No-op.  pRec is unchanged.
  297. */
  298. static void applyAffinity(
  299.   Mem *pRec,          /* The value to apply affinity to */
  300.   char affinity,      /* The affinity to be applied */
  301.   u8 enc              /* Use this text encoding */
  302. ){
  303.   if( affinity==SQLITE_AFF_TEXT ){
  304.     /* Only attempt the conversion to TEXT if there is an integer or real
  305.     ** representation (blob and NULL do not get converted) but no string
  306.     ** representation.
  307.     */
  308.     if( 0==(pRec->flags&MEM_Str) && (pRec->flags&(MEM_Real|MEM_Int)) ){
  309.       sqlite3VdbeMemStringify(pRec, enc);
  310.     }
  311.     pRec->flags &= ~(MEM_Real|MEM_Int);
  312.   }else if( affinity!=SQLITE_AFF_NONE ){
  313.     assert( affinity==SQLITE_AFF_INTEGER || affinity==SQLITE_AFF_REAL
  314.              || affinity==SQLITE_AFF_NUMERIC );
  315.     applyNumericAffinity(pRec);
  316.     if( pRec->flags & MEM_Real ){
  317.       sqlite3VdbeIntegerAffinity(pRec);
  318.     }
  319.   }
  320. }
  321. /*
  322. ** Try to convert the type of a function argument or a result column
  323. ** into a numeric representation.  Use either INTEGER or REAL whichever
  324. ** is appropriate.  But only do the conversion if it is possible without
  325. ** loss of information and return the revised type of the argument.
  326. **
  327. ** This is an EXPERIMENTAL api and is subject to change or removal.
  328. */
  329. int sqlite3_value_numeric_type(sqlite3_value *pVal){
  330.   Mem *pMem = (Mem*)pVal;
  331.   applyNumericAffinity(pMem);
  332.   storeTypeInfo(pMem, 0);
  333.   return pMem->type;
  334. }
  335. /*
  336. ** Exported version of applyAffinity(). This one works on sqlite3_value*, 
  337. ** not the internal Mem* type.
  338. */
  339. void sqlite3ValueApplyAffinity(
  340.   sqlite3_value *pVal, 
  341.   u8 affinity, 
  342.   u8 enc
  343. ){
  344.   applyAffinity((Mem *)pVal, affinity, enc);
  345. }
  346. #ifdef SQLITE_DEBUG
  347. /*
  348. ** Write a nice string representation of the contents of cell pMem
  349. ** into buffer zBuf, length nBuf.
  350. */
  351. void sqlite3VdbeMemPrettyPrint(Mem *pMem, char *zBuf){
  352.   char *zCsr = zBuf;
  353.   int f = pMem->flags;
  354.   static const char *const encnames[] = {"(X)", "(8)", "(16LE)", "(16BE)"};
  355.   if( f&MEM_Blob ){
  356.     int i;
  357.     char c;
  358.     if( f & MEM_Dyn ){
  359.       c = 'z';
  360.       assert( (f & (MEM_Static|MEM_Ephem))==0 );
  361.     }else if( f & MEM_Static ){
  362.       c = 't';
  363.       assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
  364.     }else if( f & MEM_Ephem ){
  365.       c = 'e';
  366.       assert( (f & (MEM_Static|MEM_Dyn))==0 );
  367.     }else{
  368.       c = 's';
  369.     }
  370.     sqlite3_snprintf(100, zCsr, "%c", c);
  371.     zCsr += strlen(zCsr);
  372.     sqlite3_snprintf(100, zCsr, "%d[", pMem->n);
  373.     zCsr += strlen(zCsr);
  374.     for(i=0; i<16 && i<pMem->n; i++){
  375.       sqlite3_snprintf(100, zCsr, "%02X", ((int)pMem->z[i] & 0xFF));
  376.       zCsr += strlen(zCsr);
  377.     }
  378.     for(i=0; i<16 && i<pMem->n; i++){
  379.       char z = pMem->z[i];
  380.       if( z<32 || z>126 ) *zCsr++ = '.';
  381.       else *zCsr++ = z;
  382.     }
  383.     sqlite3_snprintf(100, zCsr, "]%s", encnames[pMem->enc]);
  384.     zCsr += strlen(zCsr);
  385.     if( f & MEM_Zero ){
  386.       sqlite3_snprintf(100, zCsr,"+%lldz",pMem->u.i);
  387.       zCsr += strlen(zCsr);
  388.     }
  389.     *zCsr = '';
  390.   }else if( f & MEM_Str ){
  391.     int j, k;
  392.     zBuf[0] = ' ';
  393.     if( f & MEM_Dyn ){
  394.       zBuf[1] = 'z';
  395.       assert( (f & (MEM_Static|MEM_Ephem))==0 );
  396.     }else if( f & MEM_Static ){
  397.       zBuf[1] = 't';
  398.       assert( (f & (MEM_Dyn|MEM_Ephem))==0 );
  399.     }else if( f & MEM_Ephem ){
  400.       zBuf[1] = 'e';
  401.       assert( (f & (MEM_Static|MEM_Dyn))==0 );
  402.     }else{
  403.       zBuf[1] = 's';
  404.     }
  405.     k = 2;
  406.     sqlite3_snprintf(100, &zBuf[k], "%d", pMem->n);
  407.     k += strlen(&zBuf[k]);
  408.     zBuf[k++] = '[';
  409.     for(j=0; j<15 && j<pMem->n; j++){
  410.       u8 c = pMem->z[j];
  411.       if( c>=0x20 && c<0x7f ){
  412.         zBuf[k++] = c;
  413.       }else{
  414.         zBuf[k++] = '.';
  415.       }
  416.     }
  417.     zBuf[k++] = ']';
  418.     sqlite3_snprintf(100,&zBuf[k], encnames[pMem->enc]);
  419.     k += strlen(&zBuf[k]);
  420.     zBuf[k++] = 0;
  421.   }
  422. }
  423. #endif
  424. #ifdef SQLITE_DEBUG
  425. /*
  426. ** Print the value of a register for tracing purposes:
  427. */
  428. static void memTracePrint(FILE *out, Mem *p){
  429.   if( p->flags & MEM_Null ){
  430.     fprintf(out, " NULL");
  431.   }else if( (p->flags & (MEM_Int|MEM_Str))==(MEM_Int|MEM_Str) ){
  432.     fprintf(out, " si:%lld", p->u.i);
  433.   }else if( p->flags & MEM_Int ){
  434.     fprintf(out, " i:%lld", p->u.i);
  435.   }else if( p->flags & MEM_Real ){
  436.     fprintf(out, " r:%g", p->r);
  437.   }else{
  438.     char zBuf[200];
  439.     sqlite3VdbeMemPrettyPrint(p, zBuf);
  440.     fprintf(out, " ");
  441.     fprintf(out, "%s", zBuf);
  442.   }
  443. }
  444. static void registerTrace(FILE *out, int iReg, Mem *p){
  445.   fprintf(out, "REG[%d] = ", iReg);
  446.   memTracePrint(out, p);
  447.   fprintf(out, "n");
  448. }
  449. #endif
  450. #ifdef SQLITE_DEBUG
  451. #  define REGISTER_TRACE(R,M) if(p->trace&&R>0)registerTrace(p->trace,R,M)
  452. #else
  453. #  define REGISTER_TRACE(R,M)
  454. #endif
  455. #ifdef VDBE_PROFILE
  456. /*
  457. ** The following routine only works on pentium-class processors.
  458. ** It uses the RDTSC opcode to read the cycle count value out of the
  459. ** processor and returns that value.  This can be used for high-res
  460. ** profiling.
  461. */
  462. __inline__ unsigned long long int hwtime(void){
  463.    unsigned int lo, hi;
  464.    /* We cannot use "=A", since this would use %rax on x86_64 */
  465.    __asm__ __volatile__ ("rdtsc" : "=a" (lo), "=d" (hi));
  466.    return (unsigned long long int)hi << 32 | lo;
  467. }
  468. #endif
  469. /*
  470. ** The CHECK_FOR_INTERRUPT macro defined here looks to see if the
  471. ** sqlite3_interrupt() routine has been called.  If it has been, then
  472. ** processing of the VDBE program is interrupted.
  473. **
  474. ** This macro added to every instruction that does a jump in order to
  475. ** implement a loop.  This test used to be on every single instruction,
  476. ** but that meant we more testing that we needed.  By only testing the
  477. ** flag on jump instructions, we get a (small) speed improvement.
  478. */
  479. #define CHECK_FOR_INTERRUPT 
  480.    if( db->u1.isInterrupted ) goto abort_due_to_interrupt;
  481. /*
  482. ** Execute as much of a VDBE program as we can then return.
  483. **
  484. ** sqlite3VdbeMakeReady() must be called before this routine in order to
  485. ** close the program with a final OP_Halt and to set up the callbacks
  486. ** and the error message pointer.
  487. **
  488. ** Whenever a row or result data is available, this routine will either
  489. ** invoke the result callback (if there is one) or return with
  490. ** SQLITE_ROW.
  491. **
  492. ** If an attempt is made to open a locked database, then this routine
  493. ** will either invoke the busy callback (if there is one) or it will
  494. ** return SQLITE_BUSY.
  495. **
  496. ** If an error occurs, an error message is written to memory obtained
  497. ** from sqlite3_malloc() and p->zErrMsg is made to point to that memory.
  498. ** The error code is stored in p->rc and this routine returns SQLITE_ERROR.
  499. **
  500. ** If the callback ever returns non-zero, then the program exits
  501. ** immediately.  There will be no error message but the p->rc field is
  502. ** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
  503. **
  504. ** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
  505. ** routine to return SQLITE_ERROR.
  506. **
  507. ** Other fatal errors return SQLITE_ERROR.
  508. **
  509. ** After this routine has finished, sqlite3VdbeFinalize() should be
  510. ** used to clean up the mess that was left behind.
  511. */
  512. int sqlite3VdbeExec(
  513.   Vdbe *p                    /* The VDBE */
  514. ){
  515.   int pc;                    /* The program counter */
  516.   Op *pOp;                   /* Current operation */
  517.   int rc = SQLITE_OK;        /* Value to return */
  518.   sqlite3 *db = p->db;       /* The database */
  519.   u8 encoding = ENC(db);     /* The database encoding */
  520.   Mem *pIn1, *pIn2, *pIn3;   /* Input operands */
  521.   Mem *pOut;                 /* Output operand */
  522.   u8 opProperty;
  523. #ifdef VDBE_PROFILE
  524.   unsigned long long start;  /* CPU clock count at start of opcode */
  525.   int origPc;                /* Program counter at start of opcode */
  526. #endif
  527. #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  528.   int nProgressOps = 0;      /* Opcodes executed since progress callback. */
  529. #endif
  530.   assert( p->magic==VDBE_MAGIC_RUN );  /* sqlite3_step() verifies this */
  531.   assert( db->magic==SQLITE_MAGIC_BUSY );
  532.   sqlite3BtreeMutexArrayEnter(&p->aMutex);
  533.   if( p->rc==SQLITE_NOMEM ){
  534.     /* This happens if a malloc() inside a call to sqlite3_column_text() or
  535.     ** sqlite3_column_text16() failed.  */
  536.     goto no_mem;
  537.   }
  538.   assert( p->rc==SQLITE_OK || p->rc==SQLITE_BUSY );
  539.   p->rc = SQLITE_OK;
  540.   assert( p->explain==0 );
  541.   p->pResultSet = 0;
  542.   db->busyHandler.nBusy = 0;
  543.   CHECK_FOR_INTERRUPT;
  544.   sqlite3VdbeIOTraceSql(p);
  545. #ifdef SQLITE_DEBUG
  546.   sqlite3FaultBenign(-1, 1);
  547.   if( p->pc==0 && ((p->db->flags & SQLITE_VdbeListing)!=0
  548.     || sqlite3OsAccess(db->pVfs, "vdbe_explain", SQLITE_ACCESS_EXISTS)==1 )
  549.   ){
  550.     int i;
  551.     printf("VDBE Program Listing:n");
  552.     sqlite3VdbePrintSql(p);
  553.     for(i=0; i<p->nOp; i++){
  554.       sqlite3VdbePrintOp(stdout, i, &p->aOp[i]);
  555.     }
  556.   }
  557.   if( sqlite3OsAccess(db->pVfs, "vdbe_trace", SQLITE_ACCESS_EXISTS)==1 ){
  558.     p->trace = stdout;
  559.   }
  560.   sqlite3FaultBenign(-1, 0);
  561. #endif
  562.   for(pc=p->pc; rc==SQLITE_OK; pc++){
  563.     assert( pc>=0 && pc<p->nOp );
  564.     if( db->mallocFailed ) goto no_mem;
  565. #ifdef VDBE_PROFILE
  566.     origPc = pc;
  567.     start = hwtime();
  568. #endif
  569.     pOp = &p->aOp[pc];
  570.     /* Only allow tracing if SQLITE_DEBUG is defined.
  571.     */
  572. #ifdef SQLITE_DEBUG
  573.     if( p->trace ){
  574.       if( pc==0 ){
  575.         printf("VDBE Execution Trace:n");
  576.         sqlite3VdbePrintSql(p);
  577.       }
  578.       sqlite3VdbePrintOp(p->trace, pc, pOp);
  579.     }
  580.     if( p->trace==0 && pc==0 ){
  581.       sqlite3FaultBenign(-1, 1);
  582.       if( sqlite3OsAccess(db->pVfs, "vdbe_sqltrace", SQLITE_ACCESS_EXISTS)==1 ){
  583.         sqlite3VdbePrintSql(p);
  584.       }
  585.       sqlite3FaultBenign(-1, 0);
  586.     }
  587. #endif
  588.       
  589.     /* Check to see if we need to simulate an interrupt.  This only happens
  590.     ** if we have a special test build.
  591.     */
  592. #ifdef SQLITE_TEST
  593.     if( sqlite3_interrupt_count>0 ){
  594.       sqlite3_interrupt_count--;
  595.       if( sqlite3_interrupt_count==0 ){
  596.         sqlite3_interrupt(db);
  597.       }
  598.     }
  599. #endif
  600. #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
  601.     /* Call the progress callback if it is configured and the required number
  602.     ** of VDBE ops have been executed (either since this invocation of
  603.     ** sqlite3VdbeExec() or since last time the progress callback was called).
  604.     ** If the progress callback returns non-zero, exit the virtual machine with
  605.     ** a return code SQLITE_ABORT.
  606.     */
  607.     if( db->xProgress ){
  608.       if( db->nProgressOps==nProgressOps ){
  609.         int prc;
  610.         if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  611.         prc =db->xProgress(db->pProgressArg);
  612.         if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  613.         if( prc!=0 ){
  614.           rc = SQLITE_INTERRUPT;
  615.           goto vdbe_error_halt;
  616.         }
  617.         nProgressOps = 0;
  618.       }
  619.       nProgressOps++;
  620.     }
  621. #endif
  622.     /* Do common setup processing for any opcode that is marked
  623.     ** with the "out2-prerelease" tag.  Such opcodes have a single
  624.     ** output which is specified by the P2 parameter.  The P2 register
  625.     ** is initialized to a NULL.
  626.     */
  627.     opProperty = opcodeProperty[pOp->opcode];
  628.     if( (opProperty & OPFLG_OUT2_PRERELEASE)!=0 ){
  629.       assert( pOp->p2>0 );
  630.       assert( pOp->p2<=p->nMem );
  631.       pOut = &p->aMem[pOp->p2];
  632.       sqlite3VdbeMemReleaseExternal(pOut);
  633.       pOut->flags = MEM_Null;
  634.     }else
  635.  
  636.     /* Do common setup for opcodes marked with one of the following
  637.     ** combinations of properties.
  638.     **
  639.     **           in1
  640.     **           in1 in2
  641.     **           in1 in2 out3
  642.     **           in1 in3
  643.     **
  644.     ** Variables pIn1, pIn2, and pIn3 are made to point to appropriate
  645.     ** registers for inputs.  Variable pOut points to the output register.
  646.     */
  647.     if( (opProperty & OPFLG_IN1)!=0 ){
  648.       assert( pOp->p1>0 );
  649.       assert( pOp->p1<=p->nMem );
  650.       pIn1 = &p->aMem[pOp->p1];
  651.       REGISTER_TRACE(pOp->p1, pIn1);
  652.       if( (opProperty & OPFLG_IN2)!=0 ){
  653.         assert( pOp->p2>0 );
  654.         assert( pOp->p2<=p->nMem );
  655.         pIn2 = &p->aMem[pOp->p2];
  656.         REGISTER_TRACE(pOp->p2, pIn2);
  657.         if( (opProperty & OPFLG_OUT3)!=0 ){
  658.           assert( pOp->p3>0 );
  659.           assert( pOp->p3<=p->nMem );
  660.           pOut = &p->aMem[pOp->p3];
  661.         }
  662.       }else if( (opProperty & OPFLG_IN3)!=0 ){
  663.         assert( pOp->p3>0 );
  664.         assert( pOp->p3<=p->nMem );
  665.         pIn3 = &p->aMem[pOp->p3];
  666.         REGISTER_TRACE(pOp->p3, pIn3);
  667.       }
  668.     }else if( (opProperty & OPFLG_IN2)!=0 ){
  669.       assert( pOp->p2>0 );
  670.       assert( pOp->p2<=p->nMem );
  671.       pIn2 = &p->aMem[pOp->p2];
  672.       REGISTER_TRACE(pOp->p2, pIn2);
  673.     }else if( (opProperty & OPFLG_IN3)!=0 ){
  674.       assert( pOp->p3>0 );
  675.       assert( pOp->p3<=p->nMem );
  676.       pIn3 = &p->aMem[pOp->p3];
  677.       REGISTER_TRACE(pOp->p3, pIn3);
  678.     }
  679.     switch( pOp->opcode ){
  680. /*****************************************************************************
  681. ** What follows is a massive switch statement where each case implements a
  682. ** separate instruction in the virtual machine.  If we follow the usual
  683. ** indentation conventions, each case should be indented by 6 spaces.  But
  684. ** that is a lot of wasted space on the left margin.  So the code within
  685. ** the switch statement will break with convention and be flush-left. Another
  686. ** big comment (similar to this one) will mark the point in the code where
  687. ** we transition back to normal indentation.
  688. **
  689. ** The formatting of each case is important.  The makefile for SQLite
  690. ** generates two C files "opcodes.h" and "opcodes.c" by scanning this
  691. ** file looking for lines that begin with "case OP_".  The opcodes.h files
  692. ** will be filled with #defines that give unique integer values to each
  693. ** opcode and the opcodes.c file is filled with an array of strings where
  694. ** each string is the symbolic name for the corresponding opcode.  If the
  695. ** case statement is followed by a comment of the form "/# same as ... #/"
  696. ** that comment is used to determine the particular value of the opcode.
  697. **
  698. ** Other keywords in the comment that follows each case are used to
  699. ** construct the OPFLG_INITIALIZER value that initializes opcodeProperty[].
  700. ** Keywords include: in1, in2, in3, out2_prerelease, out2, out3.  See
  701. ** the mkopcodeh.awk script for additional information.
  702. **
  703. ** Documentation about VDBE opcodes is generated by scanning this file
  704. ** for lines of that contain "Opcode:".  That line and all subsequent
  705. ** comment lines are used in the generation of the opcode.html documentation
  706. ** file.
  707. **
  708. ** SUMMARY:
  709. **
  710. **     Formatting is important to scripts that scan this file.
  711. **     Do not deviate from the formatting style currently in use.
  712. **
  713. *****************************************************************************/
  714. /* Opcode:  Goto * P2 * * *
  715. **
  716. ** An unconditional jump to address P2.
  717. ** The next instruction executed will be 
  718. ** the one at index P2 from the beginning of
  719. ** the program.
  720. */
  721. case OP_Goto: {             /* jump */
  722.   CHECK_FOR_INTERRUPT;
  723.   pc = pOp->p2 - 1;
  724.   break;
  725. }
  726. /* Opcode:  Gosub * P2 * * *
  727. **
  728. ** Push the current address plus 1 onto the return address stack
  729. ** and then jump to address P2.
  730. **
  731. ** The return address stack is of limited depth.  If too many
  732. ** OP_Gosub operations occur without intervening OP_Returns, then
  733. ** the return address stack will fill up and processing will abort
  734. ** with a fatal error.
  735. */
  736. case OP_Gosub: {            /* jump */
  737.   assert( p->returnDepth<sizeof(p->returnStack)/sizeof(p->returnStack[0]) );
  738.   p->returnStack[p->returnDepth++] = pc+1;
  739.   pc = pOp->p2 - 1;
  740.   break;
  741. }
  742. /* Opcode:  Return * * * * *
  743. **
  744. ** Jump immediately to the next instruction after the last unreturned
  745. ** OP_Gosub.  If an OP_Return has occurred for all OP_Gosubs, then
  746. ** processing aborts with a fatal error.
  747. */
  748. case OP_Return: {
  749.   assert( p->returnDepth>0 );
  750.   p->returnDepth--;
  751.   pc = p->returnStack[p->returnDepth] - 1;
  752.   break;
  753. }
  754. /* Opcode:  Halt P1 P2 * P4 *
  755. **
  756. ** Exit immediately.  All open cursors, Fifos, etc are closed
  757. ** automatically.
  758. **
  759. ** P1 is the result code returned by sqlite3_exec(), sqlite3_reset(),
  760. ** or sqlite3_finalize().  For a normal halt, this should be SQLITE_OK (0).
  761. ** For errors, it can be some other value.  If P1!=0 then P2 will determine
  762. ** whether or not to rollback the current transaction.  Do not rollback
  763. ** if P2==OE_Fail. Do the rollback if P2==OE_Rollback.  If P2==OE_Abort,
  764. ** then back out all changes that have occurred during this execution of the
  765. ** VDBE, but do not rollback the transaction. 
  766. **
  767. ** If P4 is not null then it is an error message string.
  768. **
  769. ** There is an implied "Halt 0 0 0" instruction inserted at the very end of
  770. ** every program.  So a jump past the last instruction of the program
  771. ** is the same as executing Halt.
  772. */
  773. case OP_Halt: {
  774.   p->rc = pOp->p1;
  775.   p->pc = pc;
  776.   p->errorAction = pOp->p2;
  777.   if( pOp->p4.z ){
  778.     sqlite3SetString(&p->zErrMsg, pOp->p4.z, (char*)0);
  779.   }
  780.   rc = sqlite3VdbeHalt(p);
  781.   assert( rc==SQLITE_BUSY || rc==SQLITE_OK );
  782.   if( rc==SQLITE_BUSY ){
  783.     p->rc = rc = SQLITE_BUSY;
  784.   }else{
  785.     rc = p->rc ? SQLITE_ERROR : SQLITE_DONE;
  786.   }
  787.   goto vdbe_return;
  788. }
  789. /* Opcode: Integer P1 P2 * * *
  790. **
  791. ** The 32-bit integer value P1 is written into register P2.
  792. */
  793. case OP_Integer: {         /* out2-prerelease */
  794.   pOut->flags = MEM_Int;
  795.   pOut->u.i = pOp->p1;
  796.   break;
  797. }
  798. /* Opcode: Int64 * P2 * P4 *
  799. **
  800. ** P4 is a pointer to a 64-bit integer value.
  801. ** Write that value into register P2.
  802. */
  803. case OP_Int64: {           /* out2-prerelease */
  804.   assert( pOp->p4.pI64!=0 );
  805.   pOut->flags = MEM_Int;
  806.   pOut->u.i = *pOp->p4.pI64;
  807.   break;
  808. }
  809. /* Opcode: Real * P2 * P4 *
  810. **
  811. ** P4 is a pointer to a 64-bit floating point value.
  812. ** Write that value into register P2.
  813. */
  814. case OP_Real: {            /* same as TK_FLOAT, out2-prerelease */
  815.   pOut->flags = MEM_Real;
  816.   pOut->r = *pOp->p4.pReal;
  817.   break;
  818. }
  819. /* Opcode: String8 * P2 * P4 *
  820. **
  821. ** P4 points to a nul terminated UTF-8 string. This opcode is transformed 
  822. ** into an OP_String before it is executed for the first time.
  823. */
  824. case OP_String8: {         /* same as TK_STRING, out2-prerelease */
  825.   assert( pOp->p4.z!=0 );
  826.   pOp->opcode = OP_String;
  827.   pOp->p1 = strlen(pOp->p4.z);
  828. #ifndef SQLITE_OMIT_UTF16
  829.   if( encoding!=SQLITE_UTF8 ){
  830.     sqlite3VdbeMemSetStr(pOut, pOp->p4.z, -1, SQLITE_UTF8, SQLITE_STATIC);
  831.     if( SQLITE_OK!=sqlite3VdbeChangeEncoding(pOut, encoding) ) goto no_mem;
  832.     if( SQLITE_OK!=sqlite3VdbeMemDynamicify(pOut) ) goto no_mem;
  833.     pOut->zMalloc = 0;
  834.     pOut->flags |= MEM_Static;
  835.     pOut->flags &= ~MEM_Dyn;
  836.     if( pOp->p4type==P4_DYNAMIC ){
  837.       sqlite3_free(pOp->p4.z);
  838.     }
  839.     pOp->p4type = P4_DYNAMIC;
  840.     pOp->p4.z = pOut->z;
  841.     pOp->p1 = pOut->n;
  842.     if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
  843.       goto too_big;
  844.     }
  845.     UPDATE_MAX_BLOBSIZE(pOut);
  846.     break;
  847.   }
  848. #endif
  849.   if( pOp->p1>db->aLimit[SQLITE_LIMIT_LENGTH] ){
  850.     goto too_big;
  851.   }
  852.   /* Fall through to the next case, OP_String */
  853. }
  854.   
  855. /* Opcode: String P1 P2 * P4 *
  856. **
  857. ** The string value P4 of length P1 (bytes) is stored in register P2.
  858. */
  859. case OP_String: {          /* out2-prerelease */
  860.   assert( pOp->p4.z!=0 );
  861.   pOut->flags = MEM_Str|MEM_Static|MEM_Term;
  862.   pOut->z = pOp->p4.z;
  863.   pOut->n = pOp->p1;
  864.   pOut->enc = encoding;
  865.   UPDATE_MAX_BLOBSIZE(pOut);
  866.   break;
  867. }
  868. /* Opcode: Null * P2 * * *
  869. **
  870. ** Write a NULL into register P2.
  871. */
  872. case OP_Null: {           /* out2-prerelease */
  873.   break;
  874. }
  875. #ifndef SQLITE_OMIT_BLOB_LITERAL
  876. /* Opcode: Blob P1 P2 * P4
  877. **
  878. ** P4 points to a blob of data P1 bytes long.  Store this
  879. ** blob in register P2. This instruction is not coded directly
  880. ** by the compiler. Instead, the compiler layer specifies
  881. ** an OP_HexBlob opcode, with the hex string representation of
  882. ** the blob as P4. This opcode is transformed to an OP_Blob
  883. ** the first time it is executed.
  884. */
  885. case OP_Blob: {                /* out2-prerelease */
  886.   assert( pOp->p1 <= SQLITE_MAX_LENGTH );
  887.   sqlite3VdbeMemSetStr(pOut, pOp->p4.z, pOp->p1, 0, 0);
  888.   pOut->enc = encoding;
  889.   UPDATE_MAX_BLOBSIZE(pOut);
  890.   break;
  891. }
  892. #endif /* SQLITE_OMIT_BLOB_LITERAL */
  893. /* Opcode: Variable P1 P2 * * *
  894. **
  895. ** The value of variable P1 is written into register P2. A variable is
  896. ** an unknown in the original SQL string as handed to sqlite3_compile().
  897. ** Any occurance of the '?' character in the original SQL is considered
  898. ** a variable.  Variables in the SQL string are number from left to
  899. ** right beginning with 1.  The values of variables are set using the
  900. ** sqlite3_bind() API.
  901. */
  902. case OP_Variable: {           /* out2-prerelease */
  903.   int j = pOp->p1 - 1;
  904.   Mem *pVar;
  905.   assert( j>=0 && j<p->nVar );
  906.   pVar = &p->aVar[j];
  907.   if( sqlite3VdbeMemTooBig(pVar) ){
  908.     goto too_big;
  909.   }
  910.   sqlite3VdbeMemShallowCopy(pOut, &p->aVar[j], MEM_Static);
  911.   UPDATE_MAX_BLOBSIZE(pOut);
  912.   break;
  913. }
  914. /* Opcode: Move P1 P2 * * *
  915. **
  916. ** Move the value in register P1 over into register P2.  Register P1
  917. ** is left holding a NULL.  It is an error for P1 and P2 to be the
  918. ** same register.
  919. */
  920. case OP_Move: {
  921.   char *zMalloc;
  922.   assert( pOp->p1>0 );
  923.   assert( pOp->p1<=p->nMem );
  924.   pIn1 = &p->aMem[pOp->p1];
  925.   REGISTER_TRACE(pOp->p1, pIn1);
  926.   assert( pOp->p2>0 );
  927.   assert( pOp->p2<=p->nMem );
  928.   pOut = &p->aMem[pOp->p2];
  929.   assert( pOut!=pIn1 );
  930.   zMalloc = pOut->zMalloc;
  931.   pOut->zMalloc = 0;
  932.   sqlite3VdbeMemMove(pOut, pIn1);
  933.   pIn1->zMalloc = zMalloc;
  934.   REGISTER_TRACE(pOp->p2, pOut);
  935.   break;
  936. }
  937. /* Opcode: Copy P1 P2 * * *
  938. **
  939. ** Make a copy of register P1 into register P2.
  940. **
  941. ** This instruction makes a deep copy of the value.  A duplicate
  942. ** is made of any string or blob constant.  See also OP_SCopy.
  943. */
  944. case OP_Copy: {
  945.   assert( pOp->p1>0 );
  946.   assert( pOp->p1<=p->nMem );
  947.   pIn1 = &p->aMem[pOp->p1];
  948.   REGISTER_TRACE(pOp->p1, pIn1);
  949.   assert( pOp->p2>0 );
  950.   assert( pOp->p2<=p->nMem );
  951.   pOut = &p->aMem[pOp->p2];
  952.   assert( pOut!=pIn1 );
  953.   sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
  954.   Deephemeralize(pOut);
  955.   REGISTER_TRACE(pOp->p2, pOut);
  956.   break;
  957. }
  958. /* Opcode: SCopy P1 P2 * * *
  959. **
  960. ** Make a shallow copy of register P1 into register P2.
  961. **
  962. ** This instruction makes a shallow copy of the value.  If the value
  963. ** is a string or blob, then the copy is only a pointer to the
  964. ** original and hence if the original changes so will the copy.
  965. ** Worse, if the original is deallocated, the copy becomes invalid.
  966. ** Thus the program must guarantee that the original will not change
  967. ** during the lifetime of the copy.  Use OP_Copy to make a complete
  968. ** copy.
  969. */
  970. case OP_SCopy: {
  971.   assert( pOp->p1>0 );
  972.   assert( pOp->p1<=p->nMem );
  973.   pIn1 = &p->aMem[pOp->p1];
  974.   REGISTER_TRACE(pOp->p1, pIn1);
  975.   assert( pOp->p2>0 );
  976.   assert( pOp->p2<=p->nMem );
  977.   pOut = &p->aMem[pOp->p2];
  978.   assert( pOut!=pIn1 );
  979.   sqlite3VdbeMemShallowCopy(pOut, pIn1, MEM_Ephem);
  980.   REGISTER_TRACE(pOp->p2, pOut);
  981.   break;
  982. }
  983. /* Opcode: ResultRow P1 P2 * * *
  984. **
  985. ** The registers P1 throught P1+P2-1 contain a single row of
  986. ** results. This opcode causes the sqlite3_step() call to terminate
  987. ** with an SQLITE_ROW return code and it sets up the sqlite3_stmt
  988. ** structure to provide access to the top P1 values as the result
  989. ** row.
  990. */
  991. case OP_ResultRow: {
  992.   Mem *pMem;
  993.   int i;
  994.   assert( p->nResColumn==pOp->p2 );
  995.   assert( pOp->p1>0 );
  996.   assert( pOp->p1+pOp->p2<=p->nMem );
  997.   /* Invalidate all ephemeral cursor row caches */
  998.   p->cacheCtr = (p->cacheCtr + 2)|1;
  999.   /* Make sure the results of the current row are 00 terminated
  1000.   ** and have an assigned type.  The results are deephemeralized as
  1001.   ** as side effect.
  1002.   */
  1003.   pMem = p->pResultSet = &p->aMem[pOp->p1];
  1004.   for(i=0; i<pOp->p2; i++){
  1005.     sqlite3VdbeMemNulTerminate(&pMem[i]);
  1006.     storeTypeInfo(&pMem[i], encoding);
  1007.   }
  1008.   if( db->mallocFailed ) goto no_mem;
  1009.   /* Return SQLITE_ROW
  1010.   */
  1011.   p->nCallback++;
  1012.   p->pc = pc + 1;
  1013.   rc = SQLITE_ROW;
  1014.   goto vdbe_return;
  1015. }
  1016. /* Opcode: Concat P1 P2 P3 * *
  1017. **
  1018. ** Add the text in register P1 onto the end of the text in
  1019. ** register P2 and store the result in register P3.
  1020. ** If either the P1 or P2 text are NULL then store NULL in P3.
  1021. **
  1022. **   P3 = P2 || P1
  1023. **
  1024. ** It is illegal for P1 and P3 to be the same register. Sometimes,
  1025. ** if P3 is the same register as P2, the implementation is able
  1026. ** to avoid a memcpy().
  1027. */
  1028. case OP_Concat: {           /* same as TK_CONCAT, in1, in2, out3 */
  1029.   i64 nByte;
  1030.   assert( pIn1!=pOut );
  1031.   if( (pIn1->flags | pIn2->flags) & MEM_Null ){
  1032.     sqlite3VdbeMemSetNull(pOut);
  1033.     break;
  1034.   }
  1035.   ExpandBlob(pIn1);
  1036.   Stringify(pIn1, encoding);
  1037.   ExpandBlob(pIn2);
  1038.   Stringify(pIn2, encoding);
  1039.   nByte = pIn1->n + pIn2->n;
  1040.   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
  1041.     goto too_big;
  1042.   }
  1043.   MemSetTypeFlag(pOut, MEM_Str);
  1044.   if( sqlite3VdbeMemGrow(pOut, nByte+2, pOut==pIn2) ){
  1045.     goto no_mem;
  1046.   }
  1047.   if( pOut!=pIn2 ){
  1048.     memcpy(pOut->z, pIn2->z, pIn2->n);
  1049.   }
  1050.   memcpy(&pOut->z[pIn2->n], pIn1->z, pIn1->n);
  1051.   pOut->z[nByte] = 0;
  1052.   pOut->z[nByte+1] = 0;
  1053.   pOut->flags |= MEM_Term;
  1054.   pOut->n = nByte;
  1055.   pOut->enc = encoding;
  1056.   UPDATE_MAX_BLOBSIZE(pOut);
  1057.   break;
  1058. }
  1059. /* Opcode: Add P1 P2 P3 * *
  1060. **
  1061. ** Add the value in register P1 to the value in register P2
  1062. ** and store the result in regiser P3.
  1063. ** If either input is NULL, the result is NULL.
  1064. */
  1065. /* Opcode: Multiply P1 P2 P3 * *
  1066. **
  1067. **
  1068. ** Multiply the value in regiser P1 by the value in regiser P2
  1069. ** and store the result in register P3.
  1070. ** If either input is NULL, the result is NULL.
  1071. */
  1072. /* Opcode: Subtract P1 P2 P3 * *
  1073. **
  1074. ** Subtract the value in register P1 from the value in register P2
  1075. ** and store the result in register P3.
  1076. ** If either input is NULL, the result is NULL.
  1077. */
  1078. /* Opcode: Divide P1 P2 P3 * *
  1079. **
  1080. ** Divide the value in register P1 by the value in register P2
  1081. ** and store the result in register P3.  If the value in register P2
  1082. ** is zero, then the result is NULL.
  1083. ** If either input is NULL, the result is NULL.
  1084. */
  1085. /* Opcode: Remainder P1 P2 P3 * *
  1086. **
  1087. ** Compute the remainder after integer division of the value in
  1088. ** register P1 by the value in register P2 and store the result in P3. 
  1089. ** If the value in register P2 is zero the result is NULL.
  1090. ** If either operand is NULL, the result is NULL.
  1091. */
  1092. case OP_Add:                   /* same as TK_PLUS, in1, in2, out3 */
  1093. case OP_Subtract:              /* same as TK_MINUS, in1, in2, out3 */
  1094. case OP_Multiply:              /* same as TK_STAR, in1, in2, out3 */
  1095. case OP_Divide:                /* same as TK_SLASH, in1, in2, out3 */
  1096. case OP_Remainder: {           /* same as TK_REM, in1, in2, out3 */
  1097.   int flags;
  1098.   flags = pIn1->flags | pIn2->flags;
  1099.   if( (flags & MEM_Null)!=0 ) goto arithmetic_result_is_null;
  1100.   if( (pIn1->flags & pIn2->flags & MEM_Int)==MEM_Int ){
  1101.     i64 a, b;
  1102.     a = pIn1->u.i;
  1103.     b = pIn2->u.i;
  1104.     switch( pOp->opcode ){
  1105.       case OP_Add:         b += a;       break;
  1106.       case OP_Subtract:    b -= a;       break;
  1107.       case OP_Multiply:    b *= a;       break;
  1108.       case OP_Divide: {
  1109.         if( a==0 ) goto arithmetic_result_is_null;
  1110.         /* Dividing the largest possible negative 64-bit integer (1<<63) by 
  1111.         ** -1 returns an integer to large to store in a 64-bit data-type. On
  1112.         ** some architectures, the value overflows to (1<<63). On others,
  1113.         ** a SIGFPE is issued. The following statement normalizes this
  1114.         ** behaviour so that all architectures behave as if integer 
  1115.         ** overflow occured.
  1116.         */
  1117.         if( a==-1 && b==(((i64)1)<<63) ) a = 1;
  1118.         b /= a;
  1119.         break;
  1120.       }
  1121.       default: {
  1122.         if( a==0 ) goto arithmetic_result_is_null;
  1123.         if( a==-1 ) a = 1;
  1124.         b %= a;
  1125.         break;
  1126.       }
  1127.     }
  1128.     pOut->u.i = b;
  1129.     MemSetTypeFlag(pOut, MEM_Int);
  1130.   }else{
  1131.     double a, b;
  1132.     a = sqlite3VdbeRealValue(pIn1);
  1133.     b = sqlite3VdbeRealValue(pIn2);
  1134.     switch( pOp->opcode ){
  1135.       case OP_Add:         b += a;       break;
  1136.       case OP_Subtract:    b -= a;       break;
  1137.       case OP_Multiply:    b *= a;       break;
  1138.       case OP_Divide: {
  1139.         if( a==0.0 ) goto arithmetic_result_is_null;
  1140.         b /= a;
  1141.         break;
  1142.       }
  1143.       default: {
  1144.         i64 ia = (i64)a;
  1145.         i64 ib = (i64)b;
  1146.         if( ia==0 ) goto arithmetic_result_is_null;
  1147.         if( ia==-1 ) ia = 1;
  1148.         b = ib % ia;
  1149.         break;
  1150.       }
  1151.     }
  1152.     if( sqlite3_isnan(b) ){
  1153.       goto arithmetic_result_is_null;
  1154.     }
  1155.     pOut->r = b;
  1156.     MemSetTypeFlag(pOut, MEM_Real);
  1157.     if( (flags & MEM_Real)==0 ){
  1158.       sqlite3VdbeIntegerAffinity(pOut);
  1159.     }
  1160.   }
  1161.   break;
  1162. arithmetic_result_is_null:
  1163.   sqlite3VdbeMemSetNull(pOut);
  1164.   break;
  1165. }
  1166. /* Opcode: CollSeq * * P4
  1167. **
  1168. ** P4 is a pointer to a CollSeq struct. If the next call to a user function
  1169. ** or aggregate calls sqlite3GetFuncCollSeq(), this collation sequence will
  1170. ** be returned. This is used by the built-in min(), max() and nullif()
  1171. ** functions.
  1172. **
  1173. ** The interface used by the implementation of the aforementioned functions
  1174. ** to retrieve the collation sequence set by this opcode is not available
  1175. ** publicly, only to user functions defined in func.c.
  1176. */
  1177. case OP_CollSeq: {
  1178.   assert( pOp->p4type==P4_COLLSEQ );
  1179.   break;
  1180. }
  1181. /* Opcode: Function P1 P2 P3 P4 P5
  1182. **
  1183. ** Invoke a user function (P4 is a pointer to a Function structure that
  1184. ** defines the function) with P5 arguments taken from register P2 and
  1185. ** successors.  The result of the function is stored in register P3.
  1186. ** Register P3 must not be one of the function inputs.
  1187. **
  1188. ** P1 is a 32-bit bitmask indicating whether or not each argument to the 
  1189. ** function was determined to be constant at compile time. If the first
  1190. ** argument was constant then bit 0 of P1 is set. This is used to determine
  1191. ** whether meta data associated with a user function argument using the
  1192. ** sqlite3_set_auxdata() API may be safely retained until the next
  1193. ** invocation of this opcode.
  1194. **
  1195. ** See also: AggStep and AggFinal
  1196. */
  1197. case OP_Function: {
  1198.   int i;
  1199.   Mem *pArg;
  1200.   sqlite3_context ctx;
  1201.   sqlite3_value **apVal;
  1202.   int n = pOp->p5;
  1203.   apVal = p->apArg;
  1204.   assert( apVal || n==0 );
  1205.   assert( n==0 || (pOp->p2>0 && pOp->p2+n<=p->nMem) );
  1206.   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
  1207.   pArg = &p->aMem[pOp->p2];
  1208.   for(i=0; i<n; i++, pArg++){
  1209.     apVal[i] = pArg;
  1210.     storeTypeInfo(pArg, encoding);
  1211.     REGISTER_TRACE(pOp->p2, pArg);
  1212.   }
  1213.   assert( pOp->p4type==P4_FUNCDEF || pOp->p4type==P4_VDBEFUNC );
  1214.   if( pOp->p4type==P4_FUNCDEF ){
  1215.     ctx.pFunc = pOp->p4.pFunc;
  1216.     ctx.pVdbeFunc = 0;
  1217.   }else{
  1218.     ctx.pVdbeFunc = (VdbeFunc*)pOp->p4.pVdbeFunc;
  1219.     ctx.pFunc = ctx.pVdbeFunc->pFunc;
  1220.   }
  1221.   assert( pOp->p3>0 && pOp->p3<=p->nMem );
  1222.   pOut = &p->aMem[pOp->p3];
  1223.   ctx.s.flags = MEM_Null;
  1224.   ctx.s.db = db;
  1225.   ctx.s.xDel = 0;
  1226.   ctx.s.zMalloc = 0;
  1227.   /* The output cell may already have a buffer allocated. Move
  1228.   ** the pointer to ctx.s so in case the user-function can use
  1229.   ** the already allocated buffer instead of allocating a new one.
  1230.   */
  1231.   sqlite3VdbeMemMove(&ctx.s, pOut);
  1232.   MemSetTypeFlag(&ctx.s, MEM_Null);
  1233.   ctx.isError = 0;
  1234.   if( ctx.pFunc->needCollSeq ){
  1235.     assert( pOp>p->aOp );
  1236.     assert( pOp[-1].p4type==P4_COLLSEQ );
  1237.     assert( pOp[-1].opcode==OP_CollSeq );
  1238.     ctx.pColl = pOp[-1].p4.pColl;
  1239.   }
  1240.   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  1241.   (*ctx.pFunc->xFunc)(&ctx, n, apVal);
  1242.   if( sqlite3SafetyOn(db) ){
  1243.     sqlite3VdbeMemRelease(&ctx.s);
  1244.     goto abort_due_to_misuse;
  1245.   }
  1246.   if( db->mallocFailed ){
  1247.     /* Even though a malloc() has failed, the implementation of the
  1248.     ** user function may have called an sqlite3_result_XXX() function
  1249.     ** to return a value. The following call releases any resources
  1250.     ** associated with such a value.
  1251.     **
  1252.     ** Note: Maybe MemRelease() should be called if sqlite3SafetyOn()
  1253.     ** fails also (the if(...) statement above). But if people are
  1254.     ** misusing sqlite, they have bigger problems than a leaked value.
  1255.     */
  1256.     sqlite3VdbeMemRelease(&ctx.s);
  1257.     goto no_mem;
  1258.   }
  1259.   /* If any auxilary data functions have been called by this user function,
  1260.   ** immediately call the destructor for any non-static values.
  1261.   */
  1262.   if( ctx.pVdbeFunc ){
  1263.     sqlite3VdbeDeleteAuxData(ctx.pVdbeFunc, pOp->p1);
  1264.     pOp->p4.pVdbeFunc = ctx.pVdbeFunc;
  1265.     pOp->p4type = P4_VDBEFUNC;
  1266.   }
  1267.   /* If the function returned an error, throw an exception */
  1268.   if( ctx.isError ){
  1269.     sqlite3SetString(&p->zErrMsg, sqlite3_value_text(&ctx.s), (char*)0);
  1270.     rc = ctx.isError;
  1271.   }
  1272.   /* Copy the result of the function into register P3 */
  1273.   sqlite3VdbeChangeEncoding(&ctx.s, encoding);
  1274.   sqlite3VdbeMemMove(pOut, &ctx.s);
  1275.   if( sqlite3VdbeMemTooBig(pOut) ){
  1276.     goto too_big;
  1277.   }
  1278.   REGISTER_TRACE(pOp->p3, pOut);
  1279.   UPDATE_MAX_BLOBSIZE(pOut);
  1280.   break;
  1281. }
  1282. /* Opcode: BitAnd P1 P2 P3 * *
  1283. **
  1284. ** Take the bit-wise AND of the values in register P1 and P2 and
  1285. ** store the result in register P3.
  1286. ** If either input is NULL, the result is NULL.
  1287. */
  1288. /* Opcode: BitOr P1 P2 P3 * *
  1289. **
  1290. ** Take the bit-wise OR of the values in register P1 and P2 and
  1291. ** store the result in register P3.
  1292. ** If either input is NULL, the result is NULL.
  1293. */
  1294. /* Opcode: ShiftLeft P1 P2 P3 * *
  1295. **
  1296. ** Shift the integer value in register P2 to the left by the
  1297. ** number of bits specified by the integer in regiser P1.
  1298. ** Store the result in register P3.
  1299. ** If either input is NULL, the result is NULL.
  1300. */
  1301. /* Opcode: ShiftRight P1 P2 P3 * *
  1302. **
  1303. ** Shift the integer value in register P2 to the right by the
  1304. ** number of bits specified by the integer in register P1.
  1305. ** Store the result in register P3.
  1306. ** If either input is NULL, the result is NULL.
  1307. */
  1308. case OP_BitAnd:                 /* same as TK_BITAND, in1, in2, out3 */
  1309. case OP_BitOr:                  /* same as TK_BITOR, in1, in2, out3 */
  1310. case OP_ShiftLeft:              /* same as TK_LSHIFT, in1, in2, out3 */
  1311. case OP_ShiftRight: {           /* same as TK_RSHIFT, in1, in2, out3 */
  1312.   i64 a, b;
  1313.   if( (pIn1->flags | pIn2->flags) & MEM_Null ){
  1314.     sqlite3VdbeMemSetNull(pOut);
  1315.     break;
  1316.   }
  1317.   a = sqlite3VdbeIntValue(pIn2);
  1318.   b = sqlite3VdbeIntValue(pIn1);
  1319.   switch( pOp->opcode ){
  1320.     case OP_BitAnd:      a &= b;     break;
  1321.     case OP_BitOr:       a |= b;     break;
  1322.     case OP_ShiftLeft:   a <<= b;    break;
  1323.     default:  assert( pOp->opcode==OP_ShiftRight );
  1324.                          a >>= b;    break;
  1325.   }
  1326.   pOut->u.i = a;
  1327.   MemSetTypeFlag(pOut, MEM_Int);
  1328.   break;
  1329. }
  1330. /* Opcode: AddImm  P1 P2 * * *
  1331. ** 
  1332. ** Add the constant P2 the value in register P1.
  1333. ** The result is always an integer.
  1334. **
  1335. ** To force any register to be an integer, just add 0.
  1336. */
  1337. case OP_AddImm: {            /* in1 */
  1338.   sqlite3VdbeMemIntegerify(pIn1);
  1339.   pIn1->u.i += pOp->p2;
  1340.   break;
  1341. }
  1342. /* Opcode: ForceInt P1 P2 P3 * *
  1343. **
  1344. ** Convert value in register P1 into an integer.  If the value 
  1345. ** in P1 is not numeric (meaning that is is a NULL or a string that
  1346. ** does not look like an integer or floating point number) then
  1347. ** jump to P2.  If the value in P1 is numeric then
  1348. ** convert it into the least integer that is greater than or equal to its
  1349. ** current value if P3==0, or to the least integer that is strictly
  1350. ** greater than its current value if P3==1.
  1351. */
  1352. case OP_ForceInt: {            /* jump, in1 */
  1353.   i64 v;
  1354.   applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
  1355.   if( (pIn1->flags & (MEM_Int|MEM_Real))==0 ){
  1356.     pc = pOp->p2 - 1;
  1357.     break;
  1358.   }
  1359.   if( pIn1->flags & MEM_Int ){
  1360.     v = pIn1->u.i + (pOp->p3!=0);
  1361.   }else{
  1362.     assert( pIn1->flags & MEM_Real );
  1363.     v = (sqlite3_int64)pIn1->r;
  1364.     if( pIn1->r>(double)v ) v++;
  1365.     if( pOp->p3 && pIn1->r==(double)v ) v++;
  1366.   }
  1367.   pIn1->u.i = v;
  1368.   MemSetTypeFlag(pIn1, MEM_Int);
  1369.   break;
  1370. }
  1371. /* Opcode: MustBeInt P1 P2 * * *
  1372. ** 
  1373. ** Force the value in register P1 to be an integer.  If the value
  1374. ** in P1 is not an integer and cannot be converted into an integer
  1375. ** without data loss, then jump immediately to P2, or if P2==0
  1376. ** raise an SQLITE_MISMATCH exception.
  1377. */
  1378. case OP_MustBeInt: {            /* jump, in1 */
  1379.   applyAffinity(pIn1, SQLITE_AFF_NUMERIC, encoding);
  1380.   if( (pIn1->flags & MEM_Int)==0 ){
  1381.     if( pOp->p2==0 ){
  1382.       rc = SQLITE_MISMATCH;
  1383.       goto abort_due_to_error;
  1384.     }else{
  1385.       pc = pOp->p2 - 1;
  1386.     }
  1387.   }else{
  1388.     MemSetTypeFlag(pIn1, MEM_Int);
  1389.   }
  1390.   break;
  1391. }
  1392. /* Opcode: RealAffinity P1 * * * *
  1393. **
  1394. ** If register P1 holds an integer convert it to a real value.
  1395. **
  1396. ** This opcode is used when extracting information from a column that
  1397. ** has REAL affinity.  Such column values may still be stored as
  1398. ** integers, for space efficiency, but after extraction we want them
  1399. ** to have only a real value.
  1400. */
  1401. case OP_RealAffinity: {                  /* in1 */
  1402.   if( pIn1->flags & MEM_Int ){
  1403.     sqlite3VdbeMemRealify(pIn1);
  1404.   }
  1405.   break;
  1406. }
  1407. #ifndef SQLITE_OMIT_CAST
  1408. /* Opcode: ToText P1 * * * *
  1409. **
  1410. ** Force the value in register P1 to be text.
  1411. ** If the value is numeric, convert it to a string using the
  1412. ** equivalent of printf().  Blob values are unchanged and
  1413. ** are afterwards simply interpreted as text.
  1414. **
  1415. ** A NULL value is not changed by this routine.  It remains NULL.
  1416. */
  1417. case OP_ToText: {                  /* same as TK_TO_TEXT, in1 */
  1418.   if( pIn1->flags & MEM_Null ) break;
  1419.   assert( MEM_Str==(MEM_Blob>>3) );
  1420.   pIn1->flags |= (pIn1->flags&MEM_Blob)>>3;
  1421.   applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
  1422.   rc = ExpandBlob(pIn1);
  1423.   assert( pIn1->flags & MEM_Str || db->mallocFailed );
  1424.   pIn1->flags &= ~(MEM_Int|MEM_Real|MEM_Blob);
  1425.   UPDATE_MAX_BLOBSIZE(pIn1);
  1426.   break;
  1427. }
  1428. /* Opcode: ToBlob P1 * * * *
  1429. **
  1430. ** Force the value in register P1 to be a BLOB.
  1431. ** If the value is numeric, convert it to a string first.
  1432. ** Strings are simply reinterpreted as blobs with no change
  1433. ** to the underlying data.
  1434. **
  1435. ** A NULL value is not changed by this routine.  It remains NULL.
  1436. */
  1437. case OP_ToBlob: {                  /* same as TK_TO_BLOB, in1 */
  1438.   if( pIn1->flags & MEM_Null ) break;
  1439.   if( (pIn1->flags & MEM_Blob)==0 ){
  1440.     applyAffinity(pIn1, SQLITE_AFF_TEXT, encoding);
  1441.     assert( pIn1->flags & MEM_Str || db->mallocFailed );
  1442.   }
  1443.   MemSetTypeFlag(pIn1, MEM_Blob);
  1444.   UPDATE_MAX_BLOBSIZE(pIn1);
  1445.   break;
  1446. }
  1447. /* Opcode: ToNumeric P1 * * * *
  1448. **
  1449. ** Force the value in register P1 to be numeric (either an
  1450. ** integer or a floating-point number.)
  1451. ** If the value is text or blob, try to convert it to an using the
  1452. ** equivalent of atoi() or atof() and store 0 if no such conversion 
  1453. ** is possible.
  1454. **
  1455. ** A NULL value is not changed by this routine.  It remains NULL.
  1456. */
  1457. case OP_ToNumeric: {                  /* same as TK_TO_NUMERIC, in1 */
  1458.   if( (pIn1->flags & (MEM_Null|MEM_Int|MEM_Real))==0 ){
  1459.     sqlite3VdbeMemNumerify(pIn1);
  1460.   }
  1461.   break;
  1462. }
  1463. #endif /* SQLITE_OMIT_CAST */
  1464. /* Opcode: ToInt P1 * * * *
  1465. **
  1466. ** Force the value in register P1 be an integer.  If
  1467. ** The value is currently a real number, drop its fractional part.
  1468. ** If the value is text or blob, try to convert it to an integer using the
  1469. ** equivalent of atoi() and store 0 if no such conversion is possible.
  1470. **
  1471. ** A NULL value is not changed by this routine.  It remains NULL.
  1472. */
  1473. case OP_ToInt: {                  /* same as TK_TO_INT, in1 */
  1474.   if( (pIn1->flags & MEM_Null)==0 ){
  1475.     sqlite3VdbeMemIntegerify(pIn1);
  1476.   }
  1477.   break;
  1478. }
  1479. #ifndef SQLITE_OMIT_CAST
  1480. /* Opcode: ToReal P1 * * * *
  1481. **
  1482. ** Force the value in register P1 to be a floating point number.
  1483. ** If The value is currently an integer, convert it.
  1484. ** If the value is text or blob, try to convert it to an integer using the
  1485. ** equivalent of atoi() and store 0.0 if no such conversion is possible.
  1486. **
  1487. ** A NULL value is not changed by this routine.  It remains NULL.
  1488. */
  1489. case OP_ToReal: {                  /* same as TK_TO_REAL, in1 */
  1490.   if( (pIn1->flags & MEM_Null)==0 ){
  1491.     sqlite3VdbeMemRealify(pIn1);
  1492.   }
  1493.   break;
  1494. }
  1495. #endif /* SQLITE_OMIT_CAST */
  1496. /* Opcode: Lt P1 P2 P3 P4 P5
  1497. **
  1498. ** Compare the values in register P1 and P3.  If reg(P3)<reg(P1) then
  1499. ** jump to address P2.  
  1500. **
  1501. ** If the SQLITE_JUMPIFNULL bit of P5 is set and either reg(P1) or
  1502. ** reg(P3) is NULL then take the jump.  If the SQLITE_JUMPIFNULL 
  1503. ** bit is clear then fall thru if either operand is NULL.
  1504. **
  1505. ** If the SQLITE_NULLEQUAL bit of P5 is set then treat NULL operands
  1506. ** as being equal to one another.  Normally NULLs are not equal to 
  1507. ** anything including other NULLs.
  1508. **
  1509. ** The SQLITE_AFF_MASK portion of P5 must be an affinity character -
  1510. ** SQLITE_AFF_TEXT, SQLITE_AFF_INTEGER, and so forth. An attempt is made 
  1511. ** to coerce both inputs according to this affinity before the
  1512. ** comparison is made. If the SQLITE_AFF_MASK is 0x00, then numeric
  1513. ** affinity is used. Note that the affinity conversions are stored
  1514. ** back into the input registers P1 and P3.  So this opcode can cause
  1515. ** persistent changes to registers P1 and P3.
  1516. **
  1517. ** Once any conversions have taken place, and neither value is NULL, 
  1518. ** the values are compared. If both values are blobs then memcmp() is
  1519. ** used to determine the results of the comparison.  If both values
  1520. ** are text, then the appropriate collating function specified in
  1521. ** P4 is  used to do the comparison.  If P4 is not specified then
  1522. ** memcmp() is used to compare text string.  If both values are
  1523. ** numeric, then a numeric comparison is used. If the two values
  1524. ** are of different types, then numbers are considered less than
  1525. ** strings and strings are considered less than blobs.
  1526. **
  1527. ** If the SQLITE_STOREP2 bit of P5 is set, then do not jump.  Instead,
  1528. ** store a boolean result (either 0, or 1, or NULL) in register P2.
  1529. */
  1530. /* Opcode: Ne P1 P2 P3 P4 P5
  1531. **
  1532. ** This works just like the Lt opcode except that the jump is taken if
  1533. ** the operands in registers P1 and P3 are not equal.  See the Lt opcode for
  1534. ** additional information.
  1535. */
  1536. /* Opcode: Eq P1 P2 P3 P4 P5
  1537. **
  1538. ** This works just like the Lt opcode except that the jump is taken if
  1539. ** the operands in registers P1 and P3 are equal.
  1540. ** See the Lt opcode for additional information.
  1541. */
  1542. /* Opcode: Le P1 P2 P3 P4 P5
  1543. **
  1544. ** This works just like the Lt opcode except that the jump is taken if
  1545. ** the content of register P3 is less than or equal to the content of
  1546. ** register P1.  See the Lt opcode for additional information.
  1547. */
  1548. /* Opcode: Gt P1 P2 P3 P4 P5
  1549. **
  1550. ** This works just like the Lt opcode except that the jump is taken if
  1551. ** the content of register P3 is greater than the content of
  1552. ** register P1.  See the Lt opcode for additional information.
  1553. */
  1554. /* Opcode: Ge P1 P2 P3 P4 P5
  1555. **
  1556. ** This works just like the Lt opcode except that the jump is taken if
  1557. ** the content of register P3 is greater than or equal to the content of
  1558. ** register P1.  See the Lt opcode for additional information.
  1559. */
  1560. case OP_Eq:               /* same as TK_EQ, jump, in1, in3 */
  1561. case OP_Ne:               /* same as TK_NE, jump, in1, in3 */
  1562. case OP_Lt:               /* same as TK_LT, jump, in1, in3 */
  1563. case OP_Le:               /* same as TK_LE, jump, in1, in3 */
  1564. case OP_Gt:               /* same as TK_GT, jump, in1, in3 */
  1565. case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
  1566.   int flags;
  1567.   int res;
  1568.   char affinity;
  1569.   Mem x1, x3;
  1570.   flags = pIn1->flags|pIn3->flags;
  1571.   if( flags&MEM_Null ){
  1572.     if( (pOp->p5 & SQLITE_NULLEQUAL)!=0 ){
  1573.       /*
  1574.       ** When SQLITE_NULLEQUAL set and either operand is NULL
  1575.       ** then both operands are converted to integers prior to being 
  1576.       ** passed down into the normal comparison logic below.  
  1577.       ** NULL operands are converted to zero and non-NULL operands
  1578.       ** are converted to 1.  Thus, for example, with SQLITE_NULLEQUAL
  1579.       ** set,  NULL==NULL is true whereas it would normally NULL.
  1580.       ** Similarly,  NULL!=123 is true.
  1581.       */
  1582.       x1.flags = MEM_Int;
  1583.       x1.u.i = (pIn1->flags & MEM_Null)==0;
  1584.       pIn1 = &x1;
  1585.       x3.flags = MEM_Int;
  1586.       x3.u.i = (pIn3->flags & MEM_Null)==0;
  1587.       pIn3 = &x3;
  1588.     }else{
  1589.       /* If the SQLITE_NULLEQUAL bit is clear and either operand is NULL then
  1590.       ** the result is always NULL.  The jump is taken if the 
  1591.       ** SQLITE_JUMPIFNULL bit is set.
  1592.       */
  1593.       if( pOp->p5 & SQLITE_STOREP2 ){
  1594.         pOut = &p->aMem[pOp->p2];
  1595.         MemSetTypeFlag(pOut, MEM_Null);
  1596.         REGISTER_TRACE(pOp->p2, pOut);
  1597.       }else if( pOp->p5 & SQLITE_JUMPIFNULL ){
  1598.         pc = pOp->p2-1;
  1599.       }
  1600.       break;
  1601.     }
  1602.   }
  1603.   affinity = pOp->p5 & SQLITE_AFF_MASK;
  1604.   if( affinity ){
  1605.     applyAffinity(pIn1, affinity, encoding);
  1606.     applyAffinity(pIn3, affinity, encoding);
  1607.   }
  1608.   assert( pOp->p4type==P4_COLLSEQ || pOp->p4.pColl==0 );
  1609.   ExpandBlob(pIn1);
  1610.   ExpandBlob(pIn3);
  1611.   res = sqlite3MemCompare(pIn3, pIn1, pOp->p4.pColl);
  1612.   switch( pOp->opcode ){
  1613.     case OP_Eq:    res = res==0;     break;
  1614.     case OP_Ne:    res = res!=0;     break;
  1615.     case OP_Lt:    res = res<0;      break;
  1616.     case OP_Le:    res = res<=0;     break;
  1617.     case OP_Gt:    res = res>0;      break;
  1618.     default:       res = res>=0;     break;
  1619.   }
  1620.   if( pOp->p5 & SQLITE_STOREP2 ){
  1621.     pOut = &p->aMem[pOp->p2];
  1622.     MemSetTypeFlag(pOut, MEM_Int);
  1623.     pOut->u.i = res;
  1624.     REGISTER_TRACE(pOp->p2, pOut);
  1625.   }else if( res ){
  1626.     pc = pOp->p2-1;
  1627.   }
  1628.   break;
  1629. }
  1630. /* Opcode: And P1 P2 P3 * *
  1631. **
  1632. ** Take the logical AND of the values in registers P1 and P2 and
  1633. ** write the result into register P3.
  1634. **
  1635. ** If either P1 or P2 is 0 (false) then the result is 0 even if
  1636. ** the other input is NULL.  A NULL and true or two NULLs give
  1637. ** a NULL output.
  1638. */
  1639. /* Opcode: Or P1 P2 P3 * *
  1640. **
  1641. ** Take the logical OR of the values in register P1 and P2 and
  1642. ** store the answer in register P3.
  1643. **
  1644. ** If either P1 or P2 is nonzero (true) then the result is 1 (true)
  1645. ** even if the other input is NULL.  A NULL and false or two NULLs
  1646. ** give a NULL output.
  1647. */
  1648. case OP_And:              /* same as TK_AND, in1, in2, out3 */
  1649. case OP_Or: {             /* same as TK_OR, in1, in2, out3 */
  1650.   int v1, v2;    /* 0==FALSE, 1==TRUE, 2==UNKNOWN or NULL */
  1651.   if( pIn1->flags & MEM_Null ){
  1652.     v1 = 2;
  1653.   }else{
  1654.     v1 = sqlite3VdbeIntValue(pIn1)!=0;
  1655.   }
  1656.   if( pIn2->flags & MEM_Null ){
  1657.     v2 = 2;
  1658.   }else{
  1659.     v2 = sqlite3VdbeIntValue(pIn2)!=0;
  1660.   }
  1661.   if( pOp->opcode==OP_And ){
  1662.     static const unsigned char and_logic[] = { 0, 0, 0, 0, 1, 2, 0, 2, 2 };
  1663.     v1 = and_logic[v1*3+v2];
  1664.   }else{
  1665.     static const unsigned char or_logic[] = { 0, 1, 2, 1, 1, 1, 2, 1, 2 };
  1666.     v1 = or_logic[v1*3+v2];
  1667.   }
  1668.   if( v1==2 ){
  1669.     MemSetTypeFlag(pOut, MEM_Null);
  1670.   }else{
  1671.     pOut->u.i = v1;
  1672.     MemSetTypeFlag(pOut, MEM_Int);
  1673.   }
  1674.   break;
  1675. }
  1676. /* Opcode: Not P1 * * * *
  1677. **
  1678. ** Interpret the value in register P1 as a boolean value.  Replace it
  1679. ** with its complement.  If the value in register P1 is NULL its value
  1680. ** is unchanged.
  1681. */
  1682. case OP_Not: {                /* same as TK_NOT, in1 */
  1683.   if( pIn1->flags & MEM_Null ) break;  /* Do nothing to NULLs */
  1684.   sqlite3VdbeMemIntegerify(pIn1);
  1685.   pIn1->u.i = !pIn1->u.i;
  1686.   assert( pIn1->flags&MEM_Int );
  1687.   break;
  1688. }
  1689. /* Opcode: BitNot P1 * * * *
  1690. **
  1691. ** Interpret the content of register P1 as an integer.  Replace it
  1692. ** with its ones-complement.  If the value is originally NULL, leave
  1693. ** it unchanged.
  1694. */
  1695. case OP_BitNot: {             /* same as TK_BITNOT, in1 */
  1696.   if( pIn1->flags & MEM_Null ) break;  /* Do nothing to NULLs */
  1697.   sqlite3VdbeMemIntegerify(pIn1);
  1698.   pIn1->u.i = ~pIn1->u.i;
  1699.   assert( pIn1->flags&MEM_Int );
  1700.   break;
  1701. }
  1702. /* Opcode: If P1 P2 P3 * *
  1703. **
  1704. ** Jump to P2 if the value in register P1 is true.  The value is
  1705. ** is considered true if it is numeric and non-zero.  If the value
  1706. ** in P1 is NULL then take the jump if P3 is true.
  1707. */
  1708. /* Opcode: IfNot P1 P2 P3 * *
  1709. **
  1710. ** Jump to P2 if the value in register P1 is False.  The value is
  1711. ** is considered true if it has a numeric value of zero.  If the value
  1712. ** in P1 is NULL then take the jump if P3 is true.
  1713. */
  1714. case OP_If:                 /* jump, in1 */
  1715. case OP_IfNot: {            /* jump, in1 */
  1716.   int c;
  1717.   if( pIn1->flags & MEM_Null ){
  1718.     c = pOp->p3;
  1719.   }else{
  1720. #ifdef SQLITE_OMIT_FLOATING_POINT
  1721.     c = sqlite3VdbeIntValue(pIn1);
  1722. #else
  1723.     c = sqlite3VdbeRealValue(pIn1)!=0.0;
  1724. #endif
  1725.     if( pOp->opcode==OP_IfNot ) c = !c;
  1726.   }
  1727.   if( c ){
  1728.     pc = pOp->p2-1;
  1729.   }
  1730.   break;
  1731. }
  1732. /* Opcode: IsNull P1 P2 P3 * *
  1733. **
  1734. ** Jump to P2 if the value in register P1 is NULL.  If P3 is greater
  1735. ** than zero, then check all values reg(P1), reg(P1+1), 
  1736. ** reg(P1+2), ..., reg(P1+P3-1).
  1737. */
  1738. case OP_IsNull: {            /* same as TK_ISNULL, jump, in1 */
  1739.   int n = pOp->p3;
  1740.   assert( pOp->p3==0 || pOp->p1>0 );
  1741.   do{
  1742.     if( (pIn1->flags & MEM_Null)!=0 ){
  1743.       pc = pOp->p2 - 1;
  1744.       break;
  1745.     }
  1746.     pIn1++;
  1747.   }while( --n > 0 );
  1748.   break;
  1749. }
  1750. /* Opcode: NotNull P1 P2 * * *
  1751. **
  1752. ** Jump to P2 if the value in register P1 is not NULL.  
  1753. */
  1754. case OP_NotNull: {            /* same as TK_NOTNULL, jump, in1 */
  1755.   if( (pIn1->flags & MEM_Null)==0 ){
  1756.     pc = pOp->p2 - 1;
  1757.   }
  1758.   break;
  1759. }
  1760. /* Opcode: SetNumColumns * P2 * * *
  1761. **
  1762. ** This opcode sets the number of columns for the cursor opened by the
  1763. ** following instruction to P2.
  1764. **
  1765. ** An OP_SetNumColumns is only useful if it occurs immediately before 
  1766. ** one of the following opcodes:
  1767. **
  1768. **     OpenRead
  1769. **     OpenWrite
  1770. **     OpenPseudo
  1771. **
  1772. ** If the OP_Column opcode is to be executed on a cursor, then
  1773. ** this opcode must be present immediately before the opcode that
  1774. ** opens the cursor.
  1775. */
  1776. case OP_SetNumColumns: {
  1777.   break;
  1778. }
  1779. /* Opcode: Column P1 P2 P3 P4 *
  1780. **
  1781. ** Interpret the data that cursor P1 points to as a structure built using
  1782. ** the MakeRecord instruction.  (See the MakeRecord opcode for additional
  1783. ** information about the format of the data.)  Extract the P2-th column
  1784. ** from this record.  If there are less that (P2+1) 
  1785. ** values in the record, extract a NULL.
  1786. **
  1787. ** The value extracted is stored in register P3.
  1788. **
  1789. ** If the KeyAsData opcode has previously executed on this cursor, then the
  1790. ** field might be extracted from the key rather than the data.
  1791. **
  1792. ** If the column contains fewer than P2 fields, then extract a NULL.  Or,
  1793. ** if the P4 argument is a P4_MEM use the value of the P4 argument as
  1794. ** the result.
  1795. */
  1796. case OP_Column: {
  1797.   u32 payloadSize;   /* Number of bytes in the record */
  1798.   int p1 = pOp->p1;  /* P1 value of the opcode */
  1799.   int p2 = pOp->p2;  /* column number to retrieve */
  1800.   Cursor *pC = 0;    /* The VDBE cursor */
  1801.   char *zRec;        /* Pointer to complete record-data */
  1802.   BtCursor *pCrsr;   /* The BTree cursor */
  1803.   u32 *aType;        /* aType[i] holds the numeric type of the i-th column */
  1804.   u32 *aOffset;      /* aOffset[i] is offset to start of data for i-th column */
  1805.   u32 nField;        /* number of fields in the record */
  1806.   int len;           /* The length of the serialized data for the column */
  1807.   int i;             /* Loop counter */
  1808.   char *zData;       /* Part of the record being decoded */
  1809.   Mem *pDest;        /* Where to write the extracted value */
  1810.   Mem sMem;          /* For storing the record being decoded */
  1811.   sMem.flags = 0;
  1812.   sMem.db = 0;
  1813.   sMem.zMalloc = 0;
  1814.   assert( p1<p->nCursor );
  1815.   assert( pOp->p3>0 && pOp->p3<=p->nMem );
  1816.   pDest = &p->aMem[pOp->p3];
  1817.   MemSetTypeFlag(pDest, MEM_Null);
  1818.   /* This block sets the variable payloadSize to be the total number of
  1819.   ** bytes in the record.
  1820.   **
  1821.   ** zRec is set to be the complete text of the record if it is available.
  1822.   ** The complete record text is always available for pseudo-tables
  1823.   ** If the record is stored in a cursor, the complete record text
  1824.   ** might be available in the  pC->aRow cache.  Or it might not be.
  1825.   ** If the data is unavailable,  zRec is set to NULL.
  1826.   **
  1827.   ** We also compute the number of columns in the record.  For cursors,
  1828.   ** the number of columns is stored in the Cursor.nField element.
  1829.   */
  1830.   pC = p->apCsr[p1];
  1831.   assert( pC!=0 );
  1832. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1833.   assert( pC->pVtabCursor==0 );
  1834. #endif
  1835.   if( pC->pCursor!=0 ){
  1836.     /* The record is stored in a B-Tree */
  1837.     rc = sqlite3VdbeCursorMoveto(pC);
  1838.     if( rc ) goto abort_due_to_error;
  1839.     zRec = 0;
  1840.     pCrsr = pC->pCursor;
  1841.     if( pC->nullRow ){
  1842.       payloadSize = 0;
  1843.     }else if( pC->cacheStatus==p->cacheCtr ){
  1844.       payloadSize = pC->payloadSize;
  1845.       zRec = (char*)pC->aRow;
  1846.     }else if( pC->isIndex ){
  1847.       i64 payloadSize64;
  1848.       sqlite3BtreeKeySize(pCrsr, &payloadSize64);
  1849.       payloadSize = payloadSize64;
  1850.     }else{
  1851.       sqlite3BtreeDataSize(pCrsr, &payloadSize);
  1852.     }
  1853.     nField = pC->nField;
  1854.   }else{
  1855.     assert( pC->pseudoTable );
  1856.     /* The record is the sole entry of a pseudo-table */
  1857.     payloadSize = pC->nData;
  1858.     zRec = pC->pData;
  1859.     pC->cacheStatus = CACHE_STALE;
  1860.     assert( payloadSize==0 || zRec!=0 );
  1861.     nField = pC->nField;
  1862.     pCrsr = 0;
  1863.   }
  1864.   /* If payloadSize is 0, then just store a NULL */
  1865.   if( payloadSize==0 ){
  1866.     assert( pDest->flags&MEM_Null );
  1867.     goto op_column_out;
  1868.   }
  1869.   if( payloadSize>db->aLimit[SQLITE_LIMIT_LENGTH] ){
  1870.     goto too_big;
  1871.   }
  1872.   assert( p2<nField );
  1873.   /* Read and parse the table header.  Store the results of the parse
  1874.   ** into the record header cache fields of the cursor.
  1875.   */
  1876.   aType = pC->aType;
  1877.   if( pC->cacheStatus==p->cacheCtr ){
  1878.     aOffset = pC->aOffset;
  1879.   }else{
  1880.     u8 *zIdx;        /* Index into header */
  1881.     u8 *zEndHdr;     /* Pointer to first byte after the header */
  1882.     u32 offset;      /* Offset into the data */
  1883.     int szHdrSz;     /* Size of the header size field at start of record */
  1884.     int avail;       /* Number of bytes of available data */
  1885.     assert(aType);
  1886.     pC->aOffset = aOffset = &aType[nField];
  1887.     pC->payloadSize = payloadSize;
  1888.     pC->cacheStatus = p->cacheCtr;
  1889.     /* Figure out how many bytes are in the header */
  1890.     if( zRec ){
  1891.       zData = zRec;
  1892.     }else{
  1893.       if( pC->isIndex ){
  1894.         zData = (char*)sqlite3BtreeKeyFetch(pCrsr, &avail);
  1895.       }else{
  1896.         zData = (char*)sqlite3BtreeDataFetch(pCrsr, &avail);
  1897.       }
  1898.       /* If KeyFetch()/DataFetch() managed to get the entire payload,
  1899.       ** save the payload in the pC->aRow cache.  That will save us from
  1900.       ** having to make additional calls to fetch the content portion of
  1901.       ** the record.
  1902.       */
  1903.       if( avail>=payloadSize ){
  1904.         zRec = zData;
  1905.         pC->aRow = (u8*)zData;
  1906.       }else{
  1907.         pC->aRow = 0;
  1908.       }
  1909.     }
  1910.     /* The following assert is true in all cases accept when
  1911.     ** the database file has been corrupted externally.
  1912.     **    assert( zRec!=0 || avail>=payloadSize || avail>=9 ); */
  1913.     szHdrSz = GetVarint((u8*)zData, offset);
  1914.     /* The KeyFetch() or DataFetch() above are fast and will get the entire
  1915.     ** record header in most cases.  But they will fail to get the complete
  1916.     ** record header if the record header does not fit on a single page
  1917.     ** in the B-Tree.  When that happens, use sqlite3VdbeMemFromBtree() to
  1918.     ** acquire the complete header text.
  1919.     */
  1920.     if( !zRec && avail<offset ){
  1921.       sMem.flags = 0;
  1922.       sMem.db = 0;
  1923.       rc = sqlite3VdbeMemFromBtree(pCrsr, 0, offset, pC->isIndex, &sMem);
  1924.       if( rc!=SQLITE_OK ){
  1925.         goto op_column_out;
  1926.       }
  1927.       zData = sMem.z;
  1928.     }
  1929.     zEndHdr = (u8 *)&zData[offset];
  1930.     zIdx = (u8 *)&zData[szHdrSz];
  1931.     /* Scan the header and use it to fill in the aType[] and aOffset[]
  1932.     ** arrays.  aType[i] will contain the type integer for the i-th
  1933.     ** column and aOffset[i] will contain the offset from the beginning
  1934.     ** of the record to the start of the data for the i-th column
  1935.     */
  1936.     for(i=0; i<nField; i++){
  1937.       if( zIdx<zEndHdr ){
  1938.         aOffset[i] = offset;
  1939.         zIdx += GetVarint(zIdx, aType[i]);
  1940.         offset += sqlite3VdbeSerialTypeLen(aType[i]);
  1941.       }else{
  1942.         /* If i is less that nField, then there are less fields in this
  1943.         ** record than SetNumColumns indicated there are columns in the
  1944.         ** table. Set the offset for any extra columns not present in
  1945.         ** the record to 0. This tells code below to store a NULL
  1946.         ** instead of deserializing a value from the record.
  1947.         */
  1948.         aOffset[i] = 0;
  1949.       }
  1950.     }
  1951.     sqlite3VdbeMemRelease(&sMem);
  1952.     sMem.flags = MEM_Null;
  1953.     /* If we have read more header data than was contained in the header,
  1954.     ** or if the end of the last field appears to be past the end of the
  1955.     ** record, then we must be dealing with a corrupt database.
  1956.     */
  1957.     if( zIdx>zEndHdr || offset>payloadSize ){
  1958.       rc = SQLITE_CORRUPT_BKPT;
  1959.       goto op_column_out;
  1960.     }
  1961.   }
  1962.   /* Get the column information. If aOffset[p2] is non-zero, then 
  1963.   ** deserialize the value from the record. If aOffset[p2] is zero,
  1964.   ** then there are not enough fields in the record to satisfy the
  1965.   ** request.  In this case, set the value NULL or to P4 if P4 is
  1966.   ** a pointer to a Mem object.
  1967.   */
  1968.   if( aOffset[p2] ){
  1969.     assert( rc==SQLITE_OK );
  1970.     if( zRec ){
  1971.       if( pDest->flags&MEM_Dyn ){
  1972.         sqlite3VdbeSerialGet((u8 *)&zRec[aOffset[p2]], aType[p2], &sMem);
  1973.         sMem.db = db; 
  1974.         rc = sqlite3VdbeMemCopy(pDest, &sMem);
  1975.         assert( !(sMem.flags&MEM_Dyn) );
  1976.         if( rc!=SQLITE_OK ){
  1977.           goto op_column_out;
  1978.         }
  1979.       }else{
  1980.         sqlite3VdbeSerialGet((u8 *)&zRec[aOffset[p2]], aType[p2], pDest);
  1981.       }
  1982.     }else{
  1983.       len = sqlite3VdbeSerialTypeLen(aType[p2]);
  1984.       sqlite3VdbeMemMove(&sMem, pDest);
  1985.       rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, pC->isIndex, &sMem);
  1986.       if( rc!=SQLITE_OK ){
  1987.         goto op_column_out;
  1988.       }
  1989.       zData = sMem.z;
  1990.       sqlite3VdbeSerialGet((u8*)zData, aType[p2], pDest);
  1991.     }
  1992.     pDest->enc = encoding;
  1993.   }else{
  1994.     if( pOp->p4type==P4_MEM ){
  1995.       sqlite3VdbeMemShallowCopy(pDest, pOp->p4.pMem, MEM_Static);
  1996.     }else{
  1997.       assert( pDest->flags&MEM_Null );
  1998.     }
  1999.   }
  2000.   /* If we dynamically allocated space to hold the data (in the
  2001.   ** sqlite3VdbeMemFromBtree() call above) then transfer control of that
  2002.   ** dynamically allocated space over to the pDest structure.
  2003.   ** This prevents a memory copy.
  2004.   */
  2005.   if( sMem.zMalloc ){
  2006.     assert( sMem.z==sMem.zMalloc );
  2007.     assert( !(pDest->flags & MEM_Dyn) );
  2008.     assert( !(pDest->flags & (MEM_Blob|MEM_Str)) || pDest->z==sMem.z );
  2009.     pDest->flags &= ~(MEM_Ephem|MEM_Static);
  2010.     pDest->flags |= MEM_Term;
  2011.     pDest->z = sMem.z;
  2012.     pDest->zMalloc = sMem.zMalloc;
  2013.   }
  2014.   rc = sqlite3VdbeMemMakeWriteable(pDest);
  2015. op_column_out:
  2016.   UPDATE_MAX_BLOBSIZE(pDest);
  2017.   REGISTER_TRACE(pOp->p3, pDest);
  2018.   break;
  2019. }
  2020. /* Opcode: MakeRecord P1 P2 P3 P4 *
  2021. **
  2022. ** Convert P2 registers beginning with P1 into a single entry
  2023. ** suitable for use as a data record in a database table or as a key
  2024. ** in an index.  The details of the format are irrelavant as long as
  2025. ** the OP_Column opcode can decode the record later.
  2026. ** Refer to source code comments for the details of the record
  2027. ** format.
  2028. **
  2029. ** P4 may be a string that is P1 characters long.  The nth character of the
  2030. ** string indicates the column affinity that should be used for the nth
  2031. ** field of the index key.
  2032. **
  2033. ** The mapping from character to affinity is given by the SQLITE_AFF_
  2034. ** macros defined in sqliteInt.h.
  2035. **
  2036. ** If P4 is NULL then all index fields have the affinity NONE.
  2037. */
  2038. case OP_MakeRecord: {
  2039.   /* Assuming the record contains N fields, the record format looks
  2040.   ** like this:
  2041.   **
  2042.   ** ------------------------------------------------------------------------
  2043.   ** | hdr-size | type 0 | type 1 | ... | type N-1 | data0 | ... | data N-1 | 
  2044.   ** ------------------------------------------------------------------------
  2045.   **
  2046.   ** Data(0) is taken from register P1.  Data(1) comes from register P1+1
  2047.   ** and so froth.
  2048.   **
  2049.   ** Each type field is a varint representing the serial type of the 
  2050.   ** corresponding data element (see sqlite3VdbeSerialType()). The
  2051.   ** hdr-size field is also a varint which is the offset from the beginning
  2052.   ** of the record to data0.
  2053.   */
  2054.   u8 *zNewRecord;        /* A buffer to hold the data for the new record */
  2055.   Mem *pRec;             /* The new record */
  2056.   u64 nData = 0;         /* Number of bytes of data space */
  2057.   int nHdr = 0;          /* Number of bytes of header space */
  2058.   u64 nByte = 0;         /* Data space required for this record */
  2059.   int nZero = 0;         /* Number of zero bytes at the end of the record */
  2060.   int nVarint;           /* Number of bytes in a varint */
  2061.   u32 serial_type;       /* Type field */
  2062.   Mem *pData0;           /* First field to be combined into the record */
  2063.   Mem *pLast;            /* Last field of the record */
  2064.   int nField;            /* Number of fields in the record */
  2065.   char *zAffinity;       /* The affinity string for the record */
  2066.   int file_format;       /* File format to use for encoding */
  2067.   int i;                 /* Space used in zNewRecord[] */
  2068.   nField = pOp->p1;
  2069.   zAffinity = pOp->p4.z;
  2070.   assert( nField>0 && pOp->p2>0 && pOp->p2+nField<=p->nMem );
  2071.   pData0 = &p->aMem[nField];
  2072.   nField = pOp->p2;
  2073.   pLast = &pData0[nField-1];
  2074.   file_format = p->minWriteFileFormat;
  2075.   /* Loop through the elements that will make up the record to figure
  2076.   ** out how much space is required for the new record.
  2077.   */
  2078.   for(pRec=pData0; pRec<=pLast; pRec++){
  2079.     int len;
  2080.     if( zAffinity ){
  2081.       applyAffinity(pRec, zAffinity[pRec-pData0], encoding);
  2082.     }
  2083.     if( pRec->flags&MEM_Zero && pRec->n>0 ){
  2084.       sqlite3VdbeMemExpandBlob(pRec);
  2085.     }
  2086.     serial_type = sqlite3VdbeSerialType(pRec, file_format);
  2087.     len = sqlite3VdbeSerialTypeLen(serial_type);
  2088.     nData += len;
  2089.     nHdr += sqlite3VarintLen(serial_type);
  2090.     if( pRec->flags & MEM_Zero ){
  2091.       /* Only pure zero-filled BLOBs can be input to this Opcode.
  2092.       ** We do not allow blobs with a prefix and a zero-filled tail. */
  2093.       nZero += pRec->u.i;
  2094.     }else if( len ){
  2095.       nZero = 0;
  2096.     }
  2097.   }
  2098.   /* Add the initial header varint and total the size */
  2099.   nHdr += nVarint = sqlite3VarintLen(nHdr);
  2100.   if( nVarint<sqlite3VarintLen(nHdr) ){
  2101.     nHdr++;
  2102.   }
  2103.   nByte = nHdr+nData-nZero;
  2104.   if( nByte>db->aLimit[SQLITE_LIMIT_LENGTH] ){
  2105.     goto too_big;
  2106.   }
  2107.   /* Make sure the output register has a buffer large enough to store 
  2108.   ** the new record. The output register (pOp->p3) is not allowed to
  2109.   ** be one of the input registers (because the following call to
  2110.   ** sqlite3VdbeMemGrow() could clobber the value before it is used).
  2111.   */
  2112.   assert( pOp->p3<pOp->p1 || pOp->p3>=pOp->p1+pOp->p2 );
  2113.   pOut = &p->aMem[pOp->p3];
  2114.   if( sqlite3VdbeMemGrow(pOut, nByte, 0) ){
  2115.     goto no_mem;
  2116.   }
  2117.   zNewRecord = (u8 *)pOut->z;
  2118.   /* Write the record */
  2119.   i = sqlite3PutVarint32(zNewRecord, nHdr);
  2120.   for(pRec=pData0; pRec<=pLast; pRec++){
  2121.     serial_type = sqlite3VdbeSerialType(pRec, file_format);
  2122.     i += sqlite3PutVarint32(&zNewRecord[i], serial_type);      /* serial type */
  2123.   }
  2124.   for(pRec=pData0; pRec<=pLast; pRec++){  /* serial data */
  2125.     i += sqlite3VdbeSerialPut(&zNewRecord[i], nByte-i, pRec, file_format);
  2126.   }
  2127.   assert( i==nByte );
  2128.   assert( pOp->p3>0 && pOp->p3<=p->nMem );
  2129.   pOut->n = nByte;
  2130.   pOut->flags = MEM_Blob | MEM_Dyn;
  2131.   pOut->xDel = 0;
  2132.   if( nZero ){
  2133.     pOut->u.i = nZero;
  2134.     pOut->flags |= MEM_Zero;
  2135.   }
  2136.   pOut->enc = SQLITE_UTF8;  /* In case the blob is ever converted to text */
  2137.   REGISTER_TRACE(pOp->p3, pOut);
  2138.   UPDATE_MAX_BLOBSIZE(pOut);
  2139.   break;
  2140. }
  2141. /* Opcode: Statement P1 * * * *
  2142. **
  2143. ** Begin an individual statement transaction which is part of a larger
  2144. ** BEGIN..COMMIT transaction.  This is needed so that the statement
  2145. ** can be rolled back after an error without having to roll back the
  2146. ** entire transaction.  The statement transaction will automatically
  2147. ** commit when the VDBE halts.
  2148. **
  2149. ** The statement is begun on the database file with index P1.  The main
  2150. ** database file has an index of 0 and the file used for temporary tables
  2151. ** has an index of 1.
  2152. */
  2153. case OP_Statement: {
  2154.   if( db->autoCommit==0 || db->activeVdbeCnt>1 ){
  2155.     int i = pOp->p1;
  2156.     Btree *pBt;
  2157.     assert( i>=0 && i<db->nDb );
  2158.     assert( db->aDb[i].pBt!=0 );
  2159.     pBt = db->aDb[i].pBt;
  2160.     assert( sqlite3BtreeIsInTrans(pBt) );
  2161.     assert( (p->btreeMask & (1<<i))!=0 );
  2162.     if( !sqlite3BtreeIsInStmt(pBt) ){
  2163.       rc = sqlite3BtreeBeginStmt(pBt);
  2164.       p->openedStatement = 1;
  2165.     }
  2166.   }
  2167.   break;
  2168. }
  2169. /* Opcode: AutoCommit P1 P2 * * *
  2170. **
  2171. ** Set the database auto-commit flag to P1 (1 or 0). If P2 is true, roll
  2172. ** back any currently active btree transactions. If there are any active
  2173. ** VMs (apart from this one), then the COMMIT or ROLLBACK statement fails.
  2174. **
  2175. ** This instruction causes the VM to halt.
  2176. */
  2177. case OP_AutoCommit: {
  2178.   u8 i = pOp->p1;
  2179.   u8 rollback = pOp->p2;
  2180.   assert( i==1 || i==0 );
  2181.   assert( i==1 || rollback==0 );
  2182.   assert( db->activeVdbeCnt>0 );  /* At least this one VM is active */
  2183.   if( db->activeVdbeCnt>1 && i && !db->autoCommit ){
  2184.     /* If this instruction implements a COMMIT or ROLLBACK, other VMs are
  2185.     ** still running, and a transaction is active, return an error indicating
  2186.     ** that the other VMs must complete first. 
  2187.     */
  2188.     sqlite3SetString(&p->zErrMsg, "cannot ", rollback?"rollback":"commit", 
  2189.         " transaction - SQL statements in progress", (char*)0);
  2190.     rc = SQLITE_ERROR;
  2191.   }else if( i!=db->autoCommit ){
  2192.     if( pOp->p2 ){
  2193.       assert( i==1 );
  2194.       sqlite3RollbackAll(db);
  2195.       db->autoCommit = 1;
  2196.     }else{
  2197.       db->autoCommit = i;
  2198.       if( sqlite3VdbeHalt(p)==SQLITE_BUSY ){
  2199.         p->pc = pc;
  2200.         db->autoCommit = 1-i;
  2201.         p->rc = rc = SQLITE_BUSY;
  2202.         goto vdbe_return;
  2203.       }
  2204.     }
  2205.     if( p->rc==SQLITE_OK ){
  2206.       rc = SQLITE_DONE;
  2207.     }else{
  2208.       rc = SQLITE_ERROR;
  2209.     }
  2210.     goto vdbe_return;
  2211.   }else{
  2212.     sqlite3SetString(&p->zErrMsg,
  2213.         (!i)?"cannot start a transaction within a transaction":(
  2214.         (rollback)?"cannot rollback - no transaction is active":
  2215.                    "cannot commit - no transaction is active"), (char*)0);
  2216.          
  2217.     rc = SQLITE_ERROR;
  2218.   }
  2219.   break;
  2220. }
  2221. /* Opcode: Transaction P1 P2 * * *
  2222. **
  2223. ** Begin a transaction.  The transaction ends when a Commit or Rollback
  2224. ** opcode is encountered.  Depending on the ON CONFLICT setting, the
  2225. ** transaction might also be rolled back if an error is encountered.
  2226. **
  2227. ** P1 is the index of the database file on which the transaction is
  2228. ** started.  Index 0 is the main database file and index 1 is the
  2229. ** file used for temporary tables.  Indices of 2 or more are used for
  2230. ** attached databases.
  2231. **
  2232. ** If P2 is non-zero, then a write-transaction is started.  A RESERVED lock is
  2233. ** obtained on the database file when a write-transaction is started.  No
  2234. ** other process can start another write transaction while this transaction is
  2235. ** underway.  Starting a write transaction also creates a rollback journal. A
  2236. ** write transaction must be started before any changes can be made to the
  2237. ** database.  If P2 is 2 or greater then an EXCLUSIVE lock is also obtained
  2238. ** on the file.
  2239. **
  2240. ** If P2 is zero, then a read-lock is obtained on the database file.
  2241. */
  2242. case OP_Transaction: {
  2243.   int i = pOp->p1;
  2244.   Btree *pBt;
  2245.   assert( i>=0 && i<db->nDb );
  2246.   assert( (p->btreeMask & (1<<i))!=0 );
  2247.   pBt = db->aDb[i].pBt;
  2248.   if( pBt ){
  2249.     rc = sqlite3BtreeBeginTrans(pBt, pOp->p2);
  2250.     if( rc==SQLITE_BUSY ){
  2251.       p->pc = pc;
  2252.       p->rc = rc = SQLITE_BUSY;
  2253.       goto vdbe_return;
  2254.     }
  2255.     if( rc!=SQLITE_OK && rc!=SQLITE_READONLY /* && rc!=SQLITE_BUSY */ ){
  2256.       goto abort_due_to_error;
  2257.     }
  2258.   }
  2259.   break;
  2260. }
  2261. /* Opcode: ReadCookie P1 P2 P3 * *
  2262. **
  2263. ** Read cookie number P3 from database P1 and write it into register P2.
  2264. ** P3==0 is the schema version.  P3==1 is the database format.
  2265. ** P3==2 is the recommended pager cache size, and so forth.  P1==0 is
  2266. ** the main database file and P1==1 is the database file used to store
  2267. ** temporary tables.
  2268. **
  2269. ** If P1 is negative, then this is a request to read the size of a
  2270. ** databases free-list. P3 must be set to 1 in this case. The actual
  2271. ** database accessed is ((P1+1)*-1). For example, a P1 parameter of -1
  2272. ** corresponds to database 0 ("main"), a P1 of -2 is database 1 ("temp").
  2273. **
  2274. ** There must be a read-lock on the database (either a transaction
  2275. ** must be started or there must be an open cursor) before
  2276. ** executing this instruction.
  2277. */
  2278. case OP_ReadCookie: {               /* out2-prerelease */
  2279.   int iMeta;
  2280.   int iDb = pOp->p1;
  2281.   int iCookie = pOp->p3;
  2282.   assert( pOp->p3<SQLITE_N_BTREE_META );
  2283.   if( iDb<0 ){
  2284.     iDb = (-1*(iDb+1));
  2285.     iCookie *= -1;
  2286.   }
  2287.   assert( iDb>=0 && iDb<db->nDb );
  2288.   assert( db->aDb[iDb].pBt!=0 );
  2289.   assert( (p->btreeMask & (1<<iDb))!=0 );
  2290.   /* The indexing of meta values at the schema layer is off by one from
  2291.   ** the indexing in the btree layer.  The btree considers meta[0] to
  2292.   ** be the number of free pages in the database (a read-only value)
  2293.   ** and meta[1] to be the schema cookie.  The schema layer considers
  2294.   ** meta[1] to be the schema cookie.  So we have to shift the index
  2295.   ** by one in the following statement.
  2296.   */
  2297.   rc = sqlite3BtreeGetMeta(db->aDb[iDb].pBt, 1 + iCookie, (u32 *)&iMeta);
  2298.   pOut->u.i = iMeta;
  2299.   MemSetTypeFlag(pOut, MEM_Int);
  2300.   break;
  2301. }
  2302. /* Opcode: SetCookie P1 P2 P3 * *
  2303. **
  2304. ** Write the content of register P3 (interpreted as an integer)
  2305. ** into cookie number P2 of database P1.
  2306. ** P2==0 is the schema version.  P2==1 is the database format.
  2307. ** P2==2 is the recommended pager cache size, and so forth.  P1==0 is
  2308. ** the main database file and P1==1 is the database file used to store
  2309. ** temporary tables.
  2310. **
  2311. ** A transaction must be started before executing this opcode.
  2312. */
  2313. case OP_SetCookie: {       /* in3 */
  2314.   Db *pDb;
  2315.   assert( pOp->p2<SQLITE_N_BTREE_META );
  2316.   assert( pOp->p1>=0 && pOp->p1<db->nDb );
  2317.   assert( (p->btreeMask & (1<<pOp->p1))!=0 );
  2318.   pDb = &db->aDb[pOp->p1];
  2319.   assert( pDb->pBt!=0 );
  2320.   sqlite3VdbeMemIntegerify(pIn3);
  2321.   /* See note about index shifting on OP_ReadCookie */
  2322.   rc = sqlite3BtreeUpdateMeta(pDb->pBt, 1+pOp->p2, (int)pIn3->u.i);
  2323.   if( pOp->p2==0 ){
  2324.     /* When the schema cookie changes, record the new cookie internally */