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