@yanit/jsondb 0.1.1

package/src/SQLParser.ts

@@ -0,0 +1,814 @@
+/**
+ * SQL 解析器模块
+ * 支持标准 SQL 语法子集，转换为 JSONDB 查询操作
+ */
+
+/**
+ * SQL 语句类型
+ */
+export type SQLStatementType = 'SELECT' | 'INSERT' | 'UPDATE' | 'DELETE';
+
+/**
+ * SQL 解析后的 SELECT 语句结构
+ */
+export interface SelectStatement {
+  type: 'SELECT';
+  columns: string[];
+  table: string;
+  where?: WhereClause;
+  orderBy?: OrderByClause[];
+  limit?: number;
+  offset?: number;
+  groupBy?: string[];
+  having?: WhereClause;
+  distinct?: boolean;
+}
+
+/**
+ * SQL 解析后的 INSERT 语句结构
+ */
+export interface InsertStatement {
+  type: 'INSERT';
+  table: string;
+  columns: string[];
+  values: unknown[][];
+}
+
+/**
+ * SQL 解析后的 UPDATE 语句结构
+ */
+export interface UpdateStatement {
+  type: 'UPDATE';
+  table: string;
+  set: { column: string; value: unknown }[];
+  where?: WhereClause;
+}
+
+/**
+ * SQL 解析后的 DELETE 语句结构
+ */
+export interface DeleteStatement {
+  type: 'DELETE';
+  table: string;
+  where?: WhereClause;
+}
+
+/**
+ * WHERE 子句结构
+ */
+export type WhereClause = 
+  | { type: 'condition'; column: string; operator: string; value: unknown }
+  | { type: 'and'; conditions: WhereClause[] }
+  | { type: 'or'; conditions: WhereClause[] }
+  | { type: 'not'; condition: WhereClause };
+
+/**
+ * ORDER BY 子句结构
+ */
+export interface OrderByClause {
+  column: string;
+  direction: 'ASC' | 'DESC';
+}
+
+/**
+ * SQL 语句联合类型
+ */
+export type SQLStatement = SelectStatement | InsertStatement | UpdateStatement | DeleteStatement;
+
+/**
+ * SQL 解析结果
+ */
+export interface SQLParseResult {
+  success: boolean;
+  statement?: SQLStatement;
+  error?: string;
+}
+
+/**
+ * SQL 解析器类
+ */
+export class SQLParser {
+  private sql: string = '';
+  private pos: number = 0;
+  private currentChar: string = '';
+
+  /**
+   * 解析 SQL 语句
+   */
+  parse(sql: string): SQLParseResult {
+    try {
+      this.sql = sql.trim();
+      this.pos = 0;
+      this.currentChar = this.sql[0] || '';
+
+      // 跳过空白字符
+      this.skipWhitespace();
+
+      // 获取第一个词判断语句类型
+      const firstWord = this.readWord().toUpperCase();
+
+      this.skipWhitespace();
+
+      switch (firstWord) {
+        case 'SELECT':
+          return { success: true, statement: this.parseSelect() };
+        case 'INSERT':
+          return { success: true, statement: this.parseInsert() };
+        case 'UPDATE':
+          return { success: true, statement: this.parseUpdate() };
+        case 'DELETE':
+          return { success: true, statement: this.parseDelete() };
+        default:
+          return { success: false, error: `不支持的 SQL 语句类型：${firstWord}` };
+      }
+    } catch (error) {
+      return { 
+        success: false, 
+        error: `SQL 解析错误：${(error as Error).message}` 
+      };
+    }
+  }
+
+  /**
+   * 解析 SELECT 语句
+   */
+  private parseSelect(): SelectStatement {
+    const statement: SelectStatement = {
+      type: 'SELECT',
+      columns: [],
+      table: '',
+      distinct: false
+    };
+
+    // 检查 DISTINCT
+    if (this.peekWord().toUpperCase() === 'DISTINCT') {
+      this.readWord();
+      statement.distinct = true;
+    }
+
+    // 解析列
+    statement.columns = this.parseColumnList();
+
+    // 解析 FROM
+    this.skipWhitespace();
+    const fromWord = this.readWord().toUpperCase();
+    if (fromWord !== 'FROM') {
+      throw new Error(`期望 FROM 关键字，得到：${fromWord}`);
+    }
+
+    // 解析表名
+    this.skipWhitespace();
+    statement.table = this.readIdentifier();
+
+    // 解析可选子句
+    while (this.pos < this.sql.length) {
+      this.skipWhitespace();
+      if (this.pos >= this.sql.length) break;
+
+      const keyword = this.peekWord().toUpperCase();
+
+      switch (keyword) {
+        case 'WHERE':
+          this.readWord();
+          this.skipWhitespace();
+          statement.where = this.parseWhereClause();
+          break;
+        case 'GROUP':
+          this.readWord();
+          this.skipWhitespace();
+          const byWord = this.readWord().toUpperCase();
+          if (byWord !== 'BY') {
+            throw new Error('期望 GROUP BY');
+          }
+          this.skipWhitespace();
+          statement.groupBy = this.parseColumnList();
+          break;
+        case 'HAVING':
+          this.readWord();
+          this.skipWhitespace();
+          statement.having = this.parseWhereClause();
+          break;
+        case 'ORDER':
+          this.readWord();
+          this.skipWhitespace();
+          const orderByWord = this.readWord().toUpperCase();
+          if (orderByWord !== 'BY') {
+            throw new Error('期望 ORDER BY');
+          }
+          this.skipWhitespace();
+          statement.orderBy = this.parseOrderByList();
+          break;
+        case 'LIMIT':
+          this.readWord();
+          this.skipWhitespace();
+          statement.limit = this.readNumber();
+          break;
+        case 'OFFSET':
+          this.readWord();
+          this.skipWhitespace();
+          statement.offset = this.readNumber();
+          break;
+        default:
+          // 未知关键字，跳过
+          this.readWord();
+      }
+    }
+
+    return statement;
+  }
+
+  /**
+   * 解析 INSERT 语句
+   */
+  private parseInsert(): InsertStatement {
+    const statement: InsertStatement = {
+      type: 'INSERT',
+      table: '',
+      columns: [],
+      values: []
+    };
+
+    // 解析 INTO (可选)
+    const intoWord = this.peekWord().toUpperCase();
+    if (intoWord === 'INTO') {
+      this.readWord();
+      this.skipWhitespace();
+    }
+
+    // 解析表名
+    statement.table = this.readIdentifier();
+
+    // 解析列名
+    this.skipWhitespace();
+    if (this.currentChar === '(') {
+      this.readChar();
+      this.skipWhitespace();
+      statement.columns = this.parseColumnList();
+      this.skipWhitespace();
+      // 读取闭合括号
+      // @ts-ignore - 类型推断问题
+      if (this.sql[this.pos] === ')') {
+        this.readChar();
+      } else {
+        throw new Error('期望闭合括号 )');
+      }
+    }
+
+    // 解析 VALUES
+    this.skipWhitespace();
+    const valuesWord = this.readWord().toUpperCase();
+    if (valuesWord !== 'VALUES') {
+      throw new Error(`期望 VALUES 关键字，得到：${valuesWord}`);
+    }
+
+    // 解析值列表
+    this.skipWhitespace();
+    statement.values = this.parseValuesList();
+
+    return statement;
+  }
+
+  /**
+   * 解析 UPDATE 语句
+   */
+  private parseUpdate(): UpdateStatement {
+    const statement: UpdateStatement = {
+      type: 'UPDATE',
+      table: '',
+      set: []
+    };
+
+    // 解析表名
+    statement.table = this.readIdentifier();
+
+    // 解析 SET
+    this.skipWhitespace();
+    const setWord = this.readWord().toUpperCase();
+    if (setWord !== 'SET') {
+      throw new Error(`期望 SET 关键字，得到：${setWord}`);
+    }
+
+    // 解析 SET 子句
+    this.skipWhitespace();
+    statement.set = this.parseSetClause();
+
+    // 解析可选 WHERE
+    this.skipWhitespace();
+    if (this.peekWord().toUpperCase() === 'WHERE') {
+      this.readWord();
+      this.skipWhitespace();
+      statement.where = this.parseWhereClause();
+    }
+
+    return statement;
+  }
+
+  /**
+   * 解析 DELETE 语句
+   */
+  private parseDelete(): DeleteStatement {
+    const statement: DeleteStatement = {
+      type: 'DELETE',
+      table: ''
+    };
+
+    // 解析 FROM
+    const fromWord = this.peekWord().toUpperCase();
+    if (fromWord === 'FROM') {
+      this.readWord();
+      this.skipWhitespace();
+    }
+
+    // 解析表名
+    statement.table = this.readIdentifier();
+
+    // 解析可选 WHERE
+    this.skipWhitespace();
+    if (this.peekWord().toUpperCase() === 'WHERE') {
+      this.readWord();
+      this.skipWhitespace();
+      statement.where = this.parseWhereClause();
+    }
+
+    return statement;
+  }
+
+  /**
+   * 解析列名列表
+   */
+  private parseColumnList(): string[] {
+    const columns: string[] = [];
+
+    // 处理 * 情况
+    if (this.currentChar === '*') {
+      this.readChar();
+      return ['*'];
+    }
+
+    columns.push(this.readIdentifier());
+
+    while (true) {
+      this.skipWhitespace();
+      if (this.currentChar === ',') {
+        this.readChar();
+        this.skipWhitespace();
+        columns.push(this.readIdentifier());
+      } else {
+        break;
+      }
+    }
+
+    return columns;
+  }
+
+  /**
+   * 解析 WHERE 子句
+   */
+  private parseWhereClause(): WhereClause {
+    const conditions = this.parseCondition();
+    return conditions;
+  }
+
+  /**
+   * 解析条件（支持 AND/OR）
+   */
+  private parseCondition(): WhereClause {
+    const left = this.parseSimpleCondition();
+
+    this.skipWhitespace();
+    const keyword = this.peekWord().toUpperCase();
+
+    if (keyword === 'AND') {
+      this.readWord();
+      this.skipWhitespace();
+      const right = this.parseCondition();
+      return {
+        type: 'and',
+        conditions: [left, right]
+      };
+    } else if (keyword === 'OR') {
+      this.readWord();
+      this.skipWhitespace();
+      const right = this.parseCondition();
+      return {
+        type: 'or',
+        conditions: [left, right]
+      };
+    }
+
+    return left;
+  }
+
+  /**
+   * 解析简单条件
+   */
+  private parseSimpleCondition(): WhereClause {
+    // 处理括号
+    this.skipWhitespace();
+    if (this.currentChar === '(') {
+      this.readChar();
+      const condition = this.parseCondition();
+      this.skipWhitespace();
+      // @ts-ignore - 类型推断问题
+      if (this.sql[this.pos] === ')') {
+        this.readChar();
+      }
+      return condition;
+    }
+
+    // 处理 NOT
+    if (this.peekWord().toUpperCase() === 'NOT') {
+      this.readWord();
+      this.skipWhitespace();
+      const condition = this.parseSimpleCondition();
+      return { type: 'not', condition };
+    }
+
+    const column = this.readIdentifier();
+    this.skipWhitespace();
+
+    // 解析操作符
+    let operator = this.readOperator();
+    this.skipWhitespace();
+
+    // 解析值
+    const value = this.readValue();
+
+    return {
+      type: 'condition',
+      column,
+      operator,
+      value
+    };
+  }
+
+  /**
+   * 解析操作符
+   */
+  private readOperator(): string {
+    this.skipWhitespace();
+    let op = '';
+
+    // 双字符操作符
+    if (this.currentChar === '=' && this.peekChar(1) !== '=') {
+      this.readChar();
+      return '=';
+    }
+    if (this.currentChar === '<' && this.peekChar(1) === '=') {
+      this.readChar();
+      this.readChar();
+      return '<=';
+    }
+    if (this.currentChar === '>' && this.peekChar(1) === '=') {
+      this.readChar();
+      this.readChar();
+      return '>=';
+    }
+    if (this.currentChar === '!' && this.peekChar(1) === '=') {
+      this.readChar();
+      this.readChar();
+      return '!=';
+    }
+    if (this.currentChar === '<' && this.peekChar(1) === '>') {
+      this.readChar();
+      this.readChar();
+      return '<>';
+    }
+
+    // 单字符操作符
+    if (['=', '<', '>', '!'].includes(this.currentChar)) {
+      op = this.currentChar;
+      this.readChar();
+      return op;
+    }
+
+    // 单词操作符 (LIKE, IN, IS, BETWEEN)
+    // 先检查是否是字母开头，避免遇到引号
+    if (/[a-zA-Z]/.test(this.currentChar)) {
+      const word = this.readWord().toUpperCase();
+      if (['LIKE', 'IN', 'IS', 'BETWEEN'].includes(word)) {
+        return word;
+      }
+      // 如果不是已知操作符，可能是值的一部分，回退
+      throw new Error(`未知操作符：${word}`);
+    }
+
+    throw new Error(`未知操作符：${this.currentChar}`);
+  }
+
+  /**
+   * 解析值
+   */
+  private readValue(): unknown {
+    this.skipWhitespace();
+
+    // NULL
+    if (this.peekWord().toUpperCase() === 'NULL') {
+      this.readWord();
+      return null;
+    }
+
+    // TRUE
+    if (this.peekWord().toUpperCase() === 'TRUE') {
+      this.readWord();
+      return true;
+    }
+
+    // FALSE
+    if (this.peekWord().toUpperCase() === 'FALSE') {
+      this.readWord();
+      return false;
+    }
+
+    // 数组 (value1, value2, ...)
+    if (this.currentChar === '(') {
+      this.readChar();
+      this.skipWhitespace();
+      const values: unknown[] = [];
+      
+      // @ts-ignore - 类型推断问题
+      while (this.sql[this.pos] !== ')') {
+        values.push(this.readValue());
+        this.skipWhitespace();
+        // @ts-ignore - 类型推断问题
+        if (this.sql[this.pos] === ',') {
+          this.readChar();
+          this.skipWhitespace();
+        }
+      }
+      
+      // @ts-ignore - 类型推断问题
+      if (this.sql[this.pos] === ')') {
+        this.readChar();
+      }
+      
+      return values;
+    }
+
+    // 字符串
+    if (this.currentChar === "'" || this.currentChar === '"') {
+      return this.readString();
+    }
+
+    // 数字
+    if (this.isDigit(this.currentChar) || (this.currentChar === '-' && this.isDigit(this.peekChar(1)))) {
+      return this.readNumber();
+    }
+
+    // 标识符
+    return this.readIdentifier();
+  }
+
+  /**
+   * 解析 SET 子句
+   */
+  private parseSetClause(): { column: string; value: unknown }[] {
+    const set: { column: string; value: unknown }[] = [];
+
+    set.push({
+      column: this.readIdentifier(),
+      value: this.parseSetValue()
+    });
+
+    while (true) {
+      this.skipWhitespace();
+      if (this.currentChar === ',') {
+        this.readChar();
+        this.skipWhitespace();
+        set.push({
+          column: this.readIdentifier(),
+          value: this.parseSetValue()
+        });
+      } else {
+        break;
+      }
+    }
+
+    return set;
+  }
+
+  /**
+   * 解析 SET 值
+   */
+  private parseSetValue(): unknown {
+    this.skipWhitespace();
+    if (this.currentChar === '=') {
+      this.readChar();
+    }
+    this.skipWhitespace();
+    return this.readValue();
+  }
+
+  /**
+   * 解析值列表
+   */
+  private parseValuesList(): unknown[][] {
+    const values: unknown[][] = [];
+
+    values.push(this.parseValueRow());
+
+    while (true) {
+      this.skipWhitespace();
+      if (this.currentChar === ',') {
+        this.readChar();
+        this.skipWhitespace();
+        values.push(this.parseValueRow());
+      } else {
+        break;
+      }
+    }
+
+    return values;
+  }
+
+  /**
+   * 解析单行值
+   */
+  private parseValueRow(): unknown[] {
+    const row: unknown[] = [];
+
+    this.skipWhitespace();
+    if (this.currentChar === '(') {
+      this.readChar();
+      this.skipWhitespace();
+      row.push(this.readValue());
+
+      while (true) {
+        this.skipWhitespace();
+        // @ts-ignore - 类型推断问题
+        if (this.sql[this.pos] === ',') {
+          this.readChar();
+          this.skipWhitespace();
+          row.push(this.readValue());
+        } else {
+          break;
+        }
+      }
+
+      this.skipWhitespace();
+      // @ts-ignore - 类型推断问题
+      if (this.sql[this.pos] === ')') {
+        this.readChar();
+      } else {
+        throw new Error('期望闭合括号 )');
+      }
+    }
+
+    return row;
+  }
+
+  /**
+   * 解析 ORDER BY 列表
+   */
+  private parseOrderByList(): OrderByClause[] {
+    const orderBy: OrderByClause[] = [];
+
+    orderBy.push(this.parseOrderByItem());
+
+    while (true) {
+      this.skipWhitespace();
+      if (this.currentChar === ',') {
+        this.readChar();
+        this.skipWhitespace();
+        orderBy.push(this.parseOrderByItem());
+      } else {
+        break;
+      }
+    }
+
+    return orderBy;
+  }
+
+  /**
+   * 解析单个 ORDER BY
+   */
+  private parseOrderByItem(): OrderByClause {
+    const column = this.readIdentifier();
+    this.skipWhitespace();
+
+    let direction: 'ASC' | 'DESC' = 'ASC';
+    const dirWord = this.peekWord().toUpperCase();
+    if (dirWord === 'ASC' || dirWord === 'DESC') {
+      this.readWord();
+      direction = dirWord as 'ASC' | 'DESC';
+    }
+
+    return { column, direction };
+  }
+
+  // ========== 词法分析辅助方法 ==========
+
+  private skipWhitespace(): void {
+    while (this.isWhitespace(this.currentChar)) {
+      this.pos++;
+      this.currentChar = this.sql[this.pos] || '';
+    }
+  }
+
+  private readChar(): string {
+    const char = this.currentChar;
+    this.pos++;
+    this.currentChar = this.sql[this.pos] || '';
+    return char;
+  }
+
+  private peekChar(offset: number = 0): string {
+    return this.sql[this.pos + offset] || '';
+  }
+
+  private readWord(): string {
+    let word = '';
+    while (this.isWordChar(this.currentChar)) {
+      word += this.readChar();
+    }
+    return word;
+  }
+
+  private peekWord(): string {
+    const savedPos = this.pos;
+    const word = this.readWord();
+    this.pos = savedPos;
+    this.currentChar = this.sql[this.pos] || '';
+    return word;
+  }
+
+  private readIdentifier(): string {
+    this.skipWhitespace();
+    
+    // 处理引号标识符
+    if (this.currentChar === '`' || this.currentChar === '"') {
+      const quote = this.readChar();
+      let identifier = '';
+      while (this.currentChar !== quote && this.pos < this.sql.length) {
+        identifier += this.readChar();
+      }
+      if (this.currentChar === quote) {
+        this.readChar();
+      }
+      return identifier;
+    }
+
+    return this.readWord();
+  }
+
+  private readString(): string {
+    const quote = this.readChar();
+    let str = '';
+    while (this.currentChar !== quote && this.pos < this.sql.length) {
+      if (this.currentChar === '\\' && this.peekChar(1) === quote) {
+        this.readChar();
+        str += this.readChar();
+      } else {
+        str += this.readChar();
+      }
+    }
+    if (this.currentChar === quote) {
+      this.readChar();
+    }
+    return str;
+  }
+
+  private readNumber(): number {
+    let numStr = '';
+    
+    // 处理负数
+    if (this.currentChar === '-') {
+      numStr += this.readChar();
+    }
+
+    // 整数部分
+    while (this.isDigit(this.currentChar)) {
+      numStr += this.readChar();
+    }
+
+    // 小数部分
+    if (this.currentChar === '.' && this.isDigit(this.peekChar(1))) {
+      numStr += this.readChar();
+      while (this.isDigit(this.currentChar)) {
+        numStr += this.readChar();
+      }
+    }
+
+    return parseFloat(numStr);
+  }
+
+  private isWhitespace(char: string): boolean {
+    return char === ' ' || char === '\t' || char === '\n' || char === '\r';
+  }
+
+  private isWordChar(char: string): boolean {
+    return /[a-zA-Z0-9_]/.test(char);
+  }
+
+  private isDigit(char: string): boolean {
+    return /[0-9]/.test(char);
+  }
+}
+
+/**
+ * 解析 SQL 语句
+ */
+export function parseSQL(sql: string): SQLParseResult {
+  const parser = new SQLParser();
+  return parser.parse(sql);
+}