iridium_core 0.1.0

SQL Server-compatible Rust engine core for Iridium SQL
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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct ObjectName {
    pub schema: Option<String>,
    pub name: String,
}

impl ObjectName {
    pub fn schema_or_dbo(&self) -> &str {
        self.schema.as_deref().unwrap_or("dbo")
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum DataType {
    Int,
    BigInt,
    SmallInt,
    TinyInt,
    Bit,
    Float,
    Real,
    Decimal(u8, u8),
    Numeric(u8, u8),
    Money,
    SmallMoney,
    Char(Option<u32>),
    NChar(Option<u32>),
    VarChar(Option<u32>),
    NVarChar(Option<u32>),
    Binary(Option<u32>),
    VarBinary(Option<u32>),
    Date,
    Time,
    DateTime,
    DateTime2,
    DateTimeOffset,
    SmallDateTime,
    UniqueIdentifier,
    Xml,
    Image,
    Text,
    NText,
    SqlVariant,
    Table,
    Custom(String),
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum TableFactor {
    Named(ObjectName),
    Derived(Box<crate::parser::ast::statements::query::SelectStmt>),
    JoinedGroup {
        base: Box<TableRef>,
        joins: Vec<crate::parser::ast::statements::query::JoinClause>,
    },
    Values {
        rows: Vec<Vec<crate::parser::ast::expressions::Expr>>,
        columns: Vec<String>,
    },
    TableValuedFunction {
        name: Vec<String>,
        args: Vec<crate::parser::ast::expressions::Expr>,
        alias: Option<String>,
    },
}

impl TableFactor {
    pub fn as_object_name(&self) -> Option<&ObjectName> {
        match self {
            TableFactor::Named(name) => Some(name),
            TableFactor::Derived(_)
            | TableFactor::JoinedGroup { .. }
            | TableFactor::Values { .. }
            | TableFactor::TableValuedFunction { .. } => None,
        }
    }

    pub fn is_derived(&self) -> bool {
        matches!(self, TableFactor::Derived(_))
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct TableRef {
    pub factor: TableFactor,
    pub alias: Option<String>,
    pub pivot: Option<Box<PivotSpec>>,
    pub unpivot: Option<Box<UnpivotSpec>>,
    pub hints: Vec<String>,
}

impl TableRef {
    pub fn name_as_object(&self) -> Option<&ObjectName> {
        self.factor.as_object_name()
    }

    pub fn object(name: ObjectName) -> Self {
        Self {
            factor: TableFactor::Named(name),
            alias: None,
            pivot: None,
            unpivot: None,
            hints: Vec::new(),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct PivotSpec {
    pub aggregate_func: String,
    pub aggregate_col: String,
    pub pivot_col: String,
    pub pivot_values: Vec<String>,
    #[serde(default)]
    pub alias: Option<String>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct UnpivotSpec {
    pub value_col: String,
    pub pivot_col: String,
    pub column_list: Vec<String>,
    #[serde(default)]
    pub alias: Option<String>,
    #[serde(default)]
    pub source_alias: Option<String>,
}