SQLite4  Check-in [9e00823074]

              clients are still running) whereas lsmtest2.c tests recovery
              from a system or power failure.

  lsmtest9.c: More data tests. These focus on testing that calling
              lsm_work(nMerge=1) to compact the database does not corrupt it.
              In other words, that databases containing block-redirects
              can be read and written.

** Begin(): If (L>=iLevel), this is a no-op. Otherwise, open the read and/or
**          write transactions required to set L to iLevel.
**
** Commit(): If (L<=iLevel), this is a no-op. Otherwise, close as many
**           transactions as required to set L to iLevel. Commit any write
**           transactions closed by this action.
**
** Rollback(): If (L<=iLevel), this is a no-op. Otherwise, rollback and 
**             close as many transactions as required to set L to iLevel. 
**             Then, if iLevel is greater than or equal to 2, rollback



**             (but do not close) the innermost remaining sub-transaction.
**
**    SAVEPOINT one;              -- Begin(2)
**      SAVEPOINT two;            -- Begin(3)
**      ROLLBACK TO one;          -- Rollback(2)
**      SAVEPOINT two;            -- Begin(3)
**        SAVEPOINT three;        -- Begin(4)
**        ROLLBACK TO three;      -- Rollback(5)
**        RELEASE three;          -- Commit(3)
**    RELEASE one;                -- Commit(1)
**
** The TransactionLevel() method returns the current transaction level.
*/
int sqlite4BtBegin(bt_db*, int iLevel);
int sqlite4BtCommit(bt_db*, int iLevel);

int sqlite4BtRollback(bt_db*, int iLevel);
int sqlite4BtTransactionLevel(bt_db*);

/*
** Open and close a database cursor.
*/
int sqlite4BtCsrOpen(bt_db*, int nExtra, bt_cursor **ppCsr);

/* By default auto-checkpoint is 1000 */
#define BT_DEFAULT_AUTOCKPT 1000

typedef struct BtPageHash BtPageHash;
typedef struct BtDbhdr BtDbhdr;

typedef struct BtSavepoint BtSavepoint;
typedef struct BtSavepage BtSavepage;

/*
** Hash table for page references currently in memory. Manipulated using
** the following functions:
**
**     btHashAdd()
**     btHashRemove()
**     btHashSearch()
**     btHashClear()
*/
struct BtPageHash {
  int nEntry;                     /* Number of entries in hash table */
  int nHash;                      /* Size of aHash[] array */
  BtPage **aHash;                 /* Hash array */
};

/*
** There is one object of this type for each open sub-transaction. Stored
** in the BtPager.aSavepoint[] array.
*/
struct BtSavepoint {
  int iLevel;                     /* Transaction level value (always >2) */
  BtSavepage *pSavepage;          /* First in linked list of saved data */
};

struct BtSavepage {
  BtPage *pPg;                    /* Pointer to page this object belongs to */
  u8 *aData;                      /* Saved data */
  BtSavepage *pNext;              /* Next saved page in the same savepoint */
  int iSavepoint;                 /* Transaction number of savepoint */
  BtSavepage *pNextSavepage;      /* Next saved page on the same BtPage */
};

struct BtPage {
  BtPager *pPager;                /* Pager object that owns this page handle */
  u32 pgno;                       /* Current page number */
  int nRef;                       /* Number of references to this page */
  int flags;                      /* Mask of BTPAGE_XXX flags */
  u8 *aData;                      /* Pointer to current data */
  BtPage *pNextHash;              /* Next entry with same hash key */
  BtPage *pNextDirty;             /* Next page in BtPager.pDirty list */
  BtSavepage *pSavepage;          /* List of saved page images */
};

/*
** Candidate values for BtPage.flags
*/
#define BT_PAGE_DIRTY 0x0001      /* Set for pages in BtPager.pDirty list */

  int nFile;                      /* Length of string zFile in bytes */
  BtPageHash hash;                /* Hash table */
  BtPage *pDirty;                 /* List of all dirty pages */
  int nTotalRef;                  /* Total number of outstanding page refs */
  int nAutoCkpt;                  /* Auto-checkpoint when log is this large */
  int bDoAutoCkpt;                /* Do auto-checkpoint after next unlock */
  BtDbhdr dbhdr;
  BtSavepoint *aSavepoint;        /* Savepoint array */
  int nSavepoint;                 /* Number of entries in aSavepoint array */
};


/**************************************************************************
** Interface to BtPageHash object.
*/

