@tachybase/module-collection 1.6.25 → 1.6.26

package/dist/node_modules/node-sql-parser/lib/expr.js

@@ -0,0 +1,147 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./alter", "./aggregation", "./assign", "./binary", "./case", "./collate", "./column", "./func", "./interval", "./json", "./select", "./show", "./array-struct", "./tables", "./union", "./window"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./alter"), require("./aggregation"), require("./assign"), require("./binary"), require("./case"), require("./collate"), require("./column"), require("./func"), require("./interval"), require("./json"), require("./select"), require("./show"), require("./array-struct"), require("./tables"), require("./union"), require("./window"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.alter, global.aggregation, global.assign, global.binary, global._case, global.collate, global.column, global.func, global.interval, global.json, global.select, global.show, global.arrayStruct, global.tables, global.union, global.window);
+    global.expr = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _alter, _aggregation, _assign, _binary, _case, _collate, _column, _func, _interval, _json, _select, _show, _arrayStruct, _tables, _union, _window) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.exprToSQL = exprToSQL;
+  _exports.exprToSQLConvertFn = void 0;
+  _exports.getExprListSQL = getExprListSQL;
+  _exports.orderOrPartitionByToSQL = orderOrPartitionByToSQL;
+  _exports.varToSQL = varToSQL;
+  const exprToSQLConvertFn = _exports.exprToSQLConvertFn = {
+    alter: _alter.alterExprToSQL,
+    aggr_func: _aggregation.aggrToSQL,
+    any_value: _func.anyValueFuncToSQL,
+    window_func: _window.windowFuncToSQL,
+    'array': _arrayStruct.arrayStructExprToSQL,
+    assign: _assign.assignToSQL,
+    binary_expr: _binary.binaryToSQL,
+    case: _case.caseToSQL,
+    cast: _func.castToSQL,
+    collate: _collate.collateToSQL,
+    column_ref: _column.columnRefToSQL,
+    column_definition: _column.columnDefinitionToSQL,
+    datatype: _util.dataTypeToSQL,
+    extract: _func.extractFunToSQL,
+    flatten: _func.flattenFunToSQL,
+    fulltext_search: _column.fullTextSearchToSQL,
+    function: _func.funcToSQL,
+    lambda: _func.lambdaToSQL,
+    insert: _union.unionToSQL,
+    interval: _interval.intervalToSQL,
+    json: _json.jsonExprToSQL,
+    json_object_arg: _func.jsonObjectArgToSQL,
+    json_visitor: _json.jsonVisitorExprToSQL,
+    func_arg: _func.funcArgToSQL,
+    show: _show.showToSQL,
+    struct: _arrayStruct.arrayStructExprToSQL,
+    tablefunc: _func.tablefuncFunToSQL,
+    tables: _tables.tablesToSQL,
+    unnest: _tables.unnestToSQL,
+    'window': _window.namedWindowExprListToSQL
+  };
+  function varToSQL(expr) {
+    const {
+      prefix = '@',
+      name,
+      members,
+      quoted,
+      suffix
+    } = expr;
+    const val = [];
+    const varName = members && members.length > 0 ? `${name}.${members.join('.')}` : name;
+    let result = `${prefix || ''}${varName}`;
+    if (suffix) result += suffix;
+    val.push(result);
+    return [quoted, val.join(' '), quoted].filter(_util.hasVal).join('');
+  }
+  exprToSQLConvertFn.var = varToSQL;
+  function exprToSQL(exprOrigin) {
+    if (!exprOrigin) return;
+    const expr = exprOrigin;
+    if (exprOrigin.ast) {
+      const {
+        ast
+      } = expr;
+      Reflect.deleteProperty(expr, ast);
+      for (const key of Object.keys(ast)) {
+        expr[key] = ast[key];
+      }
+    }
+    const {
+      type
+    } = expr;
+    if (type === 'expr') return exprToSQL(expr.expr);
+    return exprToSQLConvertFn[type] ? exprToSQLConvertFn[type](expr) : (0, _util.literalToSQL)(expr);
+  }
+  function unaryToSQL(unarExpr) {
+    const {
+      operator,
+      parentheses,
+      expr
+    } = unarExpr;
+    const space = operator === '-' || operator === '+' || operator === '~' || operator === '!' ? '' : ' ';
+    const str = `${operator}${space}${exprToSQL(expr)}`;
+    return parentheses ? `(${str})` : str;
+  }
+  function getExprListSQL(exprList) {
+    if (!exprList) return [];
+    if (!Array.isArray(exprList)) exprList = [exprList];
+    return exprList.map(exprToSQL);
+  }
+  exprToSQLConvertFn.expr_list = expr => {
+    const result = getExprListSQL(expr.value);
+    const {
+      parentheses,
+      separator
+    } = expr;
+    if (!parentheses && !separator) return result;
+    const joinSymbol = separator || ', ';
+    const str = result.join(joinSymbol);
+    return 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 mapObjectToSQL(mapExpr) {
+    const {
+      keyword,
+      expr
+    } = mapExpr;
+    const exprStr = expr.map(exprItem => [(0, _util.literalToSQL)(exprItem.key), (0, _util.literalToSQL)(exprItem.value)].join(', ')).join(', ');
+    return [(0, _util.toUpper)(keyword), `[${exprStr}]`].join('');
+  }
+  exprToSQLConvertFn.map_object = mapObjectToSQL;
+  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 || 'ASC', (0, _util.toUpper)(info.nulls)].filter(_util.hasVal).join(' '));
+        break;
+      case 'PARTITION BY':
+        expressions = expr.map(info => exprToSQL(info.expr));
+        break;
+      default:
+        expressions = expr.map(info => exprToSQL(info.expr));
+        break;
+    }
+    return (0, _util.connector)(upperPrefix, expressions.join(', '));
+  }
+});

