@nocobase/plugin-collection-fdw 2.0.3

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

@@ -0,0 +1,39 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./assign", "./expr", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./assign"), require("./expr"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.assign, global.expr, global.util);
+    global.proc = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _assign, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.procToSQL = procToSQL;
+  _exports.returnToSQL = returnToSQL;
+  function returnToSQL(stmt) {
+    const {
+      type,
+      expr
+    } = stmt;
+    return [(0, _util.toUpper)(type), (0, _expr.exprToSQL)(expr)].join(' ');
+  }
+  function procToSQL(expr) {
+    const {
+      stmt
+    } = expr;
+    switch (stmt.type) {
+      case 'assign':
+        return (0, _assign.assignToSQL)(stmt);
+      case 'return':
+        return returnToSQL(stmt);
+    }
+  }
+});

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

@@ -0,0 +1,132 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./column", "./limit", "./with", "./tables", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./column"), require("./limit"), require("./with"), require("./tables"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.column, global.limit, global._with, global.tables, global.util);
+    global.select = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _column, _limit, _with, _tables, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.selectIntoToSQL = selectIntoToSQL;
+  _exports.selectToSQL = selectToSQL;
+  function distinctToSQL(distinct) {
+    if (!distinct) return;
+    if (typeof distinct === 'string') return distinct;
+    const {
+      type,
+      columns
+    } = distinct;
+    const result = [(0, _util.toUpper)(type)];
+    if (columns) result.push(`(${columns.map(_column.columnRefToSQL).join(', ')})`);
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function selectIntoToSQL(into) {
+    if (!into) return;
+    const {
+      position
+    } = into;
+    if (!position) return;
+    const {
+      keyword,
+      expr
+    } = into;
+    const result = [];
+    const intoType = (0, _util.toUpper)(keyword);
+    switch (intoType) {
+      case 'VAR':
+        result.push(expr.map(_expr.varToSQL).join(', '));
+        break;
+      default:
+        result.push(intoType, typeof expr === 'string' ? (0, _util.identifierToSql)(expr) : (0, _expr.exprToSQL)(expr));
+    }
+    return result.filter(_util.hasVal).join(' ');
+  }
+  /**
+   * @param {Object}      stmt
+   * @param {?Array}      stmt.with
+   * @param {?Array}      stmt.options
+   * @param {?string}     stmt.distinct
+   * @param {?Array|string}   stmt.columns
+   * @param {?Array}      stmt.from
+   * @param {?Object}     stmt.where
+   * @param {?Array}      stmt.groupby
+   * @param {?Object}     stmt.having
+   * @param {?Array}      stmt.orderby
+   * @param {?Array}      stmt.limit
+   * @return {string}
+   */
+
+  function forXmlToSQL(stmt) {
+    if (!stmt) return;
+    const {
+      expr,
+      keyword,
+      type
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword)];
+    if (!expr) return result.join(' ');
+    return `${result.join(' ')}(${(0, _expr.exprToSQL)(expr)})`;
+  }
+  function selectToSQL(stmt) {
+    const {
+      as_struct_val: asStructVal,
+      columns,
+      distinct,
+      for: forXml,
+      from,
+      for_sys_time_as_of: forSystem = {},
+      locking_read: lockingRead,
+      groupby,
+      having,
+      into = {},
+      limit,
+      options,
+      orderby,
+      parentheses_symbol: parentheses,
+      qualify,
+      top,
+      window: windowInfo,
+      with: withInfo,
+      where
+    } = stmt;
+    const clauses = [(0, _with.withToSQL)(withInfo), 'SELECT', (0, _util.toUpper)(asStructVal)];
+    clauses.push((0, _util.topToSQL)(top));
+    if (Array.isArray(options)) clauses.push(options.join(' '));
+    clauses.push(distinctToSQL(distinct), (0, _column.columnsToSQL)(columns, from));
+    const {
+      position
+    } = into;
+    let intoSQL = '';
+    if (position) intoSQL = (0, _util.commonOptionConnector)('INTO', selectIntoToSQL, into);
+    if (position === 'column') clauses.push(intoSQL);
+    // FROM + joins
+    clauses.push((0, _util.commonOptionConnector)('FROM', _tables.tablesToSQL, from));
+    if (position === 'from') clauses.push(intoSQL);
+    const {
+      keyword,
+      expr
+    } = forSystem || {};
+    clauses.push((0, _util.commonOptionConnector)(keyword, _expr.exprToSQL, expr));
+    clauses.push((0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, where));
+    clauses.push((0, _util.connector)('GROUP BY', (0, _expr.getExprListSQL)(groupby).join(', ')));
+    clauses.push((0, _util.commonOptionConnector)('HAVING', _expr.exprToSQL, having));
+    clauses.push((0, _util.commonOptionConnector)('QUALIFY', _expr.exprToSQL, qualify));
+    clauses.push((0, _util.commonOptionConnector)('WINDOW', _expr.exprToSQL, windowInfo));
+    clauses.push((0, _expr.orderOrPartitionByToSQL)(orderby, 'order by'));
+    clauses.push((0, _limit.limitToSQL)(limit));
+    clauses.push((0, _util.toUpper)(lockingRead));
+    if (position === 'end') clauses.push(intoSQL);
+    clauses.push(forXmlToSQL(forXml));
+    const sql = clauses.filter(_util.hasVal).join(' ');
+    return parentheses ? `(${sql})` : sql;
+  }
+});

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