static int btCleanup(BtLock *pLock){
  BtPager *p = (BtPager*)pLock;
  int rc = sqlite4BtLogClose(p->pLog, 1);
  p->pLog = 0;
  return rc;
}

static int btOpenSavepoints(BtPager *p, int iLevel){
  int rc = SQLITE4_OK;            /* Return code */
  int nReq = iLevel - 2;          /* Required number of savepoints */

  if( nReq>p->nSavepoint ){
    BtSavepoint *aNew;
    int nByte = (nReq * sizeof(BtSavepoint));

    aNew = sqlite4_realloc(p->btl.pEnv, p->aSavepoint, nByte);
    if( aNew ){
      int i;
      for(i=p->nSavepoint; i<nReq; i++){
        aNew[i].pSavepage = 0;
        aNew[i].iLevel = i+3;
      }
      p->aSavepoint = aNew;
      p->nSavepoint = nReq;
    }else{
      rc = btErrorBkpt(SQLITE4_NOMEM);
    }
  }

  return rc;
}

static void btCloseSavepoints(BtPager *p, int iLevel){
  int nReq = MAX(iLevel - 2, 0);
  if( nReq<p->nSavepoint ){
    int i;
    for(i=p->nSavepoint-1; i>=nReq; i--){
      BtSavepoint *pSavepoint = &p->aSavepoint[i];
      BtSavepage *pSavepage;
      BtSavepage *pNext;

      /* Loop through each of the BtSavepage objects associated with this
      ** savepoint. Detach them from the BtPage objects and free all
      ** allocated memory.  */
      for(pSavepage=pSavepoint->pSavepage; pSavepage; pSavepage=pNext){
        BtPage *pPg = pSavepage->pPg;
        pNext = pSavepage->pNext;

        /* Detach the BtSavepage from its BtPage object */
        assert( pSavepage==pPg->pSavepage );
        pPg->pSavepage = pSavepage->pNextSavepage;

        /* Free associated memory allocations */
        sqlite4_free(p->btl.pEnv, pSavepage->aData);
        sqlite4_free(p->btl.pEnv, pSavepage);
      }
    }

    p->nSavepoint = nReq;
  }
}

/*
** If it has not already been added, add page pPg to the innermost 
** savepoint.
*/
static int btAddToSavepoint(BtPager *p, BtPage *pPg){
  int rc = SQLITE4_OK;
  BtSavepage *pSavepage;
  int iLevel = p->iTransactionLevel;

  /* Check if there is already a BtSavepage for this page associated with
  ** the innermost open savepoint. If so, this function becomes a no-op.  */
  for(pSavepage=pPg->pSavepage; pSavepage; pSavepage=pSavepage->pNextSavepage){
    if( pSavepage->iSavepoint==iLevel ) break;
  }

  if( pSavepage==0 ){
    pSavepage = sqlite4_malloc(p->btl.pEnv, sizeof(BtSavepage));
    if( pSavepage==0 ){
      rc = btErrorBkpt(SQLITE4_NOMEM);
    }else{
      memset(pSavepage, 0, sizeof(BtSavepage));
    }

    if( rc==SQLITE4_OK && (1 || (pPg->flags & BT_PAGE_DIRTY)) ){
      pSavepage->aData = (u8*)sqlite4_malloc(p->btl.pEnv, p->dbhdr.pgsz);
      if( pSavepage->aData==0 ){
        sqlite4_free(p->btl.pEnv, pSavepage);
        rc = btErrorBkpt(SQLITE4_NOMEM);
      }else{
        memcpy(pSavepage->aData, pPg->aData, p->dbhdr.pgsz);
      }
    }

    if( rc==SQLITE4_OK ){
      pSavepage->pPg = pPg;
      pSavepage->iSavepoint = iLevel;

      pSavepage->pNextSavepage = pPg->pSavepage;
      pPg->pSavepage = pSavepage;

      assert( p->aSavepoint[iLevel-3].iLevel==iLevel ); 
      pSavepage->pNext = p->aSavepoint[iLevel-3].pSavepage;
      p->aSavepoint[iLevel-3].pSavepage = pSavepage;
    }
  }

  return rc;
}

/*
** Close a pager database handle.
*/
int sqlite4BtPagerClose(BtPager *p){

  int rc;

  rc = sqlite4BtLockDisconnect((BtLock*)p, btCheckpoint, btCleanup);

  if( p->btl.pFd ){
    p->btl.pVfs->xClose(p->btl.pFd);
  }

  btCloseSavepoints(p, 0);
  btPurgeCache(p);
  sqlite4BtLogClose(p->pLog, 0);
  sqlite4_free(p->btl.pEnv, p->zFile);
  sqlite4_free(p->btl.pEnv, p->aSavepoint);
  sqlite4_free(p->btl.pEnv, p);
  return rc;
}

