SQLite

  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

   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 * 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