lora-compiler 0.4.0

Query-plan compiler for LoraDB's Cypher implementation.
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use lora_analyzer::symbols::VarId;
use lora_analyzer::{
    ResolvedExpr, ResolvedMergeAction, ResolvedPattern, ResolvedPatternPart, ResolvedProjection,
    ResolvedRemoveItem, ResolvedSetItem, ResolvedSortItem,
};
use lora_ast::{Direction, RangeLiteral};

pub type PhysicalNodeId = usize;

#[derive(Debug, Clone)]
pub struct PhysicalPlan {
    pub root: PhysicalNodeId,
    pub nodes: Vec<PhysicalOp>,
}

#[derive(Debug, Clone)]
pub enum PhysicalOp {
    Argument(ArgumentExec),
    NodeScan(NodeScanExec),
    NodeByLabelScan(NodeByLabelScanExec),
    Expand(ExpandExec),
    Filter(FilterExec),
    Projection(ProjectionExec),
    Unwind(UnwindExec),
    HashAggregation(HashAggregationExec),
    Sort(SortExec),
    Limit(LimitExec),
    Create(CreateExec),
    Merge(MergeExec),
    Delete(DeleteExec),
    Set(SetExec),
    Remove(RemoveExec),
    OptionalMatch(OptionalMatchExec),
    PathBuild(PathBuildExec),
}

#[derive(Debug, Clone)]
pub struct PathBuildExec {
    pub input: PhysicalNodeId,
    pub output: VarId,
    pub node_vars: Vec<VarId>,
    pub rel_vars: Vec<VarId>,
    pub shortest_path_all: Option<bool>,
}

/// Left-outer-join: for each input row, runs inner sub-plan.
/// If inner produces nothing, emits one row with nulls for new_vars.
#[derive(Debug, Clone)]
pub struct OptionalMatchExec {
    pub input: PhysicalNodeId,
    pub inner: PhysicalNodeId,
    pub new_vars: Vec<VarId>,
}

#[derive(Debug, Clone)]
pub struct ArgumentExec;

#[derive(Debug, Clone)]
pub struct NodeScanExec {
    pub input: Option<PhysicalNodeId>,
    pub var: VarId,
}

#[derive(Debug, Clone)]
pub struct NodeByLabelScanExec {
    pub input: Option<PhysicalNodeId>,
    pub var: VarId,
    /// Each inner Vec is a disjunctive group (OR). Outer Vec is conjunctive (AND).
    pub labels: Vec<Vec<String>>,
}

#[derive(Debug, Clone)]
pub struct ExpandExec {
    pub input: PhysicalNodeId,
    pub src: VarId,
    pub rel: Option<VarId>,
    pub dst: VarId,
    pub types: Vec<String>,
    pub direction: Direction,
    pub rel_properties: Option<ResolvedExpr>,
    pub range: Option<RangeLiteral>,
}

#[derive(Debug, Clone)]
pub struct FilterExec {
    pub input: PhysicalNodeId,
    pub predicate: ResolvedExpr,
}

#[derive(Debug, Clone)]
pub struct ProjectionExec {
    pub input: PhysicalNodeId,
    pub distinct: bool,
    pub items: Vec<ResolvedProjection>,
    pub include_existing: bool,
}

#[derive(Debug, Clone)]
pub struct UnwindExec {
    pub input: PhysicalNodeId,
    pub expr: ResolvedExpr,
    pub alias: VarId,
}

#[derive(Debug, Clone)]
pub struct HashAggregationExec {
    pub input: PhysicalNodeId,
    pub group_by: Vec<ResolvedProjection>,
    pub aggregates: Vec<ResolvedProjection>,
}

#[derive(Debug, Clone)]
pub struct SortExec {
    pub input: PhysicalNodeId,
    pub items: Vec<ResolvedSortItem>,
}

#[derive(Debug, Clone)]
pub struct LimitExec {
    pub input: PhysicalNodeId,
    pub skip: Option<ResolvedExpr>,
    pub limit: Option<ResolvedExpr>,
}

#[derive(Debug, Clone)]
pub struct CreateExec {
    pub input: PhysicalNodeId,
    pub pattern: ResolvedPattern,
}

#[derive(Debug, Clone)]
pub struct MergeExec {
    pub input: PhysicalNodeId,
    pub pattern_part: ResolvedPatternPart,
    pub actions: Vec<ResolvedMergeAction>,
}

#[derive(Debug, Clone)]
pub struct DeleteExec {
    pub input: PhysicalNodeId,
    pub detach: bool,
    pub expressions: Vec<ResolvedExpr>,
}

#[derive(Debug, Clone)]
pub struct SetExec {
    pub input: PhysicalNodeId,
    pub items: Vec<ResolvedSetItem>,
}

#[derive(Debug, Clone)]
pub struct RemoveExec {
    pub input: PhysicalNodeId,
    pub items: Vec<ResolvedRemoveItem>,
}