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
112
113
114
115
116
117
118
119

use super::*;

pub(super) fn convert_multi_shortest_path(
    n: crate::planning::plan::logical::logical_nodes::algorithm::LogicalMultiShortestPathNode,
) -> PlanNodeEnum {
    let left = convert_logical_to_physical(*n.left);
    let right = convert_logical_to_physical(*n.right);
    let mut node =
        crate::planning::plan::core::nodes::traversal::path_algorithms::MultiShortestPathNode::new(
            left, right, n.steps,
        );
    node.set_left_vid_var(&n.left_vid_var);
    node.set_right_vid_var(&n.right_vid_var);
    node.set_edge_types(n.edge_types);
    node.set_direction(n.direction);
    node.set_target_vertex_ids(n.target_vertex_ids);
    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::MultiShortestPath(node)
}

pub(super) fn convert_b_f_s_shortest(
    n: crate::planning::plan::logical::logical_nodes::algorithm::LogicalBFSShortestNode,
) -> PlanNodeEnum {
    let left = convert_logical_to_physical(*n.left);
    let right = convert_logical_to_physical(*n.right);
    let mut node =
        crate::planning::plan::core::nodes::traversal::path_algorithms::BFSShortestNode::new(
            left,
            right,
            n.space_id,
            n.steps,
            n.edge_types,
            n.with_walk,
        );
    if n.with_loop {
        node.set_loop(true);
    }
    if n.reverse {
        node.set_reverse(true);
    }
    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::BFSShortest(node)
}

pub(super) fn convert_all_paths(
    n: crate::planning::plan::logical::logical_nodes::algorithm::LogicalAllPathsNode,
) -> PlanNodeEnum {
    let left = convert_logical_to_physical(*n.left);
    let right = convert_logical_to_physical(*n.right);
    let mut node =
        crate::planning::plan::core::nodes::traversal::path_algorithms::AllPathsNode::new(
            left,
            right,
            n.space_id,
            n.steps,
            n.edge_types,
            n.min_hop,
            n.max_hop,
            n.path_uniqueness,
        );
    node.set_start_vertex_ids(n.start_vertex_ids);
    node.set_end_vertex_ids(n.end_vertex_ids);
    node.set_direction(n.direction);
    if n.limit != 0 {
        node.set_limit(n.limit);
    }
    if n.offset != 0 {
        node.set_offset(n.offset);
    }
    if let Some(filter) = n.filter {
        node.set_filter(filter);
    }
    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::AllPaths(node)
}

pub(super) fn convert_shortest_path(
    n: crate::planning::plan::logical::logical_nodes::algorithm::LogicalShortestPathNode,
) -> PlanNodeEnum {
    let left = convert_logical_to_physical(*n.left);
    let right = convert_logical_to_physical(*n.right);
    let mut node =
        crate::planning::plan::core::nodes::traversal::path_algorithms::ShortestPathNode::new(
            left,
            right,
            n.space_id,
            n.edge_types,
            n.max_step,
        );
    node.set_start_vertex_ids(n.start_vertex_ids);
    node.set_end_vertex_ids(n.end_vertex_ids);
    if let Some(expr) = n.weight_expression {
        node.set_weight_expression(expr);
    }
    if let Some(expr) = n.heuristic_expression {
        node.set_heuristic_expression(expr);
    }
    if n.no_reverse {
        node.set_no_reverse(true);
    }
    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::ShortestPath(node)
}