SQLite

#define ZONEFILE_SCHEMA          \
  "CREATE TABLE z1("             \
  "  k INTEGER PRIMARY KEY,"     \
  "  v BLOB,"                    \


  "  file TEXT,"                 \
  "  sz INTEGER"                 \
  ")"

#define ZONEFILE_FILES_SCHEMA    \
  "CREATE TABLE z2("             \
  "  filename TEXT,"             \
  "  ekey BLOB,"                 \

    int nKey;                     /* Size of buffer aKey[] in bytes */
    int i;

    rc = zonefileLoadIndex(&hdr, pFd, &aKey, &nKey, &pTab->base.zErrMsg);

    if( rc==SQLITE_OK && pTab->pInsertIdx==0 ){
      rc = zonefilePrepare(pTab->db, &pTab->pInsertIdx, &pTab->base.zErrMsg,
          "INSERT INTO %Q.'%q_shadow_idx'(k, fileid, fofst, fsz, ofst, sz)"
          "VALUES(?,?,?,?,?,?)",
          pTab->zDb, pTab->zBase
      );
    }

    for(i=0; i<hdr.numKeys && rc==SQLITE_OK; i++){
      u8 *aEntry = &aKey[4*hdr.numFrames + ZONEFILE_SZ_KEYOFFSETS_ENTRY * i];
      int iFrame = zonefileGet32(&aEntry[8]);
      i64 iFrameOff = 0;          /* Offset of frame */
      int szFrame;                /* Compressed size of frame */
      i64 iOff;                   /* Offset of blob within uncompressed frame */
      int sz;                     /* Size of blob within uncompressed frame */

      szFrame = zonefileGet32(&aKey[iFrame*4]);
      if( iFrame>0 ){
        iFrameOff = zonefileGet32(&aKey[(iFrame-1)*4]);
        szFrame -= iFrameOff;
      }
      iFrameOff += hdr.byteOffsetFrames;
      iOff = (i64)zonefileGet32(&aEntry[12]);
      sz = (int)zonefileGet32(&aEntry[16]);

      sqlite3_bind_int64(pTab->pInsertIdx, 1, (i64)zonefileGet64(&aEntry[0]));
      sqlite3_bind_int64(pTab->pInsertIdx, 2, iFileid);
      if( hdr.encryptionType || hdr.compressionTypeContent ){
        sqlite3_bind_int64(pTab->pInsertIdx, 5, iOff);
        sqlite3_bind_int(pTab->pInsertIdx, 6, sz);
      }else{
        iFrameOff += iOff;
        szFrame = sz;
      }
      sqlite3_bind_int64(pTab->pInsertIdx, 3, iFrameOff);
      sqlite3_bind_int(pTab->pInsertIdx, 4, szFrame);

      sqlite3_step(pTab->pInsertIdx);
      rc = sqlite3_reset(pTab->pInsertIdx);
      if( rc!=SQLITE_OK ){
        pTab->base.zErrMsg = sqlite3_mprintf("%s", sqlite3_errmsg(pTab->db));
      }
    }

    p->zDb = &p->zName[nName+1];
    memcpy(p->zDb, zDb, nDb+1);
    p->db = db;
    p->pGlobal = (ZonefileGlobal*)pAux;
  
    if( bCreate ){
      char *zSql = sqlite3_mprintf(
          "CREATE TABLE %Q.'%q_shadow_idx'("
          "  k INTEGER PRIMARY KEY,"
          "  fileid INTEGER,"
          "  fofst INTEGER,"
          "  fsz INTEGER,"
          "  ofst INTEGER,"
          "  sz INTEGER"
          ");"
          "CREATE TABLE %Q.'%q_shadow_file'(" 
          "  filename TEXT,"
          "  fileid INTEGER PRIMARY KEY"
          ");" 

*/
static int zonefileDestroy(sqlite3_vtab *pVtab){
  ZonefileTab *pTab = (ZonefileTab*)pVtab;
  int rc = SQLITE_OK;
  char *zSql = sqlite3_mprintf(
      "DROP TABLE IF EXISTS %Q.'%q_shadow_idx';"
      "DROP TABLE IF EXISTS %Q.'%q_shadow_file';"
      "DROP TABLE IF EXISTS %Q.'%q_shadow_frame';"
      "DROP TABLE IF EXISTS %Q.'%q_files';",
      pTab->zDb, pTab->zName, pTab->zDb, pTab->zName, pTab->zDb, pTab->zName
  );
  if( zSql==0 ){
    rc = SQLITE_NOMEM;
  }else{
    rc = sqlite3_exec(pTab->db, zSql, 0, 0, 0);

    if( idxNum & 0x02 ) { z1 = "k < ?"; }
    if( idxNum & 0x04 ) { z1 = "k <= ?"; }
    if( idxNum & 0x08 ) { if( z1 ) z2 = "k > ?"; else z1 = "k > ?"; }
    if( idxNum & 0x10 ) { if( z1 ) z2 = "k <= ?"; else z1 = "k <= ?"; }
  }

  rc = zonefilePrepare(pTab->db, &pCsr->pSelect, &pTab->base.zErrMsg, 
      "SELECT k, fileid, fofst, fsz, ofst, sz FROM %Q.'%q_shadow_idx'%s%s%s%s",
      pTab->zDb, pTab->zName,
      z1 ? " WHERE " : "", z1, 
      z2 ? " AND " : "", z2
  );

  if( z1 ) sqlite3_bind_value(pCsr->pSelect, 1, argv[0]);
  if( z2 ) sqlite3_bind_value(pCsr->pSelect, 2, argv[1]);

      return pKey->nKey;
    }
  }

  return 0;
}

