citadeldb-sql 0.4.0

SQL parser, planner, and executor for Citadel encrypted database
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

use thiserror::Error;

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

#[derive(Debug, Error)]
pub enum SqlError {
    #[error("parse error: {0}")]
    Parse(String),

    #[error("table '{0}' not found")]
    TableNotFound(String),

    #[error("table '{0}' already exists")]
    TableAlreadyExists(String),

    #[error("column '{0}' not found")]
    ColumnNotFound(String),

    #[error("duplicate primary key")]
    DuplicateKey,

    #[error("NOT NULL constraint failed: {0}")]
    NotNullViolation(String),

    #[error("type mismatch: expected {expected}, got {got}")]
    TypeMismatch { expected: String, got: String },

    #[error("primary key required")]
    PrimaryKeyRequired,

    #[error("duplicate column: {0}")]
    DuplicateColumn(String),

    #[error("row too large: encoded size {size} exceeds limit {max}")]
    RowTooLarge { size: usize, max: usize },

    #[error("key too large: encoded size {size} exceeds limit {max}")]
    KeyTooLarge { size: usize, max: usize },

    #[error("unsupported: {0}")]
    Unsupported(String),

    #[error("invalid value: {0}")]
    InvalidValue(String),

    #[error("division by zero")]
    DivisionByZero,

    #[error("integer overflow")]
    IntegerOverflow,

    #[error("column '{0}' is ambiguous")]
    AmbiguousColumn(String),

    #[error("index '{0}' not found")]
    IndexNotFound(String),

    #[error("index '{0}' already exists")]
    IndexAlreadyExists(String),

    #[error("unique constraint violated on index '{0}'")]
    UniqueViolation(String),

    #[error("CHECK constraint failed: {0}")]
    CheckViolation(String),

    #[error("FOREIGN KEY constraint violated: {0}")]
    ForeignKeyViolation(String),

    #[error("transaction already active")]
    TransactionAlreadyActive,

    #[error("no active transaction")]
    NoActiveTransaction,

    #[error("subquery must return exactly one column")]
    SubqueryMultipleColumns,

    #[error("scalar subquery returned more than one row")]
    SubqueryMultipleRows,

    #[error("parameter count mismatch: expected {expected}, got {got}")]
    ParameterCountMismatch { expected: usize, got: usize },

    #[error("compound column count mismatch: left has {left}, right has {right}")]
    CompoundColumnCountMismatch { left: usize, right: usize },

    #[error("CTE '{name}' column alias count mismatch: expected {expected}, got {got}")]
    CteColumnAliasMismatch {
        name: String,
        expected: usize,
        got: usize,
    },

    #[error("duplicate CTE name: '{0}'")]
    DuplicateCteName(String),

    #[error("recursive CTE '{0}' requires UNION or UNION ALL")]
    RecursiveCteNoUnion(String),

    #[error("recursive CTE '{0}' exceeded maximum iterations ({1})")]
    RecursiveCteMaxIterations(String, usize),

    #[error("storage error: {0}")]
    Storage(#[from] citadel_core::Error),
}