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

use crate::planning::plan::factorization::{FactorizationError, FactorizedSchema};

use super::bi_expand_schema;
use super::register_output_names;

use crate::planning::plan::logical::logical_nodes::traversal::{
    LogicalAppendVerticesNode, LogicalBiExpandNode, LogicalBiTraverseNode, LogicalExpandAllNode,
    LogicalExpandNode, LogicalTraverseNode,
};

pub(super) fn traverse(
    n: &LogicalTraverseNode,
    child_schemas: &[FactorizedSchema],
) -> Result<FactorizedSchema, FactorizationError> {
    let mut schema = child_schemas.first().cloned().unwrap_or_default();
    if schema.has_unflat_group() {
        if let Some(pos) = schema.unflat_group_pos() {
            schema.flatten_group(pos)?;
        }
    }
    let out = schema.create_group();
    if let Some(alias) = &n.vertex_alias {
        schema.insert_name_for_group(alias.clone(), out)?;
    }
    if let Some(alias) = &n.edge_alias {
        schema.insert_name_for_group(alias.clone(), out)?;
    }
    register_output_names(&mut schema, n.output_var.as_deref(), &n.col_names, out)?;
    schema.validate_at_most_one_unflat()?;
    Ok(schema)
}

pub(super) fn expand(
    n: &LogicalExpandNode,
    child_schemas: &[FactorizedSchema],
) -> Result<FactorizedSchema, FactorizationError> {
    let mut schema = child_schemas.first().cloned().unwrap_or_default();
    if schema.has_unflat_group() {
        if let Some(pos) = schema.unflat_group_pos() {
            schema.flatten_group(pos)?;
        }
    }
    let out = schema.create_group();
    register_output_names(&mut schema, n.output_var.as_deref(), &n.col_names, out)?;
    schema.validate_at_most_one_unflat()?;
    Ok(schema)
}

pub(super) fn expand_all(
    n: &LogicalExpandAllNode,
    child_schemas: &[FactorizedSchema],
) -> Result<FactorizedSchema, FactorizationError> {
    let mut schema = child_schemas.first().cloned().unwrap_or_default();
    if schema.has_unflat_group() {
        if let Some(pos) = schema.unflat_group_pos() {
            schema.flatten_group(pos)?;
        }
    }
    let out = schema.create_group();
    register_output_names(&mut schema, n.output_var.as_deref(), &n.col_names, out)?;
    schema.validate_at_most_one_unflat()?;
    Ok(schema)
}

pub(super) fn append_vertices(
    n: &LogicalAppendVerticesNode,
    child_schemas: &[FactorizedSchema],
) -> Result<FactorizedSchema, FactorizationError> {
    let mut schema = child_schemas.first().cloned().unwrap_or_default();
    if schema.has_unflat_group() {
        if let Some(pos) = schema.unflat_group_pos() {
            schema.flatten_group(pos)?;
        }
    }
    let out = schema.create_group();
    if let Some(alias) = &n.node_alias {
        schema.insert_name_for_group(alias.clone(), out)?;
    }
    register_output_names(&mut schema, n.output_var.as_deref(), &n.col_names, out)?;
    schema.validate_at_most_one_unflat()?;
    Ok(schema)
}

pub(super) fn bi_expand(
    n: &LogicalBiExpandNode,
    child_schemas: &[FactorizedSchema],
) -> Result<FactorizedSchema, FactorizationError> {
    let mut aliases = Vec::new();
    if let Some(var) = &n.meeting_point_var {
        aliases.push(var.clone());
    }
    if let Some(var) = n.output_var.as_deref() {
        aliases.push(var.to_string());
    }
    aliases.extend(n.col_names.iter().cloned());
    bi_expand_schema(child_schemas, &aliases)
}

pub(super) fn bi_traverse(
    n: &LogicalBiTraverseNode,
    child_schemas: &[FactorizedSchema],
) -> Result<FactorizedSchema, FactorizationError> {
    let mut aliases = vec![n.path_var.clone()];
    if let Some(alias) = &n.edge_alias {
        aliases.push(alias.clone());
    }
    if let Some(alias) = &n.vertex_alias {
        aliases.push(alias.clone());
    }
    if let Some(var) = n.output_var.as_deref() {
        aliases.push(var.to_string());
    }
    aliases.extend(n.col_names.iter().cloned());
    bi_expand_schema(child_schemas, &aliases)
}