/*
** Return a pointer to the nExtra bytes of space allocated by PagerNew().
*/

** Commit the current write transaction to disk.
*/
static int btCommitTransaction(BtPager *p){
  int rc = SQLITE4_OK;
  BtPage *pPg;
  BtPage *pNext;
  assert( p->iTransactionLevel>=2 );

  btCloseSavepoints(p, 2);

  for(pPg=p->pDirty; pPg; pPg=pNext){
    pNext = pPg->pNextDirty;
    pPg->flags &= ~(BT_PAGE_DIRTY);
    pPg->pNextDirty = 0;
    if( rc==SQLITE4_OK ){
      int bCommit = (pNext==0);

  }

  *ppPg = pRet;
  return rc;
}

/*
** Roll back, but do not close, the current write transaction. 
*/
static int btRollbackTransaction(BtPager *p){
  int rc = SQLITE4_OK;
  BtPage *pPg;
  BtPage *pNext;

  assert( p->iTransactionLevel>=2 );
  btCloseSavepoints(p, 2);

  /* Load the old db header from disk */
  rc = p->btl.pVfs->xRead(p->btl.pFd, 0, &p->dbhdr, sizeof(p->dbhdr));

  /* Loop through all dirty pages in memory. Discard those with nRef==0.
  ** Reload data from disk for any others.  */
  for(pPg=p->pDirty; pPg; pPg=pNext){
    pNext = pPg->pNextDirty;
    pPg->flags &= ~(BT_PAGE_DIRTY);
    pPg->pNextDirty = 0;
    if( pPg->nRef==0 ){
      btHashRemove(p, pPg);
      btFreePage(p, pPg);
    }else if( rc==SQLITE4_OK && (pPg->pgno<=p->dbhdr.nPg) ){
      rc = btLoadPageData(p, pPg);
    }
  }
  p->pDirty = 0;


  return rc;
}

static int btRollbackSavepoints(BtPager *p, int iLevel){
  int nReq = iLevel - 2;

  assert( nReq>=1 );
  if( nReq<=p->nSavepoint ){
    int i;
    for(i=p->nSavepoint-1; i>=(nReq-1); i--){
      BtSavepoint *pSavepoint = &p->aSavepoint[i];
      BtSavepage *pSavepage;
      BtSavepage *pNext;

      /* Loop through each of the BtSavepage objects associated with this
      ** savepoint. Detach them from the BtPage objects and free all
      ** allocated memory.  */
      for(pSavepage=pSavepoint->pSavepage; pSavepage; pSavepage=pNext){
        BtPage *pPg = pSavepage->pPg;
        pNext = pSavepage->pNext;

        /* Detach the BtSavepage from its BtPage object */
        assert( pSavepage==pPg->pSavepage );
        pPg->pSavepage = pSavepage->pNextSavepage;

        /* Restore the page data */
        memcpy(pPg->aData, pSavepage->aData, p->dbhdr.pgsz);

        /* Free associated memory allocations */
        assert( pSavepage->aData ); /* temp */
        sqlite4_free(p->btl.pEnv, pSavepage->aData);
        sqlite4_free(p->btl.pEnv, pSavepage);
      }

      pSavepoint->pSavepage = 0;
    }

    p->nSavepoint = nReq;
  }

  return SQLITE4_OK;
}

/*
** Transactions. These methods are more or less the same as their 
** counterparts in bt.h.
*/
int sqlite4BtPagerBegin(BtPager *p, int iLevel){
  int rc = SQLITE4_OK;
  assert( p->btl.pFd );

  if( p->iTransactionLevel<iLevel ){
    /* Open a read transaction if one is not already open */
    if( p->iTransactionLevel==0 ){
      rc = btOpenReadTransaction(p);
    }

    /* Open a write transaction if one is required */
    if( rc==SQLITE4_OK && p->iTransactionLevel<2 && iLevel>=2 ){
      rc = btOpenWriteTransaction(p);
    }

    /* Open any required savepoints */
    if( rc==SQLITE4_OK ){
      rc = btOpenSavepoints(p, iLevel);
    }

    /* If nothing has gone wrong, update BtPager.iTransactionLevel */
    if( rc==SQLITE4_OK ){
      assert( p->iTransactionLevel>=1 && iLevel>=p->iTransactionLevel );
      p->iTransactionLevel = iLevel;
    }
  }

  return rc;

}

int sqlite4BtPagerRollback(BtPager *p, int iLevel){
  int rc = SQLITE4_OK;

  assert( p->btl.pFd );
  if( p->iTransactionLevel>=iLevel ){

    /* If a write transaction is open and the requested level is 2 or
    ** lower, rollback the outermost write transaction. If the requested
    ** level is less than 2, also drop the WRITER lock.  */
    if( p->iTransactionLevel>=2 ){
      if( iLevel<=2 ){
        rc = btRollbackTransaction(p);
        if( iLevel<2 ) sqlite4BtLogSnapshotEndWrite(p->pLog);
      }else{
        rc = btRollbackSavepoints(p, iLevel);
      }
    }

    p->iTransactionLevel = iLevel;
    if( iLevel==0 ){
      int rc2 = btCloseReadTransaction(p);
      if( rc==SQLITE4_OK ) rc2 = rc;
    }
  }

  return rc;
}

int sqlite4BtPagerRevert(BtPager *p, int iLevel){

    pRet->nRef++;
  }
  *ppPg = pRet;
  return rc;
}

