drizzle_core/sql/
tokens.rs

1/// A SQL keyword, operator, or punctuation mark.
2///
3/// Each variant renders as fixed text (see [`Token::as_str`]). Most render
4/// as their own name; operators and punctuation render as symbols, for
5/// example `EQ` as `=`, `LPAREN` as `(`, and `CONCAT` as `||`.
6///
7/// # Examples
8///
9/// ```
10/// use drizzle_core::Token;
11///
12/// assert_eq!(Token::SELECT.as_str(), "SELECT");
13/// assert_eq!(Token::NE.as_str(), "<>");
14/// ```
15#[derive(Debug, Clone, Copy)]
16pub enum Token {
17    ABORT,
18    ACTION,
19    ADD,
20    AFTER,
21    ALL,
22    ALTER,
23    ALWAYS,
24    ANALYZE,
25    AND,
26    ANY,
27    AS,
28    ASC,
29    ATTACH,
30    AUTOINCR,
31    BEFORE,
32    BEGIN,
33    BETWEEN,
34    BITAND,
35    BITNOT,
36    BITOR,
37    BLOB,
38    BY,
39    CASCADE,
40    CASE,
41    CAST,
42    CHECK,
43    COLLATE,
44    COLUMN,
45    COMMA,
46    COMMIT,
47    CONCAT,
48    CONCURRENTLY,
49    CONFLICT,
50    CONSTRAINT,
51    CREATE,
52    CTIME,
53    CURRENT,
54    DATA,
55    DATABASE,
56    DEFAULT,
57    DEFERRABLE,
58    DEFERRED,
59    DELETE,
60    DESC,
61    DETACH,
62    DISTINCT,
63    DO,
64    DOT,
65    DROP,
66    DUPLICATE,
67    EACH,
68    ELSE,
69    END,
70    EOF,
71    EQ,
72    ESCAPE,
73    EXCEPT,
74    EXCLUDE,
75    EXCLUDED,
76    EXCLUSIVE,
77    EXISTS,
78    EXPLAIN,
79    FAIL,
80    FILTER,
81    FIRST,
82    FLOAT,
83    FOLLOWING,
84    FOR,
85    FOREIGN,
86    FROM,
87    GE,
88    GENERATED,
89    GROUP,
90    GROUPS,
91    GT,
92    HAVING,
93    ID,
94    IF,
95    IGNORE,
96    ILLEGAL,
97    IMMEDIATE,
98    IN,
99    INDEX,
100    INDEXED,
101    INITIALLY,
102    INSERT,
103    INSTEAD,
104    INTEGER,
105    INTERSECT,
106    INTO,
107    IS,
108    ISNOT,
109    ISNULL,
110    JOIN,
111    KEY,
112    LAST,
113    LE,
114    LIKE,
115    LIMIT,
116    LOCKED,
117    LPAREN,
118    LSHIFT,
119    LT,
120    MATCH,
121    MATERIALIZED,
122    MINUS,
123    NE,
124    NO,
125    NOT,
126    NOTHING,
127    NOTNULL,
128    NOWAIT,
129    NULL,
130    NULLS,
131    OF,
132    OFFSET,
133    ON,
134    OR,
135    ORDER,
136    OTHERS,
137    OVER,
138    PARTITION,
139    PLAN,
140    PLUS,
141    PRAGMA,
142    PRECEDING,
143    PRIMARY,
144    PTR,
145    QUERY,
146    RAISE,
147    RANGE,
148    RECURSIVE,
149    REFRESH,
150    REFERENCES,
151    REINDEX,
152    RELEASE,
153    REM,
154    RENAME,
155    REPLACE,
156    RESTRICT,
157    RETURNING,
158    ROLLBACK,
159    ROW,
160    ROWS,
161    RPAREN,
162    RSHIFT,
163    SAVEPOINT,
164    SELECT,
165    SEMI,
166    SET,
167    SHARE,
168    SKIP,
169    SLASH,
170    STAR,
171    STRING,
172    TABLE,
173    TEMP,
174    THEN,
175    TIES,
176    TO,
177    TRANSACTION,
178    TRIGGER,
179    UNBOUNDED,
180    UNION,
181    UNIQUE,
182    UPDATE,
183    USING,
184    VACUUM,
185    VALUES,
186    VARIABLE,
187    VIEW,
188    VIRTUAL,
189    WHEN,
190    WHERE,
191    WINDOW,
192    WITH,
193    WITHOUT,
194}
195
196impl Token {
197    /// Returns `true` for operators, which are rendered with a space on each
198    /// side (`=`, `+`, `||`, ...).
199    #[inline]
200    #[must_use]
201    pub const fn is_operator(&self) -> bool {
202        matches!(
203            self,
204            Self::EQ
205                | Self::NE
206                | Self::LT
207                | Self::GT
208                | Self::LE
209                | Self::GE
210                | Self::PLUS
211                | Self::MINUS
212                | Self::STAR
213                | Self::SLASH
214                | Self::REM
215                | Self::CONCAT
216                | Self::BITAND
217                | Self::BITOR
218                | Self::LSHIFT
219                | Self::RSHIFT
220        )
221    }
222
223    /// Returns `true` for punctuation (`(`, `)`, `,`, `;`, `.`), which is not
224    /// spaced like a word.
225    #[inline]
226    #[must_use]
227    pub const fn is_punctuation(&self) -> bool {
228        matches!(
229            self,
230            Self::LPAREN | Self::RPAREN | Self::COMMA | Self::SEMI | Self::DOT
231        )
232    }
233
234    /// Returns the SQL text of this token.
235    #[inline]
236    #[must_use]
237    pub const fn as_str(&self) -> &'static str {
238        match Self::as_str_a_to_f(*self) {
239            Some(s) => s,
240            None => match Self::as_str_g_to_p(*self) {
241                Some(s) => s,
242                None => Self::as_str_q_to_z(*self),
243            },
244        }
245    }
246
247    const fn as_str_a_to_f(self) -> Option<&'static str> {
248        Some(match self {
249            Self::ABORT => "ABORT",
250            Self::ACTION => "ACTION",
251            Self::ADD => "ADD",
252            Self::AFTER => "AFTER",
253            Self::ALL => "ALL",
254            Self::ALTER => "ALTER",
255            Self::ALWAYS => "ALWAYS",
256            Self::ANALYZE => "ANALYZE",
257            Self::AND => "AND",
258            Self::ANY => "ANY",
259            Self::AS => "AS",
260            Self::ASC => "ASC",
261            Self::ATTACH => "ATTACH",
262            Self::AUTOINCR => "AUTOINCREMENT",
263            Self::BEFORE => "BEFORE",
264            Self::BEGIN => "BEGIN",
265            Self::BETWEEN => "BETWEEN",
266            Self::BITAND => "&",
267            Self::BITNOT => "~",
268            Self::BITOR => "|",
269            Self::BLOB => "BLOB",
270            Self::BY => "BY",
271            Self::CASCADE => "CASCADE",
272            Self::CASE => "CASE",
273            Self::CAST => "CAST",
274            Self::CHECK => "CHECK",
275            Self::COLLATE => "COLLATE",
276            Self::COLUMN => "COLUMN",
277            Self::COMMA => ",",
278            Self::COMMIT => "COMMIT",
279            Self::CONCAT => "||",
280            Self::CONCURRENTLY => "CONCURRENTLY",
281            Self::CONFLICT => "CONFLICT",
282            Self::CONSTRAINT => "CONSTRAINT",
283            Self::CREATE => "CREATE",
284            Self::CTIME => "CTIME",
285            Self::CURRENT => "CURRENT",
286            Self::DATA => "DATA",
287            Self::DATABASE => "DATABASE",
288            Self::DEFAULT => "DEFAULT",
289            Self::DEFERRABLE => "DEFERRABLE",
290            Self::DEFERRED => "DEFERRED",
291            Self::DELETE => "DELETE",
292            Self::DESC => "DESC",
293            Self::DETACH => "DETACH",
294            Self::DISTINCT => "DISTINCT",
295            Self::DO => "DO",
296            Self::DOT => ".",
297            Self::DROP => "DROP",
298            Self::DUPLICATE => "DUPLICATE",
299            Self::EACH => "EACH",
300            Self::ELSE => "ELSE",
301            Self::END => "END",
302            Self::EOF => "EOF",
303            Self::EQ => "=",
304            Self::ESCAPE => "ESCAPE",
305            Self::EXCEPT => "EXCEPT",
306            Self::EXCLUDE => "EXCLUDE",
307            Self::EXCLUDED => "EXCLUDED",
308            Self::EXCLUSIVE => "EXCLUSIVE",
309            Self::EXISTS => "EXISTS",
310            Self::EXPLAIN => "EXPLAIN",
311            Self::FAIL => "FAIL",
312            Self::FILTER => "FILTER",
313            Self::FIRST => "FIRST",
314            Self::FLOAT => "FLOAT",
315            Self::FOLLOWING => "FOLLOWING",
316            Self::FOR => "FOR",
317            Self::FOREIGN => "FOREIGN",
318            Self::FROM => "FROM",
319            _ => return None,
320        })
321    }
322
323    const fn as_str_g_to_p(self) -> Option<&'static str> {
324        Some(match self {
325            Self::GE => ">=",
326            Self::GENERATED => "GENERATED",
327            Self::GROUP => "GROUP",
328            Self::GROUPS => "GROUPS",
329            Self::GT => ">",
330            Self::HAVING => "HAVING",
331            Self::ID => "ID",
332            Self::IF => "IF",
333            Self::IGNORE => "IGNORE",
334            Self::ILLEGAL => "ILLEGAL",
335            Self::IMMEDIATE => "IMMEDIATE",
336            Self::IN => "IN",
337            Self::INDEX => "INDEX",
338            Self::INDEXED => "INDEXED",
339            Self::INITIALLY => "INITIALLY",
340            Self::INSERT => "INSERT",
341            Self::INSTEAD => "INSTEAD",
342            Self::INTEGER => "INTEGER",
343            Self::INTERSECT => "INTERSECT",
344            Self::INTO => "INTO",
345            Self::IS => "IS",
346            Self::ISNOT => "IS NOT",
347            Self::ISNULL => "ISNULL",
348            Self::JOIN => "JOIN",
349            Self::KEY => "KEY",
350            Self::LAST => "LAST",
351            Self::LE => "<=",
352            Self::LIKE => "LIKE",
353            Self::LIMIT => "LIMIT",
354            Self::LOCKED => "LOCKED",
355            Self::LPAREN => "(",
356            Self::LSHIFT => "<<",
357            Self::LT => "<",
358            Self::MATCH => "MATCH",
359            Self::MATERIALIZED => "MATERIALIZED",
360            Self::MINUS => "-",
361            Self::NE => "<>",
362            Self::NO => "NO",
363            Self::NOT => "NOT",
364            Self::NOTHING => "NOTHING",
365            Self::NOTNULL => "NOTNULL",
366            Self::NOWAIT => "NOWAIT",
367            Self::NULL => "NULL",
368            Self::NULLS => "NULLS",
369            Self::OF => "OF",
370            Self::OFFSET => "OFFSET",
371            Self::ON => "ON",
372            Self::OR => "OR",
373            Self::ORDER => "ORDER",
374            Self::OTHERS => "OTHERS",
375            Self::OVER => "OVER",
376            Self::PARTITION => "PARTITION",
377            Self::PLAN => "PLAN",
378            Self::PLUS => "+",
379            Self::PRAGMA => "PRAGMA",
380            Self::PRECEDING => "PRECEDING",
381            Self::PRIMARY => "PRIMARY",
382            Self::PTR => "PTR",
383            _ => return None,
384        })
385    }
386
387    const fn as_str_q_to_z(self) -> &'static str {
388        match self {
389            Self::QUERY => "QUERY",
390            Self::RAISE => "RAISE",
391            Self::RANGE => "RANGE",
392            Self::RECURSIVE => "RECURSIVE",
393            Self::REFRESH => "REFRESH",
394            Self::REFERENCES => "REFERENCES",
395            Self::REINDEX => "REINDEX",
396            Self::RELEASE => "RELEASE",
397            Self::REM => "%",
398            Self::RENAME => "RENAME",
399            Self::REPLACE => "REPLACE",
400            Self::RESTRICT => "RESTRICT",
401            Self::RETURNING => "RETURNING",
402            Self::ROLLBACK => "ROLLBACK",
403            Self::ROW => "ROW",
404            Self::ROWS => "ROWS",
405            Self::RPAREN => ")",
406            Self::RSHIFT => ">>",
407            Self::SAVEPOINT => "SAVEPOINT",
408            Self::SELECT => "SELECT",
409            Self::SEMI => ";",
410            Self::SET => "SET",
411            Self::SHARE => "SHARE",
412            Self::SKIP => "SKIP",
413            Self::SLASH => "/",
414            Self::STAR => "*",
415            Self::STRING => "STRING",
416            Self::TABLE => "TABLE",
417            Self::TEMP => "TEMP",
418            Self::THEN => "THEN",
419            Self::TIES => "TIES",
420            Self::TO => "TO",
421            Self::TRANSACTION => "TRANSACTION",
422            Self::TRIGGER => "TRIGGER",
423            Self::UNBOUNDED => "UNBOUNDED",
424            Self::UNION => "UNION",
425            Self::UNIQUE => "UNIQUE",
426            Self::UPDATE => "UPDATE",
427            Self::USING => "USING",
428            Self::VACUUM => "VACUUM",
429            Self::VALUES => "VALUES",
430            Self::VARIABLE => "VARIABLE",
431            Self::VIEW => "VIEW",
432            Self::VIRTUAL => "VIRTUAL",
433            Self::WHEN => "WHEN",
434            Self::WHERE => "WHERE",
435            Self::WINDOW => "WINDOW",
436            Self::WITH => "WITH",
437            Self::WITHOUT => "WITHOUT",
438            // All earlier ranges are covered by as_str_a_to_f / as_str_g_to_p.
439            _ => unreachable!(),
440        }
441    }
442}
443
444impl core::fmt::Display for Token {
445    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
446        write!(f, "{}", self.as_str())
447    }
448}
drizzle_core/sql/tokens.rs

drizzle_core/sql/
tokens.rs