@@ -0,0 +1,88 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./limit", "./tables", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./limit"), require("./tables"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.limit, global.tables, global.util);
+    global.show = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _limit, _tables, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.showToSQL = showToSQL;
+  function showEventToSQL(showEventExpr) {
+    const {
+      in: inClause,
+      from,
+      limit
+    } = showEventExpr;
+    return [(0, _util.commonOptionConnector)('IN', _util.literalToSQL, inClause && inClause.right), (0, _util.commonOptionConnector)('FROM', _tables.tablesToSQL, from), (0, _limit.limitToSQL)(limit)].filter(_util.hasVal).join(' ');
+  }
+  function showLikeAndWhereToSQL(showCharacterSetExpr) {
+    const {
+      expr
+    } = showCharacterSetExpr;
+    if (!expr) return;
+    const {
+      op
+    } = expr;
+    if ((0, _util.toUpper)(op) === 'LIKE') return (0, _util.commonOptionConnector)('LIKE', _util.literalToSQL, expr.right);
+    return (0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, expr);
+  }
+  function showGrantsForUser(showGrantsForExpr) {
+    const {
+      for: forExpr
+    } = showGrantsForExpr;
+    if (!forExpr) return;
+    const {
+      user,
+      host,
+      role_list
+    } = forExpr;
+    let userAndHost = `'${user}'`;
+    if (host) userAndHost += `@'${host}'`;
+    return ['FOR', userAndHost, role_list && 'USING', role_list && role_list.map(role => `'${role}'`).join(', ')].filter(_util.hasVal).join(' ');
+  }
+  function showToSQL(showExpr) {
+    let {
+      keyword
+    } = showExpr;
+    const {
+      suffix
+    } = showExpr;
+    let str = '';
+    switch ((0, _util.toUpper)(keyword)) {
+      case 'BINLOG':
+        str = showEventToSQL(showExpr);
+        break;
+      case 'CHARACTER':
+      case 'COLLATION':
+        str = showLikeAndWhereToSQL(showExpr);
+        break;
+      case 'COLUMNS':
+      case 'INDEXES':
+        str = (0, _util.commonOptionConnector)('FROM', _tables.tablesToSQL, showExpr.from);
+        break;
+      case 'GRANTS':
+        str = showGrantsForUser(showExpr);
+        break;
+      case 'CREATE':
+        str = (0, _util.commonOptionConnector)('', _tables.tableToSQL, showExpr[suffix]);
+        break;
+      case 'VAR':
+        str = (0, _expr.varToSQL)(showExpr.var);
+        keyword = '';
+        break;
+      default:
+        break;
+    }
+    return ['SHOW', (0, _util.toUpper)(keyword), (0, _util.toUpper)(suffix), str].filter(_util.hasVal).join(' ');
+  }
+});

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