static int zonefileGetFile(
  sqlite3_context *pCtx,          /* Leave error message here */
  ZonefileCsr *pCsr,              /* Cursor object */
  const char **pzFile             /* OUT: Pointer to current file */
){
  ZonefileTab *pTab = (ZonefileTab*)pCsr->base.pVtab;



  int rc = SQLITE_OK;




  i64 iFileid;





  if( pTab->pIdToName==0 ){
    rc = zonefilePrepare(pTab->db, &pTab->pIdToName, &pTab->base.zErrMsg, 
        "SELECT filename FROM %Q.'%q_shadow_file' WHERE fileid=?",
        pTab->zDb, pTab->zName
    );
    if( rc!=SQLITE_OK ){
      zonefileTransferError(pCtx);
      return SQLITE_ERROR;
    }
  }





  iFileid = sqlite3_column_int64(pCsr->pSelect,1);
  sqlite3_bind_int64(pTab->pIdToName, 1, iFileid);
  if( SQLITE_ROW==sqlite3_step(pTab->pIdToName) ){
    *pzFile = (const char*)sqlite3_column_text(pTab->pIdToName, 0);

  }else{

    rc = sqlite3_reset(pTab->pIdToName);
    if( rc==SQLITE_OK ){
      rc = SQLITE_CORRUPT_VTAB;
    }else{
      zonefileTransferError(pCtx);
    }
  }

  return rc;
}

static void zonefileReleaseFile(ZonefileCsr *pCsr){
  ZonefileTab *pTab = (ZonefileTab*)pCsr->base.pVtab;
  sqlite3_reset(pTab->pIdToName);
}

