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