linkrs-query 0.1.0

Query engine, parser, and executor for Linkrs
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

use super::*;

pub(super) fn convert_argument(
    n: crate::planning::plan::logical::logical_nodes::control_flow::LogicalArgumentNode,
) -> PlanNodeEnum {
    let mut node =
        crate::planning::plan::core::nodes::control_flow::control_flow_node::ArgumentNode::new(
            next_node_id(),
            &n.var,
        );
    if let Some(var) = n.output_var {
        node.set_output_var(var);
    }
    node.set_col_names(n.col_names);
    node.set_column_types(n.column_types);
    PlanNodeEnum::Argument(node)
}

pub(super) fn convert_loop(
    n: crate::planning::plan::logical::logical_nodes::control_flow::LogicalLoopNode,
) -> PlanNodeEnum {
    let body = n.body().cloned().map(convert_logical_to_physical);
    let mut node =
        crate::planning::plan::core::nodes::control_flow::control_flow_node::LoopNode::new(
            next_node_id(),
            n.condition().clone(),
        );
    if let Some(b) = body {
        node.set_body(b);
    }
    if let Some(var) = n.output_var() {
        node.set_output_var(var.to_string());
    }
    node.set_col_names(n.col_names().to_vec());
    PlanNodeEnum::Loop(node)
}

pub(super) fn convert_pass_through(
    n: crate::planning::plan::logical::logical_nodes::control_flow::LogicalPassThroughNode,
) -> PlanNodeEnum {
    let mut node =
        crate::planning::plan::core::nodes::control_flow::control_flow_node::PassThroughNode::new(
            next_node_id(),
        );
    if let Some(var) = n.output_var {
        node.set_output_var(var);
    }
    node.set_col_names(n.col_names);
    node.set_column_types(n.column_types);
    PlanNodeEnum::PassThrough(node)
}

pub(super) fn convert_select(
    n: crate::planning::plan::logical::logical_nodes::control_flow::LogicalSelectNode,
) -> PlanNodeEnum {
    let mut node =
        crate::planning::plan::core::nodes::control_flow::control_flow_node::SelectNode::new(
            next_node_id(),
            n.condition().clone(),
        );
    if let Some(if_branch) = n.if_branch().cloned() {
        node.set_if_branch(convert_logical_to_physical(if_branch));
    }
    if let Some(else_branch) = n.else_branch().cloned() {
        node.set_else_branch(convert_logical_to_physical(else_branch));
    }
    if let Some(var) = n.output_var() {
        node.set_output_var(var.to_string());
    }
    node.set_col_names(n.col_names().to_vec());
    PlanNodeEnum::Select(node)
}

pub(super) fn convert_begin_transaction(
    n: crate::planning::plan::logical::logical_nodes::control_flow::LogicalBeginTransactionNode,
) -> PlanNodeEnum {
    let mut node = crate::planning::plan::core::nodes::control_flow::control_flow_node::BeginTransactionNode::new(next_node_id());
    if let Some(var) = n.output_var {
        node.set_output_var(var);
    }
    node.set_col_names(n.col_names);
    PlanNodeEnum::BeginTransaction(node)
}

pub(super) fn convert_commit(
    n: crate::planning::plan::logical::logical_nodes::control_flow::LogicalCommitNode,
) -> PlanNodeEnum {
    let mut node =
        crate::planning::plan::core::nodes::control_flow::control_flow_node::CommitNode::new(
            next_node_id(),
        );
    if let Some(var) = n.output_var {
        node.set_output_var(var);
    }
    node.set_col_names(n.col_names);
    PlanNodeEnum::Commit(node)
}

pub(super) fn convert_rollback(
    n: crate::planning::plan::logical::logical_nodes::control_flow::LogicalRollbackNode,
) -> PlanNodeEnum {
    let mut node =
        crate::planning::plan::core::nodes::control_flow::control_flow_node::RollbackNode::new(
            next_node_id(),
        );
    if let Some(var) = n.output_var {
        node.set_output_var(var);
    }
    node.set_col_names(n.col_names);
    PlanNodeEnum::Rollback(node)
}