package/dist/node_modules/node-sql-parser/lib/func.js

@@ -0,0 +1,231 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./column", "./expr", "./util", "./over"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./column"), require("./expr"), require("./util"), require("./over"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.column, global.expr, global.util, global.over);
+    global.func = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _column, _expr, _util, _over) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.anyValueFuncToSQL = anyValueFuncToSQL;
+  _exports.arrayDimensionToSymbol = arrayDimensionToSymbol;
+  _exports.castToSQL = castToSQL;
+  _exports.extractFunToSQL = extractFunToSQL;
+  _exports.flattenFunToSQL = flattenFunToSQL;
+  _exports.funcArgToSQL = funcArgToSQL;
+  _exports.funcToSQL = funcToSQL;
+  _exports.jsonObjectArgToSQL = jsonObjectArgToSQL;
+  _exports.lambdaToSQL = lambdaToSQL;
+  _exports.tablefuncFunToSQL = tablefuncFunToSQL;
+  function anyValueFuncToSQL(stmt) {
+    const {
+      args,
+      type,
+      over
+    } = stmt;
+    const {
+      expr,
+      having
+    } = args;
+    let sql = `${(0, _util.toUpper)(type)}(${(0, _expr.exprToSQL)(expr)}`;
+    if (having) sql = `${sql} HAVING ${(0, _util.toUpper)(having.prefix)} ${(0, _expr.exprToSQL)(having.expr)}`;
+    sql = `${sql})`;
+    const overStr = (0, _over.overToSQL)(over);
+    return [sql, overStr].filter(_util.hasVal).join(' ');
+  }
+  function arrayDimensionToSymbol(target) {
+    if (!target || !target.array) return '';
+    const {
+      keyword
+    } = target.array;
+    if (keyword) return (0, _util.toUpper)(keyword);
+    const {
+      dimension,
+      length
+    } = target.array;
+    const result = [];
+    for (let i = 0; i < dimension; i++) {
+      result.push('[');
+      if (length && length[i]) result.push((0, _util.literalToSQL)(length[i]));
+      result.push(']');
+    }
+    return result.join('');
+  }
+  function castToSQL(expr) {
+    const {
+      target: targets,
+      expr: expression,
+      keyword,
+      symbol,
+      as: alias,
+      offset,
+      parentheses: outParentheses
+    } = expr;
+    let prefix = (0, _column.columnOffsetToSQL)({
+      expr: expression,
+      offset
+    });
+    const result = [];
+    for (let i = 0, len = targets.length; i < len; ++i) {
+      const target = targets[i];
+      const {
+        angle_brackets: angleBrackets,
+        length,
+        dataType,
+        parentheses,
+        quoted,
+        scale,
+        suffix: dataTypeSuffix,
+        expr: targetExpr
+      } = target;
+      let str = targetExpr ? (0, _expr.exprToSQL)(targetExpr) : '';
+      if (length != null) str = scale ? `${length}, ${scale}` : length;
+      if (parentheses) str = `(${str})`;
+      if (angleBrackets) str = `<${str}>`;
+      if (dataTypeSuffix && dataTypeSuffix.length) str += ` ${dataTypeSuffix.map(_util.literalToSQL).join(' ')}`;
+      let symbolChar = '::';
+      let suffix = '';
+      const targetResult = [];
+      if (symbol === 'as') {
+        if (i === 0) prefix = `${(0, _util.toUpper)(keyword)}(${prefix}`;
+        suffix = ')';
+        symbolChar = ` ${symbol.toUpperCase()} `;
+      }
+      if (i === 0) targetResult.push(prefix);
+      const arrayDimension = arrayDimensionToSymbol(target);
+      targetResult.push(symbolChar, quoted, dataType, quoted, arrayDimension, str, suffix);
+      result.push(targetResult.filter(_util.hasVal).join(''));
+    }
+    if (alias) result.push(` AS ${(0, _util.identifierToSql)(alias)}`);
+    const sql = result.filter(_util.hasVal).join('');
+    return outParentheses ? `(${sql})` : sql;
+  }
+  function extractFunToSQL(stmt) {
+    const {
+      args,
+      type
+    } = stmt;
+    const {
+      field,
+      cast_type: castType,
+      source
+    } = args;
+    const result = [`${(0, _util.toUpper)(type)}(${(0, _util.toUpper)(field)}`, 'FROM', (0, _util.toUpper)(castType), (0, _expr.exprToSQL)(source)];
+    return `${result.filter(_util.hasVal).join(' ')})`;
+  }
+  function flattenArgToSQL(arg) {
+    if (!arg) return '';
+    const {
+      type,
+      symbol,
+      value
+    } = arg;
+    const result = [(0, _util.toUpper)(type), symbol, (0, _expr.exprToSQL)(value)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function jsonObjectArgToSQL(argExpr) {
+    const {
+      expr
+    } = argExpr;
+    const {
+      key,
+      value,
+      on
+    } = expr;
+    const result = [(0, _expr.exprToSQL)(key), 'VALUE', (0, _expr.exprToSQL)(value)];
+    if (on) result.push('ON', 'NULL', (0, _expr.exprToSQL)(on));
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function flattenFunToSQL(stmt) {
+    const {
+      args,
+      type
+    } = stmt;
+    const keys = ['input', 'path', 'outer', 'recursive', 'mode'];
+    const argsStr = keys.map(key => flattenArgToSQL(args[key])).filter(_util.hasVal).join(', ');
+    return `${(0, _util.toUpper)(type)}(${argsStr})`;
+  }
+  function funcArgToSQL(argExpr) {
+    const {
+      name,
+      symbol,
+      expr
+    } = argExpr.value;
+    return [name, symbol, (0, _expr.exprToSQL)(expr)].filter(_util.hasVal).join(' ');
+  }
+  function withinGroupToSQL(stmt) {
+    if (!stmt) return '';
+    const {
+      type,
+      keyword,
+      orderby
+    } = stmt;
+    return [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), `(${(0, _expr.orderOrPartitionByToSQL)(orderby, 'order by')})`].filter(_util.hasVal).join(' ');
+  }
+  function funcToSQL(expr) {
+    const {
+      args,
+      array_index,
+      name,
+      args_parentheses,
+      parentheses,
+      within_group: withinGroup,
+      over,
+      suffix
+    } = expr;
+    const overStr = (0, _over.overToSQL)(over);
+    const withinGroupStr = withinGroupToSQL(withinGroup);
+    const suffixStr = (0, _expr.exprToSQL)(suffix);
+    const funcName = [(0, _util.literalToSQL)(name.schema), name.name.map(_util.literalToSQL).join('.')].filter(_util.hasVal).join('.');
+    if (!args) return [funcName, withinGroupStr, overStr].filter(_util.hasVal).join(' ');
+    let separator = expr.separator || ', ';
+    if ((0, _util.toUpper)(funcName) === 'TRIM') separator = ' ';
+    let str = [funcName];
+    str.push(args_parentheses === false ? ' ' : '(');
+    const argsList = (0, _expr.exprToSQL)(args);
+    if (Array.isArray(separator)) {
+      let argsSQL = argsList[0];
+      for (let i = 1, len = argsList.length; i < len; ++i) {
+        argsSQL = [argsSQL, argsList[i]].join(` ${(0, _expr.exprToSQL)(separator[i - 1])} `);
+      }
+      str.push(argsSQL);
+    } else {
+      str.push(argsList.join(separator));
+    }
+    if (args_parentheses !== false) str.push(')');
+    str.push((0, _column.arrayIndexToSQL)(array_index));
+    str = [str.join(''), suffixStr].filter(_util.hasVal).join(' ');
+    return [parentheses ? `(${str})` : str, withinGroupStr, overStr].filter(_util.hasVal).join(' ');
+  }
+  function tablefuncFunToSQL(expr) {
+    const {
+      as,
+      name,
+      args
+    } = expr;
+    const funcName = [(0, _util.literalToSQL)(name.schema), name.name.map(_util.literalToSQL).join('.')].filter(_util.hasVal).join('.');
+    const result = [`${funcName}(${(0, _expr.exprToSQL)(args).join(', ')})`, 'AS', funcToSQL(as)];
+    return result.join(' ');
+  }
+  function lambdaToSQL(stmt) {
+    const {
+      args,
+      expr
+    } = stmt;
+    const {
+      value,
+      parentheses
+    } = args;
+    const argsList = value.map(_expr.exprToSQL).join(', ');
+    return [parentheses ? `(${argsList})` : argsList, '->', (0, _expr.exprToSQL)(expr)].join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/index-definition.js

@@ -0,0 +1,106 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./expr"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./expr"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.expr);
+    global.indexDefinition = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _expr) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.indexDefinitionToSQL = indexDefinitionToSQL;
+  _exports.indexOptionListToSQL = indexOptionListToSQL;
+  _exports.indexOptionToSQL = indexOptionToSQL;
+  _exports.indexTypeAndOptionToSQL = indexTypeAndOptionToSQL;
+  _exports.indexTypeToSQL = indexTypeToSQL;
+  function indexTypeToSQL(indexType) {
+    if (!indexType) return [];
+    const {
+      keyword,
+      type
+    } = indexType;
+    return [keyword.toUpperCase(), (0, _util.toUpper)(type)];
+  }
+  function indexOptionToSQL(indexOpt) {
+    if (!indexOpt) return;
+    const {
+      type,
+      expr,
+      symbol
+    } = indexOpt;
+    const upperType = type.toUpperCase();
+    const indexOptArray = [];
+    indexOptArray.push(upperType);
+    switch (upperType) {
+      case 'KEY_BLOCK_SIZE':
+        if (symbol) indexOptArray.push(symbol);
+        indexOptArray.push((0, _util.literalToSQL)(expr));
+        break;
+      case 'BTREE':
+      case 'HASH':
+        indexOptArray.length = 0;
+        indexOptArray.push(...indexTypeToSQL(indexOpt));
+        break;
+      case 'WITH PARSER':
+        indexOptArray.push(expr);
+        break;
+      case 'VISIBLE':
+      case 'INVISIBLE':
+        break;
+      case 'COMMENT':
+        indexOptArray.shift();
+        indexOptArray.push((0, _util.commentToSQL)(indexOpt));
+        break;
+      case 'DATA_COMPRESSION':
+        indexOptArray.push(symbol, (0, _util.toUpper)(expr.value), (0, _util.onPartitionsToSQL)(expr.on));
+        break;
+      default:
+        indexOptArray.push(symbol, (0, _util.literalToSQL)(expr));
+        break;
+    }
+    return indexOptArray.filter(_util.hasVal).join(' ');
+  }
+  function indexOptionListToSQL(indexOptList) {
+    if (!indexOptList) return [];
+    return indexOptList.map(indexOptionToSQL);
+  }
+  function indexTypeAndOptionToSQL(indexDefinition) {
+    const {
+      constraint_type: constraintType,
+      index_type: indexType,
+      index_options: indexOptions = [],
+      definition,
+      on,
+      with: withExpr
+    } = indexDefinition;
+    const dataType = [];
+    dataType.push(...indexTypeToSQL(indexType));
+    if (definition && definition.length) {
+      const definitionSQL = (0, _util.toUpper)(constraintType) === 'CHECK' ? `(${(0, _expr.exprToSQL)(definition[0])})` : `(${definition.map(col => (0, _expr.exprToSQL)(col)).join(', ')})`;
+      dataType.push(definitionSQL);
+    }
+    dataType.push(indexOptionListToSQL(indexOptions).join(' '));
+    if (withExpr) dataType.push(`WITH (${indexOptionListToSQL(withExpr).join(', ')})`);
+    if (on) dataType.push(`ON [${on}]`);
+    return dataType;
+  }
+  function indexDefinitionToSQL(indexDefinition) {
+    const indexSQL = [];
+    const {
+      keyword,
+      index
+    } = indexDefinition;
+    indexSQL.push((0, _util.toUpper)(keyword));
+    indexSQL.push(index);
+    indexSQL.push(...indexTypeAndOptionToSQL(indexDefinition));
+    return indexSQL.filter(_util.hasVal).join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/insert.js

@@ -0,0 +1,112 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./tables", "./expr", "./column", "./util", "./select", "./update"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./tables"), require("./expr"), require("./column"), require("./util"), require("./select"), require("./update"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.tables, global.expr, global.column, global.util, global.select, global.update);
+    global.insert = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _tables, _expr, _column, _util, _select, _update) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.conflictToSQL = conflictToSQL;
+  _exports.insertToSQL = insertToSQL;
+  _exports.valuesToSQL = valuesToSQL;
+  /**
+   * @param {Array} values
+   * @return {string}
+   */
+  function valuesToSQL(values) {
+    if (values.type === 'select') return (0, _select.selectToSQL)(values);
+    const clauses = values.map(_expr.exprToSQL);
+    return `(${clauses.join('), (')})`;
+  }
+  function partitionToSQL(partition) {
+    if (!partition) return '';
+    const partitionArr = ['PARTITION', '('];
+    if (Array.isArray(partition)) {
+      partitionArr.push(partition.map(_util.identifierToSql).join(', '));
+    } else {
+      const {
+        value
+      } = partition;
+      partitionArr.push(value.map(_expr.exprToSQL).join(', '));
+    }
+    partitionArr.push(')');
+    return partitionArr.filter(_util.hasVal).join('');
+  }
+  function conflictTargetToSQL(conflictTarget) {
+    if (!conflictTarget) return '';
+    const {
+      type
+    } = conflictTarget;
+    switch (type) {
+      case 'column':
+        return `(${conflictTarget.expr.map(_column.columnRefToSQL).join(', ')})`;
+    }
+  }
+  function conflictActionToSQL(conflictAction) {
+    const {
+      expr,
+      keyword
+    } = conflictAction;
+    const {
+      type
+    } = expr;
+    const result = [(0, _util.toUpper)(keyword)];
+    switch (type) {
+      case 'origin':
+        result.push((0, _util.literalToSQL)(expr));
+        break;
+      case 'update':
+        result.push('UPDATE', (0, _util.commonOptionConnector)('SET', _update.setToSQL, expr.set), (0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, expr.where));
+        break;
+    }
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function conflictToSQL(conflict) {
+    if (!conflict) return '';
+    const {
+      action,
+      target
+    } = conflict;
+    const result = [conflictTargetToSQL(target), conflictActionToSQL(action)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function insertToSQL(stmt) {
+    const {
+      table,
+      type,
+      or: orExpr = [],
+      prefix = 'into',
+      columns,
+      conflict,
+      values,
+      where,
+      on_duplicate_update: onDuplicateUpdate,
+      partition,
+      returning,
+      set
+    } = stmt;
+    const {
+      keyword,
+      set: duplicateSet
+    } = onDuplicateUpdate || {};
+    const clauses = [(0, _util.toUpper)(type), orExpr.map(_util.literalToSQL).join(' '), (0, _util.toUpper)(prefix), (0, _tables.tablesToSQL)(table), partitionToSQL(partition)];
+    if (Array.isArray(columns)) clauses.push(`(${columns.map(_util.literalToSQL).join(', ')})`);
+    clauses.push((0, _util.commonOptionConnector)(Array.isArray(values) ? 'VALUES' : '', valuesToSQL, values));
+    clauses.push((0, _util.commonOptionConnector)('ON CONFLICT', conflictToSQL, conflict));
+    clauses.push((0, _util.commonOptionConnector)('SET', _update.setToSQL, set));
+    clauses.push((0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, where));
+    clauses.push((0, _util.commonOptionConnector)(keyword, _update.setToSQL, duplicateSet));
+    clauses.push((0, _util.returningToSQL)(returning));
+    return clauses.filter(_util.hasVal).join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/interval.js

@@ -0,0 +1,29 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./util", "./expr"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./util"), require("./expr"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.util, global.expr);
+    global.interval = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _util, _expr) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.intervalToSQL = intervalToSQL;
+  function intervalToSQL(intervalExpr) {
+    const {
+      expr,
+      unit,
+      suffix
+    } = intervalExpr;
+    const result = ['INTERVAL', (0, _expr.exprToSQL)(expr), (0, _util.toUpper)(unit), (0, _expr.exprToSQL)(suffix)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+});

package/dist/node_modules/node-sql-parser/lib/json.js

@@ -0,0 +1,36 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.util);
+    global.json = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.jsonExprToSQL = jsonExprToSQL;
+  _exports.jsonVisitorExprToSQL = jsonVisitorExprToSQL;
+  function jsonExprToSQL(expr) {
+    const {
+      keyword,
+      expr_list: exprList
+    } = expr;
+    const result = [(0, _util.toUpper)(keyword), exprList.map(exprItem => (0, _expr.exprToSQL)(exprItem)).join(', ')].join(' ');
+    return result;
+  }
+  function jsonVisitorExprToSQL(stmt) {
+    const {
+      symbol,
+      expr
+    } = stmt;
+    return [symbol, (0, _expr.exprToSQL)(expr)].join('');
+  }
+});