lbug 0.16.0

An in-process property graph database management system built for query speed and scalability
Documentation 
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

#pragma once

#include "binder/query/query_graph.h"
#include "bound_insert_info.h"
#include "bound_set_info.h"
#include "bound_updating_clause.h"

namespace lbug {
namespace binder {

class BoundMergeClause final : public BoundUpdatingClause {
    static constexpr common::ClauseType type_ = common::ClauseType::MERGE;

public:
    BoundMergeClause(expression_vector columnDataExprs, std::shared_ptr<Expression> existenceMark,
        std::shared_ptr<Expression> distinctMark, QueryGraphCollection queryGraphCollection,
        std::shared_ptr<Expression> predicate, std::vector<BoundInsertInfo> insertInfos)
        : BoundUpdatingClause{type_}, columnDataExprs{std::move(columnDataExprs)},
          existenceMark{std::move(existenceMark)}, distinctMark{std::move(distinctMark)},
          queryGraphCollection{std::move(queryGraphCollection)}, predicate{std::move(predicate)},
          insertInfos{std::move(insertInfos)} {}

    expression_vector getColumnDataExprs() const { return columnDataExprs; }

    std::shared_ptr<Expression> getExistenceMark() const { return existenceMark; }
    std::shared_ptr<Expression> getDistinctMark() const { return distinctMark; }

    const QueryGraphCollection* getQueryGraphCollection() const { return &queryGraphCollection; }
    bool hasPredicate() const { return predicate != nullptr; }
    std::shared_ptr<Expression> getPredicate() const { return predicate; }

    const std::vector<BoundInsertInfo>& getInsertInfosRef() const { return insertInfos; }
    const std::vector<BoundSetPropertyInfo>& getOnMatchSetInfosRef() const {
        return onMatchSetPropertyInfos;
    }
    const std::vector<BoundSetPropertyInfo>& getOnCreateSetInfosRef() const {
        return onCreateSetPropertyInfos;
    }

    bool hasInsertNodeInfo() const {
        return hasInsertInfo(
            [](const BoundInsertInfo& info) { return info.tableType == common::TableType::NODE; });
    }
    std::vector<const BoundInsertInfo*> getInsertNodeInfos() const {
        return getInsertInfos(
            [](const BoundInsertInfo& info) { return info.tableType == common::TableType::NODE; });
    }
    bool hasInsertRelInfo() const {
        return hasInsertInfo(
            [](const BoundInsertInfo& info) { return info.tableType == common::TableType::REL; });
    }
    std::vector<const BoundInsertInfo*> getInsertRelInfos() const {
        return getInsertInfos(
            [](const BoundInsertInfo& info) { return info.tableType == common::TableType::REL; });
    }

    bool hasOnMatchSetNodeInfo() const {
        return hasOnMatchSetInfo([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::NODE;
        });
    }
    std::vector<BoundSetPropertyInfo> getOnMatchSetNodeInfos() const {
        return getOnMatchSetInfos([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::NODE;
        });
    }
    bool hasOnMatchSetRelInfo() const {
        return hasOnMatchSetInfo([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::REL;
        });
    }
    std::vector<BoundSetPropertyInfo> getOnMatchSetRelInfos() const {
        return getOnMatchSetInfos([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::REL;
        });
    }

    bool hasOnCreateSetNodeInfo() const {
        return hasOnCreateSetInfo([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::NODE;
        });
    }
    std::vector<BoundSetPropertyInfo> getOnCreateSetNodeInfos() const {
        return getOnCreateSetInfos([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::NODE;
        });
    }
    bool hasOnCreateSetRelInfo() const {
        return hasOnCreateSetInfo([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::REL;
        });
    }
    std::vector<BoundSetPropertyInfo> getOnCreateSetRelInfos() const {
        return getOnCreateSetInfos([](const BoundSetPropertyInfo& info) {
            return info.tableType == common::TableType::REL;
        });
    }

    void addOnMatchSetPropertyInfo(BoundSetPropertyInfo setPropertyInfo) {
        onMatchSetPropertyInfos.push_back(std::move(setPropertyInfo));
    }
    void addOnCreateSetPropertyInfo(BoundSetPropertyInfo setPropertyInfo) {
        onCreateSetPropertyInfos.push_back(std::move(setPropertyInfo));
    }

private:
    bool hasInsertInfo(const std::function<bool(const BoundInsertInfo& info)>& check) const;
    std::vector<const BoundInsertInfo*> getInsertInfos(
        const std::function<bool(const BoundInsertInfo& info)>& check) const;

    bool hasOnMatchSetInfo(
        const std::function<bool(const BoundSetPropertyInfo& info)>& check) const;
    std::vector<BoundSetPropertyInfo> getOnMatchSetInfos(
        const std::function<bool(const BoundSetPropertyInfo& info)>& check) const;

    bool hasOnCreateSetInfo(
        const std::function<bool(const BoundSetPropertyInfo& info)>& check) const;
    std::vector<BoundSetPropertyInfo> getOnCreateSetInfos(
        const std::function<bool(const BoundSetPropertyInfo& info)>& check) const;

private:
    // Capture user input column (right-hand-side) values in MERGE clause
    // E.g. UNWIND [1,2,3] AS x MERGE (a {id:2, rank:x})
    // this field should be {2, x}
    expression_vector columnDataExprs;
    // Internal marks
    std::shared_ptr<Expression> existenceMark;
    std::shared_ptr<Expression> distinctMark;
    // Pattern to match.
    QueryGraphCollection queryGraphCollection;
    std::shared_ptr<Expression> predicate;
    // Pattern to create on match failure.
    std::vector<BoundInsertInfo> insertInfos;
    // Update on match
    std::vector<BoundSetPropertyInfo> onMatchSetPropertyInfos;
    // Update on create
    std::vector<BoundSetPropertyInfo> onCreateSetPropertyInfos;
};

} // namespace binder
} // namespace lbug