@tachybase/module-collection 1.6.24 → 1.6.26

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

@@ -0,0 +1,42 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./expr", "./util", "./over"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"), require("./util"), require("./over"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr, global.util, global.over);
+    global.aggregation = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _util, _over) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.aggrToSQL = aggrToSQL;
+  function aggrToSQL(expr) {
+    /** @type {Object} */
+    const {
+      args,
+      filter,
+      over,
+      within_group_orderby
+    } = expr;
+    let str = (0, _expr.exprToSQL)(args.expr);
+    str = Array.isArray(str) ? str.join(', ') : str;
+    const fnName = expr.name;
+    const overStr = (0, _over.overToSQL)(over);
+    const separator = ' ';
+    if (args.distinct) str = ['DISTINCT', str].join(separator);
+    if (args.separator && args.separator.delimiter) str = [str, (0, _util.literalToSQL)(args.separator.delimiter)].join(`${args.separator.symbol} `);
+    if (args.separator && args.separator.expr) str = [str, (0, _expr.exprToSQL)(args.separator.expr)].join(' ');
+    if (args.orderby) str = [str, (0, _expr.orderOrPartitionByToSQL)(args.orderby, 'order by')].join(' ');
+    if (args.separator && args.separator.value) str = [str, (0, _util.toUpper)(args.separator.keyword), (0, _util.literalToSQL)(args.separator.value)].filter(_util.hasVal).join(' ');
+    const withinGroup = within_group_orderby ? `WITHIN GROUP (${(0, _expr.orderOrPartitionByToSQL)(within_group_orderby, 'order by')})` : '';
+    const filterStr = filter ? `FILTER (WHERE ${(0, _expr.exprToSQL)(filter.where)})` : '';
+    return [`${fnName}(${str})`, withinGroup, overStr, filterStr].filter(_util.hasVal).join(' ');
+  }
+});

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