static int zonefileGetValue(sqlite3_context *pCtx, ZonefileCsr *pCsr){
  ZonefileTab *pTab = (ZonefileTab*)pCsr->base.pVtab;
  const char *zFile = 0;
  char *zErr = 0;
  FILE *pFd = 0;
  int rc = SQLITE_OK;
  ZonefileHeader hdr;
  ZonefileCompress *pCmpMethod = 0;
  ZonefileCodec *pCodec = 0;
  void *pCmp = 0;

  /* Open the file to read the blob from */
  rc = zonefileGetFile(pCtx, pCsr, &zFile);
  if( rc==SQLITE_OK ){
    pFd = zonefileFileOpen(zFile, 0, &zErr);
    if( pFd==0 ) rc = SQLITE_ERROR;
  }

  /* Read the zonefile header */
  if( rc==SQLITE_OK ){
    rc = zonefileReadHeader(pFd, zFile, &hdr, &zErr);
  }

  /* Find the compression method and open the compressor handle. */
  if( rc==SQLITE_OK ){
    rc = zfFindCompress(hdr.compressionTypeContent, &pCmpMethod, &zErr);
  }
  if( pCmpMethod ){
    int nDict = 0;
    u8 *aDict = 0;
    assert( rc==SQLITE_OK );

    }
    if( rc==SQLITE_OK ){
      rc = pCmpMethod->xOpen(&pCmp, aDict, nDict);
    }
    sqlite3_free(aDict);
  }

  /* Find the encryption method and key. */
  if( hdr.encryptionType ){
    const char *z= 0;
    int nKey = zonefileFindKey(pTab, sqlite3_column_int64(pCsr->pSelect,1), &z);
    if( nKey==0 ){
      zErr = sqlite3_mprintf("missing encryption key for file \"%s\"", zFile);
      rc = SQLITE_ERROR;
    }else{
      rc = zonefileCodecCreate(hdr.encryptionType,(u8*)z, nKey, &pCodec, &zErr);
    }
























  }

  /* Read some data into memory. If the data is uncompressed, then just
  ** the required record is read. Otherwise, the entire frame is read
  ** into memory.  */
  if( rc==SQLITE_OK ){


    i64 iFrameOff = sqlite3_column_int64(pCsr->pSelect, 2);

    int szFrame = sqlite3_column_int(pCsr->pSelect, 3);


    u8 *aBuf = sqlite3_malloc(szFrame);




    if( aBuf==0 ){
      rc = SQLITE_NOMEM;
    }else{
      rc = zonefileFileRead(pFd, aBuf, szFrame, iFrameOff);
      if( rc!=SQLITE_OK ){
















        zErr = sqlite3_mprintf(
            "failed to read %d bytes at offset %d from file \"%s\"", 
            szFrame, iFrameOff, zFile
        );
      }
    }

    if( rc==SQLITE_OK ){
      if( pCodec==0 && pCmpMethod==0 ){
        sqlite3_result_blob(pCtx, aBuf, szFrame, zonefileFree);
        aBuf = 0;
      }else{
        i64 iOff = sqlite3_column_int64(pCsr->pSelect, 4);
        int sz = sqlite3_column_int(pCsr->pSelect, 5);

        /* Decrypt the data if necessary */
        if( pCodec ){
          zonefileCodecDecode(pCodec, aBuf, szFrame);
          szFrame -= zonefileCodecNonceSize(pCodec);
        }
        if( pCmpMethod ){
          rc = zonefileCtxUncompress(
              pCtx, pCmpMethod, pCmp, aBuf, szFrame, iOff, sz
          );
        }else{
          sqlite3_result_blob(pCtx, &aBuf[iOff], sz, SQLITE_TRANSIENT);
        }
      }
    }
    sqlite3_free(aBuf);
  }

  zonefileReleaseFile(pCsr);
  if( zErr ){
    assert( rc!=SQLITE_OK );
    sqlite3_result_error(pCtx, zErr, -1);
    sqlite3_free(zErr);
  }
  zonefileFileClose(pFd);
  zonefileCodecDestroy(pCodec);

  switch( i ){
    case 0: /* k */
      sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pSelect, 0));
      break;
    case 1: /* v */
      rc = zonefileGetValue(pCtx, pCsr);
      break;
    case 2: /* file */
      sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pSelect, 1));
      break;
    default: { /* sz */


      int iCol;
      if( sqlite3_column_type(pCsr->pSelect, 5)==SQLITE_NULL ){
        iCol = 3;
      }else{

        iCol = 5;
      }
      sqlite3_result_value(pCtx, sqlite3_column_value(pCsr->pSelect, iCol));
      break;
    }
  }
  return rc;
}

/* 
** zonefile virtual table module xRowid method.
*/

         json_extract(header, '$.numKeys')
         FROM z1_files;
} {test.zonefile 1179332920 1 3}

do_execsql_test 1.4 { SELECT count(*) FROM z1_shadow_idx } 3

do_execsql_test 1.5.1 { SELECT k FROM z1 } {1 2 3}
do_execsql_test 1.5.2 { SELECT file FROM z1 } {
  test.zonefile test.zonefile test.zonefile
}
do_execsql_test 1.5.4 { SELECT sz FROM z1 } {100 100 100}
exit

do_execsql_test 1.5.5 {
  SELECT zz.v==z1.v FROM zz, z1 WHERE zz.k=z1.k
} {1 1 1}

do_execsql_test 1.5 {
  DELETE FROM z1_files;