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

use crate::parser::ast::FetchTarget;
use linkrs_core::DBResult;

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

use super::Binder;

impl Binder {
    pub(crate) fn bind_fetch(
        &mut self,
        stmt: &crate::parser::ast::FetchStmt,
    ) -> DBResult<BoundStatement> {
        match &stmt.target {
            FetchTarget::Vertices {
                tag_name,
                ids,
                properties,
            } => {
                if let Some(tag_name) = tag_name {
                    self.resolve_tags(std::slice::from_ref(tag_name))?;
                }
                let bound_ids = ids
                    .iter()
                    .map(|id| self.bind_expr(id))
                    .collect::<DBResult<Vec<_>>>()?;
                Ok(BoundStatement::FetchVertices(BoundFetchVerticesStatement {
                    tag_name: tag_name.clone(),
                    ids: bound_ids,
                    properties: properties.clone(),
                }))
            }
            FetchTarget::Edges {
                src,
                dst,
                edge_type,
                rank,
                properties,
            } => {
                let bound_src = self.bind_expr(src)?;
                let bound_dst = self.bind_expr(dst)?;
                let bound_rank = rank.as_ref().map(|r| self.bind_expr(r)).transpose()?;
                Ok(BoundStatement::FetchEdges(BoundFetchEdgesStatement {
                    src: bound_src,
                    dst: bound_dst,
                    edge_type: edge_type.clone(),
                    rank: bound_rank,
                    properties: properties.clone(),
                }))
            }
        }
    }
}