Cloud Backed SQLite

  const char *zName;
  const char *zStorage;           /* Storage module */
  const char *zAccount;           /* Account name (if any) */
  const char *zContainer;         /* Name of container in cloud */
  const char *zLocalDir;          /* Local directory used by container */

  Manifest *pMan;                 /* Current container manifest */
  int nClient;                    /* Number of clients (incl. prefetch) */
  Container *pNext;               /* Next container on same VFS */

  int nBcv;
  BcvWrapper *aBcv;
  int eState;                     /* CONTAINER_STATE_* constant */

  u8 aKey[BCV_LOCAL_KEYSIZE];     /* Encryption key to use */

void bcvfsHashRemove(BcvCommon *p, CacheEntry *pEntry);
void bcvfsLruRemoveIf(BcvCommon *p, CacheEntry *pEntry);
void bcvfsEntryUnref(BcvCommon *p, CacheEntry *pEntry);
void bcvfsBlockidToText(const u8 *pBlk, int nBlk, char *aBuf);
ManifestDb *bcvManifestDbidToDb(Manifest *p, i64 iDbId);
void bcvfsLruAdd(BcvCommon *p, CacheEntry *pEntry);
u8 *bcvDatabaseVtabData(
    int*, BcvCommon*, const char*, const char*, const char*, 
    void(*xClientCount)(BcvCommon*,Container*,int,int*,int*),
    u32, int*, int*
);
int bcvManifestUpdate(BcvCommon*, Container*, Manifest*, char**);
void bcvExecPrintf(int *pRc, sqlite3 *db, const char *zFmt, ...);
void bcvfsUnusedAdd(BcvCommon *p, CacheEntry *pEntry);
void bcvfsLruAddIf(BcvCommon *p, CacheEntry *pEntry);
int bcvfsNameToBlockid(Manifest *p, const char *zName, u8 *aBlk);
u8 *bcvEmptyKV(int *pRc, int *pnData);

typedef struct BcvVtabReply BcvVtabReply;
typedef struct BcvPrefetchMsg BcvPrefetchMsg;
typedef struct BcvPrefetchReply BcvPrefetchReply;

struct BcvHelloMsg {
  const char *zContainer;
  const char *zDatabase;
  int bPrefetch;
};

struct BcvHelloReply {
  u32 errCode;                    /* Error code */
  const char *zErrMsg;            /* Error message */

  const char *zStorage;           /* Storage system in use for db */

};

struct BcvVtabMsg {
  const char *zVtab;
  const char *zContainer;
  const char *zDatabase;
  u32 colUsed;
  int iVersion;                   /* Vtab schema version requested */
};

struct BcvVtabReply {
  int nData;
  const u8 *aData;
  int iVersion;                   /* Vtab schema version supplied */
};

struct BcvDetachMsg {
  const char *zName;
};

struct BcvReadMsg {

** Valid values for BcvMessage.
*/
#define BCV_MESSAGE_HELLO          0x01      /* c->d   BcvHelloMsg */
#define BCV_MESSAGE_HELLO_REPLY    0x02      /* d->c   BcvHelloReply */
#define BCV_MESSAGE_REPLY          0x03      /* d->c   BcvReply */
#define BCV_MESSAGE_ATTACH         0x04      /* d->c   BcvAttachMsg */
#define BCV_MESSAGE_VTAB           0x05      /* c->d   BcvVtabMsg */
#define BCV_MESSAGE_VTAB_REPLY     0x06      /* d->c   BcvVtabReply */
#define BCV_MESSAGE_DETACH         0x07      /* c->d   BcvDetachMsg */
#define BCV_MESSAGE_READ           0x08      /* c->d   BcvReadMsg */
#define BCV_MESSAGE_READ_REPLY     0x09      /* d->c   BcvReadReply */
#define BCV_MESSAGE_END            0x0A      /* c->d   BcvEndMsg */
#define BCV_MESSAGE_CMD            0x0B      /* c->d   BcvCmdMsg */
#define BCV_MESSAGE_PASS           0x0C      /* c->d   BcvPassMsg */
#define BCV_MESSAGE_PASS_REPLY     0x0D      /* d->c   BcvPassReply */

      bcvBufferMsgString(&rc, &buf, pMsg->u.error_r.zErrMsg);
      break;
    case BCV_MESSAGE_VTAB:
      bcvBufferMsgString(&rc, &buf, pMsg->u.vtab.zVtab);
      bcvBufferMsgString(&rc, &buf, pMsg->u.vtab.zContainer);
      bcvBufferMsgString(&rc, &buf, pMsg->u.vtab.zDatabase);
      bcvBufferAppendU32(&rc, &buf, pMsg->u.vtab.colUsed);
      bcvBufferAppendU32(&rc, &buf, pMsg->u.vtab.iVersion);
      break;
    case BCV_MESSAGE_VTAB_REPLY:
      bcvBufferMsgBlob(&rc, &buf, pMsg->u.vtab_r.aData, pMsg->u.vtab_r.nData);
      bcvBufferAppendU32(&rc, &buf, pMsg->u.vtab_r.iVersion);
      break;
    case BCV_MESSAGE_DETACH:
      bcvBufferMsgString(&rc, &buf, pMsg->u.detach.zName);
      break;
    case BCV_MESSAGE_HELLO:
      bcvBufferMsgString(&rc, &buf, pMsg->u.hello.zContainer);
      bcvBufferMsgString(&rc, &buf, pMsg->u.hello.zDatabase);
      bcvBufferAppendU32(&rc, &buf, pMsg->u.hello.bPrefetch);
      break;
    case BCV_MESSAGE_HELLO_REPLY:
      bcvBufferAppendU32(&rc, &buf, pMsg->u.hello_r.errCode);
      bcvBufferMsgString(&rc, &buf, pMsg->u.hello_r.zErrMsg);
      bcvBufferMsgString(&rc, &buf, pMsg->u.hello_r.zStorage);
      bcvBufferMsgString(&rc, &buf, pMsg->u.hello_r.zAccount);
      bcvBufferMsgString(&rc, &buf, pMsg->u.hello_r.zContainer);

