/*
** Return the value of the iSize parameter specified when Bitvec *p
** was created.
*/
u32 sqlite3BitvecSize(Bitvec *p){
  return p->iSize;
}

int bitvecAppendArrayElem(int *pnAlloc, int *pnElem, u32 **paElem, u32 iNew){
  if( *pnElem==*pnAlloc ){
    int nNew = *pnAlloc ? (*pnAlloc)*2 : 128;
    u32 *aNew;
    aNew = sqlite3_realloc(*paElem, nNew*sizeof(u32));
    if( aNew==0 ){
      sqlite3_free(*paElem);
      *paElem = 0;
      return SQLITE_NOMEM;
    }
    *paElem = aNew;
    *pnAlloc = nNew;
  }

  (*paElem)[(*pnElem)++] = iNew;
  return SQLITE_OK;
}

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
int bitvecToArray(Bitvec *p, int iOff, int *pnAlloc, int *pnElem, u32 **paElem){
  int rc = SQLITE_OK;
  int i;
  if( p->iDivisor ){
    for(i=0; rc==SQLITE_OK && i<BITVEC_NPTR; i++){
      if( p->u.apSub[i] ){
        int iOff2 = iOff + i*p->iDivisor;
        rc = bitvecToArray(p->u.apSub[i], iOff2, pnAlloc, pnElem, paElem);
      }
    }
  }else{
    if( p->iSize<=BITVEC_NBIT ){
      for(i=0; rc==SQLITE_OK && i<BITVEC_NBIT; i++){
        if( p->u.aBitmap[i/BITVEC_SZELEM] & (1<<(i&(BITVEC_SZELEM-1))) ){
          rc = bitvecAppendArrayElem(pnAlloc, pnElem, paElem, i+iOff);
        }
      }
    }else{
      for(i=0; rc==SQLITE_OK && i<BITVEC_NINT; i++){
        u32 iVal = p->u.aHash[i];
        if( iVal ){
          rc = bitvecAppendArrayElem(pnAlloc, pnElem, paElem, iVal-1+iOff);
        }
      }
    }
  }

  return rc;
}

int sqlite3BitvecToArray(Bitvec *p, int *pnElem, u32 **paElem){
  int nAlloc = 0;
  *pnElem = 0;
  *paElem = 0;
  return bitvecToArray(p, 1, &nAlloc, pnElem, paElem);
}
#endif

#ifndef SQLITE_UNTESTABLE
/*
** Let V[] be an array of unsigned characters sufficient to hold
** up to N bits.  Let I be an integer between 0 and N.  0<=I<N.
** Then the following macros can be used to set, clear, or test
** individual bits within V.

  /* If obtaining a child page for a cursor, we must verify that the page is
  ** compatible with the root page. */
  if( pCur && ((*ppPage)->nCell<1 || (*ppPage)->intKey!=pCur->curIntKey) ){
    rc = SQLITE_CORRUPT_BKPT;
    releasePage(*ppPage);
    goto getAndInitPage_error;
  }

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
  if( pBt->inTransaction==TRANS_WRITE 
   && pgno<=sqlite3BitvecSize(pBt->pBtRead) 
  ){
    rc = sqlite3BitvecSet(pBt->pBtRead, pgno);
    if( rc!=SQLITE_OK ){
      releasePage(*ppPage);
      goto getAndInitPage_error;
    }
  }
#endif

  return SQLITE_OK;

