CatCacheBase.h

Go to the documentation of this file.

#ifndef CATALOG_CATCACHEBASE_H
#define CATALOG_CATCACHEBASE_H
 
#include "tdb.h"
 
#include <absl/container/flat_hash_map.h>
 
#include "catalog/TableDesc.h"
#include "catalog/IndexDesc.h"
#include "catalog/systables.h"
#include "storage/Record.h"
 
namespace taco {
 
struct CCLookupTableEntry {
    CCLookupTableEntry(RecordId recid, std::shared_ptr<void> systable_struct):
        m_recid(recid),
        m_systable_struct(std::move(systable_struct)) {}
 
    CCLookupTableEntry(const CCLookupTableEntry&) = delete;
    CCLookupTableEntry &operator=(const CCLookupTableEntry&) = delete;
    CCLookupTableEntry(CCLookupTableEntry&& e) = default;
    CCLookupTableEntry &operator=(CCLookupTableEntry&& e) = default;
 
    RecordId                m_recid;
    std::shared_ptr<void>   m_systable_struct;
};
 
class CatCacheInternalAccess {
protected:
 
    static std::shared_ptr<void> CreateSysTableStruct(
        Oid tabid, const std::vector<Datum> &data);
 
    template<class T>
    static T*
    CreateSysTableStruct(const std::vector<Datum> &data) {
        return T::Create(data);
    }
 
    template<class T>
    static T*
    CopySysTableStruct(const T *s) {
        T *copy = new T(*s);
        return copy;
    }
 
    template<class T, class ...Args>
    static T*
    ConstructSysTableStruct(Args&& ...args) {
        return new T(std::forward<Args>(args)...);
    }
 
    template<class T>
    std::vector<Datum>
    GetDatumVector(const T& systable_struct) {
        return systable_struct->GetDatumVector();
    }
};
 
template<class CatCacheCls>
class CatCacheBase: public CatCacheInternalAccess {
public:
    CatCacheBase();
 
    void InitializeFromExistingData();
 
    void InitializeFromInitData(const std::string &init_datafile);
 
    constexpr
    bool IsInitialized() const {
        return m_initialized;
    }
 
    inline std::shared_ptr<const SysTable_Table>
    FindTable(Oid tabid) {
        auto entry =
            SearchForCatalogEntryByOid(initoids::TAB_Table,
                                       initoids::IDX_Table_tabid,
                                       SysTable_Table::tabid_colid(),
                                       tabid);
        if (!entry) {
            return nullptr;
        }
        return static_pointer_cast<const SysTable_Table>(
            entry->m_systable_struct);
    }
 
    inline Oid
    FindTableByName(absl::string_view tabname) {
        auto entry =
            SearchForCatalogEntryByName(initoids::TAB_Table,
                                        initoids::IDX_Table_tabname,
                                        SysTable_Table::tabname_colid(),
                                        tabname);
        if (!entry) {
            return InvalidOid;
        }
        return ((const SysTable_Table*)(entry->m_systable_struct.get()))
            ->tabid();
    }
 
    std::shared_ptr<const TableDesc> FindTableDesc(Oid tabid);
 
    inline std::shared_ptr<const SysTable_Type>
    FindType(Oid typid) {
        auto entry =
            SearchForCatalogEntryByOid(initoids::TAB_Type,
                                       initoids::IDX_Type_typid,
                                       SysTable_Type::typid_colid(),
                                       typid);
        if (!entry) {
            return nullptr;
        }
        return static_pointer_cast<const SysTable_Type>(
            entry->m_systable_struct);
    }
 
    inline std::string
    GetTypeName(Oid typid) {
        auto typ = FindType(typid);
        if (!typ.get()) {
            return "INVALID_TYPE";
        }
        return typ->typname();
    }
 
    inline std::shared_ptr<const SysTable_Function>
    FindFunction(Oid funcid) {
        auto entry =
            SearchForCatalogEntryByOid(initoids::TAB_Function,
                                       initoids::IDX_Function_funcid,
                                       SysTable_Function::funcid_colid(),
                                       funcid);
        if (!entry) {
            return nullptr;
        }
        return static_pointer_cast<const SysTable_Function>(
            entry->m_systable_struct);
    }
 
    inline Oid
    FindFunctionByName(absl::string_view funcname) {
        auto entry =
            SearchForCatalogEntryByName(initoids::TAB_Function,
                                        initoids::IDX_Function_funcname,
                                        SysTable_Function::funcname_colid(),
                                        funcname);
        if (!entry) {
            return InvalidOid;
        }
        return ((const SysTable_Function*)(entry->m_systable_struct.get()))
            ->funcid();
    }
 
    std::shared_ptr<const SysTable_FunctionArgs> FindFunctionArgs(
        Oid funcid, int16_t funcargid);
 
    inline std::shared_ptr<const SysTable_Index>
    FindIndex(Oid idxid) {
        auto entry =
            SearchForCatalogEntryByOid(initoids::TAB_Index,
                                       initoids::IDX_Index_idxid,
                                       SysTable_Index::idxid_colid(),
                                       idxid);
        if (!entry) {
            return nullptr;
        }
        return static_pointer_cast<const SysTable_Index>(
            entry->m_systable_struct);
    }
 
    inline Oid
    FindIndexByName(absl::string_view idxname) {
        auto entry =
            SearchForCatalogEntryByName(initoids::TAB_Index,
                                        InvalidOid,
                                        SysTable_Index::idxname_colid(),
                                        idxname);
        if (!entry) {
            return InvalidOid;
        }
        return ((const SysTable_Index*)(entry->m_systable_struct.get()))
            ->idxid();
    }
 
    std::vector<Oid> FindAllIndexesOfTable(Oid idxtabid);
 
