JS类SQL语句解析引擎

// parsing-engine.js
/**
 * ParsingEngine 解析引擎
 */
import { isValue, isNumber, isString, isObject, formatValue } from './utils';
const LEFT_BRACKET = '(';
const RIGHT_BRACKET = ')';
const END_SYMBOLS = [LEFT_BRACKET, RIGHT_BRACKET, ' '];

class ParsingEngine {
  constructor({relations, operations, identifiers}) {
    this.relations = relations || ['AND', 'OR'];
    this.operations = operations || [];
    this.tokens = [];
    this.identifiers = identifiers;
  }

  /**
  * 词法分析
  * @param {String} str
  */
  lex(str) {
    this.lexCheck(str);

    let tokens = [], token = '';
    for (let i = 0; i < str.length; i++) {
      const char = str.charAt(i);
      if (!END_SYMBOLS.includes(char)) {
        token += char;
      } else {
        token && (tokens.push(token), token = '');
        tokens.push(char);
      }
    }
    tokens = tokens.filter(v => v !== ' ');
    this.tokens = tokens;
  }

  /**
   * 词法校验
   * @param {String} str
   */
  lexCheck(str) {
    const leftBracketLength = str.split(LEFT_BRACKET).length - 1;
    const rightBracketLength = str.split(RIGHT_BRACKET).length - 1;
    const differenceValue = leftBracketLength - rightBracketLength;
    if (differenceValue !== 0) {
      throw new Error(`语法错误: 缺少 "${differenceValue > 0 ? RIGHT_BRACKET : LEFT_BRACKET}"`);
    }

    const doubleQuoteLength = str.split('"').length - 1;
    if (doubleQuoteLength % 2) {
      throw new Error('语法错误: 缺少 \'"\'');
    }

    const singleQuoteLength =  str.split('\'').length - 1;
    if (singleQuoteLength % 2) {
      throw new Error('语法错误: 缺少 "\'"');
    }
  }

  /**
  * 语法分析
  */
  parser() {
    const { tokens, relations, operations } = this;

    /**
    * 1. 解析最小表达式
    */
    tokens.forEach((token, index) => {
      if (!this.grammarCheck(token, tokens[index + 1])) {
        throw new Error(`语法错误："${token} ${tokens[index + 1]}"`);
      }
      if (operations.includes(token)) {
        const identifier = tokens[index - 1];

        let value = tokens[index + 1];
        if (isNumber(value)) value = (+value);
        if (isString(value)) value = formatValue(value);
        const statement = { identifier, operator: token, value };

        tokens[index - 1] = statement;
        tokens.splice(index, 2);
      }
    });
    /**
    * 2. 逻辑组合最小表达式
    */
    tokens.forEach((item, index) => {
      if (relations.includes(item)) {
        const left = tokens[index - 1];
        const right = tokens[index + 1];

        if (isObject(left) && isObject(right)) {
          if (left.statements && left.relation === item) {
            left.statements.push(right);
          } else {
            const statement = {
              relation: item,
              statements: [left, right]
            };
            tokens[index - 1] = statement;
          }

          tokens.splice(index, 2);
        }
      }
    });
    /**
    * 3. 去括号
    */
    tokens.forEach((item, index) => {
      if (isObject(item)) {
        const isLeftBracket = tokens[index - 1] === LEFT_BRACKET;
        const isRightBracket = tokens[index + 1] === RIGHT_BRACKET;
        const isBracket = isLeftBracket && isRightBracket;

        if (isBracket) {
          tokens[index - 1] = item;
          tokens.splice(index, 2);
        }
      }
    });
    /**
    * 4. 递归
    */
    if (tokens.length > 1) {
      this.tokens = tokens;
      return this.parser();
    }
    return tokens[0];
  }

  /**
   * 语法校验
   */
  grammarCheck(prev, next) {
    /**
     * eg:
     * - ( 创建时间
     * - ( (
     */
    const isBracketBegin = (LEFT_BRACKET === prev) && (this.identifiers.includes(next) || LEFT_BRACKET === next || isObject(next));
    if (isBracketBegin) return true;
    /**
     * eg:
     * - 创建时间 属于
     */
    const isStatementLeft = this.identifiers.includes(prev) && this.operations.includes(next);
    if (isStatementLeft) return true;
    /**
     * eg:
     * - 属于 "当天"
     */
    const isStatementRight = this.operations.includes(prev) && isValue(next);
    if (isStatementRight) return true;
    /**
     * eg:
     * - { identifier: '剩余天数', operator: '>=', value: 3  } AND
     * - ) OR
     */
    const isRelationLeft = (RIGHT_BRACKET === prev || isObject(prev)) && this.relations.includes(next);
    if (isRelationLeft) return true;
    /**
     * eg:
     * - AND (
     * - AND { identifier: '剩余天数', operator: '>=', value: 3  }
     */
    const isRelationRight = this.relations.includes(prev) && (LEFT_BRACKET === next || isObject(next));
    if (isRelationRight) return true;
    /**
     * eg:
     * -  当天 )
     * - { identifier: '剩余天数', operator: '>=', value: 3  } )
     * - ))
     * - )
     */
    const isBracketEnd = ((RIGHT_BRACKET === prev) && next === undefined) || ((isValue(prev) || isObject(prev) || RIGHT_BRACKET === prev) && (RIGHT_BRACKET === next));
    if (isBracketEnd) return true;

    /**
     * eg:
     * - { identifier: '剩余天数', operator: '>=', value: 3  }
     */
    const isObjectEnd = isObject(prev) && next === undefined;
    if (isObjectEnd) return true;

    return false;
  }

  run(str) {
    this.lex(str);
    return this.parser();
  }
}

export default ParsingEngine;

// utils.js
export function isNumber(value) {
  return Number(value).toString() !== 'NaN';
}

export function isString(value) {
  if (typeof value !== 'string') return false;
  const firstChar = value.charAt(0);
  const lastChar = value.charAt(value.length - 1);
  return (firstChar === '"' && lastChar === '"') || (firstChar === '\'' && lastChar === '\'');
}

export function isObject(value) {
  return Object.prototype.toString.call(value) === '[object Object]';
}

export function isValue(value) {
  return isNumber(value) || isString(value);
}

export function formatValue(value) {
  value = value.replace(/"|'/g, '');
  if (value.indexOf(',') > -1) {
    value = value.split(',');
  }
  return value;
}