getAndInitPage_error:
  if( pCur ) pCur->iPage--;
  testcase( pgno==0 );
  assert( pgno!=0 || rc==SQLITE_CORRUPT );
  return rc;

  sqlite3BtreeEnter(p);
  p->pBt->nPage = 0;
  rc = newDatabase(p->pBt);
  sqlite3BtreeLeave(p);
  return rc;
}

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
/*
** If the b-tree is not currently in a write transaction, free the various
** resources allocated for the sqlite3_transaction_pages() functionality.
*/
static void freeTransactionPagesBitvec(BtShared *pBt){
  if( pBt->inTransaction!=TRANS_WRITE ){
    sqlite3BitvecDestroy(pBt->pBtRead);
    sqlite3BitvecDestroy(pBt->pBtWrite);
    sqlite3BitvecDestroy(pBt->pBtAlloc);
    pBt->pBtAlloc = pBt->pBtRead = pBt->pBtWrite = 0;
    sqlite3_free(pBt->aiRead);
    sqlite3_free(pBt->aiWrite);
    pBt->aiRead = pBt->aiWrite = 0;
    pBt->nRead = pBt->nWrite = 0;
  }
}
#else
# define freeTransactionPagesBitvec(x) 
#endif

/*
** Attempt to start a new transaction. A write-transaction
** is started if the second argument is nonzero, otherwise a read-
** transaction.  If the second argument is 2 or more and exclusive
** transaction is started, meaning that no other process is allowed
** to access the database.  A preexisting transaction may not be
** upgraded to exclusive by calling this routine a second time - the

    if( pBlock ){
      sqlite3ConnectionBlocked(p->db, pBlock);
      rc = SQLITE_LOCKED_SHAREDCACHE;
      goto trans_begun;
    }
  }
#endif

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
  if( wrflag ){
    assert( pBt->pBtRead==0 && pBt->pBtWrite==0 && pBt->pBtAlloc==0 );
    assert( rc==SQLITE_OK );
    pBt->pBtRead = sqlite3BitvecCreate(pBt->nPage);
    pBt->pBtWrite = sqlite3BitvecCreate(pBt->nPage);
    pBt->pBtAlloc = sqlite3BitvecCreate(pBt->nPage);
    if( pBt->pBtRead==0 || pBt->pBtWrite==0 || pBt->pBtAlloc==0 ){
      rc = SQLITE_NOMEM;
      goto trans_begun;
    }
  }
#endif

  /* Any read-only or read-write transaction implies a read-lock on 
  ** page 1. So if some other shared-cache client already has a write-lock 
  ** on page 1, the transaction cannot be opened. */
  rc = querySharedCacheTableLock(p, MASTER_ROOT, READ_LOCK);
  if( SQLITE_OK!=rc ) goto trans_begun;

        if( rc==SQLITE_OK ){
          put4byte(&pPage1->aData[28], pBt->nPage);
        }
      }
    }
  }


trans_begun:
  if( rc==SQLITE_OK && wrflag ){
    /* This call makes sure that the pager has the correct number of
    ** open savepoints. If the second parameter is greater than 0 and
    ** the sub-journal is not already open, then it will be opened here.
    */
    rc = sqlite3PagerOpenSavepoint(pBt->pPager, p->db->nSavepoint);
  }

  freeTransactionPagesBitvec(pBt);
  btreeIntegrity(p);
  sqlite3BtreeLeave(p);
  return rc;
}

#ifndef SQLITE_OMIT_AUTOVACUUM

    /* Set the current transaction state to TRANS_NONE and unlock the 
    ** pager if this call closed the only read or write transaction.  */
    p->inTrans = TRANS_NONE;
    unlockBtreeIfUnused(pBt);
  }

  freeTransactionPagesBitvec(pBt);
  btreeIntegrity(p);
}

/*
** Commit the transaction currently in progress.
**
** This routine implements the second phase of a 2-phase commit.  The

    memcpy(pPayload, pBuf, nByte);
  }else{
    /* Copy data from page to buffer (a read operation) */
    memcpy(pBuf, pPayload, nByte);
  }
  return SQLITE_OK;
}

/*
** Call PagerWrite() on pager page pDbPage. And, if the page is currently
** in the pBtRead bit vector, add it to pBtWrite as well.
*/
static int pagerWrite(BtShared *pBt, DbPage *pDbPage){
  Pgno pgno = sqlite3PagerPagenumber(pDbPage);
  int rc = SQLITE_OK;
#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
  if( sqlite3BitvecTestNotNull(pBt->pBtRead, pgno) ){
    rc = sqlite3BitvecSet(pBt->pBtWrite, pgno);
  }
#endif
  if( rc==SQLITE_OK ){
    rc = sqlite3PagerWrite(pDbPage);
  }
  return rc;
}

