solidb 1.0.1

A lightweight, high-performance structured database server written in Rust.
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

//! Comparison and binary operator parsing for SDBQL.
//!
//! Handles operators:
//! - Equality: `==`, `!=`
//! - Relational: `<`, `<=`, `>`, `>=`
//! - Membership: `IN`, `NOT IN`
//! - Pattern matching: `LIKE`, `NOT LIKE`, `=~`, `!~`
//! - Fuzzy matching: `~=`

use crate::error::DbResult;
use crate::sdbql::ast::BinaryOperator;
use crate::sdbql::lexer::Token;
use crate::sdbql::parser::Parser;

impl Parser {
    /// Parse a comparison operator if present.
    /// Returns Some(operator) if found, None otherwise.
    pub(super) fn parse_comparison_operator(&mut self) -> DbResult<Option<BinaryOperator>> {
        match self.current_token() {
            Token::Equal => {
                self.advance();
                Ok(Some(BinaryOperator::Equal))
            }
            Token::NotEqual => {
                self.advance();
                Ok(Some(BinaryOperator::NotEqual))
            }
            Token::LessThan => {
                self.advance();
                Ok(Some(BinaryOperator::LessThan))
            }
            Token::LessThanEq => {
                self.advance();
                Ok(Some(BinaryOperator::LessThanOrEqual))
            }
            Token::Spaceship => {
                self.advance();
                Ok(Some(BinaryOperator::Spaceship))
            }
            Token::Tilde => {
                self.advance();
                Ok(Some(BinaryOperator::SemanticMatch))
            }
            Token::GreaterThan => {
                self.advance();
                Ok(Some(BinaryOperator::GreaterThan))
            }
            Token::GreaterThanEq => {
                self.advance();
                Ok(Some(BinaryOperator::GreaterThanOrEqual))
            }
            Token::In => {
                if self.allow_in_operator {
                    self.advance();
                    Ok(Some(BinaryOperator::In))
                } else {
                    Ok(None)
                }
            }
            Token::Like => {
                self.advance();
                Ok(Some(BinaryOperator::Like))
            }
            Token::RegEx => {
                self.advance();
                Ok(Some(BinaryOperator::RegEx))
            }
            Token::NotRegEx => {
                self.advance();
                Ok(Some(BinaryOperator::NotRegEx))
            }
            Token::FuzzyEqual => {
                self.advance();
                Ok(Some(BinaryOperator::FuzzyEqual))
            }
            Token::Not => self.parse_negated_operator(),
            _ => Ok(None),
        }
    }

    /// Parse negated operators: NOT LIKE, NOT REGEX, NOT IN
    fn parse_negated_operator(&mut self) -> DbResult<Option<BinaryOperator>> {
        match self.peek_token(1) {
            Token::Like => {
                self.advance(); // consume NOT
                self.advance(); // consume LIKE
                Ok(Some(BinaryOperator::NotLike))
            }
            Token::RegEx => {
                self.advance(); // consume NOT
                self.advance(); // consume REGEX
                Ok(Some(BinaryOperator::NotRegEx))
            }
            Token::In => {
                if self.allow_in_operator {
                    self.advance(); // consume NOT
                    self.advance(); // consume IN
                    Ok(Some(BinaryOperator::NotIn))
                } else {
                    Ok(None)
                }
            }
            _ => Ok(None),
        }
    }
}