Schema.h

Go to the documentation of this file.

// catalog/Schema.h
#ifndef CATALOG_SCHEMA_H
#define CATALOG_SCHEMA_H
 
#include "tdb.h"
 
#include <vector>
 
namespace taco {
 
class BootstrapCatCache;
 
class Schema {
private:
    struct FieldInfo {
        Oid                m_typid;
 
        int16_t            m_typlen;
 
        int8_t            m_typalign;
 
        bool            m_typbyref;
 
        uint64_t        m_typparam;
 
        FieldId            m_nullbit_id;
 
        FieldOffset        m_offset;
    };
 
    Schema(const std::vector<Oid> &typid,
           const std::vector<uint64_t> &typparam,
           const std::vector<bool> &nullable,
           std::vector<std::string> field_names);
 
    Schema(const std::vector<FieldInfo>& fields,
           const std::vector<std::string>& field_names);
 
    Schema() = default;
 
public:
    static Schema *Create(const std::vector<Oid> &typid,
                          const std::vector<uint64_t> &typparam,
                          const std::vector<bool> &nullable);
 
    static Schema *Create(const std::vector<Oid> &typid,
                          const std::vector<uint64_t> &typparam,
                          const std::vector<bool> &nullable,
                          std::vector<std::string> field_names);
 
    static Schema *Combine(const Schema* left, const Schema* right);
 
    static bool Identical(const Schema* left, const Schema* right);
 
    static bool Compatible(const Schema* left, const Schema* right);
 
private:
    template<class CCache>
    void ComputeLayoutImpl(CCache *catcache, bool cache_typinfo_only);
 
public:
    void ComputeLayout();
 
    void ComputeLayout(BootstrapCatCache *catcache);
 
    void CollectTypeInfo();
 
    bool
    IsTypeInfoCollected() const {
        return m_type_info_collected;
    }
 
    bool
    IsLayoutComputed() const {
        return m_layout_computed;
    }
 
private:
 
    void EnsureLayoutComputed() const {
        if (!IsLayoutComputed()) {
            LOG(kFatal, "Schema::ComputeLayout() must be called first "
                        "before querying the on-disk layout of a Schema");
        }
    }
 
    void EnsureTypeInfoCollected() const {
        if (!IsTypeInfoCollected()) {
            LOG(kFatal, "Schema::CollectTypeInfo() or Schema::ComputeLayout() "
                        "must be called first before querying the in-memory "
                        "type info of a schema");
        }
    }
 
public:
 
    inline Oid
    GetFieldTypeId(FieldId field_id) const {
        return m_field[field_id].m_typid;
    }
 
    inline uint64_t
    GetFieldTypeParam(FieldId field_id) const {
        return m_field[field_id].m_typparam;
    }
 
    inline absl::string_view
    GetFieldName(FieldId field_id) const {
        if ((size_t) field_id >= m_field_names.size()) {
            return "";
        }
        return m_field_names[field_id];
    }
 
    inline bool
    FieldIsNullable(FieldId field_id) const {
        return m_field[field_id].m_nullbit_id >= 0;
    }
 
    inline bool
    FieldPassByRef(FieldId field_id) const {
        return m_field[field_id].m_typbyref;
    }
 
    FieldOffset
    GetFieldLength(size_t field_id) const {
        EnsureTypeInfoCollected();
        return m_field[field_id].m_typlen;
    }
 
    inline FieldId
    GetNumFields() const {
        return (FieldId) m_field.size();
    }
 
    FieldId GetFieldIdFromFieldName(absl::string_view field_name) const;
 
    std::pair<FieldOffset, FieldOffset> GetOffsetAndLength(
        FieldId field_id,
        const char *payload) const;
 
    FieldOffset WritePayloadToBuffer(const std::vector<Datum> &data,
                                     maxaligned_char_buf &buf) const;
 
    FieldOffset WritePayloadToBuffer(const std::vector<DatumRef> &data,
                                     maxaligned_char_buf &buf) const;
 
    FieldOffset WritePayloadToBuffer(const std::vector<NullableDatumRef> &data,
                                     maxaligned_char_buf &buf) const;
 
 
    bool FieldIsNull(FieldId field_id, const char *payload) const;
 
    Datum GetField(FieldId field_id, const char *payload) const;
 
    std::vector<Datum> DissemblePayload(const char *payload) const;
 
 
private:
    template<class SomeDatum>
    FieldOffset WritePayloadToBufferImpl(const std::vector<SomeDatum> &data,
                                         maxaligned_char_buf &buf) const;
 
    bool m_type_info_collected;
 
    bool m_layout_computed;
 
    bool m_has_only_nonnullable_fixedlen_fields;
 
    FieldId m_num_nonnullable_fixedlen_fields;
 
    FieldId m_num_nullable_fixedlen_fields;
 
    FieldId m_num_varlen_fields;
 
    FieldOffset m_null_bitmap_begin;
 
    FieldOffset m_varlen_end_array_begin;
 
    FieldOffset m_varlen_payload_begin;
 
    std::vector<FieldId> m_field_reorder_idx;
 
    std::vector<FieldInfo> m_field;
 
    std::vector<std::string> m_field_names;
};
 
}   // namespace taco
 
#endif      // CATALOG_SCHEMA_H