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 ''

switch (target.array) {

case 'one':

return '[]'

case 'two':

return '[][]'

}

const { arrows = [], collate, target, expr: expression, keyword, symbol, as: alias, properties = [] } = expr

const { 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 (dataTypeSuffix && dataTypeSuffix.length) str += ` ${dataTypeSuffix.join(' ')}`

let prefix = exprToSQL(expression)

let symbolChar = '::'

let suffix = ''

if (symbol === 'as') {

prefix = `${toUpper(keyword)}(${prefix}`

suffix = ')'

symbolChar = ` ${symbol.toUpperCase()} `

}

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

if (alias) suffix += ` AS ${identifierToSql(alias)}`

if (collate) suffix += ` ${commonTypeValue(collate).join(' ')}`

const arrayDimension = arrayDimensionToSymbol(target)

const result = [prefix, symbolChar, quoted, dataType, quoted, arrayDimension, str, suffix]

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

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 { 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})`

const { args, name, args_parentheses, parentheses, over, collate, suffix } = expr

const collateStr = commonTypeValue(collate).join(' ')

const overStr = overToSQL(over)

const suffixStr = exprToSQL(suffix)

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

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

let separator = expr.separator || ', '

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

let str = [funcName]

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

str.push(exprToSQL(args).join(separator))

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

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

return [parentheses ? `(${str})` : str, collateStr, 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(' ')