@@ -0,0 +1,43 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./union"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./union"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.union);
+    global.sql = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _union) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.default = astToSQL;
+  const supportedTypes = ['analyze', 'attach', 'select', 'deallocate', 'delete', 'exec', 'update', 'insert', 'drop', 'rename', 'truncate', 'call', 'desc', 'use', 'alter', 'set', 'create', 'lock', 'unlock', 'declare', 'show', 'replace', 'if', 'grant', 'revoke', 'proc', 'raise', 'execute', 'transaction'];
+  function checkSupported(expr) {
+    const ast = expr && expr.ast ? expr.ast : expr;
+    if (!supportedTypes.includes(ast.type)) throw new Error(`${ast.type} statements not supported at the moment`);
+  }
+  function toSQL(ast) {
+    if (Array.isArray(ast)) {
+      ast.forEach(checkSupported);
+      return (0, _union.multipleToSQL)(ast);
+    }
+    checkSupported(ast);
+    return (0, _union.unionToSQL)(ast);
+  }
+  function goToSQL(stmt) {
+    if (!stmt || stmt.length === 0) return '';
+    const res = [toSQL(stmt.ast)];
+    if (stmt.go_next) res.push(stmt.go.toUpperCase(), goToSQL(stmt.go_next));
+    return res.filter(sqlItem => sqlItem).join(' ');
+  }
+  function astToSQL(ast) {
+    const sql = ast.go === 'go' ? goToSQL(ast) : toSQL(ast);
+    return sql;
+  }
+});

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

