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

数据库系统

开发平台:

C/C++

  1.     pDb->pSchema->schema_cookie = pIn3->u.i;
  2.     db->flags |= SQLITE_InternChanges;
  3.   }else if( pOp->p2==1 ){
  4.     /* Record changes in the file format */
  5.     pDb->pSchema->file_format = pIn3->u.i;
  6.   }
  7.   if( pOp->p1==1 ){
  8.     /* Invalidate all prepared statements whenever the TEMP database
  9.     ** schema is changed.  Ticket #1644 */
  10.     sqlite3ExpirePreparedStatements(db);
  11.   }
  12.   break;
  13. }
  14. /* Opcode: VerifyCookie P1 P2 *
  15. **
  16. ** Check the value of global database parameter number 0 (the
  17. ** schema version) and make sure it is equal to P2.  
  18. ** P1 is the database number which is 0 for the main database file
  19. ** and 1 for the file holding temporary tables and some higher number
  20. ** for auxiliary databases.
  21. **
  22. ** The cookie changes its value whenever the database schema changes.
  23. ** This operation is used to detect when that the cookie has changed
  24. ** and that the current process needs to reread the schema.
  25. **
  26. ** Either a transaction needs to have been started or an OP_Open needs
  27. ** to be executed (to establish a read lock) before this opcode is
  28. ** invoked.
  29. */
  30. case OP_VerifyCookie: {
  31.   int iMeta;
  32.   Btree *pBt;
  33.   assert( pOp->p1>=0 && pOp->p1<db->nDb );
  34.   assert( (p->btreeMask & (1<<pOp->p1))!=0 );
  35.   pBt = db->aDb[pOp->p1].pBt;
  36.   if( pBt ){
  37.     rc = sqlite3BtreeGetMeta(pBt, 1, (u32 *)&iMeta);
  38.   }else{
  39.     rc = SQLITE_OK;
  40.     iMeta = 0;
  41.   }
  42.   if( rc==SQLITE_OK && iMeta!=pOp->p2 ){
  43.     sqlite3_free(p->zErrMsg);
  44.     p->zErrMsg = sqlite3DbStrDup(db, "database schema has changed");
  45.     /* If the schema-cookie from the database file matches the cookie 
  46.     ** stored with the in-memory representation of the schema, do
  47.     ** not reload the schema from the database file.
  48.     **
  49.     ** If virtual-tables are in use, this is not just an optimisation.
  50.     ** Often, v-tables store their data in other SQLite tables, which
  51.     ** are queried from within xNext() and other v-table methods using
  52.     ** prepared queries. If such a query is out-of-date, we do not want to
  53.     ** discard the database schema, as the user code implementing the
  54.     ** v-table would have to be ready for the sqlite3_vtab structure itself
  55.     ** to be invalidated whenever sqlite3_step() is called from within 
  56.     ** a v-table method.
  57.     */
  58.     if( db->aDb[pOp->p1].pSchema->schema_cookie!=iMeta ){
  59.       sqlite3ResetInternalSchema(db, pOp->p1);
  60.     }
  61.     sqlite3ExpirePreparedStatements(db);
  62.     rc = SQLITE_SCHEMA;
  63.   }
  64.   break;
  65. }
  66. /* Opcode: OpenRead P1 P2 P3 P4 P5
  67. **
  68. ** Open a read-only cursor for the database table whose root page is
  69. ** P2 in a database file.  The database file is determined by P3. 
  70. ** P3==0 means the main database, P3==1 means the database used for 
  71. ** temporary tables, and P3>1 means used the corresponding attached
  72. ** database.  Give the new cursor an identifier of P1.  The P1
  73. ** values need not be contiguous but all P1 values should be small integers.
  74. ** It is an error for P1 to be negative.
  75. **
  76. ** If P5!=0 then use the content of register P2 as the root page, not
  77. ** the value of P2 itself.
  78. **
  79. ** There will be a read lock on the database whenever there is an
  80. ** open cursor.  If the database was unlocked prior to this instruction
  81. ** then a read lock is acquired as part of this instruction.  A read
  82. ** lock allows other processes to read the database but prohibits
  83. ** any other process from modifying the database.  The read lock is
  84. ** released when all cursors are closed.  If this instruction attempts
  85. ** to get a read lock but fails, the script terminates with an
  86. ** SQLITE_BUSY error code.
  87. **
  88. ** The P4 value is a pointer to a KeyInfo structure that defines the
  89. ** content and collating sequence of indices.  P4 is NULL for cursors
  90. ** that are not pointing to indices.
  91. **
  92. ** See also OpenWrite.
  93. */
  94. /* Opcode: OpenWrite P1 P2 P3 P4 P5
  95. **
  96. ** Open a read/write cursor named P1 on the table or index whose root
  97. ** page is P2.  Or if P5!=0 use the content of register P2 to find the
  98. ** root page.
  99. **
  100. ** The P4 value is a pointer to a KeyInfo structure that defines the
  101. ** content and collating sequence of indices.  P4 is NULL for cursors
  102. ** that are not pointing to indices.
  103. **
  104. ** This instruction works just like OpenRead except that it opens the cursor
  105. ** in read/write mode.  For a given table, there can be one or more read-only
  106. ** cursors or a single read/write cursor but not both.
  107. **
  108. ** See also OpenRead.
  109. */
  110. case OP_OpenRead:
  111. case OP_OpenWrite: {
  112.   int i = pOp->p1;
  113.   int p2 = pOp->p2;
  114.   int iDb = pOp->p3;
  115.   int wrFlag;
  116.   Btree *pX;
  117.   Cursor *pCur;
  118.   Db *pDb;
  119.   
  120.   assert( iDb>=0 && iDb<db->nDb );
  121.   assert( (p->btreeMask & (1<<iDb))!=0 );
  122.   pDb = &db->aDb[iDb];
  123.   pX = pDb->pBt;
  124.   assert( pX!=0 );
  125.   if( pOp->opcode==OP_OpenWrite ){
  126.     wrFlag = 1;
  127.     if( pDb->pSchema->file_format < p->minWriteFileFormat ){
  128.       p->minWriteFileFormat = pDb->pSchema->file_format;
  129.     }
  130.   }else{
  131.     wrFlag = 0;
  132.   }
  133.   if( pOp->p5 ){
  134.     assert( p2>0 );
  135.     assert( p2<=p->nMem );
  136.     pIn2 = &p->aMem[p2];
  137.     sqlite3VdbeMemIntegerify(pIn2);
  138.     p2 = pIn2->u.i;
  139.     assert( p2>=2 );
  140.   }
  141.   assert( i>=0 );
  142.   pCur = allocateCursor(p, i, &pOp[-1], iDb, 1);
  143.   if( pCur==0 ) goto no_mem;
  144.   pCur->nullRow = 1;
  145.   rc = sqlite3BtreeCursor(pX, p2, wrFlag, pOp->p4.p, pCur->pCursor);
  146.   if( pOp->p4type==P4_KEYINFO ){
  147.     pCur->pKeyInfo = pOp->p4.pKeyInfo;
  148.     pCur->pIncrKey = &pCur->pKeyInfo->incrKey;
  149.     pCur->pKeyInfo->enc = ENC(p->db);
  150.   }else{
  151.     pCur->pKeyInfo = 0;
  152.     pCur->pIncrKey = &pCur->bogusIncrKey;
  153.   }
  154.   switch( rc ){
  155.     case SQLITE_BUSY: {
  156.       p->pc = pc;
  157.       p->rc = rc = SQLITE_BUSY;
  158.       goto vdbe_return;
  159.     }
  160.     case SQLITE_OK: {
  161.       int flags = sqlite3BtreeFlags(pCur->pCursor);
  162.       /* Sanity checking.  Only the lower four bits of the flags byte should
  163.       ** be used.  Bit 3 (mask 0x08) is unpreditable.  The lower 3 bits
  164.       ** (mask 0x07) should be either 5 (intkey+leafdata for tables) or
  165.       ** 2 (zerodata for indices).  If these conditions are not met it can
  166.       ** only mean that we are dealing with a corrupt database file
  167.       */
  168.       if( (flags & 0xf0)!=0 || ((flags & 0x07)!=5 && (flags & 0x07)!=2) ){
  169.         rc = SQLITE_CORRUPT_BKPT;
  170.         goto abort_due_to_error;
  171.       }
  172.       pCur->isTable = (flags & BTREE_INTKEY)!=0;
  173.       pCur->isIndex = (flags & BTREE_ZERODATA)!=0;
  174.       /* If P4==0 it means we are expected to open a table.  If P4!=0 then
  175.       ** we expect to be opening an index.  If this is not what happened,
  176.       ** then the database is corrupt
  177.       */
  178.       if( (pCur->isTable && pOp->p4type==P4_KEYINFO)
  179.        || (pCur->isIndex && pOp->p4type!=P4_KEYINFO) ){
  180.         rc = SQLITE_CORRUPT_BKPT;
  181.         goto abort_due_to_error;
  182.       }
  183.       break;
  184.     }
  185.     case SQLITE_EMPTY: {
  186.       pCur->isTable = pOp->p4type!=P4_KEYINFO;
  187.       pCur->isIndex = !pCur->isTable;
  188.       pCur->pCursor = 0;
  189.       rc = SQLITE_OK;
  190.       break;
  191.     }
  192.     default: {
  193.       goto abort_due_to_error;
  194.     }
  195.   }
  196.   break;
  197. }
  198. /* Opcode: OpenEphemeral P1 P2 * P4 *
  199. **
  200. ** Open a new cursor P1 to a transient table.
  201. ** The cursor is always opened read/write even if 
  202. ** the main database is read-only.  The transient or virtual
  203. ** table is deleted automatically when the cursor is closed.
  204. **
  205. ** P2 is the number of columns in the virtual table.
  206. ** The cursor points to a BTree table if P4==0 and to a BTree index
  207. ** if P4 is not 0.  If P4 is not NULL, it points to a KeyInfo structure
  208. ** that defines the format of keys in the index.
  209. **
  210. ** This opcode was once called OpenTemp.  But that created
  211. ** confusion because the term "temp table", might refer either
  212. ** to a TEMP table at the SQL level, or to a table opened by
  213. ** this opcode.  Then this opcode was call OpenVirtual.  But
  214. ** that created confusion with the whole virtual-table idea.
  215. */
  216. case OP_OpenEphemeral: {
  217.   int i = pOp->p1;
  218.   Cursor *pCx;
  219.   static const int openFlags = 
  220.       SQLITE_OPEN_READWRITE |
  221.       SQLITE_OPEN_CREATE |
  222.       SQLITE_OPEN_EXCLUSIVE |
  223.       SQLITE_OPEN_DELETEONCLOSE |
  224.       SQLITE_OPEN_TRANSIENT_DB;
  225.   assert( i>=0 );
  226.   pCx = allocateCursor(p, i, pOp, -1, 1);
  227.   if( pCx==0 ) goto no_mem;
  228.   pCx->nullRow = 1;
  229.   rc = sqlite3BtreeFactory(db, 0, 1, SQLITE_DEFAULT_TEMP_CACHE_SIZE, openFlags,
  230.                            &pCx->pBt);
  231.   if( rc==SQLITE_OK ){
  232.     rc = sqlite3BtreeBeginTrans(pCx->pBt, 1);
  233.   }
  234.   if( rc==SQLITE_OK ){
  235.     /* If a transient index is required, create it by calling
  236.     ** sqlite3BtreeCreateTable() with the BTREE_ZERODATA flag before
  237.     ** opening it. If a transient table is required, just use the
  238.     ** automatically created table with root-page 1 (an INTKEY table).
  239.     */
  240.     if( pOp->p4.pKeyInfo ){
  241.       int pgno;
  242.       assert( pOp->p4type==P4_KEYINFO );
  243.       rc = sqlite3BtreeCreateTable(pCx->pBt, &pgno, BTREE_ZERODATA); 
  244.       if( rc==SQLITE_OK ){
  245.         assert( pgno==MASTER_ROOT+1 );
  246.         rc = sqlite3BtreeCursor(pCx->pBt, pgno, 1, 
  247.                                 (KeyInfo*)pOp->p4.z, pCx->pCursor);
  248.         pCx->pKeyInfo = pOp->p4.pKeyInfo;
  249.         pCx->pKeyInfo->enc = ENC(p->db);
  250.         pCx->pIncrKey = &pCx->pKeyInfo->incrKey;
  251.       }
  252.       pCx->isTable = 0;
  253.     }else{
  254.       rc = sqlite3BtreeCursor(pCx->pBt, MASTER_ROOT, 1, 0, pCx->pCursor);
  255.       pCx->isTable = 1;
  256.       pCx->pIncrKey = &pCx->bogusIncrKey;
  257.     }
  258.   }
  259.   pCx->isIndex = !pCx->isTable;
  260.   break;
  261. }
  262. /* Opcode: OpenPseudo P1 P2 * * *
  263. **
  264. ** Open a new cursor that points to a fake table that contains a single
  265. ** row of data.  Any attempt to write a second row of data causes the
  266. ** first row to be deleted.  All data is deleted when the cursor is
  267. ** closed.
  268. **
  269. ** A pseudo-table created by this opcode is useful for holding the
  270. ** NEW or OLD tables in a trigger.  Also used to hold the a single
  271. ** row output from the sorter so that the row can be decomposed into
  272. ** individual columns using the OP_Column opcode.
  273. **
  274. ** When OP_Insert is executed to insert a row in to the pseudo table,
  275. ** the pseudo-table cursor may or may not make it's own copy of the
  276. ** original row data. If P2 is 0, then the pseudo-table will copy the
  277. ** original row data. Otherwise, a pointer to the original memory cell
  278. ** is stored. In this case, the vdbe program must ensure that the 
  279. ** memory cell containing the row data is not overwritten until the
  280. ** pseudo table is closed (or a new row is inserted into it).
  281. */
  282. case OP_OpenPseudo: {
  283.   int i = pOp->p1;
  284.   Cursor *pCx;
  285.   assert( i>=0 );
  286.   pCx = allocateCursor(p, i, &pOp[-1], -1, 0);
  287.   if( pCx==0 ) goto no_mem;
  288.   pCx->nullRow = 1;
  289.   pCx->pseudoTable = 1;
  290.   pCx->ephemPseudoTable = pOp->p2;
  291.   pCx->pIncrKey = &pCx->bogusIncrKey;
  292.   pCx->isTable = 1;
  293.   pCx->isIndex = 0;
  294.   break;
  295. }
  296. /* Opcode: Close P1 * * * *
  297. **
  298. ** Close a cursor previously opened as P1.  If P1 is not
  299. ** currently open, this instruction is a no-op.
  300. */
  301. case OP_Close: {
  302.   int i = pOp->p1;
  303.   assert( i>=0 && i<p->nCursor );
  304.   sqlite3VdbeFreeCursor(p, p->apCsr[i]);
  305.   p->apCsr[i] = 0;
  306.   break;
  307. }
  308. /* Opcode: MoveGe P1 P2 P3 * *
  309. **
  310. ** Use the value in register P3 as a key.  Reposition
  311. ** cursor P1 so that it points to the smallest entry that is greater
  312. ** than or equal to the key in register P3.
  313. ** If there are no records greater than or equal to the key and P2 
  314. ** is not zero, then jump to P2.
  315. **
  316. ** A special feature of this opcode (and different from the
  317. ** related OP_MoveGt, OP_MoveLt, and OP_MoveLe) is that if P2 is
  318. ** zero and P1 is an SQL table (a b-tree with integer keys) then
  319. ** the seek is deferred until it is actually needed.  It might be
  320. ** the case that the cursor is never accessed.  By deferring the
  321. ** seek, we avoid unnecessary seeks.
  322. **
  323. ** See also: Found, NotFound, Distinct, MoveLt, MoveGt, MoveLe
  324. */
  325. /* Opcode: MoveGt P1 P2 P3 * *
  326. **
  327. ** Use the value in register P3 as a key.  Reposition
  328. ** cursor P1 so that it points to the smallest entry that is greater
  329. ** than the key in register P3.
  330. ** If there are no records greater than the key 
  331. ** then jump to P2.
  332. **
  333. ** See also: Found, NotFound, Distinct, MoveLt, MoveGe, MoveLe
  334. */
  335. /* Opcode: MoveLt P1 P2 P3 * * 
  336. **
  337. ** Use the value in register P3 as a key.  Reposition
  338. ** cursor P1 so that it points to the largest entry that is less
  339. ** than the key in register P3.
  340. ** If there are no records less than the key
  341. ** then jump to P2.
  342. **
  343. ** See also: Found, NotFound, Distinct, MoveGt, MoveGe, MoveLe
  344. */
  345. /* Opcode: MoveLe P1 P2 P3 * *
  346. **
  347. ** Use the value in register P3 as a key.  Reposition
  348. ** cursor P1 so that it points to the largest entry that is less than
  349. ** or equal to the key.
  350. ** If there are no records less than or eqal to the key
  351. ** then jump to P2.
  352. **
  353. ** See also: Found, NotFound, Distinct, MoveGt, MoveGe, MoveLt
  354. */
  355. case OP_MoveLt:         /* jump, in3 */
  356. case OP_MoveLe:         /* jump, in3 */
  357. case OP_MoveGe:         /* jump, in3 */
  358. case OP_MoveGt: {       /* jump, in3 */
  359.   int i = pOp->p1;
  360.   Cursor *pC;
  361.   assert( i>=0 && i<p->nCursor );
  362.   pC = p->apCsr[i];
  363.   assert( pC!=0 );
  364.   if( pC->pCursor!=0 ){
  365.     int res, oc;
  366.     oc = pOp->opcode;
  367.     pC->nullRow = 0;
  368.     *pC->pIncrKey = oc==OP_MoveGt || oc==OP_MoveLe;
  369.     if( pC->isTable ){
  370.       i64 iKey = sqlite3VdbeIntValue(pIn3);
  371.       if( pOp->p2==0 ){
  372.         assert( pOp->opcode==OP_MoveGe );
  373.         pC->movetoTarget = iKey;
  374.         pC->rowidIsValid = 0;
  375.         pC->deferredMoveto = 1;
  376.         break;
  377.       }
  378.       rc = sqlite3BtreeMoveto(pC->pCursor, 0, 0, (u64)iKey, 0, &res);
  379.       if( rc!=SQLITE_OK ){
  380.         goto abort_due_to_error;
  381.       }
  382.       pC->lastRowid = iKey;
  383.       pC->rowidIsValid = res==0;
  384.     }else{
  385.       assert( pIn3->flags & MEM_Blob );
  386.       ExpandBlob(pIn3);
  387.       rc = sqlite3BtreeMoveto(pC->pCursor, pIn3->z, 0, pIn3->n, 0, &res);
  388.       if( rc!=SQLITE_OK ){
  389.         goto abort_due_to_error;
  390.       }
  391.       pC->rowidIsValid = 0;
  392.     }
  393.     pC->deferredMoveto = 0;
  394.     pC->cacheStatus = CACHE_STALE;
  395.     *pC->pIncrKey = 0;
  396. #ifdef SQLITE_TEST
  397.     sqlite3_search_count++;
  398. #endif
  399.     if( oc==OP_MoveGe || oc==OP_MoveGt ){
  400.       if( res<0 ){
  401.         rc = sqlite3BtreeNext(pC->pCursor, &res);
  402.         if( rc!=SQLITE_OK ) goto abort_due_to_error;
  403.         pC->rowidIsValid = 0;
  404.       }else{
  405.         res = 0;
  406.       }
  407.     }else{
  408.       assert( oc==OP_MoveLt || oc==OP_MoveLe );
  409.       if( res>=0 ){
  410.         rc = sqlite3BtreePrevious(pC->pCursor, &res);
  411.         if( rc!=SQLITE_OK ) goto abort_due_to_error;
  412.         pC->rowidIsValid = 0;
  413.       }else{
  414.         /* res might be negative because the table is empty.  Check to
  415.         ** see if this is the case.
  416.         */
  417.         res = sqlite3BtreeEof(pC->pCursor);
  418.       }
  419.     }
  420.     assert( pOp->p2>0 );
  421.     if( res ){
  422.       pc = pOp->p2 - 1;
  423.     }
  424.   }
  425.   break;
  426. }
  427. /* Opcode: Found P1 P2 P3 * *
  428. **
  429. ** Register P3 holds a blob constructed by MakeRecord.  P1 is an index.
  430. ** If an entry that matches the value in register p3 exists in P1 then
  431. ** jump to P2.  If the P3 value does not match any entry in P1
  432. ** then fall thru.  The P1 cursor is left pointing at the matching entry
  433. ** if it exists.
  434. **
  435. ** This instruction is used to implement the IN operator where the
  436. ** left-hand side is a SELECT statement.  P1 may be a true index, or it
  437. ** may be a temporary index that holds the results of the SELECT
  438. ** statement.   This instruction is also used to implement the
  439. ** DISTINCT keyword in SELECT statements.
  440. **
  441. ** This instruction checks if index P1 contains a record for which 
  442. ** the first N serialised values exactly match the N serialised values
  443. ** in the record in register P3, where N is the total number of values in
  444. ** the P3 record (the P3 record is a prefix of the P1 record). 
  445. **
  446. ** See also: NotFound, MoveTo, IsUnique, NotExists
  447. */
  448. /* Opcode: NotFound P1 P2 P3 * *
  449. **
  450. ** Register P3 holds a blob constructed by MakeRecord.  P1 is
  451. ** an index.  If no entry exists in P1 that matches the blob then jump
  452. ** to P2.  If an entry does existing, fall through.  The cursor is left
  453. ** pointing to the entry that matches.
  454. **
  455. ** See also: Found, MoveTo, NotExists, IsUnique
  456. */
  457. case OP_NotFound:       /* jump, in3 */
  458. case OP_Found: {        /* jump, in3 */
  459.   int i = pOp->p1;
  460.   int alreadyExists = 0;
  461.   Cursor *pC;
  462.   assert( i>=0 && i<p->nCursor );
  463.   assert( p->apCsr[i]!=0 );
  464.   if( (pC = p->apCsr[i])->pCursor!=0 ){
  465.     int res;
  466.     assert( pC->isTable==0 );
  467.     assert( pIn3->flags & MEM_Blob );
  468.     if( pOp->opcode==OP_Found ){
  469.       pC->pKeyInfo->prefixIsEqual = 1;
  470.     }
  471.     rc = sqlite3BtreeMoveto(pC->pCursor, pIn3->z, 0, pIn3->n, 0, &res);
  472.     pC->pKeyInfo->prefixIsEqual = 0;
  473.     if( rc!=SQLITE_OK ){
  474.       break;
  475.     }
  476.     alreadyExists = (res==0);
  477.     pC->deferredMoveto = 0;
  478.     pC->cacheStatus = CACHE_STALE;
  479.   }
  480.   if( pOp->opcode==OP_Found ){
  481.     if( alreadyExists ) pc = pOp->p2 - 1;
  482.   }else{
  483.     if( !alreadyExists ) pc = pOp->p2 - 1;
  484.   }
  485.   break;
  486. }
  487. /* Opcode: IsUnique P1 P2 P3 P4 *
  488. **
  489. ** The P3 register contains an integer record number.  Call this
  490. ** record number R.  The P4 register contains an index key created
  491. ** using MakeIdxRec.  Call it K.
  492. **
  493. ** P1 is an index.  So it has no data and its key consists of a
  494. ** record generated by OP_MakeRecord where the last field is the 
  495. ** rowid of the entry that the index refers to.
  496. ** 
  497. ** This instruction asks if there is an entry in P1 where the
  498. ** fields matches K but the rowid is different from R.
  499. ** If there is no such entry, then there is an immediate
  500. ** jump to P2.  If any entry does exist where the index string
  501. ** matches K but the record number is not R, then the record
  502. ** number for that entry is written into P3 and control
  503. ** falls through to the next instruction.
  504. **
  505. ** See also: NotFound, NotExists, Found
  506. */
  507. case OP_IsUnique: {        /* jump, in3 */
  508.   int i = pOp->p1;
  509.   Cursor *pCx;
  510.   BtCursor *pCrsr;
  511.   Mem *pK;
  512.   i64 R;
  513.   /* Pop the value R off the top of the stack
  514.   */
  515.   assert( pOp->p4type==P4_INT32 );
  516.   assert( pOp->p4.i>0 && pOp->p4.i<=p->nMem );
  517.   pK = &p->aMem[pOp->p4.i];
  518.   sqlite3VdbeMemIntegerify(pIn3);
  519.   R = pIn3->u.i;
  520.   assert( i>=0 && i<p->nCursor );
  521.   pCx = p->apCsr[i];
  522.   assert( pCx!=0 );
  523.   pCrsr = pCx->pCursor;
  524.   if( pCrsr!=0 ){
  525.     int res;
  526.     i64 v;         /* The record number on the P1 entry that matches K */
  527.     char *zKey;    /* The value of K */
  528.     int nKey;      /* Number of bytes in K */
  529.     int len;       /* Number of bytes in K without the rowid at the end */
  530.     int szRowid;   /* Size of the rowid column at the end of zKey */
  531.     /* Make sure K is a string and make zKey point to K
  532.     */
  533.     assert( pK->flags & MEM_Blob );
  534.     zKey = pK->z;
  535.     nKey = pK->n;
  536.     szRowid = sqlite3VdbeIdxRowidLen((u8*)zKey);
  537.     len = nKey-szRowid;
  538.     /* Search for an entry in P1 where all but the last four bytes match K.
  539.     ** If there is no such entry, jump immediately to P2.
  540.     */
  541.     assert( pCx->deferredMoveto==0 );
  542.     pCx->cacheStatus = CACHE_STALE;
  543.     rc = sqlite3BtreeMoveto(pCrsr, zKey, 0, len, 0, &res);
  544.     if( rc!=SQLITE_OK ){
  545.       goto abort_due_to_error;
  546.     }
  547.     if( res<0 ){
  548.       rc = sqlite3BtreeNext(pCrsr, &res);
  549.       if( res ){
  550.         pc = pOp->p2 - 1;
  551.         break;
  552.       }
  553.     }
  554.     rc = sqlite3VdbeIdxKeyCompare(pCx, len, (u8*)zKey, &res); 
  555.     if( rc!=SQLITE_OK ) goto abort_due_to_error;
  556.     if( res>0 ){
  557.       pc = pOp->p2 - 1;
  558.       break;
  559.     }
  560.     /* At this point, pCrsr is pointing to an entry in P1 where all but
  561.     ** the final entry (the rowid) matches K.  Check to see if the
  562.     ** final rowid column is different from R.  If it equals R then jump
  563.     ** immediately to P2.
  564.     */
  565.     rc = sqlite3VdbeIdxRowid(pCrsr, &v);
  566.     if( rc!=SQLITE_OK ){
  567.       goto abort_due_to_error;
  568.     }
  569.     if( v==R ){
  570.       pc = pOp->p2 - 1;
  571.       break;
  572.     }
  573.     /* The final varint of the key is different from R.  Store it back
  574.     ** into register R3.  (The record number of an entry that violates
  575.     ** a UNIQUE constraint.)
  576.     */
  577.     pIn3->u.i = v;
  578.     assert( pIn3->flags&MEM_Int );
  579.   }
  580.   break;
  581. }
  582. /* Opcode: NotExists P1 P2 P3 * *
  583. **
  584. ** Use the content of register P3 as a integer key.  If a record 
  585. ** with that key does not exist in table of P1, then jump to P2. 
  586. ** If the record does exist, then fall thru.  The cursor is left 
  587. ** pointing to the record if it exists.
  588. **
  589. ** The difference between this operation and NotFound is that this
  590. ** operation assumes the key is an integer and that P1 is a table whereas
  591. ** NotFound assumes key is a blob constructed from MakeRecord and
  592. ** P1 is an index.
  593. **
  594. ** See also: Found, MoveTo, NotFound, IsUnique
  595. */
  596. case OP_NotExists: {        /* jump, in3 */
  597.   int i = pOp->p1;
  598.   Cursor *pC;
  599.   BtCursor *pCrsr;
  600.   assert( i>=0 && i<p->nCursor );
  601.   assert( p->apCsr[i]!=0 );
  602.   if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
  603.     int res;
  604.     u64 iKey;
  605.     assert( pIn3->flags & MEM_Int );
  606.     assert( p->apCsr[i]->isTable );
  607.     iKey = intToKey(pIn3->u.i);
  608.     rc = sqlite3BtreeMoveto(pCrsr, 0, 0, iKey, 0,&res);
  609.     pC->lastRowid = pIn3->u.i;
  610.     pC->rowidIsValid = res==0;
  611.     pC->nullRow = 0;
  612.     pC->cacheStatus = CACHE_STALE;
  613.     /* res might be uninitialized if rc!=SQLITE_OK.  But if rc!=SQLITE_OK
  614.     ** processing is about to abort so we really do not care whether or not
  615.     ** the following jump is taken.  (In other words, do not stress over
  616.     ** the error that valgrind sometimes shows on the next statement when
  617.     ** running ioerr.test and similar failure-recovery test scripts.) */
  618.     if( res!=0 ){
  619.       pc = pOp->p2 - 1;
  620.       assert( pC->rowidIsValid==0 );
  621.     }
  622.   }
  623.   break;
  624. }
  625. /* Opcode: Sequence P1 P2 * * *
  626. **
  627. ** Find the next available sequence number for cursor P1.
  628. ** Write the sequence number into register P2.
  629. ** The sequence number on the cursor is incremented after this
  630. ** instruction.  
  631. */
  632. case OP_Sequence: {           /* out2-prerelease */
  633.   int i = pOp->p1;
  634.   assert( i>=0 && i<p->nCursor );
  635.   assert( p->apCsr[i]!=0 );
  636.   pOut->u.i = p->apCsr[i]->seqCount++;
  637.   MemSetTypeFlag(pOut, MEM_Int);
  638.   break;
  639. }
  640. /* Opcode: NewRowid P1 P2 P3 * *
  641. **
  642. ** Get a new integer record number (a.k.a "rowid") used as the key to a table.
  643. ** The record number is not previously used as a key in the database
  644. ** table that cursor P1 points to.  The new record number is written
  645. ** written to register P2.
  646. **
  647. ** If P3>0 then P3 is a register that holds the largest previously
  648. ** generated record number.  No new record numbers are allowed to be less
  649. ** than this value.  When this value reaches its maximum, a SQLITE_FULL
  650. ** error is generated.  The P3 register is updated with the generated
  651. ** record number.  This P3 mechanism is used to help implement the
  652. ** AUTOINCREMENT feature.
  653. */
  654. case OP_NewRowid: {           /* out2-prerelease */
  655.   int i = pOp->p1;
  656.   i64 v = 0;
  657.   Cursor *pC;
  658.   assert( i>=0 && i<p->nCursor );
  659.   assert( p->apCsr[i]!=0 );
  660.   if( (pC = p->apCsr[i])->pCursor==0 ){
  661.     /* The zero initialization above is all that is needed */
  662.   }else{
  663.     /* The next rowid or record number (different terms for the same
  664.     ** thing) is obtained in a two-step algorithm.
  665.     **
  666.     ** First we attempt to find the largest existing rowid and add one
  667.     ** to that.  But if the largest existing rowid is already the maximum
  668.     ** positive integer, we have to fall through to the second
  669.     ** probabilistic algorithm
  670.     **
  671.     ** The second algorithm is to select a rowid at random and see if
  672.     ** it already exists in the table.  If it does not exist, we have
  673.     ** succeeded.  If the random rowid does exist, we select a new one
  674.     ** and try again, up to 1000 times.
  675.     **
  676.     ** For a table with less than 2 billion entries, the probability
  677.     ** of not finding a unused rowid is about 1.0e-300.  This is a 
  678.     ** non-zero probability, but it is still vanishingly small and should
  679.     ** never cause a problem.  You are much, much more likely to have a
  680.     ** hardware failure than for this algorithm to fail.
  681.     **
  682.     ** The analysis in the previous paragraph assumes that you have a good
  683.     ** source of random numbers.  Is a library function like lrand48()
  684.     ** good enough?  Maybe. Maybe not. It's hard to know whether there
  685.     ** might be subtle bugs is some implementations of lrand48() that
  686.     ** could cause problems. To avoid uncertainty, SQLite uses its own 
  687.     ** random number generator based on the RC4 algorithm.
  688.     **
  689.     ** To promote locality of reference for repetitive inserts, the
  690.     ** first few attempts at chosing a random rowid pick values just a little
  691.     ** larger than the previous rowid.  This has been shown experimentally
  692.     ** to double the speed of the COPY operation.
  693.     */
  694.     int res, rx=SQLITE_OK, cnt;
  695.     i64 x;
  696.     cnt = 0;
  697.     if( (sqlite3BtreeFlags(pC->pCursor)&(BTREE_INTKEY|BTREE_ZERODATA)) !=
  698.           BTREE_INTKEY ){
  699.       rc = SQLITE_CORRUPT_BKPT;
  700.       goto abort_due_to_error;
  701.     }
  702.     assert( (sqlite3BtreeFlags(pC->pCursor) & BTREE_INTKEY)!=0 );
  703.     assert( (sqlite3BtreeFlags(pC->pCursor) & BTREE_ZERODATA)==0 );
  704. #ifdef SQLITE_32BIT_ROWID
  705. #   define MAX_ROWID 0x7fffffff
  706. #else
  707.     /* Some compilers complain about constants of the form 0x7fffffffffffffff.
  708.     ** Others complain about 0x7ffffffffffffffffLL.  The following macro seems
  709.     ** to provide the constant while making all compilers happy.
  710.     */
  711. #   define MAX_ROWID  ( (((u64)0x7fffffff)<<32) | (u64)0xffffffff )
  712. #endif
  713.     if( !pC->useRandomRowid ){
  714.       if( pC->nextRowidValid ){
  715.         v = pC->nextRowid;
  716.       }else{
  717.         rc = sqlite3BtreeLast(pC->pCursor, &res);
  718.         if( rc!=SQLITE_OK ){
  719.           goto abort_due_to_error;
  720.         }
  721.         if( res ){
  722.           v = 1;
  723.         }else{
  724.           sqlite3BtreeKeySize(pC->pCursor, &v);
  725.           v = keyToInt(v);
  726.           if( v==MAX_ROWID ){
  727.             pC->useRandomRowid = 1;
  728.           }else{
  729.             v++;
  730.           }
  731.         }
  732.       }
  733. #ifndef SQLITE_OMIT_AUTOINCREMENT
  734.       if( pOp->p3 ){
  735.         Mem *pMem;
  736.         assert( pOp->p3>0 && pOp->p3<=p->nMem ); /* P3 is a valid memory cell */
  737.         pMem = &p->aMem[pOp->p3];
  738. REGISTER_TRACE(pOp->p3, pMem);
  739.         sqlite3VdbeMemIntegerify(pMem);
  740.         assert( (pMem->flags & MEM_Int)!=0 );  /* mem(P3) holds an integer */
  741.         if( pMem->u.i==MAX_ROWID || pC->useRandomRowid ){
  742.           rc = SQLITE_FULL;
  743.           goto abort_due_to_error;
  744.         }
  745.         if( v<pMem->u.i+1 ){
  746.           v = pMem->u.i + 1;
  747.         }
  748.         pMem->u.i = v;
  749.       }
  750. #endif
  751.       if( v<MAX_ROWID ){
  752.         pC->nextRowidValid = 1;
  753.         pC->nextRowid = v+1;
  754.       }else{
  755.         pC->nextRowidValid = 0;
  756.       }
  757.     }
  758.     if( pC->useRandomRowid ){
  759.       assert( pOp->p3==0 );  /* SQLITE_FULL must have occurred prior to this */
  760.       v = db->priorNewRowid;
  761.       cnt = 0;
  762.       do{
  763.         if( cnt==0 && (v&0xffffff)==v ){
  764.           v++;
  765.         }else{
  766.           sqlite3_randomness(sizeof(v), &v);
  767.           if( cnt<5 ) v &= 0xffffff;
  768.         }
  769.         if( v==0 ) continue;
  770.         x = intToKey(v);
  771.         rx = sqlite3BtreeMoveto(pC->pCursor, 0, 0, (u64)x, 0, &res);
  772.         cnt++;
  773.       }while( cnt<100 && rx==SQLITE_OK && res==0 );
  774.       db->priorNewRowid = v;
  775.       if( rx==SQLITE_OK && res==0 ){
  776.         rc = SQLITE_FULL;
  777.         goto abort_due_to_error;
  778.       }
  779.     }
  780.     pC->rowidIsValid = 0;
  781.     pC->deferredMoveto = 0;
  782.     pC->cacheStatus = CACHE_STALE;
  783.   }
  784.   MemSetTypeFlag(pOut, MEM_Int);
  785.   pOut->u.i = v;
  786.   break;
  787. }
  788. /* Opcode: Insert P1 P2 P3 P4 P5
  789. **
  790. ** Write an entry into the table of cursor P1.  A new entry is
  791. ** created if it doesn't already exist or the data for an existing
  792. ** entry is overwritten.  The data is the value stored register
  793. ** number P2. The key is stored in register P3. The key must
  794. ** be an integer.
  795. **
  796. ** If the OPFLAG_NCHANGE flag of P5 is set, then the row change count is
  797. ** incremented (otherwise not).  If the OPFLAG_LASTROWID flag of P5 is set,
  798. ** then rowid is stored for subsequent return by the
  799. ** sqlite3_last_insert_rowid() function (otherwise it is unmodified).
  800. **
  801. ** Parameter P4 may point to a string containing the table-name, or
  802. ** may be NULL. If it is not NULL, then the update-hook 
  803. ** (sqlite3.xUpdateCallback) is invoked following a successful insert.
  804. **
  805. ** (WARNING/TODO: If P1 is a pseudo-cursor and P2 is dynamically
  806. ** allocated, then ownership of P2 is transferred to the pseudo-cursor
  807. ** and register P2 becomes ephemeral.  If the cursor is changed, the
  808. ** value of register P2 will then change.  Make sure this does not
  809. ** cause any problems.)
  810. **
  811. ** This instruction only works on tables.  The equivalent instruction
  812. ** for indices is OP_IdxInsert.
  813. */
  814. case OP_Insert: {
  815.   Mem *pData = &p->aMem[pOp->p2];
  816.   Mem *pKey = &p->aMem[pOp->p3];
  817.   i64 iKey;   /* The integer ROWID or key for the record to be inserted */
  818.   int i = pOp->p1;
  819.   Cursor *pC;
  820.   assert( i>=0 && i<p->nCursor );
  821.   pC = p->apCsr[i];
  822.   assert( pC!=0 );
  823.   assert( pC->pCursor!=0 || pC->pseudoTable );
  824.   assert( pKey->flags & MEM_Int );
  825.   assert( pC->isTable );
  826.   REGISTER_TRACE(pOp->p2, pData);
  827.   REGISTER_TRACE(pOp->p3, pKey);
  828.   iKey = intToKey(pKey->u.i);
  829.   if( pOp->p5 & OPFLAG_NCHANGE ) p->nChange++;
  830.   if( pOp->p5 & OPFLAG_LASTROWID ) db->lastRowid = pKey->u.i;
  831.   if( pC->nextRowidValid && pKey->u.i>=pC->nextRowid ){
  832.     pC->nextRowidValid = 0;
  833.   }
  834.   if( pData->flags & MEM_Null ){
  835.     pData->z = 0;
  836.     pData->n = 0;
  837.   }else{
  838.     assert( pData->flags & (MEM_Blob|MEM_Str) );
  839.   }
  840.   if( pC->pseudoTable ){
  841.     if( !pC->ephemPseudoTable ){
  842.       sqlite3_free(pC->pData);
  843.     }
  844.     pC->iKey = iKey;
  845.     pC->nData = pData->n;
  846.     if( pData->z==pData->zMalloc || pC->ephemPseudoTable ){
  847.       pC->pData = pData->z;
  848.       if( !pC->ephemPseudoTable ){
  849.         pData->flags &= ~MEM_Dyn;
  850.         pData->flags |= MEM_Ephem;
  851.         pData->zMalloc = 0;
  852.       }
  853.     }else{
  854.       pC->pData = sqlite3_malloc( pC->nData+2 );
  855.       if( !pC->pData ) goto no_mem;
  856.       memcpy(pC->pData, pData->z, pC->nData);
  857.       pC->pData[pC->nData] = 0;
  858.       pC->pData[pC->nData+1] = 0;
  859.     }
  860.     pC->nullRow = 0;
  861.   }else{
  862.     int nZero;
  863.     if( pData->flags & MEM_Zero ){
  864.       nZero = pData->u.i;
  865.     }else{
  866.       nZero = 0;
  867.     }
  868.     rc = sqlite3BtreeInsert(pC->pCursor, 0, iKey,
  869.                             pData->z, pData->n, nZero,
  870.                             pOp->p5 & OPFLAG_APPEND);
  871.   }
  872.   
  873.   pC->rowidIsValid = 0;
  874.   pC->deferredMoveto = 0;
  875.   pC->cacheStatus = CACHE_STALE;
  876.   /* Invoke the update-hook if required. */
  877.   if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
  878.     const char *zDb = db->aDb[pC->iDb].zName;
  879.     const char *zTbl = pOp->p4.z;
  880.     int op = ((pOp->p5 & OPFLAG_ISUPDATE) ? SQLITE_UPDATE : SQLITE_INSERT);
  881.     assert( pC->isTable );
  882.     db->xUpdateCallback(db->pUpdateArg, op, zDb, zTbl, iKey);
  883.     assert( pC->iDb>=0 );
  884.   }
  885.   break;
  886. }
  887. /* Opcode: Delete P1 P2 * P4 *
  888. **
  889. ** Delete the record at which the P1 cursor is currently pointing.
  890. **
  891. ** The cursor will be left pointing at either the next or the previous
  892. ** record in the table. If it is left pointing at the next record, then
  893. ** the next Next instruction will be a no-op.  Hence it is OK to delete
  894. ** a record from within an Next loop.
  895. **
  896. ** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
  897. ** incremented (otherwise not).
  898. **
  899. ** P1 must not be pseudo-table.  It has to be a real table with
  900. ** multiple rows.
  901. **
  902. ** If P4 is not NULL, then it is the name of the table that P1 is
  903. ** pointing to.  The update hook will be invoked, if it exists.
  904. ** If P4 is not NULL then the P1 cursor must have been positioned
  905. ** using OP_NotFound prior to invoking this opcode.
  906. */
  907. case OP_Delete: {
  908.   int i = pOp->p1;
  909.   i64 iKey;
  910.   Cursor *pC;
  911.   assert( i>=0 && i<p->nCursor );
  912.   pC = p->apCsr[i];
  913.   assert( pC!=0 );
  914.   assert( pC->pCursor!=0 );  /* Only valid for real tables, no pseudotables */
  915.   /* If the update-hook will be invoked, set iKey to the rowid of the
  916.   ** row being deleted.
  917.   */
  918.   if( db->xUpdateCallback && pOp->p4.z ){
  919.     assert( pC->isTable );
  920.     assert( pC->rowidIsValid );  /* lastRowid set by previous OP_NotFound */
  921.     iKey = pC->lastRowid;
  922.   }
  923.   rc = sqlite3VdbeCursorMoveto(pC);
  924.   if( rc ) goto abort_due_to_error;
  925.   rc = sqlite3BtreeDelete(pC->pCursor);
  926.   pC->nextRowidValid = 0;
  927.   pC->cacheStatus = CACHE_STALE;
  928.   /* Invoke the update-hook if required. */
  929.   if( rc==SQLITE_OK && db->xUpdateCallback && pOp->p4.z ){
  930.     const char *zDb = db->aDb[pC->iDb].zName;
  931.     const char *zTbl = pOp->p4.z;
  932.     db->xUpdateCallback(db->pUpdateArg, SQLITE_DELETE, zDb, zTbl, iKey);
  933.     assert( pC->iDb>=0 );
  934.   }
  935.   if( pOp->p2 & OPFLAG_NCHANGE ) p->nChange++;
  936.   break;
  937. }
  938. /* Opcode: ResetCount P1 * *
  939. **
  940. ** This opcode resets the VMs internal change counter to 0. If P1 is true,
  941. ** then the value of the change counter is copied to the database handle
  942. ** change counter (returned by subsequent calls to sqlite3_changes())
  943. ** before it is reset. This is used by trigger programs.
  944. */
  945. case OP_ResetCount: {
  946.   if( pOp->p1 ){
  947.     sqlite3VdbeSetChanges(db, p->nChange);
  948.   }
  949.   p->nChange = 0;
  950.   break;
  951. }
  952. /* Opcode: RowData P1 P2 * * *
  953. **
  954. ** Write into register P2 the complete row data for cursor P1.
  955. ** There is no interpretation of the data.  
  956. ** It is just copied onto the P2 register exactly as 
  957. ** it is found in the database file.
  958. **
  959. ** If the P1 cursor must be pointing to a valid row (not a NULL row)
  960. ** of a real table, not a pseudo-table.
  961. */
  962. /* Opcode: RowKey P1 P2 * * *
  963. **
  964. ** Write into register P2 the complete row key for cursor P1.
  965. ** There is no interpretation of the data.  
  966. ** The key is copied onto the P3 register exactly as 
  967. ** it is found in the database file.
  968. **
  969. ** If the P1 cursor must be pointing to a valid row (not a NULL row)
  970. ** of a real table, not a pseudo-table.
  971. */
  972. case OP_RowKey:
  973. case OP_RowData: {
  974.   int i = pOp->p1;
  975.   Cursor *pC;
  976.   BtCursor *pCrsr;
  977.   u32 n;
  978.   pOut = &p->aMem[pOp->p2];
  979.   /* Note that RowKey and RowData are really exactly the same instruction */
  980.   assert( i>=0 && i<p->nCursor );
  981.   pC = p->apCsr[i];
  982.   assert( pC->isTable || pOp->opcode==OP_RowKey );
  983.   assert( pC->isIndex || pOp->opcode==OP_RowData );
  984.   assert( pC!=0 );
  985.   assert( pC->nullRow==0 );
  986.   assert( pC->pseudoTable==0 );
  987.   assert( pC->pCursor!=0 );
  988.   pCrsr = pC->pCursor;
  989.   rc = sqlite3VdbeCursorMoveto(pC);
  990.   if( rc ) goto abort_due_to_error;
  991.   if( pC->isIndex ){
  992.     i64 n64;
  993.     assert( !pC->isTable );
  994.     sqlite3BtreeKeySize(pCrsr, &n64);
  995.     if( n64>db->aLimit[SQLITE_LIMIT_LENGTH] ){
  996.       goto too_big;
  997.     }
  998.     n = n64;
  999.   }else{
  1000.     sqlite3BtreeDataSize(pCrsr, &n);
  1001.     if( n>db->aLimit[SQLITE_LIMIT_LENGTH] ){
  1002.       goto too_big;
  1003.     }
  1004.   }
  1005.   if( sqlite3VdbeMemGrow(pOut, n, 0) ){
  1006.     goto no_mem;
  1007.   }
  1008.   pOut->n = n;
  1009.   MemSetTypeFlag(pOut, MEM_Blob);
  1010.   if( pC->isIndex ){
  1011.     rc = sqlite3BtreeKey(pCrsr, 0, n, pOut->z);
  1012.   }else{
  1013.     rc = sqlite3BtreeData(pCrsr, 0, n, pOut->z);
  1014.   }
  1015.   pOut->enc = SQLITE_UTF8;  /* In case the blob is ever cast to text */
  1016.   UPDATE_MAX_BLOBSIZE(pOut);
  1017.   break;
  1018. }
  1019. /* Opcode: Rowid P1 P2 * * *
  1020. **
  1021. ** Store in register P2 an integer which is the key of the table entry that
  1022. ** P1 is currently point to.  If p2==0 then push the integer.
  1023. */
  1024. case OP_Rowid: {                 /* out2-prerelease */
  1025.   int i = pOp->p1;
  1026.   Cursor *pC;
  1027.   i64 v;
  1028.   assert( i>=0 && i<p->nCursor );
  1029.   pC = p->apCsr[i];
  1030.   assert( pC!=0 );
  1031.   rc = sqlite3VdbeCursorMoveto(pC);
  1032.   if( rc ) goto abort_due_to_error;
  1033.   if( pC->rowidIsValid ){
  1034.     v = pC->lastRowid;
  1035.   }else if( pC->pseudoTable ){
  1036.     v = keyToInt(pC->iKey);
  1037.   }else if( pC->nullRow ){
  1038.     /* Leave the rowid set to a NULL */
  1039.     break;
  1040.   }else{
  1041.     assert( pC->pCursor!=0 );
  1042.     sqlite3BtreeKeySize(pC->pCursor, &v);
  1043.     v = keyToInt(v);
  1044.   }
  1045.   pOut->u.i = v;
  1046.   MemSetTypeFlag(pOut, MEM_Int);
  1047.   break;
  1048. }
  1049. /* Opcode: NullRow P1 * * * *
  1050. **
  1051. ** Move the cursor P1 to a null row.  Any OP_Column operations
  1052. ** that occur while the cursor is on the null row will always
  1053. ** write a NULL.
  1054. */
  1055. case OP_NullRow: {
  1056.   int i = pOp->p1;
  1057.   Cursor *pC;
  1058.   assert( i>=0 && i<p->nCursor );
  1059.   pC = p->apCsr[i];
  1060.   assert( pC!=0 );
  1061.   pC->nullRow = 1;
  1062.   pC->rowidIsValid = 0;
  1063.   break;
  1064. }
  1065. /* Opcode: Last P1 P2 * * *
  1066. **
  1067. ** The next use of the Rowid or Column or Next instruction for P1 
  1068. ** will refer to the last entry in the database table or index.
  1069. ** If the table or index is empty and P2>0, then jump immediately to P2.
  1070. ** If P2 is 0 or if the table or index is not empty, fall through
  1071. ** to the following instruction.
  1072. */
  1073. case OP_Last: {        /* jump */
  1074.   int i = pOp->p1;
  1075.   Cursor *pC;
  1076.   BtCursor *pCrsr;
  1077.   int res;
  1078.   assert( i>=0 && i<p->nCursor );
  1079.   pC = p->apCsr[i];
  1080.   assert( pC!=0 );
  1081.   pCrsr = pC->pCursor;
  1082.   assert( pCrsr!=0 );
  1083.   rc = sqlite3BtreeLast(pCrsr, &res);
  1084.   pC->nullRow = res;
  1085.   pC->deferredMoveto = 0;
  1086.   pC->cacheStatus = CACHE_STALE;
  1087.   if( res && pOp->p2>0 ){
  1088.     pc = pOp->p2 - 1;
  1089.   }
  1090.   break;
  1091. }
  1092. /* Opcode: Sort P1 P2 * * *
  1093. **
  1094. ** This opcode does exactly the same thing as OP_Rewind except that
  1095. ** it increments an undocumented global variable used for testing.
  1096. **
  1097. ** Sorting is accomplished by writing records into a sorting index,
  1098. ** then rewinding that index and playing it back from beginning to
  1099. ** end.  We use the OP_Sort opcode instead of OP_Rewind to do the
  1100. ** rewinding so that the global variable will be incremented and
  1101. ** regression tests can determine whether or not the optimizer is
  1102. ** correctly optimizing out sorts.
  1103. */
  1104. case OP_Sort: {        /* jump */
  1105. #ifdef SQLITE_TEST
  1106.   sqlite3_sort_count++;
  1107.   sqlite3_search_count--;
  1108. #endif
  1109.   /* Fall through into OP_Rewind */
  1110. }
  1111. /* Opcode: Rewind P1 P2 * * *
  1112. **
  1113. ** The next use of the Rowid or Column or Next instruction for P1 
  1114. ** will refer to the first entry in the database table or index.
  1115. ** If the table or index is empty and P2>0, then jump immediately to P2.
  1116. ** If P2 is 0 or if the table or index is not empty, fall through
  1117. ** to the following instruction.
  1118. */
  1119. case OP_Rewind: {        /* jump */
  1120.   int i = pOp->p1;
  1121.   Cursor *pC;
  1122.   BtCursor *pCrsr;
  1123.   int res;
  1124.   assert( i>=0 && i<p->nCursor );
  1125.   pC = p->apCsr[i];
  1126.   assert( pC!=0 );
  1127.   if( (pCrsr = pC->pCursor)!=0 ){
  1128.     rc = sqlite3BtreeFirst(pCrsr, &res);
  1129.     pC->atFirst = res==0;
  1130.     pC->deferredMoveto = 0;
  1131.     pC->cacheStatus = CACHE_STALE;
  1132.   }else{
  1133.     res = 1;
  1134.   }
  1135.   pC->nullRow = res;
  1136.   assert( pOp->p2>0 && pOp->p2<p->nOp );
  1137.   if( res ){
  1138.     pc = pOp->p2 - 1;
  1139.   }
  1140.   break;
  1141. }
  1142. /* Opcode: Next P1 P2 * * *
  1143. **
  1144. ** Advance cursor P1 so that it points to the next key/data pair in its
  1145. ** table or index.  If there are no more key/value pairs then fall through
  1146. ** to the following instruction.  But if the cursor advance was successful,
  1147. ** jump immediately to P2.
  1148. **
  1149. ** The P1 cursor must be for a real table, not a pseudo-table.
  1150. **
  1151. ** See also: Prev
  1152. */
  1153. /* Opcode: Prev P1 P2 * * *
  1154. **
  1155. ** Back up cursor P1 so that it points to the previous key/data pair in its
  1156. ** table or index.  If there is no previous key/value pairs then fall through
  1157. ** to the following instruction.  But if the cursor backup was successful,
  1158. ** jump immediately to P2.
  1159. **
  1160. ** The P1 cursor must be for a real table, not a pseudo-table.
  1161. */
  1162. case OP_Prev:          /* jump */
  1163. case OP_Next: {        /* jump */
  1164.   Cursor *pC;
  1165.   BtCursor *pCrsr;
  1166.   CHECK_FOR_INTERRUPT;
  1167.   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
  1168.   pC = p->apCsr[pOp->p1];
  1169.   if( pC==0 ){
  1170.     break;  /* See ticket #2273 */
  1171.   }
  1172.   pCrsr = pC->pCursor;
  1173.   assert( pCrsr );
  1174.   if( pC->nullRow==0 ){
  1175.     int res = 1;
  1176.     assert( pC->deferredMoveto==0 );
  1177.     rc = pOp->opcode==OP_Next ? sqlite3BtreeNext(pCrsr, &res) :
  1178.                                 sqlite3BtreePrevious(pCrsr, &res);
  1179.     pC->nullRow = res;
  1180.     pC->cacheStatus = CACHE_STALE;
  1181.     if( res==0 ){
  1182.       pc = pOp->p2 - 1;
  1183. #ifdef SQLITE_TEST
  1184.       sqlite3_search_count++;
  1185. #endif
  1186.     }
  1187.   }
  1188.   pC->rowidIsValid = 0;
  1189.   break;
  1190. }
  1191. /* Opcode: IdxInsert P1 P2 P3 * *
  1192. **
  1193. ** Register P2 holds a SQL index key made using the
  1194. ** MakeIdxRec instructions.  This opcode writes that key
  1195. ** into the index P1.  Data for the entry is nil.
  1196. **
  1197. ** P3 is a flag that provides a hint to the b-tree layer that this
  1198. ** insert is likely to be an append.
  1199. **
  1200. ** This instruction only works for indices.  The equivalent instruction
  1201. ** for tables is OP_Insert.
  1202. */
  1203. case OP_IdxInsert: {        /* in2 */
  1204.   int i = pOp->p1;
  1205.   Cursor *pC;
  1206.   BtCursor *pCrsr;
  1207.   assert( i>=0 && i<p->nCursor );
  1208.   assert( p->apCsr[i]!=0 );
  1209.   assert( pIn2->flags & MEM_Blob );
  1210.   if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
  1211.     assert( pC->isTable==0 );
  1212.     rc = ExpandBlob(pIn2);
  1213.     if( rc==SQLITE_OK ){
  1214.       int nKey = pIn2->n;
  1215.       const char *zKey = pIn2->z;
  1216.       rc = sqlite3BtreeInsert(pCrsr, zKey, nKey, "", 0, 0, pOp->p3);
  1217.       assert( pC->deferredMoveto==0 );
  1218.       pC->cacheStatus = CACHE_STALE;
  1219.     }
  1220.   }
  1221.   break;
  1222. }
  1223. /* Opcode: IdxDeleteM P1 P2 P3 * *
  1224. **
  1225. ** The content of P3 registers starting at register P2 form
  1226. ** an unpacked index key. This opcode removes that entry from the 
  1227. ** index opened by cursor P1.
  1228. */
  1229. case OP_IdxDelete: {
  1230.   int i = pOp->p1;
  1231.   Cursor *pC;
  1232.   BtCursor *pCrsr;
  1233.   assert( pOp->p3>0 );
  1234.   assert( pOp->p2>0 && pOp->p2+pOp->p3<=p->nMem );
  1235.   assert( i>=0 && i<p->nCursor );
  1236.   assert( p->apCsr[i]!=0 );
  1237.   if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
  1238.     int res;
  1239.     UnpackedRecord r;
  1240.     r.pKeyInfo = pC->pKeyInfo;
  1241.     r.nField = pOp->p3;
  1242.     r.needFree = 0;
  1243.     r.needDestroy = 0;
  1244.     r.aMem = &p->aMem[pOp->p2];
  1245.     rc = sqlite3BtreeMoveto(pCrsr, 0, &r, 0, 0, &res);
  1246.     if( rc==SQLITE_OK && res==0 ){
  1247.       rc = sqlite3BtreeDelete(pCrsr);
  1248.     }
  1249.     assert( pC->deferredMoveto==0 );
  1250.     pC->cacheStatus = CACHE_STALE;
  1251.   }
  1252.   break;
  1253. }
  1254. /* Opcode: IdxRowid P1 P2 * * *
  1255. **
  1256. ** Write into register P2 an integer which is the last entry in the record at
  1257. ** the end of the index key pointed to by cursor P1.  This integer should be
  1258. ** the rowid of the table entry to which this index entry points.
  1259. **
  1260. ** See also: Rowid, MakeIdxRec.
  1261. */
  1262. case OP_IdxRowid: {              /* out2-prerelease */
  1263.   int i = pOp->p1;
  1264.   BtCursor *pCrsr;
  1265.   Cursor *pC;
  1266.   assert( i>=0 && i<p->nCursor );
  1267.   assert( p->apCsr[i]!=0 );
  1268.   if( (pCrsr = (pC = p->apCsr[i])->pCursor)!=0 ){
  1269.     i64 rowid;
  1270.     assert( pC->deferredMoveto==0 );
  1271.     assert( pC->isTable==0 );
  1272.     if( !pC->nullRow ){
  1273.       rc = sqlite3VdbeIdxRowid(pCrsr, &rowid);
  1274.       if( rc!=SQLITE_OK ){
  1275.         goto abort_due_to_error;
  1276.       }
  1277.       MemSetTypeFlag(pOut, MEM_Int);
  1278.       pOut->u.i = rowid;
  1279.     }
  1280.   }
  1281.   break;
  1282. }
  1283. /* Opcode: IdxGE P1 P2 P3 * P5
  1284. **
  1285. ** The value in register P3 is an index entry that omits the ROWID.  Compare
  1286. ** this value against the index that P1 is currently pointing to.
  1287. ** Ignore the ROWID on the P1 index.
  1288. **
  1289. ** If the P1 index entry is greater than or equal to the value in 
  1290. ** register P3 then jump to P2.  Otherwise fall through to the next 
  1291. ** instruction.
  1292. **
  1293. ** If P5 is non-zero then the value in register P3 is temporarily
  1294. ** increased by an epsilon prior to the comparison.  This make the opcode work
  1295. ** like IdxGT except that if the key from register P3 is a prefix of
  1296. ** the key in the cursor, the result is false whereas it would be
  1297. ** true with IdxGT.
  1298. */
  1299. /* Opcode: IdxLT P1 P2 P3 * P5
  1300. **
  1301. ** The value in register P3 is an index entry that omits the ROWID.  Compare
  1302. ** the this value against the index that P1 is currently pointing to.
  1303. ** Ignore the ROWID on the P1 index.
  1304. **
  1305. ** If the P1 index entry is less than the register P3 value
  1306. ** then jump to P2.  Otherwise fall through to the next instruction.
  1307. **
  1308. ** If P5 is non-zero then the
  1309. ** index taken from register P3 is temporarily increased by
  1310. ** an epsilon prior to the comparison.  This makes the opcode work
  1311. ** like IdxLE.
  1312. */
  1313. case OP_IdxLT:          /* jump, in3 */
  1314. case OP_IdxGE: {        /* jump, in3 */
  1315.   int i= pOp->p1;
  1316.   Cursor *pC;
  1317.   assert( i>=0 && i<p->nCursor );
  1318.   assert( p->apCsr[i]!=0 );
  1319.   if( (pC = p->apCsr[i])->pCursor!=0 ){
  1320.     int res;
  1321.  
  1322.     assert( pIn3->flags & MEM_Blob );  /* Created using OP_MakeRecord */
  1323.     assert( pC->deferredMoveto==0 );
  1324.     ExpandBlob(pIn3);
  1325.     assert( pOp->p5==0 || pOp->p5==1 );
  1326.     *pC->pIncrKey = pOp->p5;
  1327.     rc = sqlite3VdbeIdxKeyCompare(pC, pIn3->n, (u8*)pIn3->z, &res);
  1328.     *pC->pIncrKey = 0;
  1329.     if( rc!=SQLITE_OK ){
  1330.       break;
  1331.     }
  1332.     if( pOp->opcode==OP_IdxLT ){
  1333.       res = -res;
  1334.     }else{
  1335.       assert( pOp->opcode==OP_IdxGE );
  1336.       res++;
  1337.     }
  1338.     if( res>0 ){
  1339.       pc = pOp->p2 - 1 ;
  1340.     }
  1341.   }
  1342.   break;
  1343. }
  1344. /* Opcode: Destroy P1 P2 P3 * *
  1345. **
  1346. ** Delete an entire database table or index whose root page in the database
  1347. ** file is given by P1.
  1348. **
  1349. ** The table being destroyed is in the main database file if P3==0.  If
  1350. ** P3==1 then the table to be clear is in the auxiliary database file
  1351. ** that is used to store tables create using CREATE TEMPORARY TABLE.
  1352. **
  1353. ** If AUTOVACUUM is enabled then it is possible that another root page
  1354. ** might be moved into the newly deleted root page in order to keep all
  1355. ** root pages contiguous at the beginning of the database.  The former
  1356. ** value of the root page that moved - its value before the move occurred -
  1357. ** is stored in register P2.  If no page 
  1358. ** movement was required (because the table being dropped was already 
  1359. ** the last one in the database) then a zero is stored in register P2.
  1360. ** If AUTOVACUUM is disabled then a zero is stored in register P2.
  1361. **
  1362. ** See also: Clear
  1363. */
  1364. case OP_Destroy: {     /* out2-prerelease */
  1365.   int iMoved;
  1366.   int iCnt;
  1367. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1368.   Vdbe *pVdbe;
  1369.   iCnt = 0;
  1370.   for(pVdbe=db->pVdbe; pVdbe; pVdbe=pVdbe->pNext){
  1371.     if( pVdbe->magic==VDBE_MAGIC_RUN && pVdbe->inVtabMethod<2 && pVdbe->pc>=0 ){
  1372.       iCnt++;
  1373.     }
  1374.   }
  1375. #else
  1376.   iCnt = db->activeVdbeCnt;
  1377. #endif
  1378.   if( iCnt>1 ){
  1379.     rc = SQLITE_LOCKED;
  1380.     p->errorAction = OE_Abort;
  1381.   }else{
  1382.     int iDb = pOp->p3;
  1383.     assert( iCnt==1 );
  1384.     assert( (p->btreeMask & (1<<iDb))!=0 );
  1385.     rc = sqlite3BtreeDropTable(db->aDb[iDb].pBt, pOp->p1, &iMoved);
  1386.     MemSetTypeFlag(pOut, MEM_Int);
  1387.     pOut->u.i = iMoved;
  1388. #ifndef SQLITE_OMIT_AUTOVACUUM
  1389.     if( rc==SQLITE_OK && iMoved!=0 ){
  1390.       sqlite3RootPageMoved(&db->aDb[iDb], iMoved, pOp->p1);
  1391.     }
  1392. #endif
  1393.   }
  1394.   break;
  1395. }
  1396. /* Opcode: Clear P1 P2 *
  1397. **
  1398. ** Delete all contents of the database table or index whose root page
  1399. ** in the database file is given by P1.  But, unlike Destroy, do not
  1400. ** remove the table or index from the database file.
  1401. **
  1402. ** The table being clear is in the main database file if P2==0.  If
  1403. ** P2==1 then the table to be clear is in the auxiliary database file
  1404. ** that is used to store tables create using CREATE TEMPORARY TABLE.
  1405. **
  1406. ** See also: Destroy
  1407. */
  1408. case OP_Clear: {
  1409.   assert( (p->btreeMask & (1<<pOp->p2))!=0 );
  1410.   rc = sqlite3BtreeClearTable(db->aDb[pOp->p2].pBt, pOp->p1);
  1411.   break;
  1412. }
  1413. /* Opcode: CreateTable P1 P2 * * *
  1414. **
  1415. ** Allocate a new table in the main database file if P1==0 or in the
  1416. ** auxiliary database file if P1==1 or in an attached database if
  1417. ** P1>1.  Write the root page number of the new table into
  1418. ** register P2
  1419. **
  1420. ** The difference between a table and an index is this:  A table must
  1421. ** have a 4-byte integer key and can have arbitrary data.  An index
  1422. ** has an arbitrary key but no data.
  1423. **
  1424. ** See also: CreateIndex
  1425. */
  1426. /* Opcode: CreateIndex P1 P2 * * *
  1427. **
  1428. ** Allocate a new index in the main database file if P1==0 or in the
  1429. ** auxiliary database file if P1==1 or in an attached database if
  1430. ** P1>1.  Write the root page number of the new table into
  1431. ** register P2.
  1432. **
  1433. ** See documentation on OP_CreateTable for additional information.
  1434. */
  1435. case OP_CreateIndex:            /* out2-prerelease */
  1436. case OP_CreateTable: {          /* out2-prerelease */
  1437.   int pgno;
  1438.   int flags;
  1439.   Db *pDb;
  1440.   assert( pOp->p1>=0 && pOp->p1<db->nDb );
  1441.   assert( (p->btreeMask & (1<<pOp->p1))!=0 );
  1442.   pDb = &db->aDb[pOp->p1];
  1443.   assert( pDb->pBt!=0 );
  1444.   if( pOp->opcode==OP_CreateTable ){
  1445.     /* flags = BTREE_INTKEY; */
  1446.     flags = BTREE_LEAFDATA|BTREE_INTKEY;
  1447.   }else{
  1448.     flags = BTREE_ZERODATA;
  1449.   }
  1450.   rc = sqlite3BtreeCreateTable(pDb->pBt, &pgno, flags);
  1451.   if( rc==SQLITE_OK ){
  1452.     pOut->u.i = pgno;
  1453.     MemSetTypeFlag(pOut, MEM_Int);
  1454.   }
  1455.   break;
  1456. }
  1457. /* Opcode: ParseSchema P1 P2 * P4 *
  1458. **
  1459. ** Read and parse all entries from the SQLITE_MASTER table of database P1
  1460. ** that match the WHERE clause P4.  P2 is the "force" flag.   Always do
  1461. ** the parsing if P2 is true.  If P2 is false, then this routine is a
  1462. ** no-op if the schema is not currently loaded.  In other words, if P2
  1463. ** is false, the SQLITE_MASTER table is only parsed if the rest of the
  1464. ** schema is already loaded into the symbol table.
  1465. **
  1466. ** This opcode invokes the parser to create a new virtual machine,
  1467. ** then runs the new virtual machine.  It is thus a reentrant opcode.
  1468. */
  1469. case OP_ParseSchema: {
  1470.   char *zSql;
  1471.   int iDb = pOp->p1;
  1472.   const char *zMaster;
  1473.   InitData initData;
  1474.   assert( iDb>=0 && iDb<db->nDb );
  1475.   if( !pOp->p2 && !DbHasProperty(db, iDb, DB_SchemaLoaded) ){
  1476.     break;
  1477.   }
  1478.   zMaster = SCHEMA_TABLE(iDb);
  1479.   initData.db = db;
  1480.   initData.iDb = pOp->p1;
  1481.   initData.pzErrMsg = &p->zErrMsg;
  1482.   zSql = sqlite3MPrintf(db,
  1483.      "SELECT name, rootpage, sql FROM '%q'.%s WHERE %s",
  1484.      db->aDb[iDb].zName, zMaster, pOp->p4.z);
  1485.   if( zSql==0 ) goto no_mem;
  1486.   (void)sqlite3SafetyOff(db);
  1487.   assert( db->init.busy==0 );
  1488.   db->init.busy = 1;
  1489.   assert( !db->mallocFailed );
  1490.   rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
  1491.   if( rc==SQLITE_ABORT ) rc = initData.rc;
  1492.   sqlite3_free(zSql);
  1493.   db->init.busy = 0;
  1494.   (void)sqlite3SafetyOn(db);
  1495.   if( rc==SQLITE_NOMEM ){
  1496.     goto no_mem;
  1497.   }
  1498.   break;  
  1499. }
  1500. #if !defined(SQLITE_OMIT_ANALYZE) && !defined(SQLITE_OMIT_PARSER)
  1501. /* Opcode: LoadAnalysis P1 * * * *
  1502. **
  1503. ** Read the sqlite_stat1 table for database P1 and load the content
  1504. ** of that table into the internal index hash table.  This will cause
  1505. ** the analysis to be used when preparing all subsequent queries.
  1506. */
  1507. case OP_LoadAnalysis: {
  1508.   int iDb = pOp->p1;
  1509.   assert( iDb>=0 && iDb<db->nDb );
  1510.   rc = sqlite3AnalysisLoad(db, iDb);
  1511.   break;  
  1512. }
  1513. #endif /* !defined(SQLITE_OMIT_ANALYZE) && !defined(SQLITE_OMIT_PARSER)  */
  1514. /* Opcode: DropTable P1 * * P4 *
  1515. **
  1516. ** Remove the internal (in-memory) data structures that describe
  1517. ** the table named P4 in database P1.  This is called after a table
  1518. ** is dropped in order to keep the internal representation of the
  1519. ** schema consistent with what is on disk.
  1520. */
  1521. case OP_DropTable: {
  1522.   sqlite3UnlinkAndDeleteTable(db, pOp->p1, pOp->p4.z);
  1523.   break;
  1524. }
  1525. /* Opcode: DropIndex P1 * * P4 *
  1526. **
  1527. ** Remove the internal (in-memory) data structures that describe
  1528. ** the index named P4 in database P1.  This is called after an index
  1529. ** is dropped in order to keep the internal representation of the
  1530. ** schema consistent with what is on disk.
  1531. */
  1532. case OP_DropIndex: {
  1533.   sqlite3UnlinkAndDeleteIndex(db, pOp->p1, pOp->p4.z);
  1534.   break;
  1535. }
  1536. /* Opcode: DropTrigger P1 * * P4 *
  1537. **
  1538. ** Remove the internal (in-memory) data structures that describe
  1539. ** the trigger named P4 in database P1.  This is called after a trigger
  1540. ** is dropped in order to keep the internal representation of the
  1541. ** schema consistent with what is on disk.
  1542. */
  1543. case OP_DropTrigger: {
  1544.   sqlite3UnlinkAndDeleteTrigger(db, pOp->p1, pOp->p4.z);
  1545.   break;
  1546. }
  1547. #ifndef SQLITE_OMIT_INTEGRITY_CHECK
  1548. /* Opcode: IntegrityCk P1 P2 P3 * P5
  1549. **
  1550. ** Do an analysis of the currently open database.  Store in
  1551. ** register P1 the text of an error message describing any problems.
  1552. ** If no problems are found, store a NULL in register P1.
  1553. **
  1554. ** The register P3 contains the maximum number of allowed errors.
  1555. ** At most reg(P3) errors will be reported.
  1556. ** In other words, the analysis stops as soon as reg(P1) errors are 
  1557. ** seen.  Reg(P1) is updated with the number of errors remaining.
  1558. **
  1559. ** The root page numbers of all tables in the database are integer
  1560. ** stored in reg(P1), reg(P1+1), reg(P1+2), ....  There are P2 tables
  1561. ** total.
  1562. **
  1563. ** If P5 is not zero, the check is done on the auxiliary database
  1564. ** file, not the main database file.
  1565. **
  1566. ** This opcode is used to implement the integrity_check pragma.
  1567. */
  1568. case OP_IntegrityCk: {
  1569.   int nRoot;      /* Number of tables to check.  (Number of root pages.) */
  1570.   int *aRoot;     /* Array of rootpage numbers for tables to be checked */
  1571.   int j;          /* Loop counter */
  1572.   int nErr;       /* Number of errors reported */
  1573.   char *z;        /* Text of the error report */
  1574.   Mem *pnErr;     /* Register keeping track of errors remaining */
  1575.   
  1576.   nRoot = pOp->p2;
  1577.   assert( nRoot>0 );
  1578.   aRoot = sqlite3_malloc( sizeof(int)*(nRoot+1) );
  1579.   if( aRoot==0 ) goto no_mem;
  1580.   assert( pOp->p3>0 && pOp->p3<=p->nMem );
  1581.   pnErr = &p->aMem[pOp->p3];
  1582.   assert( (pnErr->flags & MEM_Int)!=0 );
  1583.   assert( (pnErr->flags & (MEM_Str|MEM_Blob))==0 );
  1584.   pIn1 = &p->aMem[pOp->p1];
  1585.   for(j=0; j<nRoot; j++){
  1586.     aRoot[j] = sqlite3VdbeIntValue(&pIn1[j]);
  1587.   }
  1588.   aRoot[j] = 0;
  1589.   assert( pOp->p5<db->nDb );
  1590.   assert( (p->btreeMask & (1<<pOp->p5))!=0 );
  1591.   z = sqlite3BtreeIntegrityCheck(db->aDb[pOp->p5].pBt, aRoot, nRoot,
  1592.                                  pnErr->u.i, &nErr);
  1593.   pnErr->u.i -= nErr;
  1594.   sqlite3VdbeMemSetNull(pIn1);
  1595.   if( nErr==0 ){
  1596.     assert( z==0 );
  1597.   }else{
  1598.     sqlite3VdbeMemSetStr(pIn1, z, -1, SQLITE_UTF8, sqlite3_free);
  1599.   }
  1600.   UPDATE_MAX_BLOBSIZE(pIn1);
  1601.   sqlite3VdbeChangeEncoding(pIn1, encoding);
  1602.   sqlite3_free(aRoot);
  1603.   break;
  1604. }
  1605. #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
  1606. /* Opcode: FifoWrite P1 * * * *
  1607. **
  1608. ** Write the integer from register P1 into the Fifo.
  1609. */
  1610. case OP_FifoWrite: {        /* in1 */
  1611.   if( sqlite3VdbeFifoPush(&p->sFifo, sqlite3VdbeIntValue(pIn1))==SQLITE_NOMEM ){
  1612.     goto no_mem;
  1613.   }
  1614.   break;
  1615. }
  1616. /* Opcode: FifoRead P1 P2 * * *
  1617. **
  1618. ** Attempt to read a single integer from the Fifo.  Store that
  1619. ** integer in register P1.
  1620. ** 
  1621. ** If the Fifo is empty jump to P2.
  1622. */
  1623. case OP_FifoRead: {         /* jump */
  1624.   CHECK_FOR_INTERRUPT;
  1625.   assert( pOp->p1>0 && pOp->p1<=p->nMem );
  1626.   pOut = &p->aMem[pOp->p1];
  1627.   MemSetTypeFlag(pOut, MEM_Int);
  1628.   if( sqlite3VdbeFifoPop(&p->sFifo, &pOut->u.i)==SQLITE_DONE ){
  1629.     pc = pOp->p2 - 1;
  1630.   }
  1631.   break;
  1632. }
  1633. #ifndef SQLITE_OMIT_TRIGGER
  1634. /* Opcode: ContextPush * * * 
  1635. **
  1636. ** Save the current Vdbe context such that it can be restored by a ContextPop
  1637. ** opcode. The context stores the last insert row id, the last statement change
  1638. ** count, and the current statement change count.
  1639. */
  1640. case OP_ContextPush: {
  1641.   int i = p->contextStackTop++;
  1642.   Context *pContext;
  1643.   assert( i>=0 );
  1644.   /* FIX ME: This should be allocated as part of the vdbe at compile-time */
  1645.   if( i>=p->contextStackDepth ){
  1646.     p->contextStackDepth = i+1;
  1647.     p->contextStack = sqlite3DbReallocOrFree(db, p->contextStack,
  1648.                                           sizeof(Context)*(i+1));
  1649.     if( p->contextStack==0 ) goto no_mem;
  1650.   }
  1651.   pContext = &p->contextStack[i];
  1652.   pContext->lastRowid = db->lastRowid;
  1653.   pContext->nChange = p->nChange;
  1654.   pContext->sFifo = p->sFifo;
  1655.   sqlite3VdbeFifoInit(&p->sFifo);
  1656.   break;
  1657. }
  1658. /* Opcode: ContextPop * * * 
  1659. **
  1660. ** Restore the Vdbe context to the state it was in when contextPush was last
  1661. ** executed. The context stores the last insert row id, the last statement
  1662. ** change count, and the current statement change count.
  1663. */
  1664. case OP_ContextPop: {
  1665.   Context *pContext = &p->contextStack[--p->contextStackTop];
  1666.   assert( p->contextStackTop>=0 );
  1667.   db->lastRowid = pContext->lastRowid;
  1668.   p->nChange = pContext->nChange;
  1669.   sqlite3VdbeFifoClear(&p->sFifo);
  1670.   p->sFifo = pContext->sFifo;
  1671.   break;
  1672. }
  1673. #endif /* #ifndef SQLITE_OMIT_TRIGGER */
  1674. #ifndef SQLITE_OMIT_AUTOINCREMENT
  1675. /* Opcode: MemMax P1 P2 * * *
  1676. **
  1677. ** Set the value of register P1 to the maximum of its current value
  1678. ** and the value in register P2.
  1679. **
  1680. ** This instruction throws an error if the memory cell is not initially
  1681. ** an integer.
  1682. */
  1683. case OP_MemMax: {        /* in1, in2 */
  1684.   sqlite3VdbeMemIntegerify(pIn1);
  1685.   sqlite3VdbeMemIntegerify(pIn2);
  1686.   if( pIn1->u.i<pIn2->u.i){
  1687.     pIn1->u.i = pIn2->u.i;
  1688.   }
  1689.   break;
  1690. }
  1691. #endif /* SQLITE_OMIT_AUTOINCREMENT */
  1692. /* Opcode: IfPos P1 P2 * * *
  1693. **
  1694. ** If the value of register P1 is 1 or greater, jump to P2.
  1695. **
  1696. ** It is illegal to use this instruction on a register that does
  1697. ** not contain an integer.  An assertion fault will result if you try.
  1698. */
  1699. case OP_IfPos: {        /* jump, in1 */
  1700.   assert( pIn1->flags&MEM_Int );
  1701.   if( pIn1->u.i>0 ){
  1702.      pc = pOp->p2 - 1;
  1703.   }
  1704.   break;
  1705. }
  1706. /* Opcode: IfNeg P1 P2 * * *
  1707. **
  1708. ** If the value of register P1 is less than zero, jump to P2. 
  1709. **
  1710. ** It is illegal to use this instruction on a register that does
  1711. ** not contain an integer.  An assertion fault will result if you try.
  1712. */
  1713. case OP_IfNeg: {        /* jump, in1 */
  1714.   assert( pIn1->flags&MEM_Int );
  1715.   if( pIn1->u.i<0 ){
  1716.      pc = pOp->p2 - 1;
  1717.   }
  1718.   break;
  1719. }
  1720. /* Opcode: IfZero P1 P2 * * *
  1721. **
  1722. ** If the value of register P1 is exactly 0, jump to P2. 
  1723. **
  1724. ** It is illegal to use this instruction on a register that does
  1725. ** not contain an integer.  An assertion fault will result if you try.
  1726. */
  1727. case OP_IfZero: {        /* jump, in1 */
  1728.   assert( pIn1->flags&MEM_Int );
  1729.   if( pIn1->u.i==0 ){
  1730.      pc = pOp->p2 - 1;
  1731.   }
  1732.   break;
  1733. }
  1734. /* Opcode: AggStep * P2 P3 P4 P5
  1735. **
  1736. ** Execute the step function for an aggregate.  The
  1737. ** function has P5 arguments.   P4 is a pointer to the FuncDef
  1738. ** structure that specifies the function.  Use register
  1739. ** P3 as the accumulator.
  1740. **
  1741. ** The P5 arguments are taken from register P2 and its
  1742. ** successors.
  1743. */
  1744. case OP_AggStep: {
  1745.   int n = pOp->p5;
  1746.   int i;
  1747.   Mem *pMem, *pRec;
  1748.   sqlite3_context ctx;
  1749.   sqlite3_value **apVal;
  1750.   assert( n>=0 );
  1751.   pRec = &p->aMem[pOp->p2];
  1752.   apVal = p->apArg;
  1753.   assert( apVal || n==0 );
  1754.   for(i=0; i<n; i++, pRec++){
  1755.     apVal[i] = pRec;
  1756.     storeTypeInfo(pRec, encoding);
  1757.   }
  1758.   ctx.pFunc = pOp->p4.pFunc;
  1759.   assert( pOp->p3>0 && pOp->p3<=p->nMem );
  1760.   ctx.pMem = pMem = &p->aMem[pOp->p3];
  1761.   pMem->n++;
  1762.   ctx.s.flags = MEM_Null;
  1763.   ctx.s.z = 0;
  1764.   ctx.s.zMalloc = 0;
  1765.   ctx.s.xDel = 0;
  1766.   ctx.s.db = db;
  1767.   ctx.isError = 0;
  1768.   ctx.pColl = 0;
  1769.   if( ctx.pFunc->needCollSeq ){
  1770.     assert( pOp>p->aOp );
  1771.     assert( pOp[-1].p4type==P4_COLLSEQ );
  1772.     assert( pOp[-1].opcode==OP_CollSeq );
  1773.     ctx.pColl = pOp[-1].p4.pColl;
  1774.   }
  1775.   (ctx.pFunc->xStep)(&ctx, n, apVal);
  1776.   if( ctx.isError ){
  1777.     sqlite3SetString(&p->zErrMsg, sqlite3_value_text(&ctx.s), (char*)0);
  1778.     rc = ctx.isError;
  1779.   }
  1780.   sqlite3VdbeMemRelease(&ctx.s);
  1781.   break;
  1782. }
  1783. /* Opcode: AggFinal P1 P2 * P4 *
  1784. **
  1785. ** Execute the finalizer function for an aggregate.  P1 is
  1786. ** the memory location that is the accumulator for the aggregate.
  1787. **
  1788. ** P2 is the number of arguments that the step function takes and
  1789. ** P4 is a pointer to the FuncDef for this function.  The P2
  1790. ** argument is not used by this opcode.  It is only there to disambiguate
  1791. ** functions that can take varying numbers of arguments.  The
  1792. ** P4 argument is only needed for the degenerate case where
  1793. ** the step function was not previously called.
  1794. */
  1795. case OP_AggFinal: {
  1796.   Mem *pMem;
  1797.   assert( pOp->p1>0 && pOp->p1<=p->nMem );
  1798.   pMem = &p->aMem[pOp->p1];
  1799.   assert( (pMem->flags & ~(MEM_Null|MEM_Agg))==0 );
  1800.   rc = sqlite3VdbeMemFinalize(pMem, pOp->p4.pFunc);
  1801.   if( rc==SQLITE_ERROR ){
  1802.     sqlite3SetString(&p->zErrMsg, sqlite3_value_text(pMem), (char*)0);
  1803.   }
  1804.   sqlite3VdbeChangeEncoding(pMem, encoding);
  1805.   UPDATE_MAX_BLOBSIZE(pMem);
  1806.   if( sqlite3VdbeMemTooBig(pMem) ){
  1807.     goto too_big;
  1808.   }
  1809.   break;
  1810. }
  1811. #if !defined(SQLITE_OMIT_VACUUM) && !defined(SQLITE_OMIT_ATTACH)
  1812. /* Opcode: Vacuum * * * * *
  1813. **
  1814. ** Vacuum the entire database.  This opcode will cause other virtual
  1815. ** machines to be created and run.  It may not be called from within
  1816. ** a transaction.
  1817. */
  1818. case OP_Vacuum: {
  1819.   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse; 
  1820.   rc = sqlite3RunVacuum(&p->zErrMsg, db);
  1821.   if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  1822.   break;
  1823. }
  1824. #endif
  1825. #if !defined(SQLITE_OMIT_AUTOVACUUM)
  1826. /* Opcode: IncrVacuum P1 P2 * * *
  1827. **
  1828. ** Perform a single step of the incremental vacuum procedure on
  1829. ** the P1 database. If the vacuum has finished, jump to instruction
  1830. ** P2. Otherwise, fall through to the next instruction.
  1831. */
  1832. case OP_IncrVacuum: {        /* jump */
  1833.   Btree *pBt;
  1834.   assert( pOp->p1>=0 && pOp->p1<db->nDb );
  1835.   assert( (p->btreeMask & (1<<pOp->p1))!=0 );
  1836.   pBt = db->aDb[pOp->p1].pBt;
  1837.   rc = sqlite3BtreeIncrVacuum(pBt);
  1838.   if( rc==SQLITE_DONE ){
  1839.     pc = pOp->p2 - 1;
  1840.     rc = SQLITE_OK;
  1841.   }
  1842.   break;
  1843. }
  1844. #endif
  1845. /* Opcode: Expire P1 * * * *
  1846. **
  1847. ** Cause precompiled statements to become expired. An expired statement
  1848. ** fails with an error code of SQLITE_SCHEMA if it is ever executed 
  1849. ** (via sqlite3_step()).
  1850. ** 
  1851. ** If P1 is 0, then all SQL statements become expired. If P1 is non-zero,
  1852. ** then only the currently executing statement is affected. 
  1853. */
  1854. case OP_Expire: {
  1855.   if( !pOp->p1 ){
  1856.     sqlite3ExpirePreparedStatements(db);
  1857.   }else{
  1858.     p->expired = 1;
  1859.   }
  1860.   break;
  1861. }
  1862. #ifndef SQLITE_OMIT_SHARED_CACHE
  1863. /* Opcode: TableLock P1 P2 P3 P4 *
  1864. **
  1865. ** Obtain a lock on a particular table. This instruction is only used when
  1866. ** the shared-cache feature is enabled. 
  1867. **
  1868. ** If P1 is  the index of the database in sqlite3.aDb[] of the database
  1869. ** on which the lock is acquired.  A readlock is obtained if P3==0 or
  1870. ** a write lock if P3==1.
  1871. **
  1872. ** P2 contains the root-page of the table to lock.
  1873. **
  1874. ** P4 contains a pointer to the name of the table being locked. This is only
  1875. ** used to generate an error message if the lock cannot be obtained.
  1876. */
  1877. case OP_TableLock: {
  1878.   int p1 = pOp->p1; 
  1879.   u8 isWriteLock = pOp->p3;
  1880.   assert( p1>=0 && p1<db->nDb );
  1881.   assert( (p->btreeMask & (1<<p1))!=0 );
  1882.   assert( isWriteLock==0 || isWriteLock==1 );
  1883.   rc = sqlite3BtreeLockTable(db->aDb[p1].pBt, pOp->p2, isWriteLock);
  1884.   if( rc==SQLITE_LOCKED ){
  1885.     const char *z = pOp->p4.z;
  1886.     sqlite3SetString(&p->zErrMsg, "database table is locked: ", z, (char*)0);
  1887.   }
  1888.   break;
  1889. }
  1890. #endif /* SQLITE_OMIT_SHARED_CACHE */
  1891. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1892. /* Opcode: VBegin * * * P4 *
  1893. **
  1894. ** P4 a pointer to an sqlite3_vtab structure. Call the xBegin method 
  1895. ** for that table.
  1896. */
  1897. case OP_VBegin: {
  1898.   rc = sqlite3VtabBegin(db, pOp->p4.pVtab);
  1899.   break;
  1900. }
  1901. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  1902. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1903. /* Opcode: VCreate P1 * * P4 *
  1904. **
  1905. ** P4 is the name of a virtual table in database P1. Call the xCreate method
  1906. ** for that table.
  1907. */
  1908. case OP_VCreate: {
  1909.   rc = sqlite3VtabCallCreate(db, pOp->p1, pOp->p4.z, &p->zErrMsg);
  1910.   break;
  1911. }
  1912. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  1913. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1914. /* Opcode: VDestroy P1 * * P4 *
  1915. **
  1916. ** P4 is the name of a virtual table in database P1.  Call the xDestroy method
  1917. ** of that table.
  1918. */
  1919. case OP_VDestroy: {
  1920.   p->inVtabMethod = 2;
  1921.   rc = sqlite3VtabCallDestroy(db, pOp->p1, pOp->p4.z);
  1922.   p->inVtabMethod = 0;
  1923.   break;
  1924. }
  1925. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  1926. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1927. /* Opcode: VOpen P1 * * P4 *
  1928. **
  1929. ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
  1930. ** P1 is a cursor number.  This opcode opens a cursor to the virtual
  1931. ** table and stores that cursor in P1.
  1932. */
  1933. case OP_VOpen: {
  1934.   Cursor *pCur = 0;
  1935.   sqlite3_vtab_cursor *pVtabCursor = 0;
  1936.   sqlite3_vtab *pVtab = pOp->p4.pVtab;
  1937.   sqlite3_module *pModule = (sqlite3_module *)pVtab->pModule;
  1938.   assert(pVtab && pModule);
  1939.   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  1940.   rc = pModule->xOpen(pVtab, &pVtabCursor);
  1941.   if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  1942.   if( SQLITE_OK==rc ){
  1943.     /* Initialise sqlite3_vtab_cursor base class */
  1944.     pVtabCursor->pVtab = pVtab;
  1945.     /* Initialise vdbe cursor object */
  1946.     pCur = allocateCursor(p, pOp->p1, &pOp[-1], -1, 0);
  1947.     if( pCur ){
  1948.       pCur->pVtabCursor = pVtabCursor;
  1949.       pCur->pModule = pVtabCursor->pVtab->pModule;
  1950.     }else{
  1951.       db->mallocFailed = 1;
  1952.       pModule->xClose(pVtabCursor);
  1953.     }
  1954.   }
  1955.   break;
  1956. }
  1957. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  1958. #ifndef SQLITE_OMIT_VIRTUALTABLE
  1959. /* Opcode: VFilter P1 P2 P3 P4 *
  1960. **
  1961. ** P1 is a cursor opened using VOpen.  P2 is an address to jump to if
  1962. ** the filtered result set is empty.
  1963. **
  1964. ** P4 is either NULL or a string that was generated by the xBestIndex
  1965. ** method of the module.  The interpretation of the P4 string is left
  1966. ** to the module implementation.
  1967. **
  1968. ** This opcode invokes the xFilter method on the virtual table specified
  1969. ** by P1.  The integer query plan parameter to xFilter is stored in register
  1970. ** P3. Register P3+1 stores the argc parameter to be passed to the
  1971. ** xFilter method. Registers P3+2..P3+1+argc are the argc additional
  1972. ** parametersneath additional parameters which are passed to
  1973. ** xFilter as argv. Register P3+2 becomes argv[0] when passed to xFilter.
  1974. **
  1975. ** A jump is made to P2 if the result set after filtering would be empty.
  1976. */
  1977. case OP_VFilter: {   /* jump */
  1978.   int nArg;
  1979.   int iQuery;
  1980.   const sqlite3_module *pModule;
  1981.   Mem *pQuery = &p->aMem[pOp->p3];
  1982.   Mem *pArgc = &pQuery[1];
  1983.   Cursor *pCur = p->apCsr[pOp->p1];
  1984.   REGISTER_TRACE(pOp->p3, pQuery);
  1985.   assert( pCur->pVtabCursor );
  1986.   pModule = pCur->pVtabCursor->pVtab->pModule;
  1987.   /* Grab the index number and argc parameters */
  1988.   assert( (pQuery->flags&MEM_Int)!=0 && pArgc->flags==MEM_Int );
  1989.   nArg = pArgc->u.i;
  1990.   iQuery = pQuery->u.i;
  1991.   /* Invoke the xFilter method */
  1992.   {
  1993.     int res = 0;
  1994.     int i;
  1995.     Mem **apArg = p->apArg;
  1996.     for(i = 0; i<nArg; i++){
  1997.       apArg[i] = &pArgc[i+1];
  1998.       storeTypeInfo(apArg[i], 0);
  1999.     }
  2000.     if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  2001.     p->inVtabMethod = 1;
  2002.     rc = pModule->xFilter(pCur->pVtabCursor, iQuery, pOp->p4.z, nArg, apArg);
  2003.     p->inVtabMethod = 0;
  2004.     if( rc==SQLITE_OK ){
  2005.       res = pModule->xEof(pCur->pVtabCursor);
  2006.     }
  2007.     if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  2008.     if( res ){
  2009.       pc = pOp->p2 - 1;
  2010.     }
  2011.   }
  2012.   pCur->nullRow = 0;
  2013.   break;
  2014. }
  2015. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  2016. #ifndef SQLITE_OMIT_VIRTUALTABLE
  2017. /* Opcode: VRowid P1 P2 * * *
  2018. **
  2019. ** Store into register P2  the rowid of
  2020. ** the virtual-table that the P1 cursor is pointing to.
  2021. */
  2022. case OP_VRowid: {             /* out2-prerelease */
  2023.   const sqlite3_module *pModule;
  2024.   sqlite_int64 iRow;
  2025.   Cursor *pCur = p->apCsr[pOp->p1];
  2026.   assert( pCur->pVtabCursor );
  2027.   if( pCur->nullRow ){
  2028.     break;
  2029.   }
  2030.   pModule = pCur->pVtabCursor->pVtab->pModule;
  2031.   assert( pModule->xRowid );
  2032.   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  2033.   rc = pModule->xRowid(pCur->pVtabCursor, &iRow);
  2034.   if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  2035.   MemSetTypeFlag(pOut, MEM_Int);
  2036.   pOut->u.i = iRow;
  2037.   break;
  2038. }
  2039. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  2040. #ifndef SQLITE_OMIT_VIRTUALTABLE
  2041. /* Opcode: VColumn P1 P2 P3 * *
  2042. **
  2043. ** Store the value of the P2-th column of
  2044. ** the row of the virtual-table that the 
  2045. ** P1 cursor is pointing to into register P3.
  2046. */
  2047. case OP_VColumn: {
  2048.   const sqlite3_module *pModule;
  2049.   Mem *pDest;
  2050.   sqlite3_context sContext;
  2051.   Cursor *pCur = p->apCsr[pOp->p1];
  2052.   assert( pCur->pVtabCursor );
  2053.   assert( pOp->p3>0 && pOp->p3<=p->nMem );
  2054.   pDest = &p->aMem[pOp->p3];
  2055.   if( pCur->nullRow ){
  2056.     sqlite3VdbeMemSetNull(pDest);
  2057.     break;
  2058.   }
  2059.   pModule = pCur->pVtabCursor->pVtab->pModule;
  2060.   assert( pModule->xColumn );
  2061.   memset(&sContext, 0, sizeof(sContext));
  2062.   /* The output cell may already have a buffer allocated. Move
  2063.   ** the current contents to sContext.s so in case the user-function 
  2064.   ** can use the already allocated buffer instead of allocating a 
  2065.   ** new one.
  2066.   */
  2067.   sqlite3VdbeMemMove(&sContext.s, pDest);
  2068.   MemSetTypeFlag(&sContext.s, MEM_Null);
  2069.   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  2070.   rc = pModule->xColumn(pCur->pVtabCursor, &sContext, pOp->p2);
  2071.   /* Copy the result of the function to the P3 register. We
  2072.   ** do this regardless of whether or not an error occured to ensure any
  2073.   ** dynamic allocation in sContext.s (a Mem struct) is  released.
  2074.   */
  2075.   sqlite3VdbeChangeEncoding(&sContext.s, encoding);
  2076.   REGISTER_TRACE(pOp->p3, pDest);
  2077.   sqlite3VdbeMemMove(pDest, &sContext.s);
  2078.   UPDATE_MAX_BLOBSIZE(pDest);
  2079.   if( sqlite3SafetyOn(db) ){
  2080.     goto abort_due_to_misuse;
  2081.   }
  2082.   if( sqlite3VdbeMemTooBig(pDest) ){
  2083.     goto too_big;
  2084.   }
  2085.   break;
  2086. }
  2087. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  2088. #ifndef SQLITE_OMIT_VIRTUALTABLE
  2089. /* Opcode: VNext P1 P2 * * *
  2090. **
  2091. ** Advance virtual table P1 to the next row in its result set and
  2092. ** jump to instruction P2.  Or, if the virtual table has reached
  2093. ** the end of its result set, then fall through to the next instruction.
  2094. */
  2095. case OP_VNext: {   /* jump */
  2096.   const sqlite3_module *pModule;
  2097.   int res = 0;
  2098.   Cursor *pCur = p->apCsr[pOp->p1];
  2099.   assert( pCur->pVtabCursor );
  2100.   if( pCur->nullRow ){
  2101.     break;
  2102.   }
  2103.   pModule = pCur->pVtabCursor->pVtab->pModule;
  2104.   assert( pModule->xNext );
  2105.   /* Invoke the xNext() method of the module. There is no way for the
  2106.   ** underlying implementation to return an error if one occurs during
  2107.   ** xNext(). Instead, if an error occurs, true is returned (indicating that 
  2108.   ** data is available) and the error code returned when xColumn or
  2109.   ** some other method is next invoked on the save virtual table cursor.
  2110.   */
  2111.   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  2112.   p->inVtabMethod = 1;
  2113.   rc = pModule->xNext(pCur->pVtabCursor);
  2114.   p->inVtabMethod = 0;
  2115.   if( rc==SQLITE_OK ){
  2116.     res = pModule->xEof(pCur->pVtabCursor);
  2117.   }
  2118.   if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  2119.   if( !res ){
  2120.     /* If there is data, jump to P2 */
  2121.     pc = pOp->p2 - 1;
  2122.   }
  2123.   break;
  2124. }
  2125. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  2126. #ifndef SQLITE_OMIT_VIRTUALTABLE
  2127. /* Opcode: VRename P1 * * P4 *
  2128. **
  2129. ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
  2130. ** This opcode invokes the corresponding xRename method. The value
  2131. ** in register P1 is passed as the zName argument to the xRename method.
  2132. */
  2133. case OP_VRename: {
  2134.   sqlite3_vtab *pVtab = pOp->p4.pVtab;
  2135.   Mem *pName = &p->aMem[pOp->p1];
  2136.   assert( pVtab->pModule->xRename );
  2137.   REGISTER_TRACE(pOp->p1, pName);
  2138.   Stringify(pName, encoding);
  2139.   if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  2140.   sqlite3VtabLock(pVtab);
  2141.   rc = pVtab->pModule->xRename(pVtab, pName->z);
  2142.   sqlite3VtabUnlock(db, pVtab);
  2143.   if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  2144.   break;
  2145. }
  2146. #endif
  2147. #ifndef SQLITE_OMIT_VIRTUALTABLE
  2148. /* Opcode: VUpdate P1 P2 P3 P4 *
  2149. **
  2150. ** P4 is a pointer to a virtual table object, an sqlite3_vtab structure.
  2151. ** This opcode invokes the corresponding xUpdate method. P2 values
  2152. ** are contiguous memory cells starting at P3 to pass to the xUpdate 
  2153. ** invocation. The value in register (P3+P2-1) corresponds to the 
  2154. ** p2th element of the argv array passed to xUpdate.
  2155. **
  2156. ** The xUpdate method will do a DELETE or an INSERT or both.
  2157. ** The argv[0] element (which corresponds to memory cell P3)
  2158. ** is the rowid of a row to delete.  If argv[0] is NULL then no 
  2159. ** deletion occurs.  The argv[1] element is the rowid of the new 
  2160. ** row.  This can be NULL to have the virtual table select the new 
  2161. ** rowid for itself.  The subsequent elements in the array are 
  2162. ** the values of columns in the new row.
  2163. **
  2164. ** If P2==1 then no insert is performed.  argv[0] is the rowid of
  2165. ** a row to delete.
  2166. **
  2167. ** P1 is a boolean flag. If it is set to true and the xUpdate call
  2168. ** is successful, then the value returned by sqlite3_last_insert_rowid() 
  2169. ** is set to the value of the rowid for the row just inserted.
  2170. */
  2171. case OP_VUpdate: {
  2172.   sqlite3_vtab *pVtab = pOp->p4.pVtab;
  2173.   sqlite3_module *pModule = (sqlite3_module *)pVtab->pModule;
  2174.   int nArg = pOp->p2;
  2175.   assert( pOp->p4type==P4_VTAB );
  2176.   if( pModule->xUpdate==0 ){
  2177.     sqlite3SetString(&p->zErrMsg, "read-only table", 0);
  2178.     rc = SQLITE_ERROR;
  2179.   }else{
  2180.     int i;
  2181.     sqlite_int64 rowid;
  2182.     Mem **apArg = p->apArg;
  2183.     Mem *pX = &p->aMem[pOp->p3];
  2184.     for(i=0; i<nArg; i++){
  2185.       storeTypeInfo(pX, 0);
  2186.       apArg[i] = pX;
  2187.       pX++;
  2188.     }
  2189.     if( sqlite3SafetyOff(db) ) goto abort_due_to_misuse;
  2190.     sqlite3VtabLock(pVtab);
  2191.     rc = pModule->xUpdate(pVtab, nArg, apArg, &rowid);
  2192.     sqlite3VtabUnlock(db, pVtab);
  2193.     if( sqlite3SafetyOn(db) ) goto abort_due_to_misuse;
  2194.     if( pOp->p1 && rc==SQLITE_OK ){
  2195.       assert( nArg>1 && apArg[0] && (apArg[0]->flags&MEM_Null) );
  2196.       db->lastRowid = rowid;
  2197.     }
  2198.     p->nChange++;
  2199.   }
  2200.   break;
  2201. }
  2202. #endif /* SQLITE_OMIT_VIRTUALTABLE */
  2203. #ifndef SQLITE_OMIT_TRACE
  2204. /* Opcode: Trace * * * P4 *
  2205. **
  2206. ** If tracing is enabled (by the sqlite3_trace()) interface, then
  2207. ** the UTF-8 string contained in P4 is emitted on the trace callback.
  2208. */
  2209. case OP_Trace: {
  2210.   if( pOp->p4.z ){
  2211.     if( db->xTrace ){
  2212.       db->xTrace(db->pTraceArg, pOp->p4.z);
  2213.     }
  2214. #ifdef SQLITE_DEBUG
  2215.     if( (db->flags & SQLITE_SqlTrace)!=0 ){
  2216.       sqlite3DebugPrintf("SQL-trace: %sn", pOp->p4.z);
  2217.     }
  2218. #endif /* SQLITE_DEBUG */
  2219.   }
  2220.   break;
  2221. }
  2222. #endif
  2223. /* Opcode: Noop * * * * *
  2224. **
  2225. ** Do nothing.  This instruction is often useful as a jump
  2226. ** destination.
  2227. */
  2228. /*
  2229. ** The magic Explain opcode are only inserted when explain==2 (which
  2230. ** is to say when the EXPLAIN QUERY PLAN syntax is used.)
  2231. ** This opcode records information from the optimizer.  It is the
  2232. ** the same as a no-op.  This opcodesnever appears in a real VM program.
  2233. */
  2234. default: {          /* This is really OP_Noop and OP_Explain */
  2235.   break;
  2236. }
  2237. /*****************************************************************************
  2238. ** The cases of the switch statement above this line should all be indented
  2239. ** by 6 spaces.  But the left-most 6 spaces have been removed to improve the
  2240. ** readability.  From this point on down, the normal indentation rules are
  2241. ** restored.
  2242. *****************************************************************************/
  2243.     }
  2244. #ifdef VDBE_PROFILE
  2245.     {
  2246.       long long elapse = hwtime() - start;
  2247.       pOp->cycles += elapse;
  2248.       pOp->cnt++;
  2249. #if 0
  2250.         fprintf(stdout, "%10lld ", elapse);
  2251.         sqlite3VdbePrintOp(stdout, origPc, &p->aOp[origPc]);
  2252. #endif
  2253.     }
  2254. #endif
  2255.     /* The following code adds nothing to the actual functionality
  2256.     ** of the program.  It is only here for testing and debugging.
  2257.     ** On the other hand, it does burn CPU cycles every time through
  2258.     ** the evaluator loop.  So we can leave it out when NDEBUG is defined.
  2259.     */
  2260. #ifndef NDEBUG
  2261.     assert( pc>=-1 && pc<p->nOp );
  2262. #ifdef SQLITE_DEBUG
  2263.     if( p->trace ){
  2264.       if( rc!=0 ) fprintf(p->trace,"rc=%dn",rc);
  2265.       if( opProperty & OPFLG_OUT2_PRERELEASE ){
  2266.         registerTrace(p->trace, pOp->p2, pOut);
  2267.       }
  2268.       if( opProperty & OPFLG_OUT3 ){
  2269.         registerTrace(p->trace, pOp->p3, pOut);
  2270.       }
  2271.     }
  2272. #endif  /* SQLITE_DEBUG */
  2273. #endif  /* NDEBUG */
  2274.   }  /* The end of the for(;;) loop the loops through opcodes */
  2275.   /* If we reach this point, it means that execution is finished with
  2276.   ** an error of some kind.
  2277.   */
  2278. vdbe_error_halt:
  2279.   assert( rc );
  2280.   p->rc = rc;
  2281.   rc = SQLITE_ERROR;
  2282.   sqlite3VdbeHalt(p);
  2283.   /* This is the only way out of this procedure.  We have to
  2284.   ** release the mutexes on btrees that were acquired at the
  2285.   ** top. */
  2286. vdbe_return:
  2287.   sqlite3BtreeMutexArrayLeave(&p->aMutex);
  2288.   return rc;
  2289.   /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
  2290.   ** is encountered.
  2291.   */
  2292. too_big:
  2293.   sqlite3SetString(&p->zErrMsg, "string or blob too big", (char*)0);
  2294.   rc = SQLITE_TOOBIG;
  2295.   goto vdbe_error_halt;
  2296.   /* Jump to here if a malloc() fails.
  2297.   */
  2298. no_mem:
  2299.   db->mallocFailed = 1;
  2300.   sqlite3SetString(&p->zErrMsg, "out of memory", (char*)0);
  2301.   rc = SQLITE_NOMEM;
  2302.   goto vdbe_error_halt;
  2303.   /* Jump to here for an SQLITE_MISUSE error.
  2304.   */
  2305. abort_due_to_misuse:
  2306.   rc = SQLITE_MISUSE;
  2307.   /* Fall thru into abort_due_to_error */
  2308.   /* Jump to here for any other kind of fatal error.  The "rc" variable
  2309.   ** should hold the error number.
  2310.   */
  2311. abort_due_to_error:
  2312.   assert( p->zErrMsg==0 );
  2313.   if( db->mallocFailed ) rc = SQLITE_NOMEM;
  2314.   sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(rc), (char*)0);
  2315.   goto vdbe_error_halt;
  2316.   /* Jump to here if the sqlite3_interrupt() API sets the interrupt
  2317.   ** flag.
  2318.   */
  2319. abort_due_to_interrupt:
  2320.   assert( db->u1.isInterrupted );
  2321.   rc = SQLITE_INTERRUPT;
  2322.   p->rc = rc;
  2323.   sqlite3SetString(&p->zErrMsg, sqlite3ErrStr(rc), (char*)0);
  2324.   goto vdbe_error_halt;
  2325. }