/*
** This function is used to read or overwrite payload information
** for the entry that the pCur cursor is pointing to. The eOp
** argument is interpreted as follows:
**
**   0: The operation is a read. Populate the overflow cache.

  /* Check if data must be read/written to/from the btree page itself. */
  if( offset<pCur->info.nLocal ){
    int a = amt;
    if( a+offset>pCur->info.nLocal ){
      a = pCur->info.nLocal - offset;
    }
#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
    if( eOp & 0x01 ){
      rc = pagerWrite(pBt, pPage->pDbPage);
    }
#endif
    if( rc==SQLITE_OK ){
      rc = copyPayload(&aPayload[offset], pBuf, a, (eOp&0x01), pPage->pDbPage);
    }
    offset = 0;
    pBuf += a;
    amt -= a;
  }else{
    offset -= pCur->info.nLocal;
  }

      releasePage(*ppPage);
      *ppPage = 0;
    }
    TRACE(("ALLOCATE: %d from end of file\n", *pPgno));
  }

  assert( *pPgno!=PENDING_BYTE_PAGE(pBt) );

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
  if( rc==SQLITE_OK && *pPgno<sqlite3BitvecSize(pBt->pBtAlloc) ){
    rc = sqlite3BitvecSet(pBt->pBtAlloc, *pPgno);
    if( rc!=SQLITE_OK ){
      releasePage(*ppPage);
      *ppPage = 0;
    }
  }
#endif

end_allocate_page:
  releasePage(pTrunk);
  releasePage(pPrevTrunk);
  assert( rc!=SQLITE_OK || sqlite3PagerPageRefcount((*ppPage)->pDbPage)<=1 );
  assert( rc!=SQLITE_OK || (*ppPage)->isInit==0 );
  return rc;

                       - pPage->childPtrSize - 8;
  }else{
    memmove(ptr, ptr+2, 2*(pPage->nCell - idx));
    put2byte(&data[hdr+3], pPage->nCell);
    pPage->nFree += 2;
  }
}