@@ -0,0 +1,211 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./binary", "./column", "./expr", "./insert", "./interval", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./binary"), require("./column"), require("./expr"), require("./insert"), require("./interval"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.binary, global.column, global.expr, global.insert, global.interval, global.util);
+    global.tables = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _binary, _column, _expr, _insert, _interval, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.operatorToSQL = operatorToSQL;
+  _exports.tableHintToSQL = tableHintToSQL;
+  _exports.tableOptionToSQL = tableOptionToSQL;
+  _exports.tableToSQL = tableToSQL;
+  _exports.tableTumbleToSQL = tableTumbleToSQL;
+  _exports.tablesToSQL = tablesToSQL;
+  _exports.unnestToSQL = unnestToSQL;
+  function unnestToSQL(unnestExpr) {
+    const {
+      type,
+      as,
+      expr,
+      with_offset: withOffset
+    } = unnestExpr;
+    const result = [`${(0, _util.toUpper)(type)}(${expr && (0, _expr.exprToSQL)(expr) || ''})`, (0, _util.commonOptionConnector)('AS', _util.identifierToSql, as), (0, _util.commonOptionConnector)((0, _util.toUpper)(withOffset && withOffset.keyword), _util.identifierToSql, withOffset && withOffset.as)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function pivotOperatorToSQL(operator) {
+    const {
+      as,
+      column,
+      expr,
+      in_expr,
+      type
+    } = operator;
+    const result = [(0, _expr.exprToSQL)(expr), 'FOR', (0, _column.columnRefToSQL)(column), (0, _binary.binaryToSQL)(in_expr)];
+    const sql = [`${(0, _util.toUpper)(type)}(${result.join(' ')})`];
+    if (as) sql.push('AS', (0, _util.identifierToSql)(as));
+    return sql.join(' ');
+  }
+  function operatorToSQL(operator) {
+    if (!operator) return;
+    const {
+      type
+    } = operator;
+    switch (type) {
+      case 'pivot':
+      case 'unpivot':
+        return pivotOperatorToSQL(operator);
+      default:
+        return '';
+    }
+  }
+  function tableHintToSQL(tableHintExpr) {
+    if (!tableHintExpr) return;
+    const {
+      keyword,
+      expr,
+      index,
+      index_columns,
+      parentheses,
+      prefix
+    } = tableHintExpr;
+    const result = [];
+    switch (keyword.toLowerCase()) {
+      case 'forceseek':
+        result.push((0, _util.toUpper)(keyword), `(${(0, _util.identifierToSql)(index)}`, `(${index_columns.map(_expr.exprToSQL).filter(_util.hasVal).join(', ')}))`);
+        break;
+      case 'spatial_window_max_cells':
+        result.push((0, _util.toUpper)(keyword), '=', (0, _expr.exprToSQL)(expr));
+        break;
+      case 'index':
+        result.push((0, _util.toUpper)(prefix), (0, _util.toUpper)(keyword), parentheses ? `(${expr.map(_util.identifierToSql).join(', ')})` : `= ${(0, _util.identifierToSql)(expr)}`);
+        break;
+      default:
+        result.push((0, _expr.exprToSQL)(expr));
+    }
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function tableTumbleToSQL(tumble) {
+    if (!tumble) return '';
+    const {
+      data: tableInfo,
+      timecol,
+      size
+    } = tumble;
+    const fullTableName = [(0, _util.identifierToSql)(tableInfo.db), (0, _util.identifierToSql)(tableInfo.table)].filter(_util.hasVal).join('.');
+    const result = ['TABLE(TUMBLE(TABLE', fullTableName, `DESCRIPTOR(${(0, _column.columnRefToSQL)(timecol)})`, `${(0, _interval.intervalToSQL)(size)}))`];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function tableToSQL(tableInfo) {
+    if ((0, _util.toUpper)(tableInfo.type) === 'UNNEST') return unnestToSQL(tableInfo);
+    const {
+      table,
+      db,
+      as,
+      expr,
+      operator,
+      prefix: prefixStr,
+      schema,
+      server,
+      tablesample,
+      table_hint
+    } = tableInfo;
+    const serverName = (0, _util.identifierToSql)(server);
+    const database = (0, _util.identifierToSql)(db);
+    const schemaStr = (0, _util.identifierToSql)(schema);
+    let tableName = table && (0, _util.identifierToSql)(table);
+    if (expr) {
+      const exprType = expr.type;
+      switch (exprType) {
+        case 'values':
+          const {
+            parentheses,
+            values,
+            prefix
+          } = expr;
+          const valueSQL = [parentheses && '(', '', parentheses && ')'];
+          let valuesExpr = (0, _insert.valuesToSQL)(values);
+          if (prefix) valuesExpr = valuesExpr.split('(').slice(1).map(val => `${(0, _util.toUpper)(prefix)}(${val}`).join('');
+          valueSQL[1] = `VALUES ${valuesExpr}`;
+          tableName = valueSQL.filter(_util.hasVal).join('');
+          break;
+        case 'tumble':
+          tableName = tableTumbleToSQL(expr);
+          break;
+        default:
+          tableName = (0, _expr.exprToSQL)(expr);
+      }
+    }
+    tableName = [(0, _util.toUpper)(prefixStr), tableName].filter(_util.hasVal).join(' ');
+    let str = [serverName, database, schemaStr, tableName].filter(_util.hasVal).join('.');
+    if (tableInfo.parentheses) str = `(${str})`;
+    const result = [str];
+    if (tablesample) {
+      const tableSampleSQL = ['TABLESAMPLE', (0, _expr.exprToSQL)(tablesample.expr), (0, _util.literalToSQL)(tablesample.repeatable)].filter(_util.hasVal).join(' ');
+      result.push(tableSampleSQL);
+    }
+    result.push((0, _util.commonOptionConnector)('AS', _util.identifierToSql, as), operatorToSQL(operator));
+    if (table_hint) result.push((0, _util.toUpper)(table_hint.keyword), `(${table_hint.expr.map(tableHintToSQL).filter(_util.hasVal).join(', ')})`);
+    return result.filter(_util.hasVal).join(' ');
+  }
+
+  /**
+   * @param {Array} tables
+   * @return {string}
+   */
+  function tablesToSQL(tables) {
+    if (!tables) return '';
+    if (!Array.isArray(tables)) {
+      const {
+        expr,
+        parentheses
+      } = tables;
+      const sql = tablesToSQL(expr);
+      if (parentheses) return `(${sql})`;
+      return sql;
+    }
+    const baseTable = tables[0];
+    const clauses = [];
+    if (baseTable.type === 'dual') return 'DUAL';
+    clauses.push(tableToSQL(baseTable));
+    for (let i = 1; i < tables.length; ++i) {
+      const joinExpr = tables[i];
+      const {
+        on,
+        using,
+        join
+      } = joinExpr;
+      const str = [];
+      str.push(join ? ` ${(0, _util.toUpper)(join)}` : ',');
+      str.push(tableToSQL(joinExpr));
+      str.push((0, _util.commonOptionConnector)('ON', _expr.exprToSQL, on));
+      if (using) str.push(`USING (${using.map(_util.identifierToSql).join(', ')})`);
+      clauses.push(str.filter(_util.hasVal).join(' '));
+    }
+    return clauses.filter(_util.hasVal).join('');
+  }
+  function tableOptionToSQL(tableOption) {
+    const {
+      keyword,
+      symbol,
+      value
+    } = tableOption;
+    const sql = [keyword.toUpperCase()];
+    if (symbol) sql.push(symbol);
+    let val = value;
+    switch (keyword) {
+      case 'partition by':
+      case 'default collate':
+        val = (0, _expr.exprToSQL)(value);
+        break;
+      case 'options':
+        val = `(${value.map(tableOptionItem => [tableOptionItem.keyword, tableOptionItem.symbol, (0, _expr.exprToSQL)(tableOptionItem.value)].join(' ')).join(', ')})`;
+        break;
+      case 'cluster by':
+        val = value.map(_expr.exprToSQL).join(', ');
+        break;
+    }
+    sql.push(val);
+    return sql.join(' ');
+  }
+});

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

@@ -0,0 +1,26 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr);
+    global.transaction = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.transactionToSQL = transactionToSQL;
+  function transactionToSQL(stmt) {
+    const {
+      expr
+    } = stmt;
+    return (0, _expr.exprToSQL)(expr);
+  }
+});

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

@@ -0,0 +1,81 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./alter", "./analyze", "./create", "./select", "./delete", "./update", "./insert", "./command", "./exec", "./expr", "./limit", "./proc", "./transaction", "./show", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./alter"), require("./analyze"), require("./create"), require("./select"), require("./delete"), require("./update"), require("./insert"), require("./command"), require("./exec"), require("./expr"), require("./limit"), require("./proc"), require("./transaction"), require("./show"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.alter, global.analyze, global.create, global.select, global._delete, global.update, global.insert, global.command, global.exec, global.expr, global.limit, global.proc, global.transaction, global.show, global.util);
+    global.union = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _alter, _analyze, _create, _select, _delete, _update, _insert, _command, _exec, _expr, _limit2, _proc, _transaction, _show, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.multipleToSQL = multipleToSQL;
+  _exports.unionToSQL = unionToSQL;
+  const typeToSQLFn = {
+    alter: _alter.alterToSQL,
+    analyze: _analyze.analyzeToSQL,
+    attach: _analyze.attachToSQL,
+    create: _create.createToSQL,
+    select: _select.selectToSQL,
+    deallocate: _command.deallocateToSQL,
+    delete: _delete.deleteToSQL,
+    exec: _exec.execToSQL,
+    execute: _command.executeToSQL,
+    for: _command.forLoopToSQL,
+    update: _update.updateToSQL,
+    if: _command.ifToSQL,
+    insert: _insert.insertToSQL,
+    drop: _command.commonCmdToSQL,
+    truncate: _command.commonCmdToSQL,
+    replace: _insert.insertToSQL,
+    declare: _command.declareToSQL,
+    use: _command.useToSQL,
+    rename: _command.renameToSQL,
+    call: _command.callToSQL,
+    desc: _command.descToSQL,
+    set: _command.setVarToSQL,
+    lock: _command.lockUnlockToSQL,
+    unlock: _command.lockUnlockToSQL,
+    show: _show.showToSQL,
+    grant: _command.grantAndRevokeToSQL,
+    revoke: _command.grantAndRevokeToSQL,
+    proc: _proc.procToSQL,
+    raise: _command.raiseToSQL,
+    transaction: _transaction.transactionToSQL
+  };
+  function unionToSQL(stmt) {
+    if (!stmt) return '';
+    const fun = typeToSQLFn[stmt.type];
+    const {
+      _parentheses,
+      _orderby,
+      _limit
+    } = stmt;
+    const res = [_parentheses && '(', fun(stmt)];
+    while (stmt._next) {
+      const nextFun = typeToSQLFn[stmt._next.type];
+      const unionKeyword = (0, _util.toUpper)(stmt.set_op);
+      res.push(unionKeyword, nextFun(stmt._next));
+      stmt = stmt._next;
+    }
+    res.push(_parentheses && ')', (0, _expr.orderOrPartitionByToSQL)(_orderby, 'order by'), (0, _limit2.limitToSQL)(_limit));
+    return res.filter(_util.hasVal).join(' ');
+  }
+  function multipleToSQL(stmt) {
+    const res = [];
+    for (let i = 0, len = stmt.length; i < len; ++i) {
+      const astInfo = stmt[i] && stmt[i].ast ? stmt[i].ast : stmt[i];
+      let sql = unionToSQL(astInfo);
+      if (i === len - 1 && astInfo.type === 'transaction') sql = `${sql} ;`;
+      res.push(sql);
+    }
+    return res.join(' ; ');
+  }
+});

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

@@ -0,0 +1,59 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./tables", "./expr", "./limit", "./util", "./with"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./tables"), require("./expr"), require("./limit"), require("./util"), require("./with"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.tables, global.expr, global.limit, global.util, global._with);
+    global.update = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _tables, _expr, _limit, _util, _with) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.setToSQL = setToSQL;
+  _exports.updateToSQL = updateToSQL;
+  /**
+   * @param {Array} sets
+   * @return {string}
+   */
+  function setToSQL(sets) {
+    if (!sets || sets.length === 0) return '';
+    const clauses = [];
+    for (const set of sets) {
+      const {
+        table,
+        column,
+        value
+      } = set;
+      const str = [table, column].filter(_util.hasVal).map(info => (0, _util.identifierToSql)(info)).join('.');
+      const setItem = [str];
+      let val = '';
+      if (value) {
+        val = (0, _expr.exprToSQL)(value);
+        setItem.push('=', val);
+      }
+      clauses.push(setItem.filter(_util.hasVal).join(' '));
+    }
+    return clauses.join(', ');
+  }
+  function updateToSQL(stmt) {
+    const {
+      from,
+      table,
+      set,
+      where,
+      orderby,
+      with: withInfo,
+      limit,
+      returning
+    } = stmt;
+    const clauses = [(0, _with.withToSQL)(withInfo), 'UPDATE', (0, _tables.tablesToSQL)(table), (0, _util.commonOptionConnector)('SET', setToSQL, set), (0, _util.commonOptionConnector)('FROM', _tables.tablesToSQL, from), (0, _util.commonOptionConnector)('WHERE', _expr.exprToSQL, where), (0, _expr.orderOrPartitionByToSQL)(orderby, 'order by'), (0, _limit.limitToSQL)(limit), (0, _util.returningToSQL)(returning)];
+    return clauses.filter(_util.hasVal).join(' ');
+  }
+});