MetonaSqlark/src/sql/tokens.ts

/**
 * metona-sqlark SQL Token Types — 词法单元定义
 * @module sql/tokens
 */

// ---------------------------------------------------------------------------
//  Token 类型枚举
// ---------------------------------------------------------------------------

export enum TokenType {
  // 关键字
  SELECT = 'SELECT',
  FROM = 'FROM',
  WHERE = 'WHERE',
  INSERT = 'INSERT',
  INTO = 'INTO',
  VALUES = 'VALUES',
  UPDATE = 'UPDATE',
  SET = 'SET',
  DELETE = 'DELETE',
  CREATE = 'CREATE',
  TABLE = 'TABLE',
  DROP = 'DROP',
  ORDER = 'ORDER',
  BY = 'BY',
  ASC = 'ASC',
  DESC = 'DESC',
  LIMIT = 'LIMIT',
  OFFSET = 'OFFSET',
  AND = 'AND',
  OR = 'OR',
  NOT = 'NOT',
  LIKE = 'LIKE',
  IN = 'IN',
  PRIMARY = 'PRIMARY',
  KEY = 'KEY',
  UNIQUE = 'UNIQUE',
  DEFAULT = 'DEFAULT',
  NULL = 'NULL',
  TRUE = 'TRUE',
  REFERENCES = 'REFERENCES',
  CASCADE = 'CASCADE',
  BETWEEN = 'BETWEEN',
  IF = 'IF',
  EXISTS = 'EXISTS',
  FALSE = 'FALSE',
  ALTER = 'ALTER',
  ADD = 'ADD',
  TRUNCATE = 'TRUNCATE',

  // JOIN 相关
  INNER = 'INNER',
  LEFT = 'LEFT',
  RIGHT = 'RIGHT',
  CROSS = 'CROSS',
  JOIN = 'JOIN',
  ON = 'ON',
  AS = 'AS',
  OUTER = 'OUTER',

  // 聚合
  GROUP = 'GROUP',
  HAVING = 'HAVING',
  COUNT = 'COUNT',
  SUM = 'SUM',
  AVG = 'AVG',
  MIN = 'MIN',
  MAX = 'MAX',
  DISTINCT = 'DISTINCT',

  // v0.3.0: 事务 / UNION / EXISTS / 动态索引
  BEGIN = 'BEGIN',
  COMMIT = 'COMMIT',
  ROLLBACK = 'ROLLBACK',
  UNION = 'UNION',
  ALL = 'ALL',
  INDEX = 'INDEX',

  // v0.3.1: CASE WHEN 表达式
  CASE = 'CASE',
  WHEN = 'WHEN',
  THEN = 'THEN',
  ELSE = 'ELSE',
  END = 'END',

  // 标识符 & 字面量
  IDENTIFIER = 'IDENTIFIER',
  STRING = 'STRING',
  NUMBER = 'NUMBER',

  // 运算符 & 分隔符
  COMMA = 'COMMA',
  LPAREN = 'LPAREN',
  RPAREN = 'RPAREN',
  SEMICOLON = 'SEMICOLON',
  EQ = 'EQ',
  NEQ = 'NEQ',
  GT = 'GT',
  GTE = 'GTE',
  LT = 'LT',
  LTE = 'LTE',
  STAR = 'STAR',
  DOT = 'DOT',

  // 特殊
  EOF = 'EOF',
  ILLEGAL = 'ILLEGAL',
}

// ---------------------------------------------------------------------------
//  Token
// ---------------------------------------------------------------------------

export interface Token {
  type: TokenType;
  value: string;
  position: number; // 在源码中的位置
}

// ---------------------------------------------------------------------------
//  关键字映射
// ---------------------------------------------------------------------------

export const KEYWORDS: Record<string, TokenType> = {
  'SELECT': TokenType.SELECT,
  'FROM': TokenType.FROM,
  'WHERE': TokenType.WHERE,
  'INSERT': TokenType.INSERT,
  'INTO': TokenType.INTO,
  'VALUES': TokenType.VALUES,
  'UPDATE': TokenType.UPDATE,
  'SET': TokenType.SET,
  'DELETE': TokenType.DELETE,
  'CREATE': TokenType.CREATE,
  'TABLE': TokenType.TABLE,
  'DROP': TokenType.DROP,
  'ORDER': TokenType.ORDER,
  'BY': TokenType.BY,
  'ASC': TokenType.ASC,
  'DESC': TokenType.DESC,
  'LIMIT': TokenType.LIMIT,
  'OFFSET': TokenType.OFFSET,
  'AND': TokenType.AND,
  'OR': TokenType.OR,
  'NOT': TokenType.NOT,
  'LIKE': TokenType.LIKE,
  'IN': TokenType.IN,
  'PRIMARY': TokenType.PRIMARY,
  'KEY': TokenType.KEY,
  'UNIQUE': TokenType.UNIQUE,
  'DEFAULT': TokenType.DEFAULT,
  'NULL': TokenType.NULL,
  'TRUE': TokenType.TRUE,
  'FALSE': TokenType.FALSE,
  'REFERENCES': TokenType.REFERENCES,
  'CASCADE': TokenType.CASCADE,
  'BETWEEN': TokenType.BETWEEN,
  'IF': TokenType.IF,
  'EXISTS': TokenType.EXISTS,
  'ALTER': TokenType.ALTER,
  'ADD': TokenType.ADD,
  'TRUNCATE': TokenType.TRUNCATE,

  // JOIN
  'INNER': TokenType.INNER,
  'LEFT': TokenType.LEFT,
  'RIGHT': TokenType.RIGHT,
  'CROSS': TokenType.CROSS,
  'JOIN': TokenType.JOIN,
  'ON': TokenType.ON,
  'AS': TokenType.AS,
  'OUTER': TokenType.OUTER,

  // 聚合
  'GROUP': TokenType.GROUP,
  'HAVING': TokenType.HAVING,
  'COUNT': TokenType.COUNT,
  'SUM': TokenType.SUM,
  'AVG': TokenType.AVG,
  'MIN': TokenType.MIN,
  'MAX': TokenType.MAX,
  'DISTINCT': TokenType.DISTINCT,

  // v0.3.0
  'BEGIN': TokenType.BEGIN,
  'COMMIT': TokenType.COMMIT,
  'ROLLBACK': TokenType.ROLLBACK,
  'UNION': TokenType.UNION,
  'ALL': TokenType.ALL,
  'INDEX': TokenType.INDEX,

  // v0.3.1
  'CASE': TokenType.CASE,
  'WHEN': TokenType.WHEN,
  'THEN': TokenType.THEN,
  'ELSE': TokenType.ELSE,
  'END': TokenType.END,
};