velesdb-core 1.6.0

High-performance vector database engine written in Rust
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

//! DML statement parsing (INSERT, UPDATE).

use super::{extract_identifier, Rule};
use crate::velesql::ast::{
    DmlStatement, InsertStatement, Query, UpdateAssignment, UpdateStatement,
};
use crate::velesql::error::ParseError;
use crate::velesql::Parser;

impl Parser {
    pub(crate) fn parse_insert_stmt(
        pair: pest::iterators::Pair<Rule>,
    ) -> Result<Query, ParseError> {
        let mut table = None;
        let mut columns = Vec::new();
        let mut values = Vec::new();

        for inner in pair.into_inner() {
            match inner.as_rule() {
                Rule::identifier => {
                    if table.is_none() {
                        table = Some(extract_identifier(&inner));
                    } else {
                        columns.push(extract_identifier(&inner));
                    }
                }
                Rule::value => values.push(Self::parse_value(inner)?),
                _ => {}
            }
        }

        let table =
            table.ok_or_else(|| ParseError::syntax(0, "", "INSERT requires target table"))?;
        if columns.is_empty() {
            return Err(ParseError::syntax(
                0,
                "",
                "INSERT requires at least one target column",
            ));
        }
        if columns.len() != values.len() {
            return Err(ParseError::syntax(
                0,
                "",
                "INSERT columns/value count mismatch",
            ));
        }

        Ok(Query::new_dml(DmlStatement::Insert(InsertStatement {
            table,
            columns,
            values,
        })))
    }

    pub(crate) fn parse_update_stmt(
        pair: pest::iterators::Pair<Rule>,
    ) -> Result<Query, ParseError> {
        let mut table = None;
        let mut assignments = Vec::new();
        let mut where_clause = None;

        for inner in pair.into_inner() {
            match inner.as_rule() {
                Rule::identifier => {
                    if table.is_none() {
                        table = Some(extract_identifier(&inner));
                    }
                }
                Rule::assignment => {
                    let mut assignment_inner = inner.into_inner();
                    let column = assignment_inner
                        .next()
                        .map(|p| extract_identifier(&p))
                        .ok_or_else(|| {
                            ParseError::syntax(0, "", "UPDATE assignment missing column")
                        })?;
                    let value_pair = assignment_inner.next().ok_or_else(|| {
                        ParseError::syntax(0, "", "UPDATE assignment missing value")
                    })?;
                    let value = Self::parse_value(value_pair)?;
                    assignments.push(UpdateAssignment { column, value });
                }
                Rule::where_clause => where_clause = Some(Self::parse_where_clause(inner)?),
                _ => {}
            }
        }

        let table =
            table.ok_or_else(|| ParseError::syntax(0, "", "UPDATE requires target table"))?;
        if assignments.is_empty() {
            return Err(ParseError::syntax(
                0,
                "",
                "UPDATE requires at least one assignment",
            ));
        }

        Ok(Query::new_dml(DmlStatement::Update(UpdateStatement {
            table,
            assignments,
            where_clause,
        })))
    }
}