selene-db-gql 1.3.0

ISO/IEC 39075:2024 GQL parser, planner, optimizer, and executor for selene-db.
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

//! Binding helpers for singleton graph element variable references.

use crate::{
    GqlType, ValueExpr,
    analyze::{
        error::AnalysisError,
        types::{AnalyzedType, ExprId},
    },
};

use super::{BindContext, expr::bind_value_expr};

pub(crate) fn bind_singleton_element_variable_references(
    ctx: &mut BindContext<'_>,
    targets: &[ValueExpr],
    context: &'static str,
) -> Result<(), AnalysisError> {
    for target in targets {
        bind_singleton_element_variable_reference(
            ctx,
            target,
            ElementReferenceRequirement::NodeOrEdgePlural,
            context,
        )?;
    }
    Ok(())
}

pub(crate) fn bind_singleton_element_variable_reference(
    ctx: &mut BindContext<'_>,
    target: &ValueExpr,
    requirement: ElementReferenceRequirement,
    context: &'static str,
) -> Result<(), AnalysisError> {
    let target_id = bind_value_expr(ctx, target)?;
    validate_singleton_element_variable_reference(ctx, target, target_id, requirement, context)
}

pub(crate) fn validate_singleton_element_variable_reference(
    ctx: &BindContext<'_>,
    target: &ValueExpr,
    target_id: ExprId,
    requirement: ElementReferenceRequirement,
    context: &'static str,
) -> Result<(), AnalysisError> {
    let ValueExpr::Variable { span, .. } = target else {
        return Err(invalid_element_reference(
            context,
            requirement,
            target.span(),
        ));
    };
    let target_type = ctx.expr_type(target_id);
    if requirement.matches(target_type) {
        Ok(())
    } else {
        Err(invalid_element_reference(context, requirement, *span))
    }
}

#[derive(Clone, Copy)]
pub(crate) enum ElementReferenceRequirement {
    Node,
    Edge,
    NodeOrEdge,
    NodeOrEdgePlural,
}

impl ElementReferenceRequirement {
    fn matches(self, ty: &AnalyzedType) -> bool {
        let node = matches!(ty, AnalyzedType::Resolved(GqlType::NodeRef));
        let edge = matches!(ty, AnalyzedType::Resolved(GqlType::EdgeRef));
        match self {
            Self::Node => node,
            Self::Edge => edge,
            Self::NodeOrEdge | Self::NodeOrEdgePlural => node || edge,
        }
    }

    fn description(self) -> &'static str {
        match self {
            Self::Node => "a singleton node variable reference",
            Self::Edge => "a singleton edge variable reference",
            Self::NodeOrEdge => "a singleton node or edge variable reference",
            Self::NodeOrEdgePlural => "singleton node or edge variable references",
        }
    }
}

fn invalid_element_reference(
    context: &'static str,
    requirement: ElementReferenceRequirement,
    span: crate::SourceSpan,
) -> AnalysisError {
    AnalysisError::InvalidReference {
        message: format!("{context} must be {}", requirement.description()),
        span,
    }
}