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

#pragma once

#include "common/constants.h"
#include "common/enums/extend_direction.h"
#include "common/enums/query_rel_type.h"
#include "function/gds/rec_joins.h"
#include "node_expression.h"

namespace lbug {
namespace binder {

enum class RelDirectionType : uint8_t {
    SINGLE = 0,
    BOTH = 1,
    UNKNOWN = 2,
};

class RelExpression;

struct RecursiveInfo {
    /*
     * E.g. [e*1..2 (r, n) | WHERE n.age > 10 AND r.year = 2012 ]
     * node = n
     * nodeCopy = n (see comment below)
     * rel = r
     * predicates = [n.age > 10, r.year = 2012]
     * */
    std::shared_ptr<NodeExpression> node = nullptr;
    // NodeCopy has the same fields as node but a different unique name.
    // We use nodeCopy to plan recursive plan because boundNode&nbrNode cannot be the same.
    std::shared_ptr<NodeExpression> nodeCopy = nullptr;
    std::shared_ptr<RelExpression> rel = nullptr;
    // Predicates
    std::shared_ptr<Expression> nodePredicate = nullptr;
    std::shared_ptr<Expression> relPredicate = nullptr;
    // Projection list
    expression_vector nodeProjectionList;
    expression_vector relProjectionList;
    // Function information
    std::unique_ptr<function::RJAlgorithm> function;
    std::unique_ptr<function::RJBindData> bindData;
};

class LBUG_API RelExpression final : public NodeOrRelExpression {
public:
    RelExpression(common::LogicalType dataType, std::string uniqueName, std::string variableName,
        std::vector<catalog::TableCatalogEntry*> entries, std::shared_ptr<NodeExpression> srcNode,
        std::shared_ptr<NodeExpression> dstNode, RelDirectionType directionType,
        common::QueryRelType relType)
        : NodeOrRelExpression{std::move(dataType), std::move(uniqueName), std::move(variableName),
              std::move(entries)},
          srcNode{std::move(srcNode)}, dstNode{std::move(dstNode)}, directionType{directionType},
          relType{relType} {}

    bool isRecursive() const {
        return dataType.getLogicalTypeID() == common::LogicalTypeID::RECURSIVE_REL;
    }

    bool isMultiLabeled() const override;
    bool isBoundByMultiLabeledNode() const {
        return srcNode->isMultiLabeled() || dstNode->isMultiLabeled();
    }

    std::shared_ptr<NodeExpression> getSrcNode() const { return srcNode; }
    std::string getSrcNodeName() const { return srcNode->getUniqueName(); }
    void setDstNode(std::shared_ptr<NodeExpression> node) { dstNode = std::move(node); }
    std::shared_ptr<NodeExpression> getDstNode() const { return dstNode; }
    std::string getDstNodeName() const { return dstNode->getUniqueName(); }

    void setLeftNode(std::shared_ptr<NodeExpression> node) { leftNode = std::move(node); }
    std::shared_ptr<NodeExpression> getLeftNode() const { return leftNode; }
    void setRightNode(std::shared_ptr<NodeExpression> node) { rightNode = std::move(node); }
    std::shared_ptr<NodeExpression> getRightNode() const { return rightNode; }

    common::QueryRelType getRelType() const { return relType; }

    void setDirectionExpr(std::shared_ptr<Expression> expr) { directionExpr = std::move(expr); }
    bool hasDirectionExpr() const { return directionExpr != nullptr; }
    std::shared_ptr<Expression> getDirectionExpr() const { return directionExpr; }
    RelDirectionType getDirectionType() const { return directionType; }

    std::shared_ptr<PropertyExpression> getInternalID() const override {
        return getPropertyExpression(common::InternalKeyword::ID);
    }

    void setRecursiveInfo(std::unique_ptr<RecursiveInfo> recursiveInfo_) {
        recursiveInfo = std::move(recursiveInfo_);
    }
    const RecursiveInfo* getRecursiveInfo() const { return recursiveInfo.get(); }
    std::shared_ptr<Expression> getLengthExpression() const {
        DASSERT(recursiveInfo != nullptr);
        return recursiveInfo->bindData->lengthExpr;
    }

    bool isSelfLoop() const { return *srcNode == *dstNode; }

    std::string detailsToString() const;

    // if multiple tables match the pattern
    // returns the intersection of available extend directions for all matched tables
    std::vector<common::ExtendDirection> getExtendDirections() const;

    std::vector<common::table_id_t> getInnerRelTableIDs() const;

private:
    // Start node if a directed arrow is given. Left node otherwise.
    std::shared_ptr<NodeExpression> srcNode;
    // End node if a directed arrow is given. Right node otherwise.
    std::shared_ptr<NodeExpression> dstNode;
    std::shared_ptr<NodeExpression> leftNode;
    std::shared_ptr<NodeExpression> rightNode;
    // Whether relationship is directed.
    RelDirectionType directionType;
    // Direction expr is nullptr when direction type is SINGLE
    std::shared_ptr<Expression> directionExpr;
    // Whether relationship type is recursive.
    common::QueryRelType relType;
    // Null if relationship type is non-recursive.
    std::unique_ptr<RecursiveInfo> recursiveInfo;
};

} // namespace binder
} // namespace lbug