/*
** Insert a new cell on pPage at cell index "i".  pCell points to the
** content of the cell.
**
** If the cell content will fit on the page, then put it there.  If it
** will not fit, then make a copy of the cell content into pTemp if

    ** sorted order.  This invariants arise because multiple overflows can
    ** only occur when inserting divider cells into the parent page during
    ** balancing, and the dividers are adjacent and sorted.
    */
    assert( j==0 || pPage->aiOvfl[j-1]<(u16)i ); /* Overflows in sorted order */
    assert( j==0 || i==pPage->aiOvfl[j-1]+1 );   /* Overflows are sequential */
  }else{
    int rc = pagerWrite(pPage->pBt, pPage->pDbPage);
    if( rc!=SQLITE_OK ){
      *pRC = rc;
      return;
    }
    assert( sqlite3PagerIswriteable(pPage->pDbPage) );
    data = pPage->aData;
    assert( &data[pPage->cellOffset]==pPage->aCellIdx );

  */
  pageFlags = apOld[0]->aData[0];
  for(i=0; i<k; i++){
    MemPage *pNew;
    if( i<nOld ){
      pNew = apNew[i] = apOld[i];
      apOld[i] = 0;
      rc = pagerWrite(pBt, pNew->pDbPage);
      nNew++;
      if( rc ) goto balance_cleanup;
    }else{
      assert( i>0 );
      rc = allocateBtreePage(pBt, &pNew, &pgno, (bBulk ? 1 : pgno), 0);
      if( rc ) goto balance_cleanup;
      zeroPage(pNew, pageFlags);

  assert( pRoot->nOverflow>0 );
  assert( sqlite3_mutex_held(pBt->mutex) );

  /* Make pRoot, the root page of the b-tree, writable. Allocate a new 
  ** page that will become the new right-child of pPage. Copy the contents
  ** of the node stored on pRoot into the new child page.
  */
  rc = pagerWrite(pBt, pRoot->pDbPage);
  if( rc==SQLITE_OK ){
    rc = allocateBtreePage(pBt,&pChild,&pgnoChild,pRoot->pgno,0);
    copyNodeContent(pRoot, pChild, &rc);
    if( ISAUTOVACUUM ){
      ptrmapPut(pBt, pgnoChild, PTRMAP_BTREE, pRoot->pgno, &rc);
    }
  }

      }
    }else if( pPage->nOverflow==0 && pPage->nFree<=nMin ){
      break;
    }else{
      MemPage * const pParent = pCur->apPage[iPage-1];
      int const iIdx = pCur->aiIdx[iPage-1];

      rc = pagerWrite(pParent->pBt, pParent->pDbPage);
      if( rc==SQLITE_OK ){
#ifndef SQLITE_OMIT_QUICKBALANCE
        if( pPage->intKeyLeaf
         && pPage->nOverflow==1
         && pPage->aiOvfl[0]==pPage->nCell
         && pParent->pgno!=1
         && pParent->nCell==iIdx

  if( rc ) goto end_insert;
  assert( szNew==pPage->xCellSize(pPage, newCell) );
  assert( szNew <= MX_CELL_SIZE(pBt) );
  idx = pCur->aiIdx[pCur->iPage];
  if( loc==0 ){
    CellInfo info;
    assert( idx<pPage->nCell );
    rc = pagerWrite(pBt, pPage->pDbPage);
    if( rc ){
      goto end_insert;
    }
    oldCell = findCell(pPage, idx);
    if( !pPage->leaf ){
      memcpy(newCell, oldCell, 4);
    }

  if( pCur->pKeyInfo==0 ){
    invalidateIncrblobCursors(p, pCur->info.nKey, 0);
  }

  /* Make the page containing the entry to be deleted writable. Then free any
  ** overflow pages associated with the entry and finally remove the cell
  ** itself from within the page.  */
  rc = pagerWrite(pBt, pPage->pDbPage);
  if( rc ) return rc;
  rc = clearCell(pPage, pCell, &info);
  dropCell(pPage, iCellIdx, info.nSize, &rc);
  if( rc ) return rc;

  /* If the cell deleted was not located on a leaf page, then the cursor
  ** is currently pointing to the largest entry in the sub-tree headed

    pCell = findCell(pLeaf, pLeaf->nCell-1);
    if( pCell<&pLeaf->aData[4] ) return SQLITE_CORRUPT_BKPT;
    nCell = pLeaf->xCellSize(pLeaf, pCell);
    assert( MX_CELL_SIZE(pBt) >= nCell );
    pTmp = pBt->pTmpSpace;
    assert( pTmp!=0 );
    rc = pagerWrite(pBt, pLeaf->pDbPage);
    if( rc==SQLITE_OK ){
      insertCell(pPage, iCellIdx, pCell-4, nCell+4, pTmp, n, &rc);
    }
    dropCell(pLeaf, pLeaf->nCell-1, nCell, &rc);
    if( rc ) return rc;
  }

  }else if( pnChange ){
    assert( pPage->intKey || CORRUPT_DB );
    testcase( !pPage->intKey );
    *pnChange += pPage->nCell;
  }
  if( freePageFlag ){
    freePage(pPage, &rc);
  }else if( (rc = pagerWrite(pBt, pPage->pDbPage))==0 ){
    zeroPage(pPage, pPage->aData[hdr] | PTF_LEAF);
  }

cleardatabasepage_out:
  pPage->bBusy = 0;
  releasePage(pPage);
  return rc;

}

/*
** Return the size of the header added to each page by this module.
*/
int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage)); }

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
int sqlite3BtreeTransactionPages(
  Btree *pBtree,                  /* Btree handle */
  int *pnRead, u32 **paiRead,     /* OUT: Pages read */
  int *pnWrite, u32 **paiWrite    /* OUT: Pages written */
){
  int rc = SQLITE_OK;
  BtShared *pBt = pBtree->pBt;
  sqlite3BtreeEnter(pBtree);
  sqlite3_free(pBt->aiRead);
  sqlite3_free(pBt->aiWrite);
  pBt->nRead = pBt->nWrite = 0;
  pBt->aiRead = pBt->aiWrite = 0;
  if( pBtree->inTrans==TRANS_WRITE ){
    assert( pBt->inTransaction==TRANS_WRITE );
    rc = sqlite3BitvecToArray(pBt->pBtRead, &pBt->nRead, &pBt->aiRead);
    if( rc==SQLITE_OK ){
      rc = sqlite3BitvecToArray(pBt->pBtWrite, &pBt->nWrite, &pBt->aiWrite);
    }
  }
  *pnRead = pBt->nRead;
  *paiRead = pBt->aiRead;
  *pnWrite = pBt->nWrite;
  *paiWrite = pBt->aiWrite;
  sqlite3BtreeLeave(pBtree);
  return rc;
}
#endif  /* SQLITE_ENABLE_TRANSACTION_PAGES */

#if !defined(SQLITE_OMIT_SHARED_CACHE)
/*
** Return true if the Btree passed as the only argument is sharable.
*/
int sqlite3BtreeSharable(Btree *p){
  return p->sharable;
}

# define sqlite3BtreeLeaveCursor(X)
# define sqlite3BtreeLeaveAll(X)

# define sqlite3BtreeHoldsMutex(X) 1
# define sqlite3BtreeHoldsAllMutexes(X) 1
# define sqlite3SchemaMutexHeld(X,Y,Z) 1
#endif

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
  int sqlite3BtreeTransactionPages(Btree*, int*, u32**, int*, u32**);
#endif


#endif /* SQLITE_BTREE_H */

#ifndef SQLITE_OMIT_SHARED_CACHE
  int nRef;             /* Number of references to this structure */
  BtShared *pNext;      /* Next on a list of sharable BtShared structs */
  BtLock *pLock;        /* List of locks held on this shared-btree struct */
  Btree *pWriter;       /* Btree with currently open write transaction */
#endif
  u8 *pTmpSpace;        /* Temp space sufficient to hold a single cell */

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
  Bitvec *pBtRead;      /* Btree pages read during current write transaction */
  Bitvec *pBtWrite;     /* Btree pages written during current transaction */
  Bitvec *pBtAlloc;     /* Btree pages allocated during current transaction */
  int nRead;            /* Number of entries in aiRead[] array */
  u32 *aiRead;          /* Array returned to sqlite3_transaction_pages() */
  int nWrite;           /* Number of entries in aiWrite[] array */
  u32 *aiWrite;         /* Array returned to sqlite3_transaction_pages() */
#endif
};

/*
** Allowed values for BtShared.btsFlags
*/
#define BTS_READ_ONLY        0x0001   /* Underlying file is readonly */
#define BTS_PAGESIZE_FIXED   0x0002   /* Page size can no longer be changed */

/*
** Free a snapshot handle obtained from sqlite3_snapshot_get().
*/
void sqlite3_snapshot_free(sqlite3_snapshot *pSnapshot){
  sqlite3_free(pSnapshot);
}

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
/*
** Return the pages read and written by the current write transaction.
*/
int sqlite3_transaction_pages(
    sqlite3 *db, const char *zDbName, 
    int *pnRead, unsigned int **paRead,
    int *pnWrite, unsigned int **paWrite
){
  Btree *pBt;                     /* Btree to query */
  int rc;                         /* Return code */
#ifdef SQLITE_ENABLE_API_ARMOR
  if( !sqlite3SafetyCheckOk(db) ){
    (void)SQLITE_MISUSE_BKPT;
    return 0;
  }
#endif

  sqlite3_mutex_enter(db->mutex);
  pBt = sqlite3DbNameToBtree(db, zDbName);
  if( pBt==0 ) return SQLITE_ERROR;
  rc = sqlite3BtreeTransactionPages(pBt, pnRead, paRead, pnWrite, paWrite);
  sqlite3_mutex_leave(db->mutex);

  return rc;
}
#endif  /* SQLITE_ENABLE_TRANSACTION_PAGES */

#endif /* SQLITE_ENABLE_SNAPSHOT */

  assert( !pPager->aSavepoint && !pPager->pInJournal );
  assert( !isOpen(pPager->jfd) && !isOpen(pPager->sjfd) );

  sqlite3_free(pPager);
  return SQLITE_OK;
}

