Update bundled library to version 2.8.2.

Make OnUpdateInt compatible with ZE2.
Fix the makefile fragment for non-gnu makes

1 files changed, 318 insertions, 210 deletions

diff --git a/ext/sqlite/libsqlite/src/vdbe.c b/ext/sqlite/libsqlite/src/vdbe.c
index f9b94824c4..3ac4a3acc8 100644
--- a/ext/sqlite/libsqlite/src/vdbe.c
+++ b/ext/sqlite/libsqlite/src/vdbe.c
@@ -79,6 +79,11 @@ typedef unsigned char Bool;
 ** 
 ** Every cursor that the virtual machine has open is represented by an
 ** instance of the following structure.
+**
+** If the Cursor.isTriggerRow flag is set it means that this cursor is
+** really a single row that represents the NEW or OLD pseudo-table of
+** a row trigger.  The data for the row is stored in Cursor.pData and
+** the rowid is in Cursor.iKey.
 */
 struct Cursor {
   BtCursor *pCursor;    /* The cursor structure of the backend */
@@ -90,7 +95,11 @@ struct Cursor {
   Bool useRandomRowid;  /* Generate new record numbers semi-randomly */
   Bool nullRow;         /* True if pointing to a row with no data */
   Bool nextRowidValid;  /* True if the nextRowid field is valid */
+  Bool pseudoTable;     /* This is a NEW or OLD pseudo-tables of a trigger */
   Btree *pBt;           /* Separate file holding temporary table */
+  int nData;            /* Number of bytes in pData */
+  char *pData;          /* Data for a NEW or OLD pseudo-table */
+  int iKey;             /* Key for the NEW or OLD pseudo-table row */
 };
 typedef struct Cursor Cursor;
 
@@ -243,7 +252,6 @@ struct Keylist {
 struct Vdbe {
   sqlite *db;         /* The whole database */
   Vdbe *pPrev,*pNext; /* Linked list of VDBEs with the same Vdbe.db */
-  Btree *pBt;         /* Opaque context structure used by DB backend */
   FILE *trace;        /* Write an execution trace here, if not NULL */
   int nOp;            /* Number of instructions in the program */
   int nOpAlloc;       /* Number of slots allocated for aOp[] */
@@ -315,7 +323,6 @@ Vdbe *sqliteVdbeCreate(sqlite *db){
   Vdbe *p;
   p = sqliteMalloc( sizeof(Vdbe) );
   if( p==0 ) return 0;
-  p->pBt = db->pBe;
   p->db = db;
   if( db->pVdbe ){
     db->pVdbe->pPrev = p;
@@ -478,6 +485,7 @@ int sqliteVdbeAddOpList(Vdbe *p, int nOp, VdbeOp const *aOp){
   return addr;
 }
 
+#if 0 /* NOT USED */
 /*
 ** Change the value of the P1 operand for a specific instruction.
 ** This routine is useful when a large program is loaded from a
@@ -490,6 +498,7 @@ void sqliteVdbeChangeP1(Vdbe *p, int addr, int val){
     p->aOp[addr].p1 = val;
   }
 }
+#endif /* NOT USED */
 
 /*
 ** Change the value of the P2 operand for a specific instruction.
@@ -605,18 +614,27 @@ void sqliteVdbeCompressSpace(Vdbe *p, int addr){
 
 /*
 ** Search for the current program for the given opcode and P2
-** value.  Return 1 if found and 0 if not found.
+** value.  Return the address plus 1 if found and 0 if not found.
 */
 int sqliteVdbeFindOp(Vdbe *p, int op, int p2){
   int i;
   assert( p->magic==VDBE_MAGIC_INIT );
   for(i=0; i<p->nOp; i++){
-    if( p->aOp[i].opcode==op && p->aOp[i].p2==p2 ) return 1;
+    if( p->aOp[i].opcode==op && p->aOp[i].p2==p2 ) return i+1;
   }
   return 0;
 }
 
 /*
+** Return the opcode for a given address.
+*/
+VdbeOp *sqliteVdbeGetOp(Vdbe *p, int addr){
+  assert( p->magic==VDBE_MAGIC_INIT );
+  assert( addr>=0 && addr<p->nOp );
+  return &p->aOp[addr];
+}
+
+/*
 ** The following group or routines are employed by installable functions
 ** to return their results.
 **
@@ -994,6 +1012,7 @@ static int toInt(const char *zNum, int *pNum){
   }else{
     neg = 0;
   }
+  if( *zNum==0 ) return 0;
   while( isdigit(*zNum) ){
     v = v*10 + *zNum - '0';
     zNum++;
@@ -1073,27 +1092,6 @@ static void PopStack(Vdbe *p, int N){
   p->tos--;
 
 /*
-** Return TRUE if zNum is a floating-point or integer number.
-*/
-static int isNumber(const char *zNum){
-  if( *zNum=='-' || *zNum=='+' ) zNum++;
-  if( !isdigit(*zNum) ) return 0;
-  while( isdigit(*zNum) ) zNum++;
-  if( *zNum==0 ) return 1;
-  if( *zNum!='.' ) return 0;
-  zNum++;
-  if( !isdigit(*zNum) ) return 0;
-  while( isdigit(*zNum) ) zNum++;
-  if( *zNum==0 ) return 1;
-  if( *zNum!='e' && *zNum!='E' ) return 0;
-  zNum++;
-  if( *zNum=='-' || *zNum=='+' ) zNum++;
-  if( !isdigit(*zNum) ) return 0;
-  while( isdigit(*zNum) ) zNum++;
-  return *zNum==0;
-}
-
-/*
 ** Delete a keylist
 */
 static void KeylistFree(Keylist *p){
@@ -1115,6 +1113,7 @@ static void cleanupCursor(Cursor *pCx){
   if( pCx->pBt ){
     sqliteBtreeClose(pCx->pBt);
   }
+  sqliteFree(pCx->pData);
   memset(pCx, 0, sizeof(Cursor));
 }
 
@@ -1300,7 +1299,7 @@ int sqliteVdbeList(
       p->rc = SQLITE_MISUSE;
     }
   }
-  return p->rc==SQLITE_OK ? SQLITE_OK : SQLITE_ERROR;
+  return p->rc==SQLITE_OK ? SQLITE_DONE : SQLITE_ERROR;
 }
 
 /*
@@ -1498,6 +1497,9 @@ void sqliteVdbeMakeReady(
   int isExplain                  /* True if the EXPLAIN keywords is present */
 ){
   int n;
+#ifdef MEMORY_DEBUG
+  extern int access(const char*,int);
+#endif
 
   assert( p!=0 );
   assert( p->aStack==0 );
@@ -1569,8 +1571,8 @@ void sqliteVdbeMakeReady(
 ** immediately.  There will be no error message but the p->rc field is
 ** set to SQLITE_ABORT and this routine will return SQLITE_ERROR.
 **
-** A memory allocation error causes p->rc to be set SQLITE_NOMEM and this
-** routien to return SQLITE_ERROR.
+** A memory allocation error causes p->rc to be set to SQLITE_NOMEM and this
+** routine to return SQLITE_ERROR.
 **
 ** Other fatal errors return SQLITE_ERROR.
 **
@@ -1583,7 +1585,6 @@ int sqliteVdbeExec(
   int pc;                    /* The program counter */
   Op *pOp;                   /* Current operation */
   int rc = SQLITE_OK;        /* Value to return */
-  Btree *pBt = p->pBt;       /* The backend driver */
   sqlite *db = p->db;        /* The database */
   char **zStack = p->zStack; /* Text stack */
   Stack *aStack = p->aStack; /* Additional stack information */
@@ -1893,6 +1894,7 @@ case OP_Push: {
 ** to all column names is passed as the 4th parameter to the callback.
 */
 case OP_ColumnName: {
+  assert( pOp->p1>=0 && pOp->p1<p->nOp );
   p->azColName[pOp->p1] = pOp->p3;
   p->nCallback = 0;
   break;
@@ -3061,7 +3063,7 @@ case OP_MakeKey: {
       Stringify(p, i);
       aStack[i].flags &= ~(STK_Int|STK_Real);
       nByte += aStack[i].n+1;
-    }else if( (flags & (STK_Real|STK_Int))!=0 || isNumber(zStack[i]) ){
+    }else if( (flags & (STK_Real|STK_Int))!=0 || sqliteIsNumber(zStack[i]) ){
       if( (flags & (STK_Real|STK_Int))==STK_Int ){
         aStack[i].r = aStack[i].i;
       }else if( (flags & (STK_Real|STK_Int))==0 ){
@@ -3153,17 +3155,21 @@ case OP_IncrKey: {
   break;
 }
 
-/* Opcode: Checkpoint * * *
+/* Opcode: Checkpoint P1 * *
 **
 ** Begin a checkpoint.  A checkpoint is the beginning of a operation that
 ** is part of a larger transaction but which might need to be rolled back
 ** itself without effecting the containing transaction.  A checkpoint will
 ** be automatically committed or rollback when the VDBE halts.
+**
+** The checkpoint is begun on the database file with index P1.  The main
+** database file has an index of 0 and the file used for temporary tables
+** has an index of 1.
 */
 case OP_Checkpoint: {
-  rc = sqliteBtreeBeginCkpt(pBt);
-  if( rc==SQLITE_OK && db->pBeTemp ){
-     rc = sqliteBtreeBeginCkpt(db->pBeTemp);
+  int i = pOp->p1;
+  if( i>=0 && i<db->nDb && db->aDb[i].pBt ){
+    rc = sqliteBtreeBeginCkpt(db->aDb[i].pBt);
   }
   break;
 }
@@ -3174,10 +3180,9 @@ case OP_Checkpoint: {
 ** opcode is encountered.  Depending on the ON CONFLICT setting, the
 ** transaction might also be rolled back if an error is encountered.
 **
-** If P1 is true, then the transaction is started on the temporary
-** tables of the database only.  The main database file is not write
-** locked and other processes can continue to read the main database
-** file.
+** P1 is the index of the database file on which the transaction is
+** started.  Index 0 is the main database file and index 1 is the
+** file used for temporary tables.
 **
 ** A write lock is obtained on the database file when a transaction is
 ** started.  No other process can read or write the file while the
@@ -3187,15 +3192,11 @@ case OP_Checkpoint: {
 */
 case OP_Transaction: {
   int busy = 1;
-  if( db->pBeTemp && !p->inTempTrans ){
-    rc = sqliteBtreeBeginTrans(db->pBeTemp);
-    if( rc!=SQLITE_OK ){
-      goto abort_due_to_error;
-    }
-    p->inTempTrans = 1;
-  }
-  while( pOp->p1==0 && busy ){
-    rc = sqliteBtreeBeginTrans(pBt);
+  int i = pOp->p1;
+  assert( i>=0 && i<db->nDb );
+  if( db->aDb[i].inTrans ) break;
+  while( db->aDb[i].pBt!=0 && busy ){
+    rc = sqliteBtreeBeginTrans(db->aDb[i].pBt);
     switch( rc ){
       case SQLITE_BUSY: {
         if( db->xBusyCallback==0 ){
@@ -3223,6 +3224,7 @@ case OP_Transaction: {
       }
     }
   }
+  db->aDb[i].inTrans = 1;
   p->undoTransOnError = 1;
   break;
 }
@@ -3236,53 +3238,47 @@ case OP_Transaction: {
 ** A read lock continues to be held if there are still cursors open.
 */
 case OP_Commit: {
-  if( db->pBeTemp==0 || (rc = sqliteBtreeCommit(db->pBeTemp))==SQLITE_OK ){
-    rc = p->inTempTrans ? SQLITE_OK : sqliteBtreeCommit(pBt);
+  int i;
+  for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
+    if( db->aDb[i].inTrans ){
+      rc = sqliteBtreeCommit(db->aDb[i].pBt);
+      db->aDb[i].inTrans = 0;
+    }
   }
   if( rc==SQLITE_OK ){
     sqliteCommitInternalChanges(db);
   }else{
-    if( db->pBeTemp ) sqliteBtreeRollback(db->pBeTemp);
-    sqliteBtreeRollback(pBt);
-    sqliteRollbackInternalChanges(db);
+    sqliteRollbackAll(db);
   }
-  p->inTempTrans = 0;
   break;
 }
 
-/* Opcode: Rollback * * *
+/* Opcode: Rollback P1 * *
 **
 ** Cause all modifications to the database that have been made since the
 ** last Transaction to be undone. The database is restored to its state
 ** before the Transaction opcode was executed.  No additional modifications
 ** are allowed until another transaction is started.
 **
+** P1 is the index of the database file that is committed.  An index of 0
+** is used for the main database and an index of 1 is used for the file used
+** to hold temporary tables.
+**
 ** This instruction automatically closes all cursors and releases both
-** the read and write locks on the database.
+** the read and write locks on the indicated database.
 */
 case OP_Rollback: {
-  if( db->pBeTemp ){
-    sqliteBtreeRollback(db->pBeTemp);
-  }
-  rc = sqliteBtreeRollback(pBt);
-  sqliteRollbackInternalChanges(db);
+  sqliteRollbackAll(db);
   break;
 }
 
-/* Opcode: ReadCookie * P2 *
-**
-** When P2==0, 
-** read the schema cookie from the database file and push it onto the
-** stack.  The schema cookie is an integer that is used like a version
-** number for the database schema.  Everytime the schema changes, the
-** cookie changes to a new random value.  This opcode is used during
-** initialization to read the initial cookie value so that subsequent
-** database accesses can verify that the cookie has not changed.
+/* Opcode: ReadCookie P1 P2 *
 **
-** If P2>0, then read global database parameter number P2.  There is
-** a small fixed number of global database parameters.  P2==1 is the
-** database version number.  P2==2 is the recommended pager cache size.
-** Other parameters are currently unused.
+** Read cookie number P2 from database P1 and push it onto the stack.
+** P2==0 is the schema version.  P2==1 is the database format.
+** P2==2 is the recommended pager cache size, and so forth.  P1==0 is
+** the main database file and P1==1 is the database file used to store
+** temporary tables.
 **
 ** There must be a read-lock on the database (either a transaction
 ** must be started or there must be an open cursor) before
@@ -3292,36 +3288,35 @@ case OP_ReadCookie: {
   int i = ++p->tos;
   int aMeta[SQLITE_N_BTREE_META];
   assert( pOp->p2<SQLITE_N_BTREE_META );
-  rc = sqliteBtreeGetMeta(pBt, aMeta);
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( db->aDb[pOp->p1].pBt!=0 );
+  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
   aStack[i].i = aMeta[1+pOp->p2];
   aStack[i].flags = STK_Int;
   break;
 }
 
-/* Opcode: SetCookie * P2 *
+/* Opcode: SetCookie P1 P2 *
 **
-** When P2==0,
-** this operation changes the value of the schema cookie on the database.
-** The new value is top of the stack.
-** When P2>0, the value of global database parameter
-** number P2 is changed.  See ReadCookie for more information about
-** global database parametes.
-**
-** The schema cookie changes its value whenever the database schema changes.
-** That way, other processes can recognize when the schema has changed
-** and reread it.
+** Write the top of the stack into cookie number P2 of database P1.
+** P2==0 is the schema version.  P2==1 is the database format.
+** P2==2 is the recommended pager cache size, and so forth.  P1==0 is
+** the main database file and P1==1 is the database file used to store
+** temporary tables.
 **
 ** A transaction must be started before executing this opcode.
 */
 case OP_SetCookie: {
   int aMeta[SQLITE_N_BTREE_META];
   assert( pOp->p2<SQLITE_N_BTREE_META );
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  assert( db->aDb[pOp->p1].pBt!=0 );
   VERIFY( if( p->tos<0 ) goto not_enough_stack; )
   Integerify(p, p->tos)
-  rc = sqliteBtreeGetMeta(pBt, aMeta);
+  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
   if( rc==SQLITE_OK ){
     aMeta[1+pOp->p2] = aStack[p->tos].i;
-    rc = sqliteBtreeUpdateMeta(pBt, aMeta);
+    rc = sqliteBtreeUpdateMeta(db->aDb[pOp->p1].pBt, aMeta);
   }
   POPSTACK;
   break;
@@ -3329,10 +3324,11 @@ case OP_SetCookie: {
 
 /* Opcode: VerifyCookie P1 P2 *
 **
-** Check the value of global database parameter number P2 and make
-** sure it is equal to P1.  P2==0 is the schema cookie.  P1==1 is
-** the database version.  If the values do not match, abort with
-** an SQLITE_SCHEMA error.
+** Check the value of global database parameter number 0 (the
+** schema version) and make sure it is equal to P2.  
+** P1 is the database number which is 0 for the main database file
+** and 1 for the file holding temporary tables and some higher number
+** for auxiliary databases.
 **
 ** The cookie changes its value whenever the database schema changes.
 ** This operation is used to detect when that the cookie has changed
@@ -3344,23 +3340,26 @@ case OP_SetCookie: {
 */
 case OP_VerifyCookie: {
   int aMeta[SQLITE_N_BTREE_META];
-  assert( pOp->p2<SQLITE_N_BTREE_META );
-  rc = sqliteBtreeGetMeta(pBt, aMeta);
-  if( rc==SQLITE_OK && aMeta[1+pOp->p2]!=pOp->p1 ){
+  assert( pOp->p1>=0 && pOp->p1<db->nDb );
+  rc = sqliteBtreeGetMeta(db->aDb[pOp->p1].pBt, aMeta);
+  if( rc==SQLITE_OK && aMeta[1]!=pOp->p2 ){
     sqliteSetString(&p->zErrMsg, "database schema has changed", 0);
     rc = SQLITE_SCHEMA;
   }
   break;
 }
 
-/* Opcode: Open P1 P2 P3
+/* Opcode: OpenRead P1 P2 P3
 **
 ** Open a read-only cursor for the database table whose root page is
-** P2 in the main database file.  Give the new cursor an identifier
-** of P1.  The P1 values need not be contiguous but all P1 values
-** should be small integers.  It is an error for P1 to be negative.
+** P2 in a database file.  The database file is determined by an 
+** integer from the top of the stack.  0 means the main database and
+** 1 means the database used for temporary tables.  Give the new 
+** cursor an identifier of P1.  The P1 values need not be contiguous
+** but all P1 values should be small integers.  It is an error for
+** P1 to be negative.
 **
-** If P2==0 then take the root page number from the top of the stack.
+** If P2==0 then take the root page number from the next of the stack.
 **
 ** There will be a read lock on the database whenever there is an
 ** open cursor.  If the database was unlocked prior to this instruction
@@ -3376,52 +3375,39 @@ case OP_VerifyCookie: {
 ** omitted.  But the code generator usually inserts the index or
 ** table name into P3 to make the code easier to read.
 **
-** See also OpenAux and OpenWrite.
-*/
-/* Opcode: OpenAux P1 P2 P3
-**
-** Open a read-only cursor in the auxiliary table set.  This opcode
-** works exactly like OP_Open except that it opens the cursor on the
-** auxiliary table set (the file used to store tables created using
-** CREATE TEMPORARY TABLE) instead of in the main database file.
-** See OP_Open for additional information.
+** See also OpenWrite.
 */
 /* Opcode: OpenWrite P1 P2 P3
 **
 ** Open a read/write cursor named P1 on the table or index whose root
 ** page is P2.  If P2==0 then take the root page number from the stack.
 **
-** This instruction works just like Open except that it opens the cursor
+** This instruction works just like OpenRead except that it opens the cursor
 ** in read/write mode.  For a given table, there can be one or more read-only
 ** cursors or a single read/write cursor but not both.
 **
-** See also OpWrAux.
+** See also OpenRead.
 */
-/* Opcode: OpenWrAux P1 P2 P3
-**
-** Open a read/write cursor in the auxiliary table set.  This opcode works
-** just like OpenWrite except that the auxiliary table set (the file used
-** to store tables created using CREATE TEMPORARY TABLE) is used in place
-** of the main database file.
-*/
-case OP_OpenAux:
-case OP_OpenWrAux:
-case OP_OpenWrite:
-case OP_Open: {
+case OP_OpenRead:
+case OP_OpenWrite: {
   int busy = 0;
   int i = pOp->p1;
   int tos = p->tos;
   int p2 = pOp->p2;
   int wrFlag;
   Btree *pX;
-  switch( pOp->opcode ){
-    case OP_Open:        wrFlag = 0;  pX = pBt;          break;
-    case OP_OpenWrite:   wrFlag = 1;  pX = pBt;          break;
-    case OP_OpenAux:     wrFlag = 0;  pX = db->pBeTemp;  break;
-    case OP_OpenWrAux:   wrFlag = 1;  pX = db->pBeTemp;  break;
-  }
+  int iDb;
+  
+  VERIFY( if( tos<0 ) goto not_enough_stack; );
+  Integerify(p, tos);
+  iDb = p->aStack[tos].i;
+  tos--;
+  VERIFY( if( iDb<0 || iDb>=db->nDb ) goto bad_instruction; );
+  VERIFY( if( db->aDb[iDb].pBt==0 ) goto bad_instruction; );
+  pX = db->aDb[iDb].pBt;
+  wrFlag = pOp->opcode==OP_OpenWrite;
   if( p2<=0 ){
-    if( tos<0 ) goto not_enough_stack;
+    VERIFY( if( tos<0 ) goto not_enough_stack; );
     Integerify(p, tos);
     p2 = p->aStack[tos].i;
     POPSTACK;
@@ -3463,15 +3449,16 @@ case OP_Open: {
   if( p2<=0 ){
     POPSTACK;
   }
+  POPSTACK;
   break;
 }
 
 /* Opcode: OpenTemp P1 P2 *
 **
-** Open a new cursor that points to a table or index in a temporary
-** database file.  The temporary file is opened read/write even if 
-** the main database is read-only.  The temporary file is deleted
-** when the cursor is closed.
+** Open a new cursor to a transient table.
+** The transient cursor is always opened read/write even if 
+** the main database is read-only.  The transient table is deleted
+** automatically when the cursor is closed.
 **
 ** The cursor points to a BTree table if P2==0 and to a BTree index
 ** if P2==1.  A BTree table must have an integer key and can have arbitrary
@@ -3479,7 +3466,7 @@ case OP_Open: {
 **
 ** This opcode is used for tables that exist for the duration of a single
 ** SQL statement only.  Tables created using CREATE TEMPORARY TABLE
-** are opened using OP_OpenAux or OP_OpenWrAux.  "Temporary" in the
+** are opened using OP_OpenRead or OP_OpenWrite.  "Temporary" in the
 ** context of this opcode means for the duration of a single SQL statement
 ** whereas "Temporary" in the context of CREATE TABLE means for the duration
 ** of the connection to the database.  Same word; different meanings.
@@ -3493,7 +3480,8 @@ case OP_OpenTemp: {
   cleanupCursor(pCx);
   memset(pCx, 0, sizeof(*pCx));
   pCx->nullRow = 1;
-  rc = sqliteBtreeOpen(0, 1, TEMP_PAGES, &pCx->pBt);
+  rc = sqliteBtreeFactory(db, 0, 1, TEMP_PAGES, &pCx->pBt);
+
   if( rc==SQLITE_OK ){
     rc = sqliteBtreeBeginTrans(pCx->pBt);
   }
@@ -3511,24 +3499,26 @@ case OP_OpenTemp: {
   break;
 }
 
-/*
-** Opcode: RenameCursor P1 P2 *
+/* Opcode: OpenPseudo P1 * *
 **
-** Rename cursor number P1 as cursor number P2.  If P2 was previously
-** opened is is closed before the renaming occurs.
+** Open a new cursor that points to a fake table that contains a single
+** row of data.  Any attempt to write a second row of data causes the
+** first row to be deleted.  All data is deleted when the cursor is
+** closed.
+**
+** A pseudo-table created by this opcode is useful for holding the
+** NEW or OLD tables in a trigger.
 */
-case OP_RenameCursor: {
-  int from = pOp->p1;
-  int to = pOp->p2;
-  VERIFY( if( from<0 || to<0 ) goto bad_instruction; )
-  if( to<p->nCursor && p->aCsr[to].pCursor ){
-    cleanupCursor(&p->aCsr[to]);
-  }
-  expandCursorArraySize(p, to);
-  if( from<p->nCursor ){
-    memcpy(&p->aCsr[to], &p->aCsr[from], sizeof(p->aCsr[0]));
-    memset(&p->aCsr[from], 0, sizeof(p->aCsr[0]));
-  }
+case OP_OpenPseudo: {
+  int i = pOp->p1;
+  Cursor *pCx;
+  VERIFY( if( i<0 ) goto bad_instruction; )
+  if( expandCursorArraySize(p, i) ) goto no_mem;
+  pCx = &p->aCsr[i];
+  cleanupCursor(pCx);
+  memset(pCx, 0, sizeof(*pCx));
+  pCx->nullRow = 1;
+  pCx->pseudoTable = 1;
   break;
 }
 
@@ -3539,7 +3529,7 @@ case OP_RenameCursor: {
 */
 case OP_Close: {
   int i = pOp->p1;
-  if( i>=0 && i<p->nCursor && p->aCsr[i].pCursor ){
+  if( i>=0 && i<p->nCursor ){
     cleanupCursor(&p->aCsr[i]);
   }
   break;
@@ -3573,7 +3563,9 @@ case OP_MoveTo: {
   Cursor *pC;
 
   VERIFY( if( tos<0 ) goto not_enough_stack; )
-  if( i>=0 && i<p->nCursor && (pC = &p->aCsr[i])->pCursor!=0 ){
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( pC->pCursor!=0 ){
     int res, oc;
     if( aStack[tos].flags & STK_Int ){
       int iKey = intToKey(aStack[tos].i);
@@ -3905,7 +3897,8 @@ case OP_NewRecno: {
 ** be an integer.  The stack is popped twice by this instruction.
 **
 ** If P2==1 then the row change count is incremented.  If P2==0 the
-** row change count is unmodified.
+** row change count is unmodified.  The rowid is stored for subsequent
+** return by the sqlite_last_insert_rowid() function if P2 is 1.
 */
 /* Opcode: PutStrKey P1 * *
 **
@@ -3914,6 +3907,8 @@ case OP_NewRecno: {
 ** entry is overwritten.  The data is the value on the top of the
 ** stack.  The key is the next value down on the stack.  The key must
 ** be a string.  The stack is popped twice by this instruction.
+**
+** P1 may not be a pseudo-table opened using the OpenPseudo opcode.
 */
 case OP_PutIntKey:
 case OP_PutStrKey: {
@@ -3922,7 +3917,8 @@ case OP_PutStrKey: {
   int i = pOp->p1;
   Cursor *pC;
   VERIFY( if( nos<0 ) goto not_enough_stack; )
-  if( VERIFY( i>=0 && i<p->nCursor && ) (pC = &p->aCsr[i])->pCursor!=0 ){
+  if( VERIFY( i>=0 && i<p->nCursor && )
+      ((pC = &p->aCsr[i])->pCursor!=0 || pC->pseudoTable) ){
     char *zKey;
     int nKey, iKey;
     if( pOp->opcode==OP_PutStrKey ){
@@ -3934,14 +3930,38 @@ case OP_PutStrKey: {
       nKey = sizeof(int);
       iKey = intToKey(aStack[nos].i);
       zKey = (char*)&iKey;
-      db->lastRowid = aStack[nos].i;
-      if( pOp->p2 ) db->nChange++;
+      if( pOp->p2 ){
+        db->nChange++;
+        db->lastRowid = aStack[nos].i;
+      }
       if( pC->nextRowidValid && aStack[nos].i>=pC->nextRowid ){
         pC->nextRowidValid = 0;
       }
     }
-    rc = sqliteBtreeInsert(pC->pCursor, zKey, nKey,
-                        zStack[tos], aStack[tos].n);
+    if( pC->pseudoTable ){
+      /* PutStrKey does not work for pseudo-tables.
+      ** The following assert makes sure we are not trying to use
+      ** PutStrKey on a pseudo-table
+      */
+      assert( pOp->opcode==OP_PutIntKey );
+      sqliteFree(pC->pData);
+      pC->iKey = iKey;
+      pC->nData = aStack[tos].n;
+      if( aStack[tos].flags & STK_Dyn ){
+        pC->pData = zStack[tos];
+        zStack[tos] = 0;
+        aStack[tos].flags = STK_Null;
+      }else{
+        pC->pData = sqliteMallocRaw( pC->nData );
+        if( pC->pData ){
+          memcpy(pC->pData, zStack[tos], pC->nData);
+        }
+      }
+      pC->nullRow = 0;
+    }else{
+      rc = sqliteBtreeInsert(pC->pCursor, zKey, nKey,
+                          zStack[tos], aStack[tos].n);
+    }
     pC->recnoIsValid = 0;
   }
   POPSTACK;
@@ -3960,11 +3980,15 @@ case OP_PutStrKey: {
 **
 ** The row change counter is incremented if P2==1 and is unmodified
 ** if P2==0.
+**
+** If P1 is a pseudo-table, then this instruction is a no-op.
 */
 case OP_Delete: {
   int i = pOp->p1;
   Cursor *pC;
-  if( VERIFY( i>=0 && i<p->nCursor && ) (pC = &p->aCsr[i])->pCursor!=0 ){
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( pC->pCursor!=0 ){
     rc = sqliteBtreeDelete(pC->pCursor);
     pC->nextRowidValid = 0;
   }
@@ -3975,14 +3999,67 @@ case OP_Delete: {
 /* Opcode: KeyAsData P1 P2 *
 **
 ** Turn the key-as-data mode for cursor P1 either on (if P2==1) or
-** off (if P2==0).  In key-as-data mode, the Field opcode pulls
-** data off of the key rather than the data.  This is useful for
+** off (if P2==0).  In key-as-data mode, the OP_Column opcode pulls
+** data off of the key rather than the data.  This is used for
 ** processing compound selects.
 */
 case OP_KeyAsData: {
   int i = pOp->p1;
-  if( VERIFY( i>=0 && i<p->nCursor && ) p->aCsr[i].pCursor!=0 ){
-    p->aCsr[i].keyAsData = pOp->p2;
+  assert( i>=0 && i<p->nCursor );
+  p->aCsr[i].keyAsData = pOp->p2;
+  break;
+}
+
+/* Opcode: RowData P1 * *
+**
+** Push onto the stack the complete row data for cursor P1.
+** There is no interpretation of the data.  It is just copied
+** onto the stack exactly as it is found in the database file.
+**
+** If the cursor is not pointing to a valid row, a NULL is pushed
+** onto the stack.
+*/
+case OP_RowData: {
+  int i = pOp->p1;
+  int tos = ++p->tos;
+  Cursor *pC;
+  int n;
+
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( pC->nullRow ){
+    aStack[tos].flags = STK_Null;
+  }else if( pC->pCursor!=0 ){
+    BtCursor *pCrsr = pC->pCursor;
+    if( pC->nullRow ){
+      aStack[tos].flags = STK_Null;
+      break;
+    }else if( pC->keyAsData ){
+      sqliteBtreeKeySize(pCrsr, &n);
+    }else{
+      sqliteBtreeDataSize(pCrsr, &n);
+    }
+    aStack[tos].n = n;
+    if( n<=NBFS ){
+      aStack[tos].flags = STK_Str;
+      zStack[tos] = aStack[tos].z;
+    }else{
+      char *z = sqliteMallocRaw( n );
+      if( z==0 ) goto no_mem;
+      aStack[tos].flags = STK_Str | STK_Dyn;
+      zStack[tos] = z;
+    }
+    if( pC->keyAsData ){
+      sqliteBtreeKey(pCrsr, 0, n, zStack[tos]);
+    }else{
+      sqliteBtreeData(pCrsr, 0, n, zStack[tos]);
+    }
+  }else if( pC->pseudoTable ){
+    aStack[tos].n = pC->nData;
+    zStack[tos] = pC->pData;
+    aStack[tos].flags = STK_Str|STK_Ephem;
+  }else{
+    aStack[tos].flags = STK_Null;
   }
   break;
 }
@@ -4017,12 +4094,13 @@ case OP_Column: {
   int idxWidth;
   unsigned char aHdr[10];
 
+  assert( i<p->nCursor );
   if( i<0 ){
     VERIFY( if( tos+i<0 ) goto bad_instruction; )
     VERIFY( if( (aStack[tos+i].flags & STK_Str)==0 ) goto bad_instruction; )
     zRec = zStack[tos+i];
     payloadSize = aStack[tos+i].n;
-  }else if( VERIFY( i>=0 && i<p->nCursor && ) (pC = &p->aCsr[i])->pCursor!=0 ){
+  }else if( (pC = &p->aCsr[i])->pCursor!=0 ){
     zRec = 0;
     pCrsr = pC->pCursor;
     if( pC->nullRow ){
@@ -4032,6 +4110,10 @@ case OP_Column: {
     }else{
       sqliteBtreeDataSize(pCrsr, &payloadSize);
     }
+  }else if( pC->pseudoTable ){
+    payloadSize = pC->nData;
+    zRec = pC->pData;
+    assert( payloadSize==0 || zRec!=0 );
   }else{
     payloadSize = 0;
   }
@@ -4121,22 +4203,24 @@ case OP_Column: {
 case OP_Recno: {
   int i = pOp->p1;
   int tos = ++p->tos;
-  BtCursor *pCrsr;
+  Cursor *pC;
+  int v;
 
-  if( VERIFY( i>=0 && i<p->nCursor && ) (pCrsr = p->aCsr[i].pCursor)!=0 ){
-    int v;
-    if( p->aCsr[i].recnoIsValid ){
-      v = p->aCsr[i].lastRecno;
-    }else if( p->aCsr[i].nullRow ){
-      aStack[tos].flags = STK_Null;
-      break;
-    }else{
-      sqliteBtreeKey(pCrsr, 0, sizeof(u32), (char*)&v);
-      v = keyToInt(v);
-    }
-    aStack[tos].i = v;
-    aStack[tos].flags = STK_Int;
+  assert( i>=0 && i<p->nCursor );
+  if( (pC = &p->aCsr[i])->recnoIsValid ){
+    v = pC->lastRecno;
+  }else if( pC->nullRow ){
+    aStack[tos].flags = STK_Null;
+    break;
+  }else if( pC->pseudoTable ){
+    v = keyToInt(pC->iKey);
+  }else{
+    assert( pC->pCursor!=0 );
+    sqliteBtreeKey(pC->pCursor, 0, sizeof(u32), (char*)&v);
+    v = keyToInt(v);
   }
+  aStack[tos].i = v;
+  aStack[tos].flags = STK_Int;
   break;
 }
 
@@ -4148,6 +4232,8 @@ case OP_Recno: {
 ** Compare this opcode to Recno.  The Recno opcode extracts the first
 ** 4 bytes of the key and pushes those bytes onto the stack as an
 ** integer.  This instruction pushes the entire key as a string.
+**
+** This opcode may not be used on a pseudo-table.
 */
 case OP_FullKey: {
   int i = pOp->p1;
@@ -4155,6 +4241,7 @@ case OP_FullKey: {
   BtCursor *pCrsr;
 
   VERIFY( if( !p->aCsr[i].keyAsData ) goto bad_instruction; )
+  VERIFY( if( p->aCsr[i].pseudoTable ) goto bad_instruction; )
   if( VERIFY( i>=0 && i<p->nCursor && ) (pCrsr = p->aCsr[i].pCursor)!=0 ){
     int amt;
     char *z;
@@ -4187,11 +4274,10 @@ case OP_FullKey: {
 */
 case OP_NullRow: {
   int i = pOp->p1;
-  BtCursor *pCrsr;
 
-  if( VERIFY( i>=0 && i<p->nCursor && ) (pCrsr = p->aCsr[i].pCursor)!=0 ){
-    p->aCsr[i].nullRow = 1;
-  }
+  assert( i>=0 && i<p->nCursor );
+  p->aCsr[i].nullRow = 1;
+  p->aCsr[i].recnoIsValid = 0;
   break;
 }
 
@@ -4205,15 +4291,20 @@ case OP_NullRow: {
 */
 case OP_Last: {
   int i = pOp->p1;
+  Cursor *pC;
   BtCursor *pCrsr;
 
-  if( VERIFY( i>=0 && i<p->nCursor && ) (pCrsr = p->aCsr[i].pCursor)!=0 ){
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( (pCrsr = pC->pCursor)!=0 ){
     int res;
-    sqliteBtreeLast(pCrsr, &res);
+    rc = sqliteBtreeLast(pCrsr, &res);
     p->aCsr[i].nullRow = res;
     if( res && pOp->p2>0 ){
       pc = pOp->p2 - 1;
     }
+  }else{
+    pC->nullRow = 0;
   }
   break;
 }
@@ -4228,16 +4319,21 @@ case OP_Last: {
 */
 case OP_Rewind: {
   int i = pOp->p1;
+  Cursor *pC;
   BtCursor *pCrsr;
 
-  if( VERIFY( i>=0 && i<p->nCursor && ) (pCrsr = p->aCsr[i].pCursor)!=0 ){
+  assert( i>=0 && i<p->nCursor );
+  pC = &p->aCsr[i];
+  if( (pCrsr = pC->pCursor)!=0 ){
     int res;
-    sqliteBtreeFirst(pCrsr, &res);
-    p->aCsr[i].atFirst = res==0;
-    p->aCsr[i].nullRow = res;
+    rc = sqliteBtreeFirst(pCrsr, &res);
+    pC->atFirst = res==0;
+    pC->nullRow = res;
     if( res && pOp->p2>0 ){
       pc = pOp->p2 - 1;
     }
+  }else{
+    pC->nullRow = 0;
   }
   break;
 }
@@ -4264,8 +4360,9 @@ case OP_Next: {
   BtCursor *pCrsr;
 
   CHECK_FOR_INTERRUPT;
-  if( VERIFY( pOp->p1>=0 && pOp->p1<p->nCursor && ) 
-      (pCrsr = (pC = &p->aCsr[pOp->p1])->pCursor)!=0 ){
+  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
+  pC = &p->aCsr[pOp->p1];
+  if( (pCrsr = pC->pCursor)!=0 ){
     int res;
     if( pC->nullRow ){
       res = 1;
@@ -4278,8 +4375,10 @@ case OP_Next: {
       pc = pOp->p2 - 1;
       sqlite_search_count++;
     }
-    pC->recnoIsValid = 0;
+  }else{
+    pC->nullRow = 1;
   }
+  pC->recnoIsValid = 0;
   break;
 }
 
@@ -4373,10 +4472,14 @@ case OP_IdxRecno: {
     int v;
     int sz;
     sqliteBtreeKeySize(pCrsr, &sz);
-    sqliteBtreeKey(pCrsr, sz - sizeof(u32), sizeof(u32), (char*)&v);
-    v = keyToInt(v);
-    aStack[tos].i = v;
-    aStack[tos].flags = STK_Int;
+    if( sz<sizeof(u32) ){
+      aStack[tos].flags = STK_Null;
+    }else{
+      sqliteBtreeKey(pCrsr, sz - sizeof(u32), sizeof(u32), (char*)&v);
+      v = keyToInt(v);
+      aStack[tos].i = v;
+      aStack[tos].flags = STK_Int;
+    }
   }
   break;
 }
@@ -4446,7 +4549,7 @@ case OP_IdxGE: {
 ** See also: Clear
 */
 case OP_Destroy: {
-  sqliteBtreeDropTable(pOp->p2 ? db->pBeTemp : pBt, pOp->p1);
+  rc = sqliteBtreeDropTable(db->aDb[pOp->p2].pBt, pOp->p1);
   break;
 }
 
@@ -4463,7 +4566,7 @@ case OP_Destroy: {
 ** See also: Destroy
 */
 case OP_Clear: {
-  sqliteBtreeClearTable(pOp->p2 ? db->pBeTemp : pBt, pOp->p1);
+  rc = sqliteBtreeClearTable(db->aDb[pOp->p2].pBt, pOp->p1);
   break;
 }
 
@@ -4497,10 +4600,12 @@ case OP_CreateTable: {
   int i = ++p->tos;
   int pgno;
   assert( pOp->p3!=0 && pOp->p3type==P3_POINTER );
+  assert( pOp->p2>=0 && pOp->p2<db->nDb );
+  assert( db->aDb[pOp->p2].pBt!=0 );
   if( pOp->opcode==OP_CreateTable ){
-    rc = sqliteBtreeCreateTable(pOp->p2 ? db->pBeTemp : pBt, &pgno);
+    rc = sqliteBtreeCreateTable(db->aDb[pOp->p2].pBt, &pgno);
   }else{
-    rc = sqliteBtreeCreateIndex(pOp->p2 ? db->pBeTemp : pBt, &pgno);
+    rc = sqliteBtreeCreateIndex(db->aDb[pOp->p2].pBt, &pgno);
   }
   if( rc==SQLITE_OK ){
     aStack[i].i = pgno;
@@ -4544,7 +4649,7 @@ case OP_IntegrityCk: {
     toInt((char*)sqliteHashKey(i), &aRoot[j]);
   }
   aRoot[j] = 0;
-  z = sqliteBtreeIntegrityCheck(pOp->p2 ? db->pBeTemp : pBt, aRoot, nRoot);
+  z = sqliteBtreeIntegrityCheck(db->aDb[pOp->p2].pBt, aRoot, nRoot);
   if( z==0 || z[0]==0 ){
     if( z ) sqliteFree(z);
     zStack[tos] = "ok";
@@ -5669,8 +5774,7 @@ bad_instruction:
 */
 int sqliteVdbeFinalize(Vdbe *p, char **pzErrMsg){
   sqlite *db = p->db;
-  Btree *pBt = p->pBt;
-  int rc;
+  int i, rc;
 
   if( p->magic!=VDBE_MAGIC_RUN && p->magic!=VDBE_MAGIC_HALT ){
     sqliteSetString(pzErrMsg, sqlite_error_string(SQLITE_MISUSE), 0);
@@ -5689,23 +5793,24 @@ int sqliteVdbeFinalize(Vdbe *p, char **pzErrMsg){
     switch( p->errorAction ){
       case OE_Abort: {
         if( !p->undoTransOnError ){
-          sqliteBtreeRollbackCkpt(pBt);
-          if( db->pBeTemp ) sqliteBtreeRollbackCkpt(db->pBeTemp);
+          for(i=0; i<db->nDb; i++){
+            if( db->aDb[i].pBt ){
+              sqliteBtreeRollbackCkpt(db->aDb[i].pBt);
+            }
+          }
           break;
         }
         /* Fall through to ROLLBACK */
       }
       case OE_Rollback: {
-        sqliteBtreeRollback(pBt);
-        if( db->pBeTemp ) sqliteBtreeRollback(db->pBeTemp);
+        sqliteRollbackAll(db);
         db->flags &= ~SQLITE_InTrans;
         db->onError = OE_Default;
         break;
       }
       default: {
         if( p->undoTransOnError ){
-          sqliteBtreeCommit(pBt);
-          if( db->pBeTemp ) sqliteBtreeCommit(db->pBeTemp);
+          sqliteRollbackAll(db);
           db->flags &= ~SQLITE_InTrans;
           db->onError = OE_Default;
         }
@@ -5714,8 +5819,11 @@ int sqliteVdbeFinalize(Vdbe *p, char **pzErrMsg){
     }
     sqliteRollbackInternalChanges(db);
   }
-  sqliteBtreeCommitCkpt(pBt);
-  if( db->pBeTemp ) sqliteBtreeCommitCkpt(db->pBeTemp);
+  for(i=0; i<db->nDb; i++){
+    if( db->aDb[i].pBt ){
+      sqliteBtreeCommitCkpt(db->aDb[i].pBt);
+    }
+  }
   assert( p->tos<p->pc || sqlite_malloc_failed==1 );
 #ifdef VDBE_PROFILE
   {