table.h

Go to the documentation of this file.

#pragma once
 
#include "table_catalog_entry.h"
#include "zone_map_check_result.h"
#include "mask.h"
#include "column_predicate.h"
#include "column.h"
#include "node_group.h"
 
namespace kuzu {
namespace evaluator {
class ExpressionEvaluator;
} // namespace evaluator
namespace storage {
 
enum class TableScanSource : uint8_t { COMMITTED = 0, UNCOMMITTED = 1, NONE = 3 };
 
struct TableScanState {
    std::unique_ptr<common::ValueVector> rowIdxVector;
    // Node/Rel ID vector. We assume all output vectors are within the same DataChunk as this one.
    common::ValueVector* IDVector;
    std::vector<common::ValueVector*> outputVectors;
    std::vector<common::column_id_t> columnIDs;
    common::NodeSemiMask* semiMask;
 
    // Only used when scan from persistent data.
    std::vector<Column*> columns;
 
    TableScanSource source = TableScanSource::NONE;
    common::node_group_idx_t nodeGroupIdx = common::INVALID_NODE_GROUP_IDX;
    NodeGroup* nodeGroup = nullptr;
    std::unique_ptr<NodeGroupScanState> nodeGroupScanState;
 
    std::vector<ColumnPredicateSet> columnPredicateSets;
    common::ZoneMapCheckResult zoneMapResult = common::ZoneMapCheckResult::ALWAYS_SCAN;
 
    explicit TableScanState(std::vector<common::column_id_t> columnIDs)
        : IDVector(nullptr), columnIDs{std::move(columnIDs)}, semiMask{nullptr} {
        rowIdxVector = std::make_unique<common::ValueVector>(common::LogicalType::INT64());
    }
    TableScanState(std::vector<common::column_id_t> columnIDs, std::vector<Column*> columns,
        std::vector<ColumnPredicateSet> columnPredicateSets)
        : IDVector(nullptr), columnIDs{std::move(columnIDs)}, semiMask{nullptr},
          columns{std::move(columns)}, columnPredicateSets{std::move(columnPredicateSets)} {
        rowIdxVector = std::make_unique<common::ValueVector>(common::LogicalType::INT64());
    }
    explicit TableScanState(std::vector<common::column_id_t> columnIDs,
        std::vector<Column*> columns)
        : IDVector(nullptr), columnIDs{std::move(columnIDs)}, semiMask{nullptr},
          columns{std::move(columns)} {
        rowIdxVector = std::make_unique<common::ValueVector>(common::LogicalType::INT64());
    }
    virtual ~TableScanState() = default;
    DELETE_COPY_DEFAULT_MOVE(TableScanState);
 
    virtual void resetState() {
        source = TableScanSource::NONE;
        nodeGroupIdx = common::INVALID_NODE_GROUP_IDX;
        nodeGroup = nullptr;
        nodeGroupScanState->resetState();
        zoneMapResult = common::ZoneMapCheckResult::ALWAYS_SCAN;
    }
 
    template<class TARGET>
    TARGET& cast() {
        return common::ku_dynamic_cast<TableScanState&, TARGET&>(*this);
    }
    template<class TARGETT>
    const TARGETT& cast() const {
        return common::ku_dynamic_cast<const TableScanState&, const TARGETT&>(*this);
    }
};
 
struct TableInsertState {
    const std::vector<common::ValueVector*>& propertyVectors;
 
    explicit TableInsertState(const std::vector<common::ValueVector*>& propertyVectors)
        : propertyVectors{propertyVectors} {}
    virtual ~TableInsertState() = default;
 
    template<typename T>
    const T& constCast() const {
        return common::ku_dynamic_cast<const TableInsertState&, const T&>(*this);
    }
    template<typename T>
    T& cast() {
        return common::ku_dynamic_cast<TableInsertState&, T&>(*this);
    }
};
 
struct TableUpdateState {
    common::column_id_t columnID;
    common::ValueVector& propertyVector;
 