#if !defined(NDEBUG) || defined(SQLITE_TEST) || defined(SQLITE_ENABLE_TRANSACTION_PAGES)
/*
** Return the page number for page pPg.
*/
Pgno sqlite3PagerPagenumber(DbPage *pPg){
  return pPg->pgno;
}
#endif

void sqlite3PagerRekey(DbPage*, Pgno, u16);

#if defined(SQLITE_HAS_CODEC) && !defined(SQLITE_OMIT_WAL)
void *sqlite3PagerCodec(DbPage *);
#endif

/* Functions to support testing and debugging. */
#if !defined(NDEBUG) || defined(SQLITE_TEST) || defined(SQLITE_ENABLE_TRANSACTION_PAGES)
  Pgno sqlite3PagerPagenumber(DbPage*);
#endif
#if !defined(NDEBUG) || defined(SQLITE_TEST)
  int sqlite3PagerIswriteable(DbPage*);
#endif
#ifdef SQLITE_TEST
  int *sqlite3PagerStats(Pager*);
  void sqlite3PagerRefdump(Pager*);
  void disable_simulated_io_errors(void);
  void enable_simulated_io_errors(void);

** sqlite3_snapshot_open(). It is an error if there is already a read
** transaction open on the database, or if the database is not a wal mode
** database.
**
** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
*/
SQLITE_EXPERIMENTAL int sqlite3_snapshot_recover(sqlite3 *db, const char *zDb);


