alopex-sql 0.6.0

SQL parser components for the Alopex DB dialect
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

use std::fmt;

/// Parser errors for the Alopex SQL dialect.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ParserError {
    /// ALOPEX-P001: An unexpected token was encountered.
    UnexpectedToken {
        line: u64,
        column: u64,
        expected: String,
        found: String,
    },

    /// ALOPEX-P002: A required token was missing.
    ExpectedToken {
        line: u64,
        column: u64,
        expected: String,
        found: String,
    },

    /// ALOPEX-P003: String literal was not closed.
    UnterminatedString { line: u64, column: u64 },

    /// ALOPEX-P004: Number literal is malformed.
    InvalidNumber {
        line: u64,
        column: u64,
        value: String,
    },

    /// ALOPEX-P005: Vector literal is malformed.
    InvalidVector { line: u64, column: u64 },

    /// ALOPEX-P006: Parser exceeded maximum recursion depth.
    RecursionLimitExceeded { depth: usize },
}

impl fmt::Display for ParserError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::UnexpectedToken {
                line,
                column,
                expected,
                found,
            } => write!(
                f,
                "error[ALOPEX-P001]: unexpected token at line {line}, column {column}: expected {expected}, found {found}"
            ),
            Self::ExpectedToken {
                line,
                column,
                expected,
                found,
            } => write!(
                f,
                "error[ALOPEX-P002]: expected {expected} but found {found} at line {line}, column {column}"
            ),
            Self::UnterminatedString { line, column } => write!(
                f,
                "error[ALOPEX-P003]: unterminated string literal starting at line {line}, column {column}"
            ),
            Self::InvalidNumber {
                line,
                column,
                value,
            } => write!(
                f,
                "error[ALOPEX-P004]: invalid number literal '{value}' at line {line}, column {column}"
            ),
            Self::InvalidVector { line, column } => write!(
                f,
                "error[ALOPEX-P005]: invalid vector literal at line {line}, column {column}"
            ),
            Self::RecursionLimitExceeded { depth } => write!(
                f,
                "error[ALOPEX-P006]: recursion limit exceeded (depth: {depth})"
            ),
        }
    }
}

impl std::error::Error for ParserError {}

/// Convenience result type for parser operations.
pub type Result<T> = std::result::Result<T, ParserError>;