lbug 0.19.0

An in-process property graph database management system built for query speed and scalability
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

#pragma once

#include "catalog/catalog_entry/rel_group_catalog_entry.h"
#include "common/exception/runtime.h"
#include "function/table/table_function.h"
#include "storage/table/rel_table.h"

namespace lbug {
namespace storage {

struct ForeignRelTableScanState final : RelTableScanState {
    std::shared_ptr<function::TableFuncSharedState> sharedState;
    std::shared_ptr<function::TableFuncLocalState> localState;
    common::DataChunk dataChunk;

    ForeignRelTableScanState(MemoryManager& mm, common::ValueVector* nodeIDVector,
        std::vector<common::ValueVector*> outputVectors,
        std::shared_ptr<common::DataChunkState> outChunkState);

    // Foreign rel tables are scan-driven and own no on-disk CSR columns, so skip
    // the RelTableScanState CSR-column resolution (which would dereference an
    // empty directedRelData and throw).
    void setToTable(const transaction::Transaction* transaction, Table* table_,
        std::vector<common::column_id_t> columnIDs_,
        std::vector<ColumnPredicateSet> columnPredicateSets_,
        common::RelDataDirection direction_) override {
        TableScanState::setToTable(transaction, table_, std::move(columnIDs_),
            std::move(columnPredicateSets_));
        columns.resize(columnIDs.size());
        direction = direction_;
        for (size_t i = 0; i < columnIDs.size(); ++i) {
            columns[i] = nullptr;
        }
        csrOffsetColumn = nullptr;
        csrLengthColumn = nullptr;
        nodeGroupIdx = common::INVALID_NODE_GROUP_IDX;
    }
};

class ForeignRelTable final : public RelTable {
public:
    ForeignRelTable(catalog::RelGroupCatalogEntry* relGroupEntry, common::table_id_t fromTableID,
        common::table_id_t toTableID, const StorageManager* storageManager,
        MemoryManager* memoryManager, function::TableFunction scanFunction,
        std::shared_ptr<function::TableFuncBindData> scanBindData);

    void initScanState(transaction::Transaction* transaction, TableScanState& scanState,
        bool resetCachedBoundNodeSelVec = true) const override;

    bool scanInternal(transaction::Transaction* transaction, TableScanState& scanState) override;

    // For foreign-backed tables, we don't support modifications
    void insert([[maybe_unused]] transaction::Transaction* transaction,
        [[maybe_unused]] TableInsertState& insertState) override {
        throw common::RuntimeException("Cannot insert into foreign-backed rel table");
    }
    void update([[maybe_unused]] transaction::Transaction* transaction,
        [[maybe_unused]] TableUpdateState& updateState) override {
        throw common::RuntimeException("Cannot update foreign-backed rel table");
    }
    bool delete_([[maybe_unused]] transaction::Transaction* transaction,
        [[maybe_unused]] TableDeleteState& deleteState) override {
        throw common::RuntimeException("Cannot delete from foreign-backed rel table");
        return false;
    }

    common::row_idx_t getNumTotalRows(const transaction::Transaction* transaction) override;

private:
    function::TableFunction scanFunction;
    std::shared_ptr<function::TableFuncBindData> scanBindData;
};

} // namespace storage
} // namespace lbug