/*
** THIS API IS A HACK ONLY. 
**
** Return the page numbers of all b-tree pages read from or written to
** database zDb ("main", "temp" etc.) belonging to handle db since the 
** current write transaction was started. A page is only reported on if:
**
**   + It is a b-tree page, not an overflow, free or pointer-map page, and
**
**   + it was a b-tree page when the transaction was started (i.e. is not a 
**     b-tree page created by reusing free page or extending the database 
**     file).
**
** If successful, this function returns SQLITE_OK and sets the four output
** variables as follows:
**
**   + (*paRead) is set to point to an array containing the page numbers
**     of all pages read since the current write transaction was opened.
**     (*pnRead) is set to the number of elements in this array.
**
**   + (*paWrite) is set to point to an array containing the page numbers
**     of all pages written since the current write transaction was opened.
**     (*paRead) is set to the number of elements in this array.
**
** The array references are valid until the next call to this API function
** on the same database or until the database is DETACHed from the database 
** handle.
**
** If this function is called when there is no write transaction opened
** on the specified database, all four output parameters are set to 0.
**
** If an error occurs, an SQLite error code is returned (e.g. SQLITE_NOMEM)
** and the final values of the four output parameters are undefined.
**
** This function is only enabled if SQLITE_ENABLE_TRANSACTION_PAGES is
** defined during compilation.
*/
SQLITE_EXPERIMENTAL int sqlite3_transaction_pages(
    sqlite3 *db, const char *zDb, 
    int *pnRead, unsigned int **paRead,
    int *pnWrite, unsigned int **paWrite
);




/*
** Undo the hack that converts floating point types to integer for
** builds on processors without floating point support.
*/
#ifdef SQLITE_OMIT_FLOATING_POINT
# undef double

