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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! Type inference for explicit `TRIM` expressions.

use crate::{
    GqlType, SourceSpan,
    analyze::{
        error::{AnalysisError, ExpectedType, TypeMismatchContext},
        types::AnalyzedType,
    },
};

/// Infer an explicit TRIM expression.
pub(crate) fn trim(
    character: Option<(&AnalyzedType, SourceSpan)>,
    source: &AnalyzedType,
    source_span: SourceSpan,
) -> Result<AnalyzedType, AnalysisError> {
    let result = match source {
        AnalyzedType::Dynamic => {
            validate_trim_character(character, None)?;
            AnalyzedType::Dynamic
        }
        AnalyzedType::Resolved(GqlType::String | GqlType::CharacterString(_)) => {
            validate_trim_character(character, Some(GqlType::String))?;
            AnalyzedType::Resolved(GqlType::String)
        }
        AnalyzedType::Resolved(GqlType::Bytes | GqlType::ByteString(_)) => {
            validate_trim_character(character, Some(GqlType::Bytes))?;
            AnalyzedType::Resolved(GqlType::Bytes)
        }
        AnalyzedType::Resolved(GqlType::Null) => match trim_character_result(character)? {
            Some(GqlType::Bytes) => AnalyzedType::Resolved(GqlType::Bytes),
            Some(GqlType::String) | Some(GqlType::Null) | None => {
                AnalyzedType::Resolved(GqlType::String)
            }
            _ => AnalyzedType::Dynamic,
        },
        AnalyzedType::Resolved(actual) => {
            return Err(type_mismatch(
                TypeMismatchContext::TrimSource,
                ExpectedType::StringOrBytes,
                actual.clone(),
                source_span,
            ));
        }
    };
    Ok(result)
}

fn trim_character_result(
    character: Option<(&AnalyzedType, SourceSpan)>,
) -> Result<Option<GqlType>, AnalysisError> {
    let Some((character, span)) = character else {
        return Ok(None);
    };
    match character {
        AnalyzedType::Dynamic => Ok(None),
        AnalyzedType::Resolved(GqlType::String | GqlType::CharacterString(_)) => {
            Ok(Some(GqlType::String))
        }
        AnalyzedType::Resolved(GqlType::Null) => Ok(Some(GqlType::Null)),
        AnalyzedType::Resolved(GqlType::Bytes | GqlType::ByteString(_)) => Ok(Some(GqlType::Bytes)),
        AnalyzedType::Resolved(actual) => Err(type_mismatch(
            TypeMismatchContext::TrimCharacter,
            ExpectedType::StringOrBytes,
            actual.clone(),
            span,
        )),
    }
}

fn validate_trim_character(
    character: Option<(&AnalyzedType, SourceSpan)>,
    expected_family: Option<GqlType>,
) -> Result<(), AnalysisError> {
    let Some((actual, span)) = character else {
        return Ok(());
    };
    match (expected_family, actual) {
        (_, AnalyzedType::Dynamic)
        | (_, AnalyzedType::Resolved(GqlType::Null))
        | (
            Some(GqlType::String),
            AnalyzedType::Resolved(GqlType::String | GqlType::CharacterString(_)),
        )
        | (Some(GqlType::Bytes), AnalyzedType::Resolved(GqlType::Bytes | GqlType::ByteString(_))) => {
            Ok(())
        }
        (
            None,
            AnalyzedType::Resolved(
                GqlType::String
                | GqlType::CharacterString(_)
                | GqlType::Bytes
                | GqlType::ByteString(_),
            ),
        ) => Ok(()),
        (Some(expected), AnalyzedType::Resolved(actual)) => Err(type_mismatch(
            TypeMismatchContext::TrimCharacter,
            ExpectedType::Specific(expected),
            actual.clone(),
            span,
        )),
        (None, AnalyzedType::Resolved(actual)) => Err(type_mismatch(
            TypeMismatchContext::TrimCharacter,
            ExpectedType::StringOrBytes,
            actual.clone(),
            span,
        )),
    }
}

fn type_mismatch(
    context: TypeMismatchContext,
    expected: ExpectedType,
    found: GqlType,
    span: SourceSpan,
) -> AnalysisError {
    AnalysisError::TypeMismatch {
        context,
        expected,
        found,
        span,
    }
}