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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

//! Names used for tables, columns, schemas, DBs, etc.
use std::fmt::Display;

use arraystring::{typenum::U63, ArrayString};

use sqlparser::ast::Ident;

/// A fixed capacity copy-able string.
pub type BoundedString = ArrayString<U63>;

/// A name given to a schema. Uniquely identifies a single schema in a database.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SchemaRef(pub BoundedString);

impl TryFrom<Vec<Ident>> for SchemaRef {
    type Error = IdentifierError;

    fn try_from(value: Vec<Ident>) -> Result<Self, Self::Error> {
        match value.as_slice() {
            [] => Err(IdentifierError {
                idents: value,
                reason: "Empty schema name",
            }),
            [schema_name] => Ok(SchemaRef(schema_name.value.as_str().into())),
            _ => Err(IdentifierError {
                idents: value,
                reason: "More than 1 part in schema name.",
            }),
        }
    }
}

/// Uniquely identifies a table in a database. The schema will be assumed to be the
/// [`default_schema`](`crate::Database::default_schema`) if not specified.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TableRef {
    pub schema_name: Option<BoundedString>,
    pub table_name: BoundedString,
}

impl TryFrom<Vec<Ident>> for TableRef {
    type Error = IdentifierError;

    fn try_from(value: Vec<Ident>) -> Result<Self, Self::Error> {
        match value.as_slice() {
            [] => Err(IdentifierError {
                idents: value,
                reason: "Empty table name",
            }),
            [table_name] => Ok(TableRef {
                schema_name: None,
                table_name: table_name.value.as_str().into(),
            }),
            [schema_name, table_name] => Ok(TableRef {
                schema_name: Some(schema_name.value.as_str().into()),
                table_name: table_name.value.as_str().into(),
            }),
            _ => Err(IdentifierError {
                idents: value,
                reason: "More than 2 parts in table name.",
            }),
        }
    }
}

impl Display for TableRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self {
                schema_name: None,
                table_name,
            } => write!(f, "{}", table_name),
            Self {
                schema_name: Some(schema_name),
                table_name,
            } => write!(f, "{}.{}", schema_name, table_name),
        }
    }
}

/// Uniquely identifies a column in a given table in a database.
///
/// The schema will be assumed to be the
/// [`default_schema`](`crate::Database::default_schema`) if not specified.
///
/// The table will be the one specified in the `WHERE` clause of the query if not specified
/// explicitly.
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ColumnRef {
    pub schema_name: Option<BoundedString>,
    pub table_name: Option<BoundedString>,
    pub col_name: BoundedString,
}

impl Display for ColumnRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self {
                schema_name: None,
                table_name: None,
                col_name,
            } => write!(f, "{}", col_name),
            Self {
                schema_name: None,
                table_name: Some(table_name),
                col_name,
            } => write!(f, "{}.{}", table_name, col_name),
            Self {
                schema_name: Some(schema_name),
                table_name: Some(table_name),
                col_name,
            } => write!(f, "{}.{}.{}", schema_name, table_name, col_name),
            // the below case does not occur
            Self {
                schema_name: Some(schema_name),
                table_name: None,
                col_name,
            } => write!(f, "{}.{}", schema_name, col_name),
        }
    }
}

impl TryFrom<Vec<Ident>> for ColumnRef {
    type Error = IdentifierError;

    fn try_from(value: Vec<Ident>) -> Result<Self, Self::Error> {
        match value.as_slice() {
            [] => Err(IdentifierError {
                idents: value,
                reason: "Empty column name",
            }),
            [col_name] => Ok(ColumnRef {
                schema_name: None,
                table_name: None,
                col_name: col_name.value.as_str().into(),
            }),
            [table_name, col_name] => Ok(ColumnRef {
                schema_name: None,
                table_name: Some(table_name.value.as_str().into()),
                col_name: col_name.value.as_str().into(),
            }),
            [schema_name, table_name, col_name] => Ok(ColumnRef {
                schema_name: Some(schema_name.value.as_str().into()),
                table_name: Some(table_name.value.as_str().into()),
                col_name: col_name.value.as_str().into(),
            }),
            _ => Err(IdentifierError {
                idents: value,
                reason: "More than 3 parts in column name.",
            }),
        }
    }
}

/// Invalid identifier.
#[derive(Debug, PartialEq)]
pub struct IdentifierError {
    idents: Vec<Ident>,
    reason: &'static str,
}

impl Display for IdentifierError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "IdentifierError: {} (Got: '{:?}')",
            self.reason, self.idents
        )
    }
}