@nocobase/plugin-collection-fdw 2.0.3

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

@@ -0,0 +1,39 @@
+(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);
+    const fnName = expr.name;
+    const overStr = (0, _over.overToSQL)(over);
+    const separator = ' ';
+    if (args.distinct) str = ['DISTINCT', str].join(separator);
+    if (args.orderby) str = `${str} ${(0, _expr.orderOrPartitionByToSQL)(args.orderby, 'order by')}`;
+    if (args.separator) 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,174 @@
+(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 alterExprToSQL(expr) {
+    if (!expr) return '';
+    const {
+      action,
+      create_definitions: createDefinition,
+      first_after: firstAfter,
+      if_not_exists: ifNotExists,
+      keyword,
+      old_column: oldColumn,
+      prefix,
+      resource,
+      symbol
+    } = 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 '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), oldColumn && (0, _column.columnRefToSQL)(oldColumn), (0, _util.toUpper)(prefix), name && name.trim(), dataType.filter(_util.hasVal).join(' '), firstAfter && `${(0, _util.toUpper)(firstAfter.keyword)} ${(0, _column.columnRefToSQL)(firstAfter.column)}`];
+    return alterArray.filter(_util.hasVal).join(' ');
+  }
+  function alterTableToSQL(stmt) {
+    const {
+      type,
+      table,
+      expr = []
+    } = stmt;
+    const action = (0, _util.toUpper)(type);
+    const tableName = (0, _tables.tablesToSQL)(table);
+    const exprList = expr.map(_expr.exprToSQL);
+    const result = [action, 'TABLE', 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 alterToSQL(stmt) {
+    const {
+      keyword = 'table'
+    } = stmt;
+    switch (keyword) {
+      case 'aggregate':
+        return alterAggregateToSQL(stmt);
+      case 'table':
+        return alterTableToSQL(stmt);
+      case 'schema':
+        return alterSchemaToSQL(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"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./expr"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.expr);
+    global.assign = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _expr) {
+  "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} ${symbol} ${rightVal}`;
+  }
+});

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

@@ -0,0 +1,46 @@
+(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 str = [(0, _expr.exprToSQL)(expr.left), operator, rstr, (0, _util.toUpper)(escape.type), (0, _expr.exprToSQL)(escape.value)].filter(_util.hasVal).join(' ');
+    return expr.parentheses ? `(${str})` : str;
+  }
+});

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/column.js

