#[derive(Debug, Clone, Copy)]
pub enum Token {
ABORT,
ACTION,
ADD,
AFTER,
ALL,
ALTER,
ALWAYS,
ANALYZE,
AND,
ANY,
AS,
ASC,
ATTACH,
AUTOINCR,
BEFORE,
BEGIN,
BETWEEN,
BITAND,
BITNOT,
BITOR,
BLOB,
BY,
CASCADE,
CASE,
CAST,
CHECK,
COLLATE,
COLUMN,
COMMA,
COMMIT,
CONCAT,
CONCURRENTLY,
CONFLICT,
CONSTRAINT,
CREATE,
CTIME,
CURRENT,
DATA,
DATABASE,
DEFAULT,
DEFERRABLE,
DEFERRED,
DELETE,
DESC,
DETACH,
DISTINCT,
DO,
DOT,
DROP,
EACH,
ELSE,
END,
EOF,
EQ,
ESCAPE,
EXCEPT,
EXCLUDE,
EXCLUSIVE,
EXISTS,
EXPLAIN,
FAIL,
FILTER,
FIRST,
FLOAT,
FOLLOWING,
FOR,
FOREIGN,
FROM,
GE,
GENERATED,
GROUP,
GROUPS,
GT,
HAVING,
ID,
IF,
IGNORE,
ILLEGAL,
IMMEDIATE,
IN,
INDEX,
INDEXED,
INITIALLY,
INSERT,
INSTEAD,
INTEGER,
INTERSECT,
INTO,
IS,
ISNOT,
ISNULL,
JOIN,
KEY,
LAST,
LE,
LIKE,
LIMIT,
LOCKED,
LPAREN,
LSHIFT,
LT,
MATCH,
MATERIALIZED,
MINUS,
NE,
NO,
NOT,
NOTHING,
NOTNULL,
NOWAIT,
NULL,
NULLS,
OF,
OFFSET,
ON,
OR,
ORDER,
OTHERS,
OVER,
PARTITION,
PLAN,
PLUS,
PRAGMA,
PRECEDING,
PRIMARY,
PTR,
QUERY,
RAISE,
RANGE,
RECURSIVE,
REFRESH,
REFERENCES,
REINDEX,
RELEASE,
REM,
RENAME,
REPLACE,
RESTRICT,
RETURNING,
ROLLBACK,
ROW,
ROWS,
RPAREN,
RSHIFT,
SAVEPOINT,
SELECT,
SEMI,
SET,
SHARE,
SKIP,
SLASH,
STAR,
STRING,
TABLE,
TEMP,
THEN,
TIES,
TO,
TRANSACTION,
TRIGGER,
UNBOUNDED,
UNION,
UNIQUE,
UPDATE,
USING,
VACUUM,
VALUES,
VARIABLE,
VIEW,
VIRTUAL,
WHEN,
WHERE,
WINDOW,
WITH,
WITHOUT,
}
impl Token {
#[inline]
pub const fn is_operator(&self) -> bool {
matches!(
self,
Token::EQ
| Token::NE
| Token::LT
| Token::GT
| Token::LE
| Token::GE
| Token::PLUS
| Token::MINUS
| Token::STAR
| Token::SLASH
| Token::REM
| Token::CONCAT
| Token::BITAND
| Token::BITOR
| Token::LSHIFT
| Token::RSHIFT
)
}
#[inline]
pub const fn is_punctuation(&self) -> bool {
matches!(
self,
Token::LPAREN | Token::RPAREN | Token::COMMA | Token::SEMI | Token::DOT
)
}
pub const fn as_str(&self) -> &'static str {
match self {
Token::ABORT => "ABORT",
Token::ACTION => "ACTION",
Token::ADD => "ADD",
Token::AFTER => "AFTER",
Token::ALL => "ALL",
Token::ALTER => "ALTER",
Token::ALWAYS => "ALWAYS",
Token::ANALYZE => "ANALYZE",
Token::AND => "AND",
Token::ANY => "ANY",
Token::AS => "AS",
Token::ASC => "ASC",
Token::ATTACH => "ATTACH",
Token::AUTOINCR => "AUTOINCREMENT",
Token::BEFORE => "BEFORE",
Token::BEGIN => "BEGIN",
Token::BETWEEN => "BETWEEN",
Token::BITAND => "&",
Token::BITNOT => "~",
Token::BITOR => "|",
Token::BLOB => "BLOB",
Token::BY => "BY",
Token::CASCADE => "CASCADE",
Token::CASE => "CASE",
Token::CAST => "CAST",
Token::CHECK => "CHECK",
Token::COLLATE => "COLLATE",
Token::COLUMN => "COLUMN",
Token::COMMA => ",",
Token::COMMIT => "COMMIT",
Token::CONCAT => "||",
Token::CONCURRENTLY => "CONCURRENTLY",
Token::CONFLICT => "CONFLICT",
Token::CONSTRAINT => "CONSTRAINT",
Token::CREATE => "CREATE",
Token::CTIME => "CTIME",
Token::CURRENT => "CURRENT",
Token::DATA => "DATA",
Token::DATABASE => "DATABASE",
Token::DEFAULT => "DEFAULT",
Token::DEFERRABLE => "DEFERRABLE",
Token::DEFERRED => "DEFERRED",
Token::DELETE => "DELETE",
Token::DESC => "DESC",
Token::DETACH => "DETACH",
Token::DISTINCT => "DISTINCT",
Token::DO => "DO",
Token::DOT => ".",
Token::DROP => "DROP",
Token::EACH => "EACH",
Token::ELSE => "ELSE",
Token::END => "END",
Token::EOF => "EOF",
Token::EQ => "=",
Token::ESCAPE => "ESCAPE",
Token::EXCEPT => "EXCEPT",
Token::EXCLUDE => "EXCLUDE",
Token::EXCLUSIVE => "EXCLUSIVE",
Token::EXISTS => "EXISTS",
Token::EXPLAIN => "EXPLAIN",
Token::FAIL => "FAIL",
Token::FILTER => "FILTER",
Token::FIRST => "FIRST",
Token::FLOAT => "FLOAT",
Token::FOLLOWING => "FOLLOWING",
Token::FOR => "FOR",
Token::FOREIGN => "FOREIGN",
Token::FROM => "FROM",
Token::GE => ">=",
Token::GENERATED => "GENERATED",
Token::GROUP => "GROUP",
Token::GROUPS => "GROUPS",
Token::GT => ">",
Token::HAVING => "HAVING",
Token::ID => "ID",
Token::IF => "IF",
Token::IGNORE => "IGNORE",
Token::ILLEGAL => "ILLEGAL",
Token::IMMEDIATE => "IMMEDIATE",
Token::IN => "IN",
Token::INDEX => "INDEX",
Token::INDEXED => "INDEXED",
Token::INITIALLY => "INITIALLY",
Token::INSERT => "INSERT",
Token::INSTEAD => "INSTEAD",
Token::INTEGER => "INTEGER",
Token::INTERSECT => "INTERSECT",
Token::INTO => "INTO",
Token::IS => "IS",
Token::ISNOT => "IS NOT",
Token::ISNULL => "ISNULL",
Token::JOIN => "JOIN",
Token::KEY => "KEY",
Token::LAST => "LAST",
Token::LE => "<=",
Token::LIKE => "LIKE",
Token::LIMIT => "LIMIT",
Token::LOCKED => "LOCKED",
Token::LPAREN => "(",
Token::LSHIFT => "<<",
Token::LT => "<",
Token::MATCH => "MATCH",
Token::MATERIALIZED => "MATERIALIZED",
Token::MINUS => "-",
Token::NE => "<>",
Token::NO => "NO",
Token::NOT => "NOT",
Token::NOTHING => "NOTHING",
Token::NOTNULL => "NOTNULL",
Token::NOWAIT => "NOWAIT",
Token::NULL => "NULL",
Token::NULLS => "NULLS",
Token::OF => "OF",
Token::OFFSET => "OFFSET",
Token::ON => "ON",
Token::OR => "OR",
Token::ORDER => "ORDER",
Token::OTHERS => "OTHERS",
Token::OVER => "OVER",
Token::PARTITION => "PARTITION",
Token::PLAN => "PLAN",
Token::PLUS => "+",
Token::PRAGMA => "PRAGMA",
Token::PRECEDING => "PRECEDING",
Token::PRIMARY => "PRIMARY",
Token::PTR => "PTR",
Token::QUERY => "QUERY",
Token::RAISE => "RAISE",
Token::RANGE => "RANGE",
Token::RECURSIVE => "RECURSIVE",
Token::REFRESH => "REFRESH",
Token::REFERENCES => "REFERENCES",
Token::REINDEX => "REINDEX",
Token::RELEASE => "RELEASE",
Token::REM => "%",
Token::RENAME => "RENAME",
Token::REPLACE => "REPLACE",
Token::RESTRICT => "RESTRICT",
Token::RETURNING => "RETURNING",
Token::ROLLBACK => "ROLLBACK",
Token::ROW => "ROW",
Token::ROWS => "ROWS",
Token::RPAREN => ")",
Token::RSHIFT => ">>",
Token::SAVEPOINT => "SAVEPOINT",
Token::SELECT => "SELECT",
Token::SEMI => ";",
Token::SET => "SET",
Token::SHARE => "SHARE",
Token::SKIP => "SKIP",
Token::SLASH => "/",
Token::STAR => "*",
Token::STRING => "STRING",
Token::TABLE => "TABLE",
Token::TEMP => "TEMP",
Token::THEN => "THEN",
Token::TIES => "TIES",
Token::TO => "TO",
Token::TRANSACTION => "TRANSACTION",
Token::TRIGGER => "TRIGGER",
Token::UNBOUNDED => "UNBOUNDED",
Token::UNION => "UNION",
Token::UNIQUE => "UNIQUE",
Token::UPDATE => "UPDATE",
Token::USING => "USING",
Token::VACUUM => "VACUUM",
Token::VALUES => "VALUES",
Token::VARIABLE => "VARIABLE",
Token::VIEW => "VIEW",
Token::VIRTUAL => "VIRTUAL",
Token::WHEN => "WHEN",
Token::WHERE => "WHERE",
Token::WINDOW => "WINDOW",
Token::WITH => "WITH",
Token::WITHOUT => "WITHOUT",
}
}
}
impl core::fmt::Display for Token {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(f, "{}", self.as_str())
}
}