iridium-db 0.2.0

A high-performance vector-graph hybrid storage and indexing engine
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

mod parse;
mod render;
mod validate;

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Ast {
    pub match_aliases: Vec<String>,
    pub match_alias: String,
    pub where_clause: Option<WhereClause>,
    pub where_predicate: Option<VectorPredicate>,
    pub where_bitmap_predicate: Option<BitmapPredicate>,
    pub with_items: Vec<ProjectionItem>,
    pub return_items: Vec<ProjectionItem>,
    pub return_alias: String,
    pub limit: Option<u64>,
}

impl Ast {
    pub fn to_json_pretty(&self) -> String {
        render::ast_to_json_pretty(self)
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ProjectionItem {
    Identifier(String),
    Function {
        name: String,
        argument: String,
        alias: Option<String>,
    },
}

impl ProjectionItem {
    fn output_name(&self) -> Option<String> {
        match self {
            Self::Identifier(value) => Some(value.clone()),
            Self::Function { alias, .. } => alias.clone(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum WhereClause {
    Function {
        function: String,
        args: Vec<String>,
        operator: String,
        threshold: String,
    },
    Comparison {
        left: String,
        operator: String,
        right: String,
    },
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct VectorPredicate {
    pub function: String,
    pub target: String,
    pub param: String,
    pub operator: String,
    pub threshold: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct BitmapPredicate {
    pub function: String,
    pub index_name: String,
    pub value_key: String,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum QueryError {
    InvalidSyntax(String),
    InvalidSemantic(String),
}

pub type Result<T> = std::result::Result<T, QueryError>;

#[derive(Debug, Clone, PartialEq, Eq, Default)]
pub struct Catalog;

#[derive(Debug, Clone, PartialEq)]
pub struct ScalarComparison {
    pub field: String,
    pub operator: String,
    pub value: f64,
}

#[derive(Debug, Clone, PartialEq)]
pub struct TypedAst {
    pub ast: Ast,
    pub scalar_predicate: Option<ScalarComparison>,
}

pub fn parse(query: &str) -> Result<Ast> {
    parse::parse(query)
}

pub fn validate(ast: &Ast, catalog: &Catalog) -> Result<TypedAst> {
    validate::validate(ast, catalog)
}

#[cfg(test)]
mod tests;