int sqlite3BitvecSet(Bitvec*, u32);
void sqlite3BitvecClear(Bitvec*, u32, void*);
void sqlite3BitvecDestroy(Bitvec*);
u32 sqlite3BitvecSize(Bitvec*);
#ifndef SQLITE_UNTESTABLE
int sqlite3BitvecBuiltinTest(int,int*);
#endif

#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
  int sqlite3BitvecToArray(Bitvec *p, int *pnElem, u32 **paElem);
#endif

RowSet *sqlite3RowSetInit(sqlite3*, void*, unsigned int);
void sqlite3RowSetClear(RowSet*);
void sqlite3RowSetInsert(RowSet*, i64);
int sqlite3RowSetTest(RowSet*, int iBatch, i64);
int sqlite3RowSetNext(RowSet*, i64*);

  zFile = (const char*)Tcl_GetString(objv[1]);
  rc = sqlite3_delete_database(zFile);

  Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
  return TCL_OK;
}

/*
** Usage: sqlite3_transaction_pages DB FILENAME
*/
#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
static int SQLITE_TCLAPI test_transaction_pages(
  void * clientData,
  Tcl_Interp *interp,
  int objc,
  Tcl_Obj *CONST objv[]
){
  const char *zDb;
  sqlite3 *db;
  int rc;

  int nRead;
  int nWrite;
  unsigned int *aiRead;
  unsigned int *aiWrite;

  if( objc!=3 ){
    Tcl_WrongNumArgs(interp, 1, objv, "DB FILE");
    return TCL_ERROR;
  }
  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR;
  zDb = (const char*)Tcl_GetString(objv[2]);

  rc = sqlite3_transaction_pages(db, zDb, &nRead, &aiRead, &nWrite, &aiWrite);
  if( rc==SQLITE_OK ){
    Tcl_Obj *pList = Tcl_NewObj();
    Tcl_Obj *p = Tcl_NewObj();
    int i;
    for(i=0; i<nRead; i++){
      Tcl_ListObjAppendElement(interp, p, Tcl_NewIntObj((int)aiRead[i]));
    }
    Tcl_ListObjAppendElement(interp, pList, p);
    p = Tcl_NewObj();
    for(i=0; i<nWrite; i++){
      Tcl_ListObjAppendElement(interp, p, Tcl_NewIntObj((int)aiWrite[i]));
    }
    Tcl_ListObjAppendElement(interp, pList, p);
    Tcl_SetObjResult(interp, pList);
  }else{
    Tcl_SetObjResult(interp, Tcl_NewStringObj(sqlite3ErrName(rc), -1));
    return TCL_ERROR;
  }
  return TCL_OK;
}
#endif

/*
** Usage:  sqlite3_next_stmt  DB  STMT
**
** Return the next statment in sequence after STMT.
*/
static int SQLITE_TCLAPI test_next_stmt(
  void * clientData,

     { "sqlite3_snapshot_cmp", test_snapshot_cmp, 0 },
     { "sqlite3_snapshot_recover", test_snapshot_recover, 0 },
     { "sqlite3_snapshot_get_blob", test_snapshot_get_blob, 0 },
     { "sqlite3_snapshot_open_blob", test_snapshot_open_blob, 0 },
     { "sqlite3_snapshot_cmp_blob", test_snapshot_cmp_blob, 0 },
#endif
     { "sqlite3_delete_database", test_delete_database, 0 },
#ifdef SQLITE_ENABLE_TRANSACTION_PAGES
     { "sqlite3_transaction_pages", test_transaction_pages, 0 },
#endif
  };
  static int bitmask_size = sizeof(Bitmask)*8;
  static int longdouble_size = sizeof(LONGDOUBLE_TYPE);
  int i;
  extern int sqlite3_sync_count, sqlite3_fullsync_count;
  extern int sqlite3_opentemp_count;
  extern int sqlite3_like_count;

