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

use linkrs_core::types::EdgeDirection;
use linkrs_core::DBResult;

use crate::binder::bound::*;

use super::Binder;

impl Binder {
    pub(crate) fn bind_go(
        &mut self,
        stmt: &crate::parser::ast::GoStmt,
    ) -> DBResult<BoundStatement> {
        let from = stmt
            .from
            .vertices
            .iter()
            .map(|v| self.bind_expr(v))
            .collect::<DBResult<Vec<_>>>()?;

        let where_clause = stmt
            .where_clause
            .as_ref()
            .map(|c| {
                self.bind_expr(c)
                    .map(|be| BoundWhereClause { condition: be })
            })
            .transpose()?;

        let yield_clause = stmt
            .yield_clause
            .as_ref()
            .map(|yc| self.bind_yield_clause(yc))
            .transpose()?;

        if let Some(ref o) = stmt.over {
            self.resolve_edge_types(&o.edge_types)?;
        }

        let over = stmt.over.as_ref().map(|o| o.edge_types.clone());

        Ok(BoundStatement::Go(BoundGoStatement {
            steps: stmt.steps.clone(),
            from,
            over,
            direction: stmt
                .over
                .as_ref()
                .map(|o| o.direction)
                .unwrap_or(EdgeDirection::Out),
            where_clause,
            yield_clause,
        }))
    }
}