    std::shared_ptr<const IndexDesc> FindIndexDesc(Oid idxid);
 
    Oid FindOperator(OpType optype, Oid oparg0typid, Oid oparg1typid);
 
    Oid FindCast(Oid castoprtypid, Oid castrettypid, bool must_be_implicit);
 
    inline std::shared_ptr<const SysTable_Aggregation>
    FindAggregation(Oid aggid) {
        auto entry =
            SearchForCatalogEntryByOid(initoids::TAB_Aggregation,
                                       initoids::IDX_Aggregation_aggid,
                                       SysTable_Aggregation::aggid_colid(),
                                       aggid);
        if (!entry) {
            return nullptr;
        }
        return static_pointer_cast<const SysTable_Aggregation>(
            entry->m_systable_struct);
    }
 
    Oid FindAggregationByNameAndOprType(absl::string_view aggname,
                                        Oid aggoprtypid);
 
    Oid FindAggregationByTidAndOprType(AggType aggtyp,
                                       Oid aggoprtypid);
 
    CCLookupTableEntry* SearchForCatalogEntryByOid(
        Oid systabid,
        Oid idxid_hint,
        FieldId oid_colid,
        Oid oid);
 
    CCLookupTableEntry* SearchForCatalogEntryByName(
        Oid systabid,
        Oid idxid_hint,
        FieldId name_colid,
        absl::string_view name);
 
    template<bool expect_unique, size_t NPreds, bool no_cache>
    struct SearchForCatalogEntry {
        using EntryPtr = typename std::conditional<
            no_cache,
            std::unique_ptr<CCLookupTableEntry>,
            CCLookupTableEntry*>::type;
        using RetType = typename std::conditional<
            expect_unique,
            EntryPtr,
            std::vector<EntryPtr>>::type;
 
        template<class RHS0, class ...RemRHS>
        inline static
        typename std::enable_if<std::is_same<RHS0, RHS0>::value
                                && expect_unique, RetType>::type
        Call(CatCacheBase *_this,
             Oid systabid,
             Oid idxid_hint,
             const std::array<FieldId, NPreds> &fieldid,
             const std::array<Oid, NPreds> &eq_funcid,
             RHS0&& rhs0,
             RemRHS&& ...remrhs) {
            return Impl(_this, systabid, idxid_hint, 0, fieldid, eq_funcid,
                std::forward<RHS0>(rhs0), std::forward<RemRHS>(remrhs)...);
        }
 
        template<class RHS0, class ...RemRHS>
        inline static
        typename std::enable_if<std::is_same<RHS0, RHS0>::value
                                && !expect_unique, RetType>::type
        Call(CatCacheBase *_this,
             Oid systabid,
             Oid idxid_hint,
             size_t expect_n,
             const std::array<FieldId, NPreds> &fieldid,
             const std::array<Oid, NPreds> &eq_funcid,
             RHS0&& rhs0,
             RemRHS&& ...remrhs) {
            return Impl(_this, systabid, idxid_hint, expect_n, fieldid,
                eq_funcid, std::forward<RHS0>(rhs0),
                std::forward<RemRHS>(remrhs)...);
        }
 
    private:
        template<class ...RHS>
        static RetType
        Impl(CatCacheBase *_this,
             Oid systabid,
             Oid idxid_hint,
             size_t expect_n,
             const std::array<FieldId, NPreds> &fieldid,
             const std::array<Oid, NPreds> &eq_funcid,
             RHS&& ...rhs);
    };
 
    template<bool, size_t, bool> friend struct SearchForCatalogEntry;
 
    Oid AddTable(absl::string_view tabname,
                 std::vector<Oid> coltypid,
                 std::vector<uint64_t> coltypparam,
                 std::vector<std::string> field_names,
                 std::vector<bool> colisnullable,
                 std::vector<bool> colisarray,
                 FileId tabfid);
 
    Oid AddIndex(absl::string_view idxname,
                 Oid idxtabid,
                 IdxType idxtyp,
                 bool idxunique,
                 std::vector<FieldId> idxcoltabcolids,
                 FileId idxfid,
                 std::vector<Oid> idxcolltfuncids,
                 std::vector<Oid> idxcoleqfuncids);
private:
    void CreateDBMeta();
 
    absl::flat_hash_map<Oid, FileId> LoadInitFile(
        const std::string &init_datafile,
        BootstrapCatCache *catcache);
 
    void FinishInitCatalog(const absl::flat_hash_map<Oid, FileId> &tabid2fid,
                           BootstrapCatCache *catcache);
 
    void LoadMinCache(BootstrapCatCache *catcache);
 
    void CheckIndexes(bool init);
 
    void BuildIndex(bool init, Oid idxid);
 
    Oid AllocateOid();
 
    template<bool no_cache>
    typename std::conditional<no_cache,
                              std::unique_ptr<CCLookupTableEntry>,
                              CCLookupTableEntry*>::type
    GetOrCreateCachedEntry(Oid systabid,
                           RecordId recid,
                           const Schema *schema,
                           const char *buf);
 
    void InsertCatalogEntries(Oid systabid,
                              const std::vector<std::vector<Datum>> &data);
 
    bool m_initialized;
    bool m_use_index;
    //absl::flat_hash_map<Oid, CCLookupTableEntry> m_oid_lookup_table;
    absl::flat_hash_map<RecordId, CCLookupTableEntry> m_recid_lookup_table;
    absl::flat_hash_map<Oid, std::shared_ptr<TableDesc>> m_table_desc;
    absl::flat_hash_map<Oid, std::shared_ptr<IndexDesc>> m_index_desc;
};
 
}   // namespace taco
 
#endif      // CATALOG_CATCACHEBASE_H