# 2017-01-19
#
# The author disclaims copyright to this source code.  In place of
# a legal notice, here is a blessing:
#
#    May you do good and not evil.
#    May you find forgiveness for yourself and forgive others.
#    May you share freely, never taking more than you give.
#
#***********************************************************************
#

set testdir [file dirname $argv0]
source $testdir/tester.tcl
set ::testprefix tpages

sqlite3_test_control_pending_byte 0x1000000

proc integers {iFirst n} {
  set ret [list]
  for {set i $iFirst} {$i<$iFirst+$n} {incr i} {
    lappend ret $i
  }
  set ret
}

do_execsql_test 1.0 {
  CREATE TABLE t1(a, b, c);
  WITH s(i) AS (
    SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<99
  )
  INSERT INTO t1 SELECT randomblob(10), randomblob(400), randomblob(400) FROM s;
}

foreach {n1 n2} {
      0   10 
     10   20
   5000   20
   5000 5000
   5001 5001
  60000 5001
  60000    5
   5000 1000
   6000 1000
   7000 1000
} {
  set n1 [expr $n1]
  set n2 [expr $n2]

  reset_db
  do_execsql_test 1.$n1.1 {
    CREATE TABLE t1(a, b, c);
    WITH s(i) AS (
        SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<$n1
    )
    INSERT INTO t1 
    SELECT randomblob(10), randomblob(400), randomblob(400) FROM s;
  }

  set iFirst [expr [db one {PRAGMA page_count}] + 1]
  do_execsql_test 1.$n1.2 {
    CREATE TABLE t2(a, b, c);
    WITH s(i) AS (
        SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<$n2
    )
    INSERT INTO t2 
    SELECT randomblob(10), randomblob(400), randomblob(400) FROM s;
  }
  set nInt [expr [db one {PRAGMA page_count}] - $iFirst + 1]

  do_test 1.$n1.3 {
    execsql {
      BEGIN IMMEDIATE;
      SELECT * FROM t2;
    }
    sqlite3_transaction_pages db main
  } [list [integers $iFirst $nInt] {}]
  execsql cOMMIT
}

#-------------------------------------------------------------------------
#
proc do_transaction_pages_test {tn sql pages} {
  uplevel [list execsql $sql]
  uplevel [list \
    do_test $tn {sqlite3_transaction_pages db main} [list {*}$pages]
  ]
}
reset_db
do_transaction_pages_test 2.0 {
  PRAGMA auto_vacuum = 0;
  PRAGMA page_size = 1024;
  CREATE TABLE t1(x);
  BEGIN;
    INSERT INTO t1 VALUES(randomblob(1500));
} {2 2}

do_transaction_pages_test 2.1 {
  COMMIT;
  BEGIN;
    DELETE FROM t1;
} {2 2}

reset_db
do_execsql_test 2.2 {
  PRAGMA auto_vacuum = 0;
  PRAGMA page_size = 1024;
  CREATE TABLE t1(x);
  INSERT INTO t1 VALUES(randomblob(900));
  INSERT INTO t1 VALUES(randomblob(900));
  CREATE TABLE t2(y);
}  

do_transaction_pages_test 2.3 {
  BEGIN;
    UPDATE t1 SET x=randomblob(899);
} {{2 3 4} {3 4}}

do_transaction_pages_test 2.4 {
    DELETE FROM t1;
  COMMIT;
} {{} {}}

do_transaction_pages_test 2.5 {
  BEGIN;
    INSERT INTO t2 VALUES(randomblob(900));
    INSERT INTO t2 VALUES(randomblob(900));
} {5 5}

do_transaction_pages_test 2.6 {
  COMMIT;
  BEGIN;
    INSERT INTO t1 VALUES(randomblob(900));
} {2 2}

do_transaction_pages_test 2.7 {
    INSERT INTO t1 VALUES(randomblob(900));
    INSERT INTO t1 VALUES(randomblob(900));
    INSERT INTO t1 VALUES(randomblob(900));
    INSERT INTO t1 VALUES(randomblob(900));
} {2 2}

finish_test