    TableUpdateState(common::column_id_t columnID, common::ValueVector& propertyVector)
        : columnID{columnID}, propertyVector{propertyVector} {}
    virtual ~TableUpdateState() = default;
 
    template<typename T>
    const T& constCast() const {
        return common::ku_dynamic_cast<const TableUpdateState&, const T&>(*this);
    }
    template<typename T>
    T& cast() {
        return common::ku_dynamic_cast<TableUpdateState&, T&>(*this);
    }
};
 
struct TableDeleteState {
    virtual ~TableDeleteState() = default;
 
    template<typename T>
    const T& constCast() const {
        return common::ku_dynamic_cast<const TableDeleteState&, const T&>(*this);
    }
    template<typename T>
    T& cast() {
        return common::ku_dynamic_cast<TableDeleteState&, T&>(*this);
    }
};
 
struct TableAddColumnState final {
    const catalog::Property& property;
    evaluator::ExpressionEvaluator& defaultEvaluator;
 
    TableAddColumnState(const catalog::Property& property,
        evaluator::ExpressionEvaluator& defaultEvaluator)
        : property{property}, defaultEvaluator{defaultEvaluator} {}
    ~TableAddColumnState() = default;
};
 
class LocalTable;
class StorageManager;
class Table {
public:
    Table(const catalog::TableCatalogEntry* tableEntry, StorageManager* storageManager,
        MemoryManager* memoryManager);
    virtual ~Table() = default;
 
    static std::unique_ptr<Table> loadTable(common::Deserializer& deSer,
        const catalog::Catalog& catalog, StorageManager* storageManager,
        MemoryManager* memoryManager, common::VirtualFileSystem* vfs, main::ClientContext* context);
 
    common::TableType getTableType() const { return tableType; }
    common::table_id_t getTableID() const { return tableID; }
    std::string getTableName() const { return tableName; }
    BMFileHandle* getDataFH() const { return dataFH; }
 
    virtual void initializeScanState(transaction::Transaction* transaction,
        TableScanState& readState) = 0;
    bool scan(transaction::Transaction* transaction, TableScanState& scanState) {
        for (const auto& vector : scanState.outputVectors) {
            vector->resetAuxiliaryBuffer();
        }
        return scanInternal(transaction, scanState);
    }
 
    virtual void insert(transaction::Transaction* transaction, TableInsertState& insertState) = 0;
    virtual void update(transaction::Transaction* transaction, TableUpdateState& updateState) = 0;
    virtual bool delete_(transaction::Transaction* transaction, TableDeleteState& deleteState) = 0;
 
    virtual void addColumn(transaction::Transaction* transaction,
        TableAddColumnState& addColumnState) = 0;
    void dropColumn() { setHasChanges(); }
 
    virtual void commit(transaction::Transaction* transaction, LocalTable* localTable) = 0;
    virtual void checkpoint(common::Serializer& ser, catalog::TableCatalogEntry* tableEntry) = 0;
 
    virtual common::row_idx_t getNumRows() = 0;
 
    void setHasChanges() { hasChanges = true; }
 
    template<class TARGET>
    TARGET& cast() {
        return common::ku_dynamic_cast<Table&, TARGET&>(*this);
    }
    template<class TARGET>
    const TARGET& cast() const {
        return common::ku_dynamic_cast<const Table&, const TARGET&>(*this);
    }
    template<class TARGET>
    TARGET* ptrCast() {
        return common::ku_dynamic_cast<Table*, TARGET*>(this);
    }
 
protected:
    virtual bool scanInternal(transaction::Transaction* transaction, TableScanState& scanState) = 0;
 
    virtual void serialize(common::Serializer& serializer) const;
 
    std::unique_ptr<common::DataChunk> constructDataChunk(
        const std::vector<common::LogicalType>& types);
 
protected:
    common::TableType tableType;
    common::table_id_t tableID;
    std::string tableName;
    bool enableCompression;
    BMFileHandle* dataFH;
    MemoryManager* memoryManager;
    BufferManager* bufferManager;
    ShadowFile* shadowFile;
    bool hasChanges;
};
 
} // namespace storage
} // namespace kuzu