lite-ui-sql-parser/lib/expr.js

simple node sql parser

(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define(["exports", "./util", "./alter", "./aggregation", "./assign", "./binary", "./case", "./func", "./interval", "./select", "./union"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports, require("./util"), require("./alter"), require("./aggregation"), require("./assign"), require("./binary"), require("./case"), require("./func"), require("./interval"), require("./select"), require("./union"));
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports, global.util, global.alter, global.aggregation, global.assign, global.binary, global._case, global.func, global.interval, global.select, global.union);
    global.expr = mod.exports;
  }
})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _alter, _aggregation, _assign, _binary, _case, _func, _interval, _select, _union) {
  "use strict";

  Object.defineProperty(_exports, "__esModule", {
    value: true
  });
  _exports.exprToSQL = exprToSQL;
  _exports.getExprListSQL = getExprListSQL;
  _exports.varToSQL = varToSQL;
  _exports.orderOrPartitionByToSQL = orderOrPartitionByToSQL;
  _exports.exprToSQLConvertFn = void 0;
  const exprToSQLConvertFn = {
    alter: _alter.alterExprToSQL,
    aggr_func: _aggregation.aggrToSQL,
    assign: _assign.assignToSQL,
    binary_expr: _binary.binaryToSQL,
    case: _case.caseToSQL,
    cast: _func.castToSQL,
    column_ref: _util.columnRefToSQL,
    function: _func.funcToSQL,
    interval: _interval.intervalToSQL
  };
  _exports.exprToSQLConvertFn = exprToSQLConvertFn;

  function varToSQL(expr) {
    const {
      prefix = '@',
      name,
      members,
      keyword
    } = expr;
    const val = [];
    if (keyword) val.push(keyword);
    const varName = members && members.length > 0 ? `${name}.${members.join('.')}` : name;
    val.push(`${prefix || ''}${varName}`);
    return val.join(' ');
  }

  exprToSQLConvertFn.var = varToSQL;

  function exprToSQL(exprOrigin) {
    const expr = exprOrigin;

    if (exprOrigin.ast) {
      const {
        ast
      } = expr;
      Reflect.deleteProperty(expr, ast);

      for (const key of Object.keys(ast)) {
        expr[key] = ast[key];
      }
    }

    return exprToSQLConvertFn[expr.type] ? exprToSQLConvertFn[expr.type](expr) : (0, _util.literalToSQL)(expr);
  }

  function unaryToSQL(expr) {
    const str = `${expr.operator} ${exprToSQL(expr.expr)}`;
    return expr.parentheses ? `(${str})` : str;
  }

  function getExprListSQL(exprList) {
    if (!exprList) return [];
    return exprList.map(exprToSQL);
  }

  exprToSQLConvertFn.expr_list = expr => {
    const str = getExprListSQL(expr.value);
    return expr.parentheses ? `(${str})` : str;
  };

  exprToSQLConvertFn.select = expr => {
    const str = typeof expr._next === 'object' ? (0, _union.unionToSQL)(expr) : (0, _select.selectToSQL)(expr);
    return expr.parentheses ? `(${str})` : str;
  };

  exprToSQLConvertFn.unary_expr = unaryToSQL;

  function orderOrPartitionByToSQL(expr, prefix) {
    if (!Array.isArray(expr)) return '';
    let expressions = [];
    const upperPrefix = (0, _util.toUpper)(prefix);

    switch (upperPrefix) {
      case 'ORDER BY':
        expressions = expr.map(info => `${exprToSQL(info.expr)} ${info.type}`);
        break;

      case 'PARTITION BY':
        expressions = expr.map(info => `${(0, _util.columnRefToSQL)(info.expr)}`);
        break;

      default:
        expressions = expr.map(info => `${(0, _util.columnRefToSQL)(info.expr)}`);
        break;
    }

    return (0, _util.connector)(upperPrefix, expressions.join(', '));
  }
});