if (typeof column === 'string') return identifierToSql(column, isDual)

const { expr, offset, suffix } = column

return [exprToSQL(expr), offset, suffix].filter(hasVal).join('')

const {

array_index, arrows = [], as, collate, column, isDual, schema, table, parentheses, properties,

suffix, order_by,

} = expr

let str = column === '*' ? '*' : columnOffsetToSQL(column, isDual)

if (table) str = `${identifierToSql(table)}.${str}`

if (schema) str = `${identifierToSql(schema)}.${str}`

if (array_index) {

str = `${str}[${array_index.number}]`

if (array_index.property) str = `${str}.${array_index.property.value}`

}

const result = [

str,

commonOptionConnector('AS', exprToSQL, as),

arrows.map((arrow, index) => commonOptionConnector(arrow, literalToSQL, properties[index])).join(' '),

]

if (collate) result.push(commonTypeValue(collate).join(' '))

result.push(toUpper(suffix))

result.push(toUpper(order_by))

const sql = result.filter(hasVal).join(' ')

return parentheses ? `(${sql})` : sql

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 += exprToSQL(expr)

return result

const reference = []

if (!referenceDefinition) return reference

const {

definition,

keyword,

match,

table,

on_delete: onDelete,

on_update: onUpdate,

} = referenceDefinition

reference.push(toUpper(keyword))

reference.push(tablesToSQL(table))

reference.push(definition && `(${definition.map(col => exprToSQL(col)).join(', ')})`)

reference.push(toUpper(match))

reference.push(...commonTypeValue(onDelete))

reference.push(...commonTypeValue(onUpdate))

return reference.filter(hasVal)

const columnOpt = []

const {

nullable, character_set: characterSet, check, comment, collate, storage,

default_val: defaultOpt,

auto_increment: autoIncrement,

unique_or_primary: uniquePrimary,

column_format: columnFormat,

reference_definition: referenceDefinition,

} = definition

columnOpt.push(toUpper(nullable && nullable.value))

if (defaultOpt) {

const { type, value } = defaultOpt

columnOpt.push(type.toUpperCase(), exprToSQL(value))

}

columnOpt.push(constraintDefinitionToSQL(check))

columnOpt.push(autoIncreatementToSQL(autoIncrement), toUpper(uniquePrimary), commentToSQL(comment))

columnOpt.push(...commonTypeValue(characterSet))

columnOpt.push(...commonTypeValue(collate))

columnOpt.push(...commonTypeValue(columnFormat))

columnOpt.push(...commonTypeValue(storage))

columnOpt.push(...columnReferenceDefinitionToSQL(referenceDefinition))

return columnOpt.filter(hasVal).join(' ')

const { column, collate, nulls, opclass, order } = columnOrder

const result = [

exprToSQL(column),

commonOptionConnector(collate && collate.type, identifierToSql, collate && collate.value),

opclass,

toUpper(order),

toUpper(nulls),

]

return result.filter(hasVal).join(' ')

if (!generated) return

const result = [toUpper(generated.value), `(${exprToSQL(generated.expr)})`, toUpper(generated.storage_type)]

return result.filter(hasVal).join(' ')

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(hasVal).join(' ')

const { against, as, columns, match, mode } = expr

const matchExpr = [toUpper(match), `(${columns.map(col => columnRefToSQL(col)).join(', ')})`].join(' ')

const againstExpr = [toUpper(against), ['(', exprToSQL(expr.expr), mode && ` ${literalToSQL(mode)}`, ')'].filter(hasVal).join('')].join(' ')

return [matchExpr, againstExpr, asToSQL(as)].filter(hasVal).join(' ')

const { expr, type } = column

if (type === 'cast') return castToSQL(column)

if (isDual) expr.isDual = isDual

let str = exprToSQL(expr)

if (expr.parentheses && Reflect.has(expr, 'array_index')) str = `(${str})`

if (expr.array_index && expr.type !== 'column_ref') str = `${str}[${expr.array_index.number}]`

return [str, asToSQL(column.as)].filter(hasVal).join(' ')

const baseTable = Array.isArray(tables) && tables[0]

if (baseTable && baseTable.type === 'dual') return true

return false

if (!columns || columns === '*') return columns

const isDual = getDual(tables)

const result = []

const { expr_list: exprList, star, type } = columns

result.push(star, toUpper(type))

const exprListArr = exprList || columns

const columnsStr = exprListArr.map(col => columnToSQL(col, isDual)).join(', ')

result.push([type && '(', columnsStr, type && ')'].filter(hasVal).join(''))

return result.filter(hasVal).join(' ')