int sqlite4BtPageWrite(BtPage *pPg){
  int rc = SQLITE4_OK;
  BtPager *p = pPg->pPager;

  /* If there are savepoints open, add this page to the innermost savepoint */
  if( p->nSavepoint>0 ){
    rc = btAddToSavepoint(p, pPg);
  }

  if( (pPg->flags & BT_PAGE_DIRTY)==0 ){
    pPg->flags |= BT_PAGE_DIRTY;
    pPg->pNextDirty = pPg->pPager->pDirty;
    pPg->pPager->pDirty = pPg;
  }
  return rc;
}

/*
** Decrement the refcount on page pPg. Also, indicate that page pPg is
** no longer in use.
*/
int sqlite4BtPageTrim(BtPage *pPg){

  pKVStore->iTransLevel = sqlite4BtTransactionLevel(p->pDb);
  return rc;
}

/*
** Revert a transaction back to what it was when it started.
*/
#if 0
static int btRevert(KVStore *pKVStore, int iLevel){
  KVBt *p = (KVBt *)pKVStore;
  int rc;
  rc = sqlite4BtRevert(p->pDb, iLevel);
  pKVStore->iTransLevel = sqlite4BtTransactionLevel(p->pDb);
  return rc;
}
#endif

/*
** Implementation of the xReplace(X, aKey, nKey, aData, nData) method.
*/
static int btReplace(
  KVStore *pKVStore,
  const KVByteArray *aKey, KVSize nKey,

    btData,                       /* xData */
    btReset,                      /* xReset */
    btCloseCursor,                /* xCloseCursor */
    btBegin,                      /* xBegin */
    btCommitPhaseOne,             /* xCommitPhaseOne */
    btCommitPhaseTwo,             /* xCommitPhaseTwo */
    btRollback,                   /* xRollback */
    0,                            /* xRevert */
    btClose,                      /* xClose */
    btControl,                    /* xControl */
    btGetMeta,                    /* xGetMeta */
    btPutMeta,                    /* xPutMeta */
    btGetMethod                   /* xGetMethod */
  };

# 2013 September 24
#
# The author disclaims copyright to this source code.  In place of
# a legal notice, here is a blessing:
#
#    May you do good and not evil.
#    May you find forgiveness for yourself and forgive others.
#    May you share freely, never taking more than you give.
#
#***********************************************************************
# The tests in this file were used while developing the SQLite 4 code. 
#
set testdir [file dirname $argv0]
source $testdir/tester.tcl
set testprefix simple3

db close
forcedelete test.db
sqlite4 db file:test.db?kv=bt

do_execsql_test 1.0 {
  CREATE TABLE t1(a, b);
  INSERT INTO t1 VALUES(1, 2);
  INSERT INTO t1 VALUES(3, 4);
}

do_execsql_test 1.1 {
  BEGIN;
    INSERT INTO t1 VALUES(5, 6);
    SAVEPOINT one;
      INSERT INTO t1 VALUES(7, 8);
}

do_execsql_test 1.2 { SELECT * FROM t1 }                   {1 2 3 4 5 6 7 8}
do_execsql_test 1.3 { ROLLBACK TO one; SELECT * FROM t1; } {1 2 3 4 5 6}
do_execsql_test 1.4 { ROLLBACK; SELECT * FROM t1; }        {1 2 3 4}

finish_test