@@ -0,0 +1,221 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "./constrain", "./expr", "./func", "./tables", "./util"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("./constrain"), require("./expr"), require("./func"), require("./tables"), require("./util"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.constrain, global.expr, global.func, global.tables, global.util);
+    global.column = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _constrain, _expr, _func, _tables, _util) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.columnDataType = columnDataType;
+  _exports.columnDefinitionToSQL = columnDefinitionToSQL;
+  _exports.columnOrderToSQL = columnOrderToSQL;
+  _exports.columnRefToSQL = columnRefToSQL;
+  _exports.columnReferenceDefinitionToSQL = columnReferenceDefinitionToSQL;
+  _exports.columnToSQL = columnToSQL;
+  _exports.columnsToSQL = columnsToSQL;
+  _exports.fullTextSearchToSQL = fullTextSearchToSQL;
+  function columnOffsetToSQL(column, isDual) {
+    if (typeof column === 'string') return (0, _util.identifierToSql)(column, isDual);
+    const {
+      expr,
+      offset,
+      suffix
+    } = column;
+    const offsetExpr = offset && offset.map(offsetItem => ['[', offsetItem.name, `${offsetItem.name ? '(' : ''}`, (0, _util.literalToSQL)(offsetItem.value), `${offsetItem.name ? ')' : ''}`, ']'].filter(_util.hasVal).join('')).join('');
+    return [(0, _expr.exprToSQL)(expr), offsetExpr, suffix].filter(_util.hasVal).join('');
+  }
+  function columnRefToSQL(expr) {
+    const {
+      array_index,
+      arrows = [],
+      as,
+      collate,
+      column,
+      db,
+      isDual,
+      schema,
+      table,
+      parentheses,
+      properties,
+      suffix,
+      order_by,
+      subFields = []
+    } = expr;
+    let str = column === '*' ? '*' : columnOffsetToSQL(column, isDual);
+    const prefix = [schema, db, table].filter(_util.hasVal).map(val => `${(0, _util.identifierToSql)(val)}`).join('.');
+    if (prefix) str = `${prefix}.${str}`;
+    if (array_index) {
+      str = `${str}[${(0, _util.literalToSQL)(array_index.index)}]`;
+      if (array_index.property) str = `${str}.${(0, _util.literalToSQL)(array_index.property)}`;
+    }
+    str = [str, ...subFields].join('.');
+    const result = [str, (0, _util.commonOptionConnector)('AS', _expr.exprToSQL, as), arrows.map((arrow, index) => (0, _util.commonOptionConnector)(arrow, _util.literalToSQL, properties[index])).join(' ')];
+    if (collate) result.push((0, _util.commonTypeValue)(collate).join(' '));
+    result.push((0, _util.toUpper)(suffix));
+    result.push((0, _util.toUpper)(order_by));
+    const sql = result.filter(_util.hasVal).join(' ');
+    return parentheses ? `(${sql})` : sql;
+  }
+  function columnDataType(definition) {
+    const {
+      dataType,
+      length,
+      suffix,
+      scale,
+      expr
+    } = definition || {};
+    let result = dataType;
+    if (length != null) result += `(${[length, scale].filter(val => val != null).join(', ')})`;
+    if (suffix && suffix.length) result += ` ${suffix.join(' ')}`;
+    if (expr) result += (0, _expr.exprToSQL)(expr);
+    return result;
+  }
+  function columnReferenceDefinitionToSQL(referenceDefinition) {
+    const reference = [];
+    if (!referenceDefinition) return reference;
+    const {
+      definition,
+      keyword,
+      match,
+      table,
+      on_action: onAction
+    } = referenceDefinition;
+    reference.push((0, _util.toUpper)(keyword));
+    reference.push((0, _tables.tablesToSQL)(table));
+    reference.push(definition && `(${definition.map(col => (0, _expr.exprToSQL)(col)).join(', ')})`);
+    reference.push((0, _util.toUpper)(match));
+    onAction.map(onRef => reference.push((0, _util.toUpper)(onRef.type), (0, _expr.exprToSQL)(onRef.value)));
+    return reference.filter(_util.hasVal);
+  }
+  function columnOption(definition) {
+    const columnOpt = [];
+    const {
+      nullable,
+      character_set: characterSet,
+      check,
+      comment,
+      collate,
+      storage,
+      default_val: defaultOpt,
+      auto_increment: autoIncrement,
+      unique: uniqueKey,
+      primary_key: primaryKey,
+      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));
+    }
+    const {
+      database
+    } = (0, _util.getParserOpt)();
+    columnOpt.push((0, _constrain.constraintDefinitionToSQL)(check));
+    columnOpt.push((0, _util.autoIncrementToSQL)(autoIncrement), (0, _util.toUpper)(primaryKey), (0, _util.toUpper)(uniqueKey), (0, _util.commentToSQL)(comment));
+    columnOpt.push(...(0, _util.commonTypeValue)(characterSet));
+    if (database !== 'sqlite') 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 columnOrderToSQL(columnOrder) {
+    const {
+      column,
+      collate,
+      nulls,
+      opclass,
+      order_by
+    } = columnOrder;
+    const result = [(0, _expr.exprToSQL)(typeof column === 'string' ? {
+      type: 'column_ref',
+      table: columnOrder.table,
+      column
+    } : columnOrder), (0, _util.commonOptionConnector)(collate && collate.type, _util.identifierToSql, collate && collate.value), opclass, (0, _util.toUpper)(order_by), (0, _util.toUpper)(nulls)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function generatedExpressionToSQL(generated) {
+    if (!generated) return;
+    const result = [(0, _util.toUpper)(generated.value), `(${(0, _expr.exprToSQL)(generated.expr)})`, (0, _util.toUpper)(generated.storage_type)];
+    return result.filter(_util.hasVal).join(' ');
+  }
+  function columnDefinitionToSQL(columnDefinition) {
+    const column = [];
+    const name = columnRefToSQL(columnDefinition.column);
+    const dataType = columnDataType(columnDefinition.definition);
+    column.push(name);
+    column.push(dataType);
+    const columnOpt = columnOption(columnDefinition);
+    column.push(columnOpt);
+    const generated = generatedExpressionToSQL(columnDefinition.generated);
+    column.push(generated);
+    return column.filter(_util.hasVal).join(' ');
+  }
+  function asToSQL(asStr) {
+    if (!asStr) return '';
+    return ['AS', /^(`?)[a-z_][0-9a-z_]*(`?)$/i.test(asStr) ? (0, _util.identifierToSql)(asStr) : (0, _util.columnIdentifierToSql)(asStr)].join(' ');
+  }
+  function fullTextSearchToSQL(expr) {
+    const {
+      against,
+      as,
+      columns,
+      match,
+      mode
+    } = expr;
+    const matchExpr = [(0, _util.toUpper)(match), `(${columns.map(col => columnRefToSQL(col)).join(', ')})`].join(' ');
+    const againstExpr = [(0, _util.toUpper)(against), ['(', (0, _expr.exprToSQL)(expr.expr), mode && ` ${(0, _util.literalToSQL)(mode)}`, ')'].filter(_util.hasVal).join('')].join(' ');
+    return [matchExpr, againstExpr, asToSQL(as)].filter(_util.hasVal).join(' ');
+  }
+  function columnToSQL(column, isDual) {
+    const {
+      expr,
+      type
+    } = column;
+    if (type === 'cast') return (0, _func.castToSQL)(column);
+    if (isDual) expr.isDual = isDual;
+    let str = (0, _expr.exprToSQL)(expr);
+    const {
+      expr_list: exprList
+    } = column;
+    if (exprList) {
+      const result = [str];
+      const columnsStr = exprList.map(col => columnToSQL(col, isDual)).join(', ');
+      result.push([(0, _util.toUpper)(type), type && '(', columnsStr, type && ')'].filter(_util.hasVal).join(''));
+      return result.filter(_util.hasVal).join(' ');
+    }
+    if (expr.parentheses && Reflect.has(expr, 'array_index')) str = `(${str})`;
+    if (expr.array_index && expr.type !== 'column_ref') str = `${str}[${(0, _util.literalToSQL)(expr.array_index.index)}]`;
+    return [str, asToSQL(column.as)].filter(_util.hasVal).join(' ');
+  }
+  function getDual(tables) {
+    const baseTable = Array.isArray(tables) && tables[0];
+    if (baseTable && baseTable.type === 'dual') return true;
+    return false;
+  }
+  /**
+   * Stringify column expressions
+   *
+   * @param {Array} columns
+   * @return {string}
+   */
+  function columnsToSQL(columns, tables) {
+    if (!columns || columns === '*') return columns;
+    const isDual = getDual(tables);
+    return columns.map(col => columnToSQL(col, isDual)).join(', ');
+  }
+});