            break;
          }
          case BCV_MESSAGE_VTAB: {
            pMsg->u.vtab.zVtab = bcvMsgGetString(&aBody);
            pMsg->u.vtab.zContainer = bcvMsgGetString(&aBody);
            pMsg->u.vtab.zDatabase = bcvMsgGetString(&aBody);
            pMsg->u.vtab.colUsed = bcvMsgGetU32(&aBody);
            if( (aBody - (u8*)&pMsg[1])<nByte ){
              pMsg->u.vtab.iVersion = bcvMsgGetU32(&aBody);
            }
            break;
          }
          case BCV_MESSAGE_VTAB_REPLY: {
            pMsg->u.vtab_r.aData = bcvMsgGetBlob(&aBody, &pMsg->u.vtab_r.nData);
            if( (aBody - (u8*)&pMsg[1])<nByte ){
              pMsg->u.vtab_r.iVersion = bcvMsgGetU32(&aBody);
            }
            break;
          }
          case BCV_MESSAGE_DETACH: {
            pMsg->u.detach.zName = bcvMsgGetString(&aBody);
            break;
          }
          case BCV_MESSAGE_HELLO: {
            pMsg->u.hello.zContainer = bcvMsgGetString(&aBody);
            pMsg->u.hello.zDatabase = bcvMsgGetString(&aBody);
            if( (aBody - (u8*)&pMsg[1])<nByte ){
              pMsg->u.hello.bPrefetch = bcvMsgGetU32(&aBody);
            }
            break;
          }

          case BCV_MESSAGE_HELLO_REPLY: {
            pMsg->u.hello_r.errCode = bcvMsgGetU32(&aBody);
            pMsg->u.hello_r.zErrMsg = bcvMsgGetString(&aBody);
            pMsg->u.hello_r.zStorage = bcvMsgGetString(&aBody);

  void(*xLog)(void*, int, const char*);
  int bCurlVerbose;

  /* Authentication callback */
  void *pAuthCtx;
  int(*xAuth)(void*, const char*, const char*, const char*, char**);

  /* Active prefetches */
  sqlite3_prefetch *pPrefetch;

  BcvCommon c;                    /* Hash tables etc. */
  Mutex mutex;                    /* Mutex/condition variable object */
};

