const { args, type, over } = stmt

const { expr, having } = args

let sql = `${toUpper(type)}(${exprToSQL(expr)}`

if (having) sql = `${sql} HAVING ${toUpper(having.prefix)} ${exprToSQL(having.expr)}`

sql = `${sql})`

const overStr = overToSQL(over)

return [sql, overStr].filter(hasVal).join(' ')

if (!target || !target.array) return ''

const { keyword } = target.array

if (keyword) return toUpper(keyword)

const { dimension, length } = target.array

const result = []

for (let i = 0; i < dimension; i++) {

result.push('[')

if (length && length[i]) result.push(literalToSQL(length[i]))

result.push(']')

}

return result.join('')

const { target: targets, expr: expression, keyword, symbol, as: alias, offset, parentheses: outParentheses } = expr

let prefix = 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 ? 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(literalToSQL).join(' ')}`

let symbolChar = '::'

let suffix = ''

const targetResult = []

if (symbol === 'as') {

if (i === 0) prefix = `${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(hasVal).join(''))

}

if (alias) result.push(` AS ${identifierToSql(alias)}`)

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

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

const { args, type } = stmt

const { field, cast_type: castType, source } = args

const result = [`${toUpper(type)}(${toUpper(field)}`, 'FROM', toUpper(castType), exprToSQL(source)]

return `${result.filter(hasVal).join(' ')})`

if (!arg) return ''

const { type, symbol, value } = arg

const result = [toUpper(type), symbol, exprToSQL(value)]

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

const { expr } = argExpr

const { key, value, on } = expr

const result = [exprToSQL(key), 'VALUE', exprToSQL(value)]

if (on) result.push('ON', 'NULL', exprToSQL(on))

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

const { args, type } = stmt

const keys = ['input', 'path', 'outer', 'recursive', 'mode']

const argsStr = keys.map(key => flattenArgToSQL(args[key])).filter(hasVal).join(', ')

return `${toUpper(type)}(${argsStr})`

if (!stmt) return ''

const { type, keyword, orderby } = stmt

return [toUpper(type), toUpper(keyword), `(${orderOrPartitionByToSQL(orderby, 'order by')})`].filter(hasVal).join(' ')

const { args, array_index, name, args_parentheses, parentheses, within_group: withinGroup, over, suffix } = expr

const overStr = overToSQL(over)

const withinGroupStr = withinGroupToSQL(withinGroup)

const suffixStr = exprToSQL(suffix)

const funcName = [literalToSQL(name.schema), name.name.map(literalToSQL).join('.')].filter(hasVal).join('.')

if (!args) return [funcName, withinGroupStr, overStr].filter(hasVal).join(' ')

let separator = expr.separator || ', '

if (toUpper(funcName) === 'TRIM') separator = ' '

let str = [funcName]

str.push(args_parentheses === false ? ' ' : '(')

const argsList = 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(` ${exprToSQL(separator[i - 1])} `)

}

str.push(argsSQL)

} else {

str.push(argsList.join(separator))

}

if (args_parentheses !== false) str.push(')')

str.push(arrayIndexToSQL(array_index))

str = [str.join(''), suffixStr].filter(hasVal).join(' ')

return [parentheses ? `(${str})` : str, withinGroupStr, overStr].filter(hasVal).join(' ')

const { as, name, args } = expr

const funcName = [literalToSQL(name.schema), name.name.map(literalToSQL).join('.')].filter(hasVal).join('.')

const result = [`${funcName}(${exprToSQL(args).join(', ')})`, 'AS', funcToSQL(as)]

return result.join(' ')

const { args, expr } = stmt

const { value, parentheses } = args

const argsList = value.map(exprToSQL).join(', ')

return [parentheses ? `(${argsList})` : argsList, '->', exprToSQL(expr)].join(' ')