@@ -0,0 +1,211 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./column", "./create", "./index-definition", "./tables", "./expr", "./select", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./column"), require("./create"), require("./index-definition"), require("./tables"), require("./expr"), require("./select"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.column, global.create, global.indexDefinition, global.tables, global.expr, global.select, global.util);
+    global.alter = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _column, _create, _indexDefinition, _tables, _expr, _select, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.alterArgsToSQL = alterArgsToSQL;
+  _exports.alterExprToSQL = alterExprToSQL;
+  _exports.alterToSQL = alterToSQL;
+  function alterExprPartition(action, expr) {
+    switch (action) {
+      case 'add':
+        const sql = expr.map(({
+          name,
+          value
+        }) => ['PARTITION', (0, _util.literalToSQL)(name), 'VALUES', (0, _util.toUpper)(value.type), `(${(0, _util.literalToSQL)(value.expr)})`].join(' ')).join(', ');
+        return `(${sql})`;
+      default:
+        return (0, _column.columnsToSQL)(expr);
+    }
+  }
+  function alterExprToSQL(expr) {
+    if (!expr) return '';
+    const {
+      action,
+      create_definitions: createDefinition,
+      if_not_exists: ifNotExists,
+      keyword,
+      if_exists: ifExists,
+      old_column: oldColumn,
+      prefix,
+      resource,
+      symbol,
+      suffix
+    } = expr;
+    let name = '';
+    let dataType = [];
+    switch (resource) {
+      case 'column':
+        dataType = [(0, _column.columnDefinitionToSQL)(expr)];
+        break;
+      case 'index':
+        dataType = (0, _indexDefinition.indexTypeAndOptionToSQL)(expr);
+        name = expr[resource];
+        break;
+      case 'table':
+      case 'schema':
+        name = (0, _util.identifierToSql)(expr[resource]);
+        break;
+      case 'aggregate':
+      case 'function':
+      case 'domain':
+      case 'type':
+        name = (0, _util.identifierToSql)(expr[resource]);
+        break;
+      case 'algorithm':
+      case 'lock':
+      case 'table-option':
+        name = [symbol, (0, _util.toUpper)(expr[resource])].filter(_util.hasVal).join(' ');
+        break;
+      case 'constraint':
+        name = (0, _util.identifierToSql)(expr[resource]);
+        dataType = [(0, _create.createDefinitionToSQL)(createDefinition)];
+        break;
+      case 'partition':
+        dataType = [alterExprPartition(action, expr.partitions)];
+        break;
+      case 'key':
+        name = (0, _util.identifierToSql)(expr[resource]);
+        break;
+      default:
+        name = [symbol, expr[resource]].filter(val => val !== null).join(' ');
+        break;
+    }
+    const alterArray = [(0, _util.toUpper)(action), (0, _util.toUpper)(keyword), (0, _util.toUpper)(ifNotExists), (0, _util.toUpper)(ifExists), oldColumn && (0, _column.columnRefToSQL)(oldColumn), (0, _util.toUpper)(prefix), name && name.trim(), dataType.filter(_util.hasVal).join(' ')];
+    if (suffix) {
+      alterArray.push((0, _util.toUpper)(suffix.keyword), suffix.expr && (0, _column.columnRefToSQL)(suffix.expr));
+    }
+    return alterArray.filter(_util.hasVal).join(' ');
+  }
+  function alterTableToSQL(stmt) {
+    const {
+      type,
+      table,
+      if_exists,
+      prefix,
+      expr = []
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    const tableName = (0, _tables.tablesToSQL)(table);
+    const exprList = expr.map(_expr.exprToSQL);
+    const result = [action, 'TABLE', (0, _util.toUpper)(if_exists), (0, _util.literalToSQL)(prefix), tableName, exprList.join(', ')];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function alterViewToSQL(stmt) {
+    const {
+      type,
+      columns,
+      attributes,
+      select,
+      view,
+      with: withExpr
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    const viewName = (0, _tables.tableToSQL)(view);
+    const result = [action, 'VIEW', viewName];
+    if (columns) result.push(`(${columns.map(_column.columnRefToSQL).join(', ')})`);
+    if (attributes) result.push(`WITH ${attributes.map(_util.toUpper).join(', ')}`);
+    result.push('AS', (0, _select.selectToSQL)(select));
+    if (withExpr) result.push((0, _util.toUpper)(withExpr));
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function alterArgsToSQL(arg) {
+    const defaultSQL = arg.default && [(0, _util.toUpper)(arg.default.keyword), (0, _expr.exprToSQL)(arg.default.value)].join(' ');
+    return [(0, _util.toUpper)(arg.mode), arg.name, (0, _util.dataTypeToSQL)(arg.type), defaultSQL].filter(_util.hasVal).join(' ');
+  }
+  function alterSchemaToSQL(stmt) {
+    const {
+      expr,
+      keyword,
+      schema,
+      type
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), (0, _util.identifierToSql)(schema), alterExprToSQL(expr)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function alterDomainTypeToSQL(stmt) {
+    const {
+      expr,
+      keyword,
+      name,
+      type
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), [(0, _util.identifierToSql)(name.schema), (0, _util.identifierToSql)(name.name)].filter(_util.hasVal).join('.'), alterExprToSQL(expr)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function alterFunctionToSQL(stmt) {
+    const {
+      args,
+      expr,
+      keyword,
+      name,
+      type
+    } = stmt;
+    const result = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), [[(0, _util.identifierToSql)(name.schema), (0, _util.identifierToSql)(name.name)].filter(_util.hasVal).join('.'), args && `(${args.expr ? args.expr.map(alterArgsToSQL).join(', ') : ''})`].filter(_util.hasVal).join(''), alterExprToSQL(expr)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function alterAggregateToSQL(stmt) {
+    const {
+      args,
+      expr,
+      keyword,
+      name,
+      type
+    } = stmt;
+    const {
+      expr: argsExpr,
+      orderby
+    } = args;
+    const result = [(0, _util.toUpper)(type), (0, _util.toUpper)(keyword), [[(0, _util.identifierToSql)(name.schema), (0, _util.identifierToSql)(name.name)].filter(_util.hasVal).join('.'), `(${argsExpr.map(alterArgsToSQL).join(', ')}${orderby ? [' ORDER', 'BY', orderby.map(alterArgsToSQL).join(', ')].join(' ') : ''})`].filter(_util.hasVal).join(''), alterExprToSQL(expr)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function alterSequenceToSQL(stmt) {
+    const {
+      type,
+      keyword,
+      sequence,
+      if_exists,
+      expr = []
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    const sequenceName = (0, _tables.tablesToSQL)(sequence);
+    const exprList = expr.map(_create.createDefinitionToSQL);
+    const result = [action, (0, _util.toUpper)(keyword), (0, _util.toUpper)(if_exists), sequenceName, exprList.join(', ')];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function alterToSQL(stmt) {
+    const {
+      keyword = 'table'
+    } = stmt;
+    switch (keyword) {
+      case 'aggregate':
+        return alterAggregateToSQL(stmt);
+      case 'table':
+        return alterTableToSQL(stmt);
+      case 'schema':
+        return alterSchemaToSQL(stmt);
+      case 'sequence':
+        return alterSequenceToSQL(stmt);
+      case 'domain':
+      case 'type':
+        return alterDomainTypeToSQL(stmt);
+      case 'function':
+        return alterFunctionToSQL(stmt);
+      case 'view':
+        return alterViewToSQL(stmt);
+    }
+  }
+});

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

@@ -0,0 +1,40 @@
+(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.analyze = 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.analyzeToSQL = analyzeToSQL;
+  _exports.attachToSQL = attachToSQL;
+  function analyzeToSQL(stmt) {
+    const {
+      type,
+      table
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    const tableName = (0, _tables.tableToSQL)(table);
+    return [action, tableName].join(' ');
+  }
+  function attachToSQL(stmt) {
+    const {
+      type,
+      database,
+      expr,
+      as,
+      schema
+    } = stmt;
+    return [(0, _util.toUpper)(type), (0, _util.toUpper)(database), (0, _expr.exprToSQL)(expr), (0, _util.toUpper)(as), (0, _util.identifierToSql)(schema)].filter(_util.hasVal).join(' ');
+  }
+});

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

@@ -0,0 +1,60 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./column", "./expr", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./column"), require("./expr"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.column, global.expr, global.util);
+    global.arrayStruct = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _column, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.arrayStructExprToSQL = arrayStructExprToSQL;
+  _exports.arrayStructValueToSQL = arrayStructValueToSQL;
+  function arrayExprListToSQL(expr) {
+    const {
+      array_path: arrayPath,
+      brackets,
+      expr_list: exprList,
+      parentheses
+    } = expr;
+    if (!exprList) return `[${(0, _column.columnsToSQL)(arrayPath)}]`;
+    const result = Array.isArray(exprList) ? exprList.map(col => `(${(0, _column.columnsToSQL)(col)})`).filter(_util.hasVal).join(', ') : (0, _expr.exprToSQL)(exprList);
+    if (brackets) return `[${result}]`;
+    return parentheses ? `(${result})` : result;
+  }
+  function arrayStructValueToSQL(expr) {
+    const {
+      expr_list: exprList,
+      type
+    } = expr;
+    switch ((0, _util.toUpper)(type)) {
+      case 'STRUCT':
+        return `(${(0, _column.columnsToSQL)(exprList)})`;
+      case 'ARRAY':
+        return arrayExprListToSQL(expr);
+      default:
+        return '';
+    }
+  }
+  function arrayStructExprToSQL(expr) {
+    const {
+      definition,
+      keyword
+    } = expr;
+    const result = [(0, _util.toUpper)(keyword)];
+    if (definition && typeof definition === 'object') {
+      result.length = 0;
+      result.push((0, _util.arrayStructTypeToSQL)(definition));
+    }
+    result.push(arrayStructValueToSQL(expr));
+    return result.filter(_util.hasVal).join('');
+  }
+});

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

@@ -0,0 +1,33 @@
+(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.assign = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.assignToSQL = assignToSQL;
+  function assignToSQL(expr) {
+    /** @type {Object} */
+    const {
+      left,
+      right,
+      symbol,
+      keyword
+    } = expr;
+    left.keyword = keyword;
+    const leftVar = (0, _expr.exprToSQL)(left);
+    const rightVal = (0, _expr.exprToSQL)(right);
+    return [leftVar, (0, _util.toUpper)(symbol), rightVal].filter(_util.hasVal).join(' ');
+  }
+});

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

@@ -0,0 +1,48 @@
+(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.binary = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.binaryToSQL = binaryToSQL;
+  function binaryToSQL(expr) {
+    let operator = expr.operator || expr.op;
+    let rstr = (0, _expr.exprToSQL)(expr.right);
+    let isBetween = false;
+    if (Array.isArray(rstr)) {
+      switch (operator) {
+        case '=':
+          operator = 'IN';
+          break;
+        case '!=':
+          operator = 'NOT IN';
+          break;
+        case 'BETWEEN':
+        case 'NOT BETWEEN':
+          isBetween = true;
+          rstr = `${rstr[0]} AND ${rstr[1]}`;
+          break;
+        default:
+          break;
+      }
+      if (!isBetween) rstr = `(${rstr.join(', ')})`;
+    }
+    const escape = expr.right.escape || {};
+    const leftPart = Array.isArray(expr.left) ? expr.left.map(_expr.exprToSQL).join(', ') : (0, _expr.exprToSQL)(expr.left);
+    const str = [leftPart, operator, rstr, (0, _util.toUpper)(escape.type), (0, _expr.exprToSQL)(escape.value)].filter(_util.hasVal).join(' ');
+    const result = [expr.parentheses ? `(${str})` : str];
+    return result.join(' ');
+  }
+});

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

@@ -0,0 +1,39 @@
+(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._case = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.caseToSQL = caseToSQL;
+  function caseToSQL(expr) {
+    const res = ['CASE'];
+    const {
+      args: conditions,
+      expr: exprItem,
+      parentheses
+    } = expr;
+    if (exprItem) res.push((0, _expr.exprToSQL)(exprItem));
+    for (let i = 0, len = conditions.length; i < len; ++i) {
+      res.push(conditions[i].type.toUpperCase());
+      if (conditions[i].cond) {
+        res.push((0, _expr.exprToSQL)(conditions[i].cond));
+        res.push('THEN');
+      }
+      res.push((0, _expr.exprToSQL)(conditions[i].result));
+    }
+    res.push('END');
+    return parentheses ? `(${res.join(' ')})` : res.join(' ');
+  }
+});

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

@@ -0,0 +1,37 @@
+(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.collate = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.collateToSQL = collateToSQL;
+  function collateToSQL(stmt) {
+    if (!stmt) return;
+    const {
+      keyword,
+      collate: {
+        name,
+        symbol,
+        value
+      }
+    } = stmt;
+    const result = [(0, _util.toUpper)(keyword)];
+    if (!value) result.push(symbol);
+    result.push(Array.isArray(name) ? name.map(_util.literalToSQL).join('.') : (0, _util.literalToSQL)(name));
+    if (value) result.push(symbol);
+    result.push((0, _expr.exprToSQL)(value));
+    return result.filter(_util.hasVal).join(' ');
+  }
+});