struct BcvDbPath {
  char *zContainer;
  char *zDatabase;

** connect to the daemon to access container zCont, and optionally database
** zDb.
*/
static int bcvfsProxyConnect(
  sqlite3_bcvfs *pFs,             /* Proxy VFS */
  const char *zCont,              /* Container to open */
  const char *zDb,                /* Name of db to open, or NULL */
  int bPrefetch,                  /* True for prefetch connection */
  BCV_SOCKET_TYPE *pS,            /* OUT: Open socket */
  BcvMessage **ppReply            /* OUT: HELLO_REPLY message */
){
  BCV_SOCKET_TYPE s = INVALID_SOCKET;
  int rc = SQLITE_OK;
  BcvMessage *pReply = 0;

  s = bcvConnectSocket(&rc, pFs->zPortnumber, 0);
  if( rc==SQLITE_OK && zCont ){
    BcvMessage hello;
    memset(&hello, 0, sizeof(BcvMessage));
    hello.eType = BCV_MESSAGE_HELLO;
    hello.u.hello.zContainer = zCont;
    hello.u.hello.zDatabase = zDb;
    hello.u.hello.bPrefetch = bPrefetch;
    pReply = bcvExchangeMessage(&rc, s, &hello);
  }
  if( rc!=SQLITE_OK ){
    assert( pReply==0 );
    bcv_close_socket(s);
    s = INVALID_SOCKET;
  }

  sqlite3_bcvfs *pFs, 
  BcvDbPath *pPath, 
  BcvfsFile *pFile
){
  int rc = SQLITE_OK;
  BcvMessage *pReply = 0;
  rc = bcvfsProxyConnect(
      pFs, pPath->zContainer, pPath->zDatabase, 0, &pFile->p.fdProxy, &pReply
  );
  if( pReply ){
    if( rc==SQLITE_OK ){
      rc = pReply->u.hello_r.errCode;
    }
    if( rc==SQLITE_OK ){
      pFile->p.zStorage = bcvStrdupRc(&rc, pReply->u.hello_r.zStorage);

  char **pzErr                    /* OUT: error message */
){
  int rc = SQLITE_OK;                       /* Error code */
  BCV_SOCKET_TYPE s = INVALID_SOCKET;       /* Socket connected to daemon */
  BcvMessage *pReply = 0;                   /* HELLO_REPLY message */

  assert( pzErr );
  rc = bcvfsProxyConnect(pFs, zCont, zDb, 0, &s, &pReply);
  if( pReply ){
    rc = pReply->u.hello_r.errCode;
    if( rc && pzErr ){
      *pzErr = sqlite3_mprintf("%s", pReply->u.hello_r.zErrMsg);
    }
  }
  if( rc==SQLITE_OK ){

      bcvfsContainerReleaseBcv(pFs, pFile->pCont, pDisp, pBcv, bError);
    } LEAVE_VFS_MUTEX;
  }
}

struct sqlite3_prefetch {
  sqlite3_bcvfs *pFs;
  sqlite3_prefetch *pNext;

  Container *pCont;
  Manifest *pMan;
  ManifestDb *pManDb;
  BcvContainer *pBcv;
  BcvDispatch *pDisp;
  sqlite3_file *pCacheFile;

  pNew = bcvMallocRc(&rc, sizeof(sqlite3_prefetch));
  if( pNew ){
    pNew->fdProxy = INVALID_SOCKET;
    pNew->pFs = pFs;
    ENTER_VFS_MUTEX; {
      pFs->nRef++;
      pNew->pNext = pFs->pPrefetch;
      pFs->pPrefetch = pNew;
    }; LEAVE_VFS_MUTEX;

    if( pFs->zPortnumber ){
      BcvMessage *pReply = 0;     /* HELLO_REPLY message */
      pNew->rc = bcvfsProxyConnect(
          pFs, zCont, zDb, 1, &pNew->fdProxy, &pReply
      );
      if( pReply ){
        assert( pNew->rc==SQLITE_OK );
        pNew->rc = pReply->u.hello_r.errCode;
        if( pNew->rc ){
          pNew->zErr = sqlite3_mprintf("%s", pReply->u.hello_r.zErrMsg);
        }

  return rc;
}

void sqlite3_bcvfs_prefetch_destroy(sqlite3_prefetch *p){
  if( p ){
    sqlite3_bcvfs *pFs = p->pFs;
    ENTER_VFS_MUTEX; {
      sqlite3_prefetch **pp;
      pFs->nRef--;
      for(pp=&pFs->pPrefetch; *pp; pp=&(*pp)->pNext){
        if( *pp==p ){
          *pp = p->pNext;
          break;
        }
      }
    }; LEAVE_VFS_MUTEX;
    bcvManifestDeref(p->pMan);
    if( p->pCont ){
      int bError = p->rc || (p->nOutstanding>0);
      p->pCont->nClient--;
      bcvfsContainerReleaseBcv(p->pFs, p->pCont, p->pDisp, p->pBcv, bError);
    }

"CREATE TABLE bcv_database("      \
"  container TEXT,"               \
"  database  TEXT,"               \
"  nblock INTEGER,"               \
"  ncache INTEGER,"               \
"  ndirty INTEGER,"               \
"  walfile BOOLEAN,"              \
"  state TEXT, "                  \
"  nclient INTEGER, "             \
"  nprefetch INTEGER"             \
")"

#define BCV_CONTAINER_VTAB_SCHEMA \
"CREATE TABLE bcv_container("     \
"  name      TEXT,"               \
"  storage   TEXT,"               \
"  user      TEXT,"               \

#define BCV_FILEMETA_VTAB_SCHEMA  \
"CREATE TABLE bcv_kv("            \
"  name      TEXT,"               \
"  value     TEXT "               \
")"

/* Current version is 1.
**
** 1: Add the "nclient" and "nprefetch" fields to the bcv_database table.
*/
#define BCV_VTAB_VERSION 1

/*
** Bits used in the idxNum value
*/
#define BCV_COLUSED_MASK   0x0000FFFF
#define BCV_CONTAINER_MASK 0x00010000
#define BCV_DATABASE_MASK  0x00020000

**   Offset of next row in pData blob.
*/
struct bcv_database_cursor {
  sqlite3_vtab_cursor base;       /* Base class */

  VtabBlob data;
  void *pFreeData;
  int iVersion;                   /* Version from VtabReply message */

  /* Values for current row */
  i64 iRow;                       /* Rowid */
  char *zContainer;
  char *zDatabase;
  int nBlock;
  int nCache;
  int nDirty;
  int bWalfile;
  int nPin;
  char *zState;
  int nClient;
  int nPrefetch;
};

/*
** pData:
**   If the underlying VFS is a proxy VFS, then the data to return
**   is contained in the pData message object obtained from the daemon
**   process within the xFilter call. The message object contains a

*/
u8 *bcvDatabaseVtabData(
  int *pRc,                       /* IN/OUT: error code */
  BcvCommon *pCommon,             /* State to base returned data on */
  const char *zName,              /* "bcv_database" or "bcv_container" */
  const char *zContFilter,        /* Container to query, or NULL */
  const char *zDbFilter,          /* Database to query, or NULL */
  void(*xClientCount)(BcvCommon*,Container*,int,int*,int*),
  u32 colUsed,                    /* Columns used mask */
  int *pnData,                    /* OUT: Size of returned buffer */
  int *piVersion                  /* IN/OUT: Vtab schema version used */
){
  int rc = SQLITE_OK;
  BcvBuffer buf = {0,0,0};
  int iVersion = MAX(*piVersion, BCV_VTAB_VERSION);

  if( bcvStrcmp(zName, "bcv_database")==0 ){
    Container *pCont;
    for(pCont=pCommon->pCList; pCont; pCont=pCont->pNext){
      int ii;
      Manifest *pMan = pCont->pMan;
      if( zContFilter && bcvStrcmp(zContFilter, pCont->zName) ) continue;

        bcvBufferAppendU32(&rc, &buf, (u32)bWalfile);
        if( pDb->nBlkLocal==0 ){
          zState = "deleted";
        }else if( pDb->iDbId>=BCVFS_FIRST_LOCAL_ID ){
          zState = "copied";
        }
        bcvBufferMsgString(&rc, &buf, zState);
        if( iVersion>=1 ){
          /* TODO: Real values! */
          int nClient = 0;
          int nPrefetch = 0;
          xClientCount(pCommon, pCont, pDb->iDbId, &nClient, &nPrefetch);
          bcvBufferAppendU32(&rc, &buf, nClient);
          bcvBufferAppendU32(&rc, &buf, nPrefetch);
        }
      }
    }
  }else if( bcvStrcmp(zName, "bcv_container")==0 ){
    Container *pCont;
    for(pCont=pCommon->pCList; pCont; pCont=pCont->pNext){
      if( zContFilter && bcvStrcmp(zContFilter, pCont->zName) ) continue;
      bcvBufferMsgString(&rc, &buf, pCont->zName);

  pCur->zContainer = (char*)bcvVtabExtractString(&pCur->data);
  pCur->zDatabase = (char*)bcvVtabExtractString(&pCur->data);
  pCur->nBlock = (int)bcvVtabExtractU32(&pCur->data);
  pCur->nCache = (int)bcvVtabExtractU32(&pCur->data);
  pCur->nDirty = (int)bcvVtabExtractU32(&pCur->data);
  pCur->bWalfile = (int)bcvVtabExtractU32(&pCur->data);
  pCur->zState = (char*)bcvVtabExtractString(&pCur->data);
  if( pCur->iVersion>=1 ){
    pCur->nClient = (int)bcvVtabExtractU32(&pCur->data);
    pCur->nPrefetch = (int)bcvVtabExtractU32(&pCur->data);
  }

  pCur->iRow++;
  return SQLITE_OK;
}

static int bcvContainerVtabNext(sqlite3_vtab_cursor *cur){
  bcv_container_cursor *pCur = (bcv_container_cursor*)cur;

      break;
    case 5: /* dirty */
      sqlite3_result_int(ctx, pCur->bWalfile);
      break;
    case 6: /* state */
      sqlite3_result_text(ctx, pCur->zState, -1, SQLITE_TRANSIENT);
      break;
    case 7: /* nclient */
      if( pCur->iVersion>=1 ) sqlite3_result_int(ctx, pCur->nClient);
      break;
    case 8: /* nprefetch */
      if( pCur->iVersion>=1 ) sqlite3_result_int(ctx, pCur->nPrefetch);
      break;
  }
  return SQLITE_OK;
}

static int bcvContainerVtabColumn(
  sqlite3_vtab_cursor *cur,   /* The cursor */
  sqlite3_context *ctx,       /* First argument to sqlite3_result_...() */

  memset(&msg, 0, sizeof(msg));
  msg.eType = BCV_MESSAGE_VTAB;
  msg.u.vtab.zVtab = zVtab;
  msg.u.vtab.zContainer = zCont;
  msg.u.vtab.zDatabase = zDb;
  msg.u.vtab.colUsed = colUsed;
  msg.u.vtab.iVersion = BCV_VTAB_VERSION;

  pReply = bcvExchangeMessage(pRc, pFile->p.fdProxy, &msg);
  assert( (pReply==0)==(*pRc!=SQLITE_OK) );

  return pReply;
}

/*
** GCC does not define the offsetof() macro so we'll have to do it
** ourselves.
*/
#ifndef offsetof
#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
#endif

/*
** Version of xClientCount for local VFS
*/
static void bcvLocalClientCount(
  BcvCommon *pCommon, 
  Container *pCont, 
  int iDbId, 
  int *pnClient,
  int *pnPrefetch
){
  BcvfsFile *pFile = 0;
  sqlite3_prefetch *pPrefetch = 0;
  sqlite3_bcvfs *pFs = 0;
  int nClient = 0;
  int nPrefetch = 0;
  pFs = (sqlite3_bcvfs*)&((u8*)pCommon)[-offsetof(sqlite3_bcvfs, c)];

  assert( pCommon->bDaemon==0 );

  for(pFile=pFs->pFileList; pFile; pFile=pFile->pNextFile){
    if( pFile->pCont==pCont && pFile->iFileDbId==iDbId ){
      nClient++;
    }
  }

  for(pPrefetch=pFs->pPrefetch; pPrefetch; pPrefetch=pPrefetch->pNext){
    if( pPrefetch->pCont==pCont && pPrefetch->pManDb->iDbId==iDbId ){
      nPrefetch++;
    }
  }

  *pnClient = nClient;
  *pnPrefetch = nPrefetch;
}

/*
** xFilter implentations for bcv_database and bcv_block.
*/
static int bcvReadonlyVtabFilter(
  sqlite3_vtab_cursor *cur, 
  int idxNum, const char *idxStr,

  sqlite3_free(pCur->pFreeData);
  pCur->pFreeData = 0;
  memset(&pCur->data, 0, sizeof(VtabBlob));

  sqlite3_file_control(pTab->db, "main", BCV_FCNTL_FD, (void*)&pFile);
  if( pFile ){
    if( pFile->pFs->zPortnumber ){
      BcvMessage *pMsg = 0;
      pMsg = bcvVtabFetchData(
          &rc, pFile, pTab->zMod, zCont, zDb, colUsed
      );
      if( pMsg ){
        pCur->data.aData = pMsg->u.vtab_r.aData;
        pCur->data.nData = pMsg->u.vtab_r.nData;
        pCur->pFreeData = (void*)pMsg;
        pCur->iVersion = pMsg->u.vtab_r.iVersion;
      }
    }else{
      pCur->iVersion = BCV_VTAB_VERSION;
      pCur->data.aData = bcvDatabaseVtabData(&rc, &pFile->pFs->c, 
          pTab->zMod, zCont, zDb, 
          bcvLocalClientCount,
          colUsed, &pCur->data.nData, &pCur->iVersion
      );
      pCur->pFreeData = (void*)pCur->data.aData;
    }
    if( rc==SQLITE_OK ){
      return pTab->base.pModule->xNext(cur);
    }
  }

      );
      if( pMsg ){
        pCur->data.aData = pMsg->u.vtab_r.aData;
        pCur->data.nData = pMsg->u.vtab_r.nData;
        pCur->pFreeData = (void*)pMsg;
      }
    }else{
      int iVersion = BCV_VTAB_VERSION;
      pCur->data.aData = bcvDatabaseVtabData(&rc, &pFile->pFs->c, 
          "bcv_container", zCont, 0, 0, colUsed, &pCur->data.nData, &iVersion
      );
      pCur->pFreeData = (void*)pCur->data.aData;
    }
    if( rc==SQLITE_OK ){
      return bcvContainerVtabNext(cur);
    }
  }

typedef struct DaemonCtx DaemonCtx;
typedef struct DClient DClient;
typedef struct FetchCtx FetchCtx;
typedef struct DPrefetch DPrefetch;

struct DPrefetch {
  int bPrefetch;                  /* True if this is a prefetch connection */
  int nOutstanding;
  int iNext;
  int bReply;
  int errCode;
  char *zErrMsg;
};

  reply.eType = BCV_MESSAGE_REPLY;
  reply.u.error_r.errCode = rc;
  reply.u.error_r.zErrMsg = zErr;
  bdSendMsg(p, pClient, &reply);
  sqlite3_free(zErr);
  sqlite3_free(pMsg);
}

/*
** GCC does not define the offsetof() macro so we'll have to do it
** ourselves.
*/
#ifndef offsetof
#define offsetof(STRUCTURE,FIELD) ((int)((char*)&((STRUCTURE*)0)->FIELD))
#endif


/*
** Version of xClientCount for proxy VFS
*/
static void bcvProxyClientCount(
  BcvCommon *pCommon, 
  Container *pCont, 
  int iDbId, 
  int *pnClient,
  int *pnPrefetch
){
  DClient *pClient = 0;
  DaemonCtx *p = 0;
  int nClient = 0;
  int nPrefetch = 0;

  p = (DaemonCtx*)&((u8*)pCommon)[-offsetof(DaemonCtx, c)];
  for(pClient=p->pClientList; pClient; pClient=pClient->pNext){
    if( pClient->pCont==pCont && pClient->iDbId==iDbId ){
      if( pClient->prefetch.bPrefetch ){
        nPrefetch++;
      }else{
        nClient++;
      }
    }
  }

  *pnClient = nClient;
  *pnPrefetch = nPrefetch;
}

/*
** Handle a message of type BCV_MESSAGE_VTAB from client pClient.
*/
static void bdHandleVtab(
  DaemonCtx *p, 
  DClient *pClient, 
  BcvMessage *pMsg
){
  const char *zTab = pMsg->u.vtab.zVtab;
  const char *zCont = pMsg->u.vtab.zContainer;
  const char *zDb = pMsg->u.vtab.zDatabase;
  const u32 colUsed = pMsg->u.vtab.colUsed;

  int rc = SQLITE_OK;
  BcvMessage reply;
  u8 *aData = 0;
  int nData = 0;
  int iVersion = pMsg->u.vtab.iVersion;

  memset(&reply, 0, sizeof(reply));
  reply.eType = BCV_MESSAGE_VTAB_REPLY;

  aData = bcvDatabaseVtabData(&rc, &p->c, 
      zTab, zCont, zDb, bcvProxyClientCount, colUsed, &nData, &iVersion
  );
  reply.u.vtab_r.aData = aData;
  reply.u.vtab_r.nData = nData;
  reply.u.vtab_r.iVersion = iVersion;
  bdSendMsg(p, pClient, &reply);

  sqlite3_free(aData);
  sqlite3_free(pMsg);
}

/*

  const char *zCont = pMsg->u.hello.zContainer;
  const char *zDb = pMsg->u.hello.zDatabase;
  Container *pCont = 0;
  ManifestDb *pDb = 0;
  BcvMessage reply;
  char *zErr = 0;

  pClient->prefetch.bPrefetch = pMsg->u.hello.bPrefetch;
  pCont = bcvfsFindContAlias(&p->c, zCont, &zErr);
  if( pCont && zDb ){
    pDb = bcvfsFindDatabase(pCont->pMan, zDb, -1);
    if( pDb==0 ){
      zErr = bcvMprintf("no such database: /%s/%s", zCont, zDb);
      pCont = 0;
    }

  DClient *pClient, 
  BcvMessage *pMsg
){
  BcvContainer *pBcv = 0;
  int rc = SQLITE_OK;

  pClient->prefetch.bReply = 1;
  pClient->prefetch.bPrefetch = 1;

  pBcv = bdUpdateBCV(pClient, pMsg->u.pass.zAuth);
  if( pClient->pManDb==0 ){
    Manifest *pMan = pClient->pCont->pMan;
    ManifestDb *pDb = bcvManifestDbidToDb(pMan, pClient->iDbId);
    if( pDb ){
      bcvManifestRef(pMan);

do_test 1.1 {
  pf run 1 1000
} {0}

do_execsql_test 1.2 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 7 1 0 0 {} 1 1
}

do_test 1.3 {
  while {[pf run 2 1000]==0} {}
  pf destroy
} {}

do_execsql_test 1.4 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 7 7 0 0 {} 1 0
}

db close
$cmd destroy

#-------------------------------------------------------------------------

do_test 2.1 {
  pf run 1 1000
} {0}

do_execsql_test 2.2 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 7 1 0 0 {} 1 1
}

do_test 2.3 {
  while {[pf run 2 1000]==0} {}
  pf errcode
} {403}
pf destroy

do_execsql_test 2.4 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 7 1 0 0 {} 1 0
}

db close
$cmd destroy

finish_test

bcvfs_attach $cmd cont1
sqlite3 db /cont1/t1.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 1.0 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
}

$cmd copy cont1 t1.db t2.db

do_execsql_test 1.1 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
  cont1 t2.db 1 1 0 0 copied 0 0
}

sqlite3 db2 /cont1/t2.db -vfs bcvfs
do_execsql2_test 1.2 {
  SELECT * FROM x1
} {
  hello world one two

  hello world one two A B
}

$cmd copy cont1 t2.db t3.db
do_execsql_test 1.5 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 0 0 0 {} 1 0
  cont1 t2.db 1 1 0 0 {} 1 0
  cont1 t3.db 1 1 0 0 copied 0 0
}

db2 close
db close
$cmd destroy

set cmd [bcvfs_create testdir bcvfs]
sqlite3 db /cont1/t1.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 1.6 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
  cont1 t2.db 1 1 0 0 {} 0 0
  cont1 t3.db 1 1 0 0 copied 0 0
}

do_execsql_test 1.7 {
  INSERT INTO x1 VALUES('yes', 'no');
}

$cmd upload cont1

do_execsql_test 1.8 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
  cont1 t2.db 1 1 0 0 {} 0 0
  cont1 t3.db 1 1 0 0 {} 0 0
}

do_test 1.9 {
  $cmd copy cont1 t1.db t4.db
  set bcv [bcv_open cont1]
  $bcv copy t1.db t5.db
  $bcv close

bcvfs_attach $bcvfs cont5
sqlite3 db /cont5/a.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 3.0 {
  SELECT * FROM bcv_database
} {
  cont5 a.db 7 1 0 0 {} 1 0
  cont5 b.db 1 0 0 0 {} 0 0
}

do_execsql_test 3.1 {
  UPDATE t1 SET y=1 WHERE rowid IN (100, 500, 900);
  PRAGMA wal_checkpoint = truncate;
} {0 0 0}

do_execsql_test 3.2 {
  SELECT * FROM bcv_database
} {
  cont5 a.db 7 3 3 0 {} 1 0
  cont5 b.db 1 0 0 0 {} 0 0
}

db close
$bcvfs delete cont5 a.db
$bcvfs upload cont5
sqlite3 db /cont5/b.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 3.3 {
  SELECT * FROM t1
} {
  hello world
}

do_execsql_test 3.2 {
  SELECT * FROM bcv_database
} {
  cont5 b.db 1 1 0 0 {} 1 0
}


db close
$bcvfs destroy

finish_test

do_execsql_test 4.1 {
  SELECT name, container FROM bcv_container
} {xyz23 xyz23}

do_execsql_test 4.2 {
  SELECT * FROM bcv_database
} {
  xyz23 a.db 1 0 0 0 {} 0 0
  xyz23 b.db 1 0 0 0 {} 0 0
}

db close
do_test 4.3 {
  list [catch { sqlite3 db /xyz24 -vfs bcvfs } msg] $msg
} {1 {unable to open database file}}

} {{hello world}}
db3 close

sqlite3_bcvfs_register_vtab db2
do_execsql2_test 3.8 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
  cont1 t2.db 1 1 1 0 {} 0 0
}


do_test 3.9 {
  $cmd2 delete cont1 t2.db
} {}
do_execsql2_test 3.10 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
  cont1 t2.db 0 0 0 0 deleted 0 0
}
do_test 3.11 {
  db eval {
    INSERT INTO t1 VALUES(5), (6);
    PRAGMA wal_checkpoint;
  }
  $cmd upload cont1
} {}

do_test 3.12 {
  $cmd2 poll cont1
} {}

do_execsql2_test 3.13 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
  cont1 t2.db 0 0 0 0 deleted 0 0
}

db2 close
db close
$cmd destroy
$cmd2 destroy

  $cmd copy mycont x2.db copy.db
  $cmd delete mycont x4.db
} {}

do_execsql_test 1.3 {
  SELECT * FROM bcv_database
} {
  mycont x1.db 1 1 1 1 {} 1 0
  mycont x2.db 1 0 0 0 {} 0 0
  mycont x3.db 1 1 0 1 {} 1 0
  mycont x4.db 0 0 0 0 deleted 0 0
  mycont copy.db 1 0 0 0 copied 0 0
}

do_test 1.4 {
  $cmd revert mycont
} {}

sqlite3 db  /mycont/x1.db -vfs bcvfs
sqlite3 db2 /mycont/x3.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 1.5 {
  SELECT * FROM t1;
} {1 4 7}
do_execsql2_test 1.6 {
  SELECT * FROM t1;
} {3 6 9}
do_execsql_test 1.7 {
  SELECT * FROM bcv_database
} {
  mycont x1.db 1 1 0 0 {} 1 0
  mycont x2.db 1 0 0 0 {} 0 0
  mycont x3.db 1 1 0 0 {} 1 0
  mycont x4.db 1 0 0 0 {} 0 0
}

db close
db2 close
$cmd destroy

#-------------------------------------------------------------------------

  list [catch { $cmd revert mycont} msg] $msg
} {0 {}}

sqlite3_bcvfs_register_vtab db
do_execsql_test 2.8 {
  SELECT * FROM bcv_database
} {
  mycont x1.db 1 1 0 0 {} 1 0
  mycont x2.db 1 0 0 0 {} 0 0
  mycont x3.db 1 0 0 0 {} 0 0
}

do_test 2.9 {
  $cmd copy mycont x2.db x4.db
  $cmd copy mycont x2.db x5.db
  $cmd delete mycont x4.db
} {}

do_execsql_test 2.10 {
  SELECT * FROM bcv_database
} {
  mycont x1.db 1 1 0 0 {} 1 0
  mycont x2.db 1 0 0 0 {} 0 0
  mycont x3.db 1 0 0 0 {} 0 0 
  mycont x4.db 0 0 0 0 deleted 0 0
  mycont x5.db 1 0 0 0 copied 0 0
}

do_test 2.11 {
  list [catch { $cmd revert mycont} msg] $msg
} {0 {}}

do_execsql_test 2.12 {
  SELECT * FROM bcv_database
} {
  mycont x1.db 1 1 0 0 {} 1 0
  mycont x2.db 1 0 0 0 {} 0 0
  mycont x3.db 1 0 0 0 {} 0 0
}

db close
sqlite3 db  / -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_test 2.13 {
   $cmd delete mycont x3.db
   $cmd delete mycont x2.db
   $cmd delete mycont x1.db
} {}

do_execsql_test 2.14 {
  SELECT * FROM bcv_database
} {
  mycont x1.db 0 0 0 0 deleted 0 0
  mycont x2.db 0 0 0 0 deleted 0 0
  mycont x3.db 0 0 0 0 deleted 0 0
}

db close
$cmd destroy

finish_test

#  nblock INTEGER
#  ncache INTEGER
#  ndirty INTEGER
#  walfile BOOLEAN
do_execsql_test 1.1 {
  SELECT * FROM bcv_database
} {
  cont1 x1.db 1 0 0 0 {} 0 0
  cont1 x2.db 1 1 0 1 {} 1 0
  cont1 x3.db 1 0 0 0 {} 0 0
}

do_test 1.2 {
  $cmd upload cont1
} {}

do_execsql_test 1.3 {
  SELECT * FROM bcv_database
} {
  cont1 x1.db 1 0 0 0 {} 0 0
  cont1 x2.db 1 1 0 0 {} 1 0
  cont1 x3.db 1 0 0 0 {} 0 0
}

do_execsql_test 1.4 {
  INSERT INTO t1 VALUES(5, 6);
  INSERT INTO t1 VALUES(7, 8);
  PRAGMA wal_checkpoint;
} {
  0 2 2
}

do_execsql_test 1.4 {
  SELECT * FROM bcv_database
} {
  cont1 x1.db 1 0 0 0 {} 0 0
  cont1 x2.db 1 1 1 1 {} 1 0
  cont1 x3.db 1 0 0 0 {} 0 0
}

do_test 1.5 {
  set fd [open testdir/cont1/x3.db-wal w]
  puts $fd hello_world
  close $fd
} {}

do_execsql_test 1.6 {
  SELECT * FROM bcv_database
} {
  cont1 x1.db 1 0 0 0 {} 0 0
  cont1 x2.db 1 1 1 1 {} 1 0
  cont1 x3.db 1 0 0 1 {} 0 0
}

do_test 1.7 {
  $cmd upload cont1
} {}

do_execsql_test 1.8 {
  SELECT * FROM bcv_database
} {
  cont1 x1.db 1 0 0 0 {} 0 0
  cont1 x2.db 1 1 0 0 {} 1 0
  cont1 x3.db 1 1 0 0 {} 0 0
}

do_execsql_test 1.9 {
  INSERT INTO t1 VALUES(9, 10);
} {
}

  BEGIN;
    SELECT * FROM t1;
} {1 2 3 4 5 6 7 8 9 10}

do_execsql_test 1.13 {
  SELECT * FROM bcv_database
} {
  cont1 x1.db 1 0 0 0 {} 0 0
  cont1 x2.db 1 1 1 1 {} 2 0
  cont1 x3.db 1 1 0 0 {} 0 0
}

do_test 1.14 {
  list [catch { $cmd upload cont1 } msg] $msg
} {0 {}}

db2 close
db close
$cmd destroy

finish_test

#
# 18-August-2023
#
#-------------------------------------------------------------------------
#

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

bcv_mkdir testdir
bcv_create_container cont1
bcv_upload_new_db cont1 test.db {
  CREATE TABLE t1(x, y);
}

set cmd [bcvfs_create testdir "bcvfs"]
bcvfs_attach $cmd cont1

sqlite3 db /cont1/test.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 1.0 {
  SELECT container, database, nclient, nprefetch FROM bcv_database
} {cont1 test.db 1 0}

sqlite3 db2 /cont1/test.db -vfs bcvfs

do_execsql_test 1.1 {
  SELECT container, database, nclient, nprefetch FROM bcv_database
} {cont1 test.db 2 0}

foreach {tn script nclient nprefetch} {
  1 {
    sqlite3 db2 /cont1/test.db -vfs bcvfs
    $cmd prefetch_new pf1 cont1 test.db
  } 2 1
  2 {
    pf1 destroy
    sqlite3 db3 /cont1/test.db -vfs bcvfs
  } 3 0
  3 {
    $cmd prefetch_new pf1 cont1 test.db
    $cmd prefetch_new pf2 cont1 test.db
    $cmd prefetch_new pf3 cont1 test.db
    db2 close
  } 2 3
  4 {
    pf1 destroy
    pf3 destroy
    db close
    sqlite3 db /cont1/test.db -vfs bcvfs
    sqlite3_bcvfs_register_vtab db
  } 2 1
  5 {
    pf2 destroy
    db3 close
  } 1 0
  6 {
    db close
    sqlite3 db2 /cont1/test.db -vfs bcvfs
    sqlite3 db /cont1/test.db -vfs bcvfs
    sqlite3_bcvfs_register_vtab db
  } 2 0
  7 {
    db2 close
  } 1 0
} {
  eval $script
  do_execsql_test 1.3.$tn {
    SELECT container, database, nclient, nprefetch FROM bcv_database
  } [list cont1 test.db $nclient $nprefetch]
}

bcv_upload_new_db cont1 test.db2 { CREATE TABLE t1(x, y); }
bcv_upload_new_db cont1 test.db3 { CREATE TABLE t1(x, y); }
bcv_upload_new_db cont1 test.db4 { CREATE TABLE t1(x, y); }

$cmd poll cont1

sqlite3 db2.1 /cont1/test.db2 -vfs bcvfs
sqlite3 db2.2 /cont1/test.db2 -vfs bcvfs
sqlite3 db3.1 /cont1/test.db3 -vfs bcvfs
sqlite3 db3.2 /cont1/test.db3 -vfs bcvfs
sqlite3 db3.3 /cont1/test.db3 -vfs bcvfs
sqlite3 db4.1 /cont1/test.db4 -vfs bcvfs
sqlite3 db4.2 /cont1/test.db4 -vfs bcvfs
sqlite3 db4.3 /cont1/test.db4 -vfs bcvfs
sqlite3 db4.4 /cont1/test.db4 -vfs bcvfs

do_execsql_test 1.4 {
  SELECT container, database, nclient, nprefetch FROM bcv_database
} {
  cont1 test.db  1 0
  cont1 test.db2 2 0
  cont1 test.db3 3 0
  cont1 test.db4 4 0
}

db2.1 close
db2.2 close
db3.1 close
db3.2 close
db3.3 close
db4.1 close
db4.2 close
db4.3 close
db4.4 close

db close
$cmd destroy
finish_test

  cont2 cont2 0
  cont1 cont1 0
}

do_execsql_test 1.2.4 {
  SELECT * FROM bcv_database
} {
  c3    t3.db 1 0 0 0 {} 0 0
  cont2 t2.db 1 0 0 0 {} 0 0
  cont1 t1.db 1 0 0 0 {} 0 0
}

db close
$cmd destroy
wait_daemon 0

#-------------------------------------------------------------------------

do_execsql_test 1.1 {
  SELECT * FROM t1
} {fox guard}

do_execsql_test 1.2 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
}

bcv_upload_new_db cont1 t2.db {
  CREATE TABLE t2(a, b);
  INSERT INTO t2 VALUES('a', 'b');
}

do_execsql_test 1.3 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
}

$::cmd poll cont1
do_execsql_test 1.4 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 1 1 0 0 {} 1 0
  cont1 t2.db 1 0 0 0 {} 0 0
}

bcv_mkdir testdir
set cmd2 [bcvfs_create testdir bcvfs2]
bcvfs_attach $cmd2 cont1
sqlite3 db2 /cont1/t1.db -vfs bcvfs2

sqlite3 db /cont1/t1.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 1.0 {
  PRAGMA cache_size = 10;
  SELECT * FROM bcv_database
} {cont1 t1.db 10 1 0 0 {} 1 0}

for {set i 0} {$i < 10} {incr i} {
  do_execsql_test 1.1.$i {
    SELECT count(x || y) FROM x1
  } {1500}
  wait_ms 1000
}

do_test 1.1 {
  pf run 1 1000
} {0}

do_execsql_test 1.2 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 7 2 0 0 {} 1 1
}

do_test 1.3 {
  while {[pf run 2 1000]==0} {}
  pf destroy
} {}

do_execsql_test 1.4 {
  SELECT * FROM bcv_database
} {
  cont1 t1.db 7 7 0 0 {} 1 0
}

db close
$cmd destroy
wait_daemon 0

#
# 18-August-2023
#
#-------------------------------------------------------------------------
#

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

bcv_create_container cont1
bcv_upload_new_db cont1 test.db {
  CREATE TABLE t1(x, y);
}

start_new_daemon 0 
set cmd [bcvfs_create testdir.0 "bcvfs"]
bcvfs_attach $cmd cont1

sqlite3 db /cont1/test.db -vfs bcvfs
sqlite3_bcvfs_register_vtab db

do_execsql_test 1.0 {
  SELECT container, database, nclient, nprefetch FROM bcv_database
} {cont1 test.db 1 0}

sqlite3 db2 /cont1/test.db -vfs bcvfs

do_execsql_test 1.1 {
  SELECT container, database, nclient, nprefetch FROM bcv_database
} {cont1 test.db 2 0}

foreach {tn script nclient nprefetch} {
  1 {
    sqlite3 db2 /cont1/test.db -vfs bcvfs
    $cmd prefetch_new pf1 cont1 test.db
  } 2 1
  2 {
    pf1 destroy
    sqlite3 db3 /cont1/test.db -vfs bcvfs
  } 3 0
  3 {
    $cmd prefetch_new pf1 cont1 test.db
    $cmd prefetch_new pf2 cont1 test.db
    $cmd prefetch_new pf3 cont1 test.db
    db2 close
  } 2 3
  4 {
    pf1 destroy
    pf3 destroy
    db close
    sqlite3 db /cont1/test.db -vfs bcvfs
    sqlite3_bcvfs_register_vtab db
  } 2 1
  5 {
    pf2 destroy
    db3 close
  } 1 0
  6 {
    sqlite3 db2 /cont1/test.db -vfs bcvfs
    db close
    sqlite3 db /cont1/test.db -vfs bcvfs
    sqlite3_bcvfs_register_vtab db
  } 2 0
  7 {
    db2 close
  } 1 0
} {
  eval $script
  do_execsql_test 1.3.$tn {
    SELECT container, database, nclient, nprefetch FROM bcv_database
  } [list cont1 test.db $nclient $nprefetch]
}

bcv_upload_new_db cont1 test.db2 { CREATE TABLE t1(x, y); }
bcv_upload_new_db cont1 test.db3 { CREATE TABLE t1(x, y); }
bcv_upload_new_db cont1 test.db4 { CREATE TABLE t1(x, y); }

$cmd poll cont1

sqlite3 db2.1 /cont1/test.db2 -vfs bcvfs
sqlite3 db2.2 /cont1/test.db2 -vfs bcvfs
sqlite3 db3.1 /cont1/test.db3 -vfs bcvfs
sqlite3 db3.2 /cont1/test.db3 -vfs bcvfs
sqlite3 db3.3 /cont1/test.db3 -vfs bcvfs
sqlite3 db4.1 /cont1/test.db4 -vfs bcvfs
sqlite3 db4.2 /cont1/test.db4 -vfs bcvfs
sqlite3 db4.3 /cont1/test.db4 -vfs bcvfs
sqlite3 db4.4 /cont1/test.db4 -vfs bcvfs

do_execsql_test 1.4 {
  SELECT container, database, nclient, nprefetch FROM bcv_database
} {
  cont1 test.db  1 0
  cont1 test.db2 2 0
  cont1 test.db3 3 0
  cont1 test.db4 4 0
}

db2.1 close
db2.2 close
db3.1 close
db3.2 close
db3.3 close
db4.1 close
db4.2 close
db4.3 close
db4.4 close

db close
$cmd destroy

wait_daemon 0
finish_test