VolatileCatCache.h

Go to the documentation of this file.

#ifndef CATALOG_VOLATILE_CATCACHE_H
#define CATALOG_VOLATILE_CATCACHE_H
 
#include "tdb.h"
 
#include "catalog/CatCacheBase.h"
#include "storage/Record.h"
#include "index/BulkLoadIterator.h"
 
namespace taco {
 
class VolatileCatCache: public CatCacheBase<VolatileCatCache> {
public:
    void InitializeFromExistingData() {
        LOG(kError,
            "voatile catlog cannot be initialized from an existing data "
            "directory");
    }
 
private:
    struct InmemFile {
        std::vector<bool>       m_valid;
        std::vector<size_t>     m_offsets;
        std::vector<char>       m_bytes;
    };
 
    struct CatFileIterator {
        FileId      m_fid;
        uint16_t    m_nextidx;
        uint16_t    m_endidx;
    };
 
    class InmemFileBulkLoadIterator: public BulkLoadIterator {
    public:
        InmemFileBulkLoadIterator(std::shared_ptr<const IndexDesc> idxdesc,
                                  std::shared_ptr<const TableDesc> tabdesc,
                                  VolatileCatCache *vcatcache,
                                  CatFileIterator iter):
            BulkLoadIterator(idxdesc->GetKeySchema()),
            m_idxdesc(std::move(idxdesc)),
            m_tabdesc(std::move(tabdesc)),
            m_vcatcache(vcatcache),
            m_iter(iter),
            m_data() {}
 
        bool Next() override;
 
        void EndScan() override {
            m_vcatcache->EndIterateCatEntry(m_iter);
        }
 
    private:
        std::shared_ptr<const IndexDesc> m_idxdesc;
        std::shared_ptr<const TableDesc> m_tabdesc;
        VolatileCatCache *m_vcatcache;
        CatFileIterator m_iter;
        std::vector<Datum> m_data;
    };
 
    friend class InmemFileBulkLoadIterator;
 
    FileId CreateCatalogFile(bool format_heapfile, FieldOffset /*unused*/ = 0);
 
    typedef FileId FileHandle;
 
    FileHandle OpenCatalogFile(FileId fid, const TableDesc *tabdesc);
 
    void CloseCatalogFile(FileHandle &fh);
 
    typedef int PageHandle;
 
    PageHandle GetFirstPage(FileHandle &fh, char **pagebuf);
 
    void MarkPageDirty(PageHandle &pghandle);
 
    void ReleasePage(PageHandle &pghandle);
 
    void AppendRecord(FileHandle &fh, Record &rec);
 
    CatFileIterator IterateCatEntry(FileHandle &fh);
 
    CatFileIterator IterateCatEntryFrom(FileHandle &fh, RecordId rid);
 
    bool NextCatEntry(CatFileIterator &iter);
 
    const char *GetCurrentCatEntry(CatFileIterator &iter);
 
    RecordId GetCurrentCatEntryRecordId(CatFileIterator &iter);
 
    void UpdateCurrentCatEntry(CatFileIterator &iter, Record &rec);
 
    void EndIterateCatEntry(CatFileIterator &iter);
 
    BulkLoadIterator *GetBulkLoadIterator(
        FileHandle &fh,
        std::shared_ptr<const TableDesc> tabdesc,
        std::shared_ptr<const IndexDesc> idxdesc);
 
    std::vector<std::unique_ptr<InmemFile>> m_systables;
 
    unique_malloced_ptr m_dbmeta_page;
 
    friend class CatCacheBase<VolatileCatCache>;
};
 
extern template class CatCacheBase<VolatileCatCache>;
 
}    // namespace taco
 
#endif      // CATALOG_VOLATILE_CATCACHE_H