Cloud Backed SQLite

      assert( bcvfsFileType(pFile)==BCVFS_DATABASE_FILE );
      rc = bcvfsReadWriteDatabaseWithRetry(1, pFile, (void*)pBuf, iAmt, iOfst);
      break;
    }
  }
  return rc;
}

/*
** Discard - undirty - all dirty blocks from database pDb between block iFirst
** and the end of the db, inclusive. i.e. if iFirst==0, undirty all blocks
** in the database.
*/
static void bcvfsUndirtyBlocks(
  sqlite3_bcvfs *pFs, 
  int nName, 
  ManifestDb *pDb,
  int iFirst
){
  int iBlk;
  CHECK_VFS_MUTEX;

  for(iBlk=iFirst; iBlk<pDb->nBlkLocal; iBlk++){
    int iOff = iBlk*nName;
    u8 *aBlk = &pDb->aBlkLocal[iOff];
    if( iBlk>=pDb->nBlkOrig || memcmp(aBlk, &pDb->aBlkOrig[iOff], nName) ){
      CacheEntry *pEntry = bcvfsHashFind(&pFs->c, aBlk, nName);
      assert( pEntry && pEntry->bDirty );
      pEntry->bDirty = 0;
      bcvfsLruAddIf(&pFs->c, pEntry);
      bcvfsWriteBlock(pFs, 0, 0, pEntry);
    }
  }
}


static int bcvfsTruncate(sqlite3_file *pFd, sqlite3_int64 size){
  int rc = SQLITE_OK;
  BcvfsFile *pFile = (BcvfsFile*)pFd;
  switch( bcvfsFileType(pFile) ){
    case BCVFS_NO_FILE:
      /* no-op */
      break;
    case BCVFS_WAL_FILE:
    case BCVFS_PASSTHRU_FILE:
      rc = pFile->pFile->pMethods->xTruncate(pFile->pFile, size);
      break;

    default: {
      sqlite3_bcvfs *pFs = pFile->pFs;
      int szBlk = pFile->pMan->szBlk;
      int nNew = (size + szBlk - 1) / szBlk;
      if( nNew<pFile->pManDb->nBlkLocal ){
        ENTER_VFS_MUTEX; {
          bcvfsUndirtyBlocks(pFs, NAMEBYTES(pFile->pMan), pFile->pManDb, nNew);
          pFile->pManDb->nBlkLocal = nNew;
        } LEAVE_VFS_MUTEX;
      }
      assert( pFile->pManDb && pFile->pManDb->nBlkLocalAlloc );
      assert( bcvfsFileType(pFile)==BCVFS_DATABASE_FILE );
      break;
    }
  }
  return rc;

    *pzErr = zErr;
  }else{
    sqlite3_free(zErr);
  }
  return rc;
}


















/*
** This function does the bulk of the work for sqlite3_bcvfs_delete(). Before
** it is called it has already been verified that:
**
**   * pFs is not a proxy VFS, and
**   * pzErr is non-NULL.

          bcvCloseLocal(pFd);
          pFd = 0;

          /* Delete the wal file, if one is present */
          pFs->c.pVfs->xDelete(pFs->c.pVfs, zWal, 0);

          /* Undirty any dirty blocks */
          bcvfsUndirtyBlocks(pFs, nName, pDb, 0);

          if( rc==SQLITE_OK ){
            if( pDb->nBlkLocalAlloc ){
              sqlite3_free(pDb->aBlkLocal);
              pDb->nBlkLocalAlloc = 0;
            }
            pDb->aBlkLocal = 0;

      /* If no error has occurred so far, discard all dirty blocks associated
      ** with the container and truncate all wal files to zero bytes in 
      ** size. */
      for(ii=0; rc==SQLITE_OK && ii<pMan->nDb; ii++){
        sqlite3_file *pFd = aWrap[ii].pWalFd;
        ManifestDb *pDb = &pMan->aDb[ii];
        bcvfsUndirtyBlocks(pFs, NAMEBYTES(pMan), pDb, 0);
        if( pFd ){
          rc = pFd->pMethods->xTruncate(pFd, 0);
        }
      }

      if( aWrap ){
        for(ii=0; ii<pMan->nDb; ii++){

#
# 19-July-2020
#
#-------------------------------------------------------------------------
#

source [file join [file dirname [info script]] test_common.tcl]
set testprefix bcvfs_vacuum1


#-------------------------------------------------------------------------
#
bcv_mkdir testdir
bcv_create_container cont1

bcv_upload_new_db cont1 t1.db {
  CREATE TABLE x1(x, y);
  WITH s(i) AS (
    SELECT 1 UNION ALL SELECT i+1 FROM s WHERE i<1000
  )
  INSERT INTO x1 SELECT randomblob(400), randomblob(400) FROM s;
  CREATE TABLE x2(x, y);
  INSERT INTO x2 VALUES(1, 2);
}

set cmd [bcvfs_create testdir bcvfs]
$cmd log all log_callback
proc log_callback {args} { # puts $args }

bcvfs_attach $cmd cont1
$cmd copy cont1 t1.db new.db

sqlite3 db /cont1/new.db -vfs bcvfs -uri 1
sqlite3_bcvfs_register_vtab db

do_execsql_test 1.0 { DELETE FROM x1 WHERE rowid>10 }
do_test 1.1 { 
  lindex [execsql { PRAGMA wal_checkpoint }] 0
} 0
do_execsql_test 1.2 { VACUUM }
db close

do_test 1.3 {
  $cmd upload cont1
} {}

do_test 1.4 {
  $cmd detach cont1
} {}

$cmd destroy

finish_test