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

simple node sql parser

(function (global, factory) {
  if (typeof define === "function" && define.amd) {
    define(["exports", "./expr", "./tables", "./util"], factory);
  } else if (typeof exports !== "undefined") {
    factory(exports, require("./expr"), require("./tables"), require("./util"));
  } else {
    var mod = {
      exports: {}
    };
    factory(mod.exports, global.expr, global.tables, global.util);
    global.column = mod.exports;
  }
})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _tables, _util) {
  "use strict";

  Object.defineProperty(_exports, "__esModule", {
    value: true
  });
  _exports.columnDefinitionToSQL = columnDefinitionToSQL;
  _exports.columnsToSQL = columnsToSQL;
  _exports.columnDataType = columnDataType;
  _exports.columnReferenceDefinitionToSQL = columnReferenceDefinitionToSQL;

  function columnDataType(definition) {
    const {
      dataType,
      length,
      suffix,
      scale
    } = definition || {};
    let result = dataType;

    if (length) {
      result += `(${[length, scale].filter(_util.hasVal).join(', ')})`;
    }

    if (suffix && suffix.length) result += ` ${suffix.join(' ')}`;
    return result;
  }

  function columnReferenceDefinitionToSQL(referenceDefinition) {
    const reference = [];
    if (!referenceDefinition) return reference;
    const {
      definition,
      keyword,
      match,
      table,
      on_delete: onDelete,
      on_update: onUpdate
    } = referenceDefinition;
    reference.push(keyword.toUpperCase());
    reference.push((0, _tables.tablesToSQL)(table));
    reference.push(`(${definition.map(_util.identifierToSql).join(', ')})`);
    reference.push((0, _util.toUpper)(match));
    reference.push(...(0, _util.commonTypeValue)(onDelete));
    reference.push(...(0, _util.commonTypeValue)(onUpdate));
    return reference.filter(_util.hasVal);
  }

  function columnOption(definition) {
    const columnOpt = [];
    const {
      nullable,
      comment,
      collate,
      storage,
      default_val: defaultOpt,
      auto_increment: autoIncrement,
      unique_or_primary: uniquePrimary,
      column_format: columnFormat,
      reference_definition: referenceDefinition
    } = definition;
    columnOpt.push((0, _util.toUpper)(nullable && nullable.value));

    if (defaultOpt) {
      const {
        type,
        value
      } = defaultOpt;
      columnOpt.push(type.toUpperCase(), (0, _expr.exprToSQL)(value));
    }

    columnOpt.push((0, _util.toUpper)(autoIncrement), (0, _util.toUpper)(uniquePrimary), (0, _util.commentToSQL)(comment));
    columnOpt.push(...(0, _util.commonTypeValue)(collate));
    columnOpt.push(...(0, _util.commonTypeValue)(columnFormat));
    columnOpt.push(...(0, _util.commonTypeValue)(storage));
    columnOpt.push(...columnReferenceDefinitionToSQL(referenceDefinition));
    return columnOpt.filter(_util.hasVal).join(' ');
  }

  function columnDefinitionToSQL(columnDefinition) {
    const column = [];
    const name = (0, _util.columnRefToSQL)(columnDefinition.column);
    const dataType = columnDataType(columnDefinition.definition);
    column.push(name);
    column.push(dataType);
    const columnOpt = columnOption(columnDefinition);
    column.push(columnOpt);
    return column.filter(_util.hasVal).join(' ');
  }
  /**
   * Stringify column expressions
   *
   * @param {Array} columns
   * @return {string}
   */


  function columnsToSQL(columns, tables) {
    if (!columns) return;
    if (columns === '*') return columns;
    const baseTable = Array.isArray(tables) && tables[0];
    let isDual = false;
    if (baseTable && baseTable.type === 'dual') isDual = true;
    return columns.map(column => {
      const {
        expr
      } = column;
      if (isDual) expr.isDual = isDual;
      let str = (0, _expr.exprToSQL)(expr);

      if (column.as !== null) {
        str = `${str} AS `;
        if (column.as.match(/^[a-z_][0-9a-z_]*$/i)) str = `${str}${(0, _util.identifierToSql)(column.as)}`;else str = `${str}\`${column.as}\``;
      }

      return str;
    }).join(', ');
  }
});