package gudusoft.gsqlparser.resolver2.namespace;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EExpressionType;
import gudusoft.gsqlparser.ETableSource;
import gudusoft.gsqlparser.nodes.TExpression;
import gudusoft.gsqlparser.nodes.TExpressionList;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TLateralView;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TObjectNameList;
import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.nodes.TUnnestClause;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TFunctoinColumn;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLFunction;
import gudusoft.gsqlparser.stmt.TCreateFunctionStmt;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * The columns of a FROM item that a call generates (a built-in table function, {@code UNNEST}, a Hive-family
 * {@code LATERAL VIEW}), and which of the call's arguments each one is computed from. One rule for every consumer:
 * {@link TableNamespace} takes a function's column names from it, and {@code TTable.getLateralColumnNames()} and its
 * siblings publish the whole layout to the SQL-LR producer (plan 09 slice 11).
 *
 * <p>A column's inputs are the indexes, in {@link #getArguments()}, of the arguments whose values make its value
 * ({@code "0,1"}); the empty string says the column is computed over the rows the call generates and has no value of
 * an argument in it (an ordinal: {@code WITH ORDINALITY}, {@code WITH OFFSET}, FLATTEN's {@code SEQ} and
 * {@code INDEX}, {@code posexplode}'s position). {@link #getRowInputs()} lists the arguments whose values decide how
 * many rows the call generates. An argument that is in neither (a FLATTEN option) feeds nothing: the layout never says
 * "every argument flows into every column".</p>
 *
 * <p>A call whose columns the vendor fixes has a layout: an unqualified built-in of the vendor
 * ({@code myschema.flatten(...)} is a user function that shares the name). So does a user table function the catalog
 * declares before the call ({@link #declaredColumns}, recorded on the call by {@link #recordDeclared}): its names only,
 * which arguments make them and decide its rows being its body's. Any other function, a call with a shape the rule
 * below does not settle (STRING_SPLIT with a non-constant {@code enable_ordinal}), has none. A call
 * whose rows are settled but not its columns (an {@code UNNEST} of several arrays without a column list naming one
 * column per array) has a layout without names: its rows still come from its arrays.</p>
 *
 * @since 4.2.17
 */
public final class TableFunctionLayout {

    /** The inputs of a column computed over the generated rows (an ordinal), with no argument value in it. */
    public static final String OVER_ROWS = "";

    private final List<String> names;
    private final List<String> inputs;
    private final String rowInputs;
    private final boolean closed;
    private final List<TParseTreeNode> arguments;

    private TableFunctionLayout(List<String> names, List<String> inputs, String rowInputs, boolean closed,
            List<? extends TParseTreeNode> arguments) {
        this.names = names == null ? null : Collections.unmodifiableList(names);
        this.inputs = inputs == null ? null : Collections.unmodifiableList(inputs);
        this.rowInputs = rowInputs;
        this.closed = closed;
        this.arguments = Collections.unmodifiableList(new ArrayList<TParseTreeNode>(arguments));
    }

    /**
     * The column names, in order; an element is null for a column the vendor leaves without a name a query can use
     * (BigQuery's element of an unaliased {@code UNNEST}). Null when only the rows are settled (an {@code UNNEST} of
     * several arrays without a column list for each): the call then has no column this rule names.
     */
    public List<String> getNames() {
        return names;
    }

    /**
     * Per column, the arguments whose values make it ({@code "0,1"}), or {@link #OVER_ROWS}; null when the names are
     * settled but the arguments are not (a FLATTEN call whose arguments the rule does not read).
     */
    public List<String> getInputs() {
        return inputs;
    }

    /** The arguments whose values decide the generated rows ({@code "0,1"}; empty when none). */
    public String getRowInputs() {
        return rowInputs;
    }

    /**
     * Whether the columns listed are all the call's columns: false when the element type of an array is not known
     * (an {@code UNNEST} of a column may hold a STRUCT or ROW whose fields are columns of their own).
     */
    public boolean isClosed() {
        return closed;
    }

    /**
     * The arguments, in order: the call's own expressions, or the arrays of an {@code UNNEST} (an expression, or the
     * column name of BigQuery's and Presto's {@code UNNEST(t.arr)}).
     */
    public List<TParseTreeNode> getArguments() {
        return arguments;
    }

    /**
     * The layout of a FROM item, or null when the item is not a call whose columns or rows this rule settles. A layout
     * whose {@link #getNames()} is null settles the rows only.
     */
    public static TableFunctionLayout of(TTable table) {
        if (table == null) {
            return null;
        }
        ETableSource type = table.getTableType();
        if (type == ETableSource.function) {
            return function(table);
        }
        if (type == ETableSource.unnest) {
            return unnest(table);
        }
        if (type == ETableSource.lateralView) {
            return lateralView(table);
        }
        return null;
    }

    /**
     * The names of a table function's columns before an alias column list renames them, or null when the function
     * has no fixed columns: the names {@link TableNamespace} registers.
     */
    static String[] builtinNames(TTable table) {
        TableFunctionLayout layout = table == null || table.getTableType() != ETableSource.function ? null
                : function(table, false);
        return layout == null || layout.names == null ? null : layout.names.toArray(new String[0]);
    }

    // ---------------------------------------------------------------------------------------------
    // Table functions
    // ---------------------------------------------------------------------------------------------

    /** SQL Server STRING_SPLIT; {@code ordinal} only when enable_ordinal is the constant 1 (SQL Server 2022+). */
    private static final String[] STRING_SPLIT = {"value", "ordinal"};
    /** Snowflake FLATTEN: https://docs.snowflake.com/en/sql-reference/functions/flatten */
    private static final String[] FLATTEN = {"SEQ", "KEY", "PATH", "INDEX", "VALUE", "THIS"};
    /** FLATTEN's arguments in their positional order. */
    private static final String[] FLATTEN_ARGUMENTS = {"INPUT", "PATH", "OUTER", "RECURSIVE", "MODE"};
    /** Snowflake SPLIT_TO_TABLE: https://docs.snowflake.com/en/sql-reference/functions/split_to_table */
    private static final String[] SPLIT_TO_TABLE = {"SEQ", "INDEX", "VALUE"};

    private static TableFunctionLayout function(TTable table) {
        return function(table, true);
    }

    // ---------------------------------------------------------------------------------------------
    // User table functions declared in the input or the catalog
    // ---------------------------------------------------------------------------------------------

    /**
     * The columns a CREATE FUNCTION declares its table result to have, in order: a {@code RETURNS TABLE (c ...)} or
     * {@code RETURNS @t TABLE (c ...)} column list, else the output names of its query (SQL Server's inline
     * {@code RETURN (SELECT ...)}, BigQuery's {@code CREATE TABLE FUNCTION ... AS SELECT ...}); null when it declares
     * no table result or a column has no name (a wildcard, an expression without an alias). Registered with the
     * function in the catalog; a call of it in FROM has these columns ({@link #recordDeclared}).
     */
    public static List<String> declaredColumns(TCreateFunctionStmt function) {
        if (function == null) {
            return null;
        }
        List<String> names = new ArrayList<String>();
        if (function.getReturnTableDefinitions() != null && function.getReturnTableDefinitions().size() > 0) {
            for (int i = 0; i < function.getReturnTableDefinitions().size(); i++) {
                gudusoft.gsqlparser.nodes.TTableElement element = function.getReturnTableDefinitions().getTableElement(i);
                if (element != null && element.getColumnDefinition() != null
                        && element.getColumnDefinition().getColumnName() != null) {
                    names.add(element.getColumnDefinition().getColumnName().toString());
                }
            }
            return names.isEmpty() ? null : names;
        }
        if (postgresFamily(function.dbvendor) && function.getParameterDeclarations() != null) {
            // PostgreSQL: the OUT and INOUT parameters are the columns of the row the function returns (plan 09 slice
            // 13f), RETURNS SETOF RECORD included; one of a composite type returns that type's row (its attributes,
            // laid out from the return type: Codex 13f #3)
            int outputs = 0;
            boolean composite = false;
            for (int i = 0; i < function.getParameterDeclarations().size(); i++) {
                gudusoft.gsqlparser.nodes.TParameterDeclaration p =
                        function.getParameterDeclarations().getParameterDeclarationItem(i);
                gudusoft.gsqlparser.EParameterMode mode = p == null ? null : p.getParameterMode();
                if (mode == gudusoft.gsqlparser.EParameterMode.out || mode == gudusoft.gsqlparser.EParameterMode.inout) {
                    outputs++;
                    composite = p.getDataType() != null
                            && p.getDataType().getDataType() == gudusoft.gsqlparser.EDataType.generic_t;
                }
            }
            if (outputs == 1 && composite) {
                return null;
            }
            for (int i = 0; i < function.getParameterDeclarations().size(); i++) {
                gudusoft.gsqlparser.nodes.TParameterDeclaration p =
                        function.getParameterDeclarations().getParameterDeclarationItem(i);
                gudusoft.gsqlparser.EParameterMode mode = p == null ? null : p.getParameterMode();
                if (mode == gudusoft.gsqlparser.EParameterMode.out || mode == gudusoft.gsqlparser.EParameterMode.inout) {
                    if (p.getParameterName() == null) {
                        return null; // an unnamed OUT parameter's column is named by position: not settled here
                    }
                    names.add(p.getParameterName().toString());
                }
            }
            if (!names.isEmpty()) {
                return names;
            }
        }
        TSelectSqlStatement query = function.getSqlQuery();
        if (query == null && function.getReturnStmt() != null) {
            query = function.getReturnStmt().getSubquery() != null ? function.getReturnStmt().getSubquery()
                    : function.getReturnStmt().getReturnExpr() != null
                    ? function.getReturnStmt().getReturnExpr().getSubQuery() : null;
        }
        while (query != null && query.isCombinedQuery()) {
            query = query.getLeftStmt(); // a set operation's columns are named by its first query
        }
        if (query == null || query.getResultColumnList() == null || query.getResultColumnList().size() == 0) {
            return null;
        }
        for (int i = 0; i < query.getResultColumnList().size(); i++) {
            gudusoft.gsqlparser.nodes.TResultColumn column = query.getResultColumnList().getResultColumn(i);
            String name = null;
            if (column != null && column.getAliasClause() != null && column.getAliasClause().getAliasName() != null) {
                name = column.getAliasClause().getAliasName().toString();
            } else if (column != null && column.getExpr() != null
                    && column.getExpr().getExpressionType() == EExpressionType.simple_object_name_t
                    && column.getExpr().getObjectOperand() != null) {
                TObjectName ref = column.getExpr().getObjectOperand();
                name = ref.getPartToken() != null && ref.getPartToken().tokentype
                        == gudusoft.gsqlparser.ETokenType.ttasterisk ? null : ref.getColumnNameOnly();
            }
            if (name == null || name.isEmpty()) {
                return null; // a wildcard or an unnamed value: the declared columns are not settled
            }
            names.add(name);
        }
        return names;
    }

    /**
     * Records on a function call in FROM the columns the catalog declares for the function it calls (a CREATE FUNCTION
     * of the input registered before the call, or the catalog's metadata), so every consumer of the layout reads the
     * columns resolver2 resolved the call with; nothing for a built-in this rule lays out, or an unknown function.
     */
    public static void recordDeclared(TTable table, TSQLEnv env) {
        if (table == null || env == null || table.getTableType() != ETableSource.function
                || table.getDeclaredFunctionColumns() != null || function(table, false) != null) {
            return;
        }
        TFunctionCall call = unwrapTable(table.dbvendor, table.getFuncCall());
        if (call == null || call.getFunctionName() == null) {
            return;
        }
        TSQLFunction declared = env.searchFunction(call.getFunctionName());
        if (declared == null) {
            return;
        }
        List<String> names = new ArrayList<String>();
        if (declared.getColumnsInReturnTable() != null && !declared.getColumnsInReturnTable().isEmpty()) {
            for (TFunctoinColumn column : declared.getColumnsInReturnTable()) {
                names.add(column.getNameKeepCase() != null ? column.getNameKeepCase() : column.getName());
            }
        } else if (postgresFamily(table.dbvendor) && declared.getReturnType() != null) {
            names = rowTypeColumns(table, call, declared.getReturnType(), env);
        }
        if (names != null && !names.isEmpty()) {
            table.setDeclaredFunctionColumns(names);
        }
    }

    /**
     * The columns of a call of a PostgreSQL-family function by its return type (plan 09 slice 13f): a base type gives
     * one column, named after the call's alias when it has no column list, else after the function; the row type of a
     * table the catalog holds gives that table's columns. Null for any other type (record, a composite type).
     */
    private static List<String> rowTypeColumns(TTable table, TFunctionCall call,
            gudusoft.gsqlparser.nodes.TTypeName type, TSQLEnv env) {
        if (type.getDataType() != gudusoft.gsqlparser.EDataType.generic_t) {
            String alias = table.getAliasClause() != null && table.getAliasClause().getAliasName() != null
                    && table.getAliasClause().getColumns() == null
                    ? table.getAliasClause().getAliasName().toString() : null;
            return list(alias != null && !alias.isEmpty() ? alias : unqualified(call.getFunctionName()));
        }
        // the type's name parts (name [. name ...]), after SETOF
        List<gudusoft.gsqlparser.TSourceToken> parts = new ArrayList<gudusoft.gsqlparser.TSourceToken>();
        for (gudusoft.gsqlparser.TSourceToken t = type.getStartToken(); t != null; t = t.getNextTokenInChain()) {
            if (t.tokentype != gudusoft.gsqlparser.ETokenType.ttwhitespace
                    && t.tokentype != gudusoft.gsqlparser.ETokenType.ttreturn
                    && t.tokentype != gudusoft.gsqlparser.ETokenType.ttsimplecomment
                    && t.tokentype != gudusoft.gsqlparser.ETokenType.ttbracketedcomment
                    && !(parts.isEmpty() && "SETOF".equalsIgnoreCase(t.toString()))) { // non-identifier-compare: keyword
                parts.add(t);
            }
            if (t == type.getEndToken()) {
                break;
            }
        }
        TObjectName name = null;
        if (parts.size() == 1) {
            name = TObjectName.createObjectName(table.dbvendor, gudusoft.gsqlparser.EDbObjectType.table, parts.get(0));
        } else if (parts.size() == 3 && ".".equals(parts.get(1).toString())) {
            name = TObjectName.createObjectName(table.dbvendor, gudusoft.gsqlparser.EDbObjectType.table, parts.get(0),
                    parts.get(2));
        }
        gudusoft.gsqlparser.sqlenv.TSQLTable rowType = name == null ? null : env.searchTable(name);
        if (rowType == null || rowType.getColumnList() == null || rowType.getColumnList().isEmpty()) {
            return null;
        }
        List<String> out = new ArrayList<String>();
        for (gudusoft.gsqlparser.sqlenv.TSQLColumn column : rowType.getColumnList()) {
            out.add(column.getNameKeepCase() != null ? column.getNameKeepCase() : column.getName());
        }
        return out;
    }

    /** The layout of a call of a declared user function: its declared names, its inputs and rows not settled. */
    private static TableFunctionLayout declared(TTable table, TFunctionCall call, boolean renamed) {
        List<String> names = table.getDeclaredFunctionColumns();
        if (names == null || names.isEmpty() || call == null || withOrdinality(table)) {
            // WITH ORDINALITY adds a column after the declared ones, computed over the call's rows: not laid out here
            // (plan 09 phase C, Codex 13c #5), so a wildcard over the call is not expanded to the declared ones only
            return null;
        }
        // which arguments make a column, and which decide the rows, is the function body's (the call binding)
        return rename(table, new ArrayList<String>(names), null, null, true, arguments(call), renamed);
    }

    /**
     * @param renamed whether an alias column list renames the leading columns (false: the function's own names)
     */
    private static TableFunctionLayout function(TTable table, boolean renamed) {
        EDbVendor vendor = table.dbvendor;
        TFunctionCall call = table.getFuncCall();
        if (call == null || call.getFunctionName() == null) {
            return null;
        }
        if (vendor == EDbVendor.dbvsnowflake) {
            // Snowflake spells its table functions both as LATERAL f(...) and as TABLE(f(...))
            TFunctionCall inner = unwrapTable(vendor, call);
            String name = unqualified(inner.getFunctionName());
            if (same(vendor, name, "FLATTEN")) {
                return flatten(table, inner, renamed);
            }
            if (same(vendor, name, "SPLIT_TO_TABLE")) {
                List<TExpression> args = arguments(inner);
                if (args.size() != 2) {
                    return null;
                }
                return rename(table, list(SPLIT_TO_TABLE), list(OVER_ROWS, OVER_ROWS, "0,1"), "0,1", true, args,
                        renamed);
            }
            return declared(table, inner, renamed);
        }
        String name = unqualified(call.getFunctionName());
        if ((vendor == EDbVendor.dbvmssql || vendor == EDbVendor.dbvazuresql) && same(vendor, name, "STRING_SPLIT")) {
            List<TExpression> args = arguments(call);
            if (args.size() == 2) {
                return rename(table, list("value"), list("0,1"), "0,1", true, args, renamed);
            }
            if (args.size() == 3 && isConstant(args.get(2), "1")) {
                return rename(table, list(STRING_SPLIT), list("0,1", OVER_ROWS), "0,1", true, args, renamed);
            }
            if (args.size() == 3 && isConstant(args.get(2), "0")) {
                return rename(table, list("value"), list("0,1"), "0,1", true, args, renamed);
            }
            return null;
        }
        if (postgresFamily(vendor)) {
            if (same(vendor, name, "unnest")) {
                List<TExpression> args = arguments(call);
                // one array: its elements, one column; an array of a composite type has the type's columns instead,
                // so only an array literal of plain items proves the one column a wildcard expands to
                if (args.size() == 1) {
                    return scalarFunction(table, name, args, list("0"), isArrayLiteral(args.get(0)) ? "" : "0",
                            isScalarArrayLiteral(args.get(0)), renamed);
                }
                // several arrays, zipped: as many rows as the longest one has; which composite columns each array
                // contributes is not settled here, so only the rows are
                StringBuilder rows = new StringBuilder();
                for (int i = 0; i < args.size(); i++) {
                    if (!isArrayLiteral(args.get(i))) {
                        rows.append(rows.length() == 0 ? "" : ",").append(i);
                    }
                }
                return args.isEmpty() ? null : new TableFunctionLayout(null, null, rows.toString(), false, args);
            }
            if (same(vendor, name, "generate_series")) {
                List<TExpression> args = arguments(call);
                if (args.size() != 2 && args.size() != 3) {
                    return null;
                }
                // start + k * step, as many rows as fit up to stop
                return scalarFunction(table, name, args, list(args.size() == 3 ? "0,2" : "0"),
                        args.size() == 3 ? "0,1,2" : "0,1", true, renamed);
            }
        }
        return declared(table, call, renamed);
    }

    /** The PostgreSQL rule for a function of a base type: its one column (with ORDINALITY, two). */
    private static TableFunctionLayout scalarFunction(TTable table, String functionName, List<TExpression> args,
            List<String> inputs, String rows, boolean closed, boolean renamed) {
        // a function returning a base type names its one column after the function, or after the table alias when
        // there is one and no column alias list
        String alias = table.getAliasClause() != null && table.getAliasClause().getAliasName() != null
                ? table.getAliasClause().getAliasName().toString() : null;
        List<String> names = list(renamed && alias != null && !alias.isEmpty() ? alias : functionName);
        List<String> in = new ArrayList<String>(inputs);
        if (withOrdinality(table)) {
            names.add("ordinality");
            in.add(OVER_ROWS);
        }
        return rename(table, names, in, rows, closed, args, renamed);
    }

    private static TableFunctionLayout flatten(TTable table, TFunctionCall call, boolean renamed) {
        List<TExpression> args = arguments(call);
        int[] at = new int[FLATTEN_ARGUMENTS.length];
        java.util.Arrays.fill(at, -1);
        boolean named = false;
        for (int i = 0; i < args.size(); i++) {
            TExpression arg = call.getArgs().getExpression(i);
            if (arg != null && arg.getExpressionType() == EExpressionType.assignment_t && arg.getLeftOperand() != null) {
                named = true;
                String parameter = arg.getLeftOperand().toString();
                int k = -1;
                for (int j = 0; j < FLATTEN_ARGUMENTS.length; j++) {
                    if (FLATTEN_ARGUMENTS[j].equalsIgnoreCase(parameter)) { // non-identifier-compare: FLATTEN's keyword argument names
                        k = j;
                    }
                }
                if (k < 0 || at[k] >= 0) {
                    return rename(table, list(FLATTEN), null, null, true, args, renamed);
                }
                at[k] = i;
            } else if (named || i >= FLATTEN_ARGUMENTS.length) {
                // a positional argument after a named one: its columns are FLATTEN's, its arguments not settled
                return rename(table, list(FLATTEN), null, null, true, args, renamed);
            } else {
                at[i] = i;
            }
        }
        if (at[0] < 0) {
            return rename(table, list(FLATTEN), null, null, true, args, renamed);
        }
        String value = at[1] >= 0 ? at[0] + "," + at[1] : String.valueOf(at[0]);
        StringBuilder rows = new StringBuilder();
        for (int i = 0; i < args.size(); i++) {
            rows.append(i == 0 ? "" : ",").append(i);
        }
        // SEQ numbers the input record and INDEX the element: computed over the rows; KEY, PATH, VALUE and THIS are
        // parts of the input at the path
        return rename(table, list(FLATTEN), list(OVER_ROWS, value, value, OVER_ROWS, value, value), rows.toString(),
                true, args, renamed);
    }

    // ---------------------------------------------------------------------------------------------
    // UNNEST
    // ---------------------------------------------------------------------------------------------

    /**
     * {@code UNNEST(a1, ...) [WITH ORDINALITY | WITH OFFSET [AS o]] [AS u [(c1, ...)]]}: the elements of each array,
     * and the ordinal. A column alias list names the columns in order; with one array every column is made from it
     * (an element of a ROW or STRUCT type is one column per field), with several arrays the list must name one column
     * per array. Without a list, BigQuery's element is named by the alias (and is a value a query cannot name without
     * one); its WITH OFFSET column is named by its own alias, else {@code offset}.
     */
    private static TableFunctionLayout unnest(TTable table) {
        TUnnestClause clause = table.getUnnestClause();
        if (clause == null) {
            return null;
        }
        List<TParseTreeNode> arrays = unnestArrays(clause);
        if (arrays.isEmpty()) {
            return null;
        }
        // an array literal ([1, 2], ARRAY[a, b]) generates one row per item, whatever their values: its rows have no
        // argument input; an array value (a column, a function's result) decides its rows (with several arrays, the
        // longest one: every array that is not a literal)
        StringBuilder rows = new StringBuilder();
        for (int i = 0; i < arrays.size(); i++) {
            if (!(arrays.get(i) instanceof TExpression && isArrayLiteral((TExpression) arrays.get(i)))) {
                rows.append(rows.length() == 0 ? "" : ",").append(i);
            }
        }
        String rowInputs = rows.toString();
        boolean ordinality = clause.isWithOrdinality();
        TObjectNameList aliasColumns = table.getAliasClause() != null ? table.getAliasClause().getColumns() : null;
        List<String> names = new ArrayList<String>();
        List<String> inputs = new ArrayList<String>();
        List<TParseTreeNode> arguments = new ArrayList<TParseTreeNode>(arrays);
        if (aliasColumns != null && aliasColumns.size() > 0) {
            int elements = aliasColumns.size() - (ordinality ? 1 : 0);
            if (elements < 1 || (arrays.size() > 1 && elements != arrays.size())) {
                // which array a column comes from is not settled; the rows still come from the arrays
                return new TableFunctionLayout(null, null, rowInputs, false, arrays);
            }
            // one array whose element is several columns (a ROW or STRUCT type): of a literal, each column is made
            // from its field's own value in every item, never from the other fields
            TExpression literal = arrays.size() == 1 && elements > 1 && arrays.get(0) instanceof TExpression
                    && isArrayLiteral((TExpression) arrays.get(0)) ? (TExpression) arrays.get(0) : null;
            for (int i = 0; i < aliasColumns.size(); i++) {
                names.add(aliasColumns.getObjectName(i) == null ? null : aliasColumns.getObjectName(i).toString());
                inputs.add(i >= elements ? OVER_ROWS : literal != null ? fieldParts(literal, i, elements, arguments)
                        : arrays.size() == 1 ? "0" : String.valueOf(i));
            }
            if (inputs.contains(null)) {
                return new TableFunctionLayout(names, null, rowInputs, true, arrays); // a part not settled: names only
            }
            return new TableFunctionLayout(names, inputs, rowInputs, true, arguments);
        }
        if (arrays.size() > 1) {
            return new TableFunctionLayout(null, null, rowInputs, false, arrays);
        }
        TExpression literal = arrays.get(0) instanceof TExpression && isArrayLiteral((TExpression) arrays.get(0))
                ? (TExpression) arrays.get(0) : null;
        // an element whose STRUCT fields are known (STRUCT literals, a typed ARRAY<STRUCT<...>> literal: the rule
        // resolver2 resolves the fields by, TSelectSqlStatement.unnestStructFieldNames) is one column per field, each a
        // part of the array's element: of a literal, the field's own value in every item (appended to the arguments),
        // never the other fields'
        List<String> fields = gudusoft.gsqlparser.stmt.TSelectSqlStatement.unnestStructFieldNames(table);
        boolean structKnown = fields != null && !fields.isEmpty();
        String alias = table.getAliasName();
        if (structKnown) {
            for (int f = 0; f < fields.size(); f++) {
                names.add(fields.get(f));
                inputs.add(literal == null ? "0" : fieldParts(literal, f, fields.size(), arguments));
            }
            if (inputs.contains(null)) {
                return new TableFunctionLayout(names, null, null, true, arrays); // a part not settled: names only
            }
        } else {
            names.add(alias != null && !alias.isEmpty() ? alias : null);
            inputs.add("0");
        }
        if (ordinality) {
            names.add("ordinality");
            inputs.add(OVER_ROWS);
        }
        if (clause.getWithOffset() != null) {
            names.add(clause.getWithOffsetAlais() != null && clause.getWithOffsetAlais().getAliasName() != null
                    ? clause.getWithOffsetAlais().getAliasName().toString() : "offset");
            inputs.add(OVER_ROWS);
        }
        // an element of a STRUCT or ROW type is one column per field: only an array literal of plain items proves the
        // element is one column
        return new TableFunctionLayout(names, inputs, rowInputs, structKnown
                || (arrays.get(0) instanceof TExpression && isScalarArrayLiteral((TExpression) arrays.get(0))),
                arguments);
    }

    /**
     * The arguments field {@code f} of a literal array of STRUCTs is made from: the f-th value of every item (a STRUCT
     * literal's field value, a typed array's tuple item), appended to {@code arguments}; null when an item's parts are
     * not {@code width} plain values.
     */
    private static String fieldParts(TExpression literal, int f, int width, List<TParseTreeNode> arguments) {
        StringBuilder out = new StringBuilder();
        TExpressionList items = literal.getExprList();
        for (int i = 0; items != null && i < items.size(); i++) {
            TExpression item = items.getExpression(i);
            TExpression part = null;
            if (item != null && (item.getExpressionType() == EExpressionType.list_t
                    || item.getExpressionType() == EExpressionType.row_constructor_t) && item.getExprList() != null
                    && item.getExprList().size() == width) {
                part = item.getExprList().getExpression(f); // ARRAY<STRUCT<x, y>>[(1, 'a')], ARRAY[ROW(1, 'a')]
            } else if (item != null && item.getFunctionCall() != null
                    && item.getFunctionCall().getFieldValues() != null
                    && item.getFunctionCall().getFieldValues().size() == width
                    && item.getFunctionCall().getFieldValues().getResultColumn(f) != null) {
                part = item.getFunctionCall().getFieldValues().getResultColumn(f).getExpr(); // STRUCT(1 AS a, 2 AS b)
            }
            if (part == null) {
                return null;
            }
            out.append(out.length() == 0 ? "" : ",").append(arguments.size());
            arguments.add(part);
        }
        return out.length() == 0 ? null : out.toString();
    }

    /**
     * The arrays of an {@code UNNEST}, in order: its expressions, or the column names the legacy form keeps
     * ({@code UNNEST(t.arr)} of BigQuery and Presto: a column list, no expression).
     */
    public static List<TParseTreeNode> unnestArrays(TUnnestClause clause) {
        List<TParseTreeNode> arrays = new ArrayList<TParseTreeNode>();
        if (clause.getExprList() != null && clause.getExprList().size() > 0) {
            for (int i = 0; i < clause.getExprList().size(); i++) {
                arrays.add(clause.getExprList().getExpression(i));
            }
        } else if (clause.getArrayExpr() != null) {
            arrays.add(clause.getArrayExpr());
        } else if (clause.getColumns() != null) {
            for (int i = 0; i < clause.getColumns().size(); i++) {
                arrays.add(clause.getColumns().getObjectName(i));
            }
        }
        return arrays;
    }

    // ---------------------------------------------------------------------------------------------
    // LATERAL VIEW
    // ---------------------------------------------------------------------------------------------

    /**
     * A Hive-family {@code LATERAL VIEW [OUTER] f(x) v AS c1, ...} of a generator whose columns its column aliases
     * name: {@code explode} (one alias: an array's element; two: a map's key and value), {@code posexplode} (the
     * position first), {@code inline} (a STRUCT array's fields), and their {@code _outer} forms.
     */
    private static TableFunctionLayout lateralView(TTable table) {
        TLateralView view = table.getLateralView();
        if (view == null || view.getUdtf() == null || view.getUdtf().getFunctionName() == null) {
            return null;
        }
        TObjectNameList aliases = view.getColumnAliasList();
        int n = aliases == null ? 0 : aliases.size();
        if (n == 0) {
            return null;
        }
        EDbVendor vendor = table.dbvendor;
        String name = unqualified(view.getUdtf().getFunctionName());
        List<TExpression> args = arguments(view.getUdtf());
        if (args.size() != 1 || name == null) {
            return null;
        }
        List<String> inputs = new ArrayList<String>();
        if (same(vendor, name, "explode") || same(vendor, name, "explode_outer")) {
            if (n > 2) {
                return null;
            }
            for (int i = 0; i < n; i++) {
                inputs.add("0");
            }
        } else if (same(vendor, name, "posexplode") || same(vendor, name, "posexplode_outer")) {
            if (n < 2 || n > 3) {
                return null;
            }
            inputs.add(OVER_ROWS);
            for (int i = 1; i < n; i++) {
                inputs.add("0");
            }
        } else if (same(vendor, name, "inline") || same(vendor, name, "inline_outer")) {
            for (int i = 0; i < n; i++) {
                inputs.add("0");
            }
        } else {
            return null;
        }
        List<String> names = new ArrayList<String>();
        for (int i = 0; i < n; i++) {
            names.add(aliases.getObjectName(i) == null ? null : aliases.getObjectName(i).toString());
        }
        return new TableFunctionLayout(names, inputs, "0", true, args);
    }

    // ---------------------------------------------------------------------------------------------
    // Helpers
    // ---------------------------------------------------------------------------------------------

    /**
     * An alias column list renames the leading columns by position; the rest keep their names. A list longer than the
     * columns is not one the rule settles.
     */
    private static TableFunctionLayout rename(TTable table, List<String> names, List<String> inputs, String rows,
            boolean closed, List<? extends TParseTreeNode> args, boolean renamed) {
        TObjectNameList aliasColumns = renamed && table.getAliasClause() != null ? table.getAliasClause().getColumns()
                : null;
        if (aliasColumns != null && aliasColumns.size() > 0) {
            if (aliasColumns.size() > names.size()) {
                return null;
            }
            for (int i = 0; i < aliasColumns.size(); i++) {
                TObjectName column = aliasColumns.getObjectName(i);
                if (column != null) {
                    names.set(i, column.toString());
                }
            }
        }
        return new TableFunctionLayout(names, inputs, rows, closed, args);
    }

    /** PostgreSQL and the dialects that keep its rule for a function of a base type in FROM. */
    private static boolean postgresFamily(EDbVendor vendor) {
        return vendor == EDbVendor.dbvpostgresql || vendor == EDbVendor.dbvgreenplum || vendor == EDbVendor.dbvgaussdb
                || vendor == EDbVendor.dbvedb;
    }

    private static boolean withOrdinality(TTable table) {
        // PostgreSQL: f(...) WITH ORDINALITY, kept in the table's text after the call
        gudusoft.gsqlparser.TSourceToken t = table.getFuncCall() == null ? null : table.getFuncCall().getEndToken();
        int words = 0;
        for (t = t == null ? null : t.getNextTokenInChain(); t != null && words < 2; t = t.getNextTokenInChain()) {
            if (t.tokentype == gudusoft.gsqlparser.ETokenType.ttwhitespace
                    || t.tokentype == gudusoft.gsqlparser.ETokenType.ttreturn) {
                continue;
            }
            String text = t.getAstext();
            if (words == 0 && !"WITH".equalsIgnoreCase(text)) { // non-identifier-compare: SQL keyword
                return false;
            }
            if (words == 1) {
                return "ORDINALITY".equalsIgnoreCase(text); // non-identifier-compare: SQL keyword
            }
            words++;
        }
        return false;
    }

    /** The argument values of a call, in order: a named argument's value ({@code input => x} is x). */
    private static List<TExpression> arguments(TFunctionCall call) {
        List<TExpression> out = new ArrayList<TExpression>();
        TExpressionList args = call.getArgs();
        for (int i = 0; args != null && i < args.size(); i++) {
            TExpression arg = args.getExpression(i);
            if (arg != null && arg.getExpressionType() == EExpressionType.assignment_t && arg.getRightOperand() != null) {
                arg = arg.getRightOperand();
            }
            out.add(arg);
        }
        return out;
    }

    /** {@code TABLE(f(...))} is f's call; anything else is the call itself. */
    private static TFunctionCall unwrapTable(EDbVendor vendor, TFunctionCall call) {
        if (unqualified(call.getFunctionName()) == null || !same(vendor, unqualified(call.getFunctionName()), "TABLE")
                || call.getArgs() == null || call.getArgs().size() != 1) {
            return call;
        }
        TExpression arg = call.getArgs().getExpression(0);
        return arg == null || arg.getFunctionCall() == null || arg.getFunctionCall().getFunctionName() == null ? call
                : arg.getFunctionCall();
    }

    /** The name of an unqualified call, or null for a schema- or database-qualified one (a user function). */
    private static String unqualified(TObjectName name) {
        if (name == null) {
            return null;
        }
        String schema = name.getSchemaString();
        String database = name.getDatabaseString();
        if ((schema != null && !schema.isEmpty()) || (database != null && !database.isEmpty())) {
            return null;
        }
        return name.toString();
    }

    private static boolean same(EDbVendor vendor, String name, String builtin) {
        return name != null && SQLUtil.sameName(vendor, ESQLDataObjectType.dotFunction, name, builtin);
    }

    private static boolean isConstant(TExpression e, String text) {
        return e != null && e.getExpressionType() == EExpressionType.simple_constant_t && text.equals(e.toString());
    }

    /** An array literal written with its items ({@code [..]}, {@code ARRAY[..]}): its rows are its items. */
    private static boolean isArrayLiteral(TExpression array) {
        return array != null && array.getExprList() != null && (array.getExpressionType() == EExpressionType.array_t
                || array.getExpressionType() == EExpressionType.array_constructor_t);
    }

    /** An array literal ({@code [..]}, {@code ARRAY[..]}) whose every item is a plain constant: its element is one column. */
    private static boolean isScalarArrayLiteral(TExpression array) {
        if (array == null || (array.getExpressionType() != EExpressionType.array_t
                && array.getExpressionType() != EExpressionType.array_constructor_t)) {
            return false;
        }
        TExpressionList items = array.getExprList();
        if (items == null || items.size() == 0) {
            return false;
        }
        for (int i = 0; i < items.size(); i++) {
            TExpression item = items.getExpression(i);
            if (item != null && item.getExpressionType() == EExpressionType.unary_minus_t) {
                item = item.getRightOperand() != null ? item.getRightOperand() : item.getLeftOperand();
            }
            if (item == null || item.getExpressionType() != EExpressionType.simple_constant_t) {
                return false;
            }
        }
        return true;
    }

    private static List<String> list(String... items) {
        List<String> out = new ArrayList<String>();
        Collections.addAll(out, items);
        return out;
    }
}