package gudusoft.gsqlparser.stmt;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.compiler.TStmtScope;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.nodes.hana.TTimeTravel;
import gudusoft.gsqlparser.nodes.hive.*;
import gudusoft.gsqlparser.nodes.mssql.TOptionClause;
import gudusoft.gsqlparser.nodes.THierarchical;
import gudusoft.gsqlparser.nodes.teradata.TExpandOnClause;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLTable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.TreeMap;


/**
 * Class {@link gudusoft.gsqlparser.stmt.TSelectSqlStatement } represents query specification, query expression and select statement.
 * <br><br><b>query specification</b> including following clause:
 * <ul>
 *     <li>select list {@link #getResultColumnList}</li>
 *     <li>from clause {@link #joins}</li>
 *     <li>where clause {@link #getWhereClause}</li>
 *     <li>group clause {@link #getGroupByClause}</li>
 *     <li>having clause {@link #getGroupByClause}</li>
 * </ul>
 * In some databases, query specification also known as sub-select.
 *
 * <br><br><b>query expression</b> including all elements in query specification and following clause:
 * <ul>
 *     <li>order by clause {@link #getOrderbyClause}</li>
 *     <li>offset clause {@link #getOffsetClause}</li>
 *     <li>for clause</li>
 * </ul>
 * In some databases, query expression also known as full-select.
 * <br>It is a component of the select-statement, the INSERT statement, and the CREATE VIEW statement.
 * And a full-select that is enclosed in parentheses is sometimes called a sub-query.
 *
 * <br><br>select statement including all elements in query expression and following clause:
 * <ul>
 *     <li>compute clause {@link #getComputeClause}</li>
 *     <li>for update clause {@link #getForUpdateClause}</li>
 *     <li>optimizer hint</li>
 *     <li>ctes {@link #getCteList}</li>
 * </ul>
 * Lots of clauses on this level are db vendors specific.
 *

 * <br><br>
 * Use {@link #isCombinedQuery} to check whether UNION, EXCEPT and INTERSECT operators is used.
 * If returns true, use {@link #getLeftStmt} and {@link #getRightStmt} to get query expression.
 * You need to check {@link #isCombinedQuery} recursively, all clauses of {@link gudusoft.gsqlparser.stmt.TSelectSqlStatement}
 * only available when this function returns false.
 *
 */

public class TSelectSqlStatement extends TCustomSqlStatement {

    // 如果是 combined query, 并且当前select 没有预先设定的 endToken， 则取最右边 query 的 endToken
    public TSourceToken getEndToken() {
        if (super.getEndToken() != null) return super.getEndToken();
        if (this.isCombinedQuery()){
            return this.getRightStmt().getEndToken();
        }else{
            return super.getEndToken();
        }
    }

    public void setSubQueryInFromClauseCanUseParentSelectAsEnclosingScope(boolean subQueryInFromClauseCanUseParentSelectAsEnclosingScope) {
        this.subQueryInFromClauseCanUseParentSelectAsEnclosingScope = subQueryInFromClauseCanUseParentSelectAsEnclosingScope;
    }

    public boolean isSubQueryInFromClauseCanUseParentSelectAsEnclosingScope() {
        return subQueryInFromClauseCanUseParentSelectAsEnclosingScope;
    }

    private boolean subQueryInFromClauseCanUseParentSelectAsEnclosingScope = false;

    boolean starColumnPushedDown = false;

    public boolean isStarColumnPushedDown() {
        return starColumnPushedDown;
    }

    public void setStarColumnPushedDown(boolean starColumnPushedDown) {
        this.starColumnPushedDown = starColumnPushedDown;
    }

    // StarRocks pipe operator support
    private TPTNodeList<TParseTreeNode> pipeOperators;
    private boolean isPipeQuery = false;

    // Oracle 12c WITH FUNCTION/PROCEDURE support - inline PL/SQL definitions
    private TStatementListSqlNode withPlsqlItems;

    /**
     * Get the inline PL/SQL function/procedure definitions from WITH clause.
     * Oracle 12c+ allows defining PL/SQL functions inline in the WITH clause:
     * WITH FUNCTION f(x NUMBER) RETURN NUMBER IS BEGIN RETURN x*2; END;
     * SELECT f(1) FROM dual
     *
     * @return list of inline function/procedure definitions, or null if none
     */
    public TStatementListSqlNode getWithPlsqlItems() {
        return withPlsqlItems;
    }

    /**
     * Set the inline PL/SQL function/procedure definitions.
     * @param withPlsqlItems list of inline function/procedure definitions
     */
    public void setWithPlsqlItems(TStatementListSqlNode withPlsqlItems) {
        this.withPlsqlItems = withPlsqlItems;
    }

    /**
     * Get the list of pipe operators for StarRocks pipe query syntax.
     * Pipe queries use the |> operator to chain operations:
     * FROM table |> SELECT * |> WHERE cond |> ORDER BY col
     *
     * @return list of TPipeOperator nodes, or null if not a pipe query
     */
    public TPTNodeList<TParseTreeNode> getPipeOperators() {
        return pipeOperators;
    }

    /**
     * Set the pipe operators list.
     * @param pipeOperators list of pipe operator nodes
     */
    public void setPipeOperators(TPTNodeList<TParseTreeNode> pipeOperators) {
        this.pipeOperators = pipeOperators;
    }

    /**
     * Check if this is a StarRocks pipe query.
     * Pipe queries use the syntax: FROM table |> SELECT * |> WHERE ...
     *
     * @return true if this is a pipe query
     */
    public boolean isPipeQuery() {
        return isPipeQuery;
    }

    /**
     * Set whether this is a pipe query.
     * @param isPipeQuery true if this is a pipe query
     */
    public void setIsPipeQuery(boolean isPipeQuery) {
        this.isPipeQuery = isPipeQuery;
    }

    /**
     * 在 sql script 中，和该 relation 关联的 attribute。
     * select a from t;
     * attribute a 就是 relation t 的 referenceAttribute, 如果没有 metadata and ddl，
     * relation t 的 getAttributes() 应该可以推断出包含 a, 但 t 是否还包含其他的 attribute 就无从得知。
     */

    @Override
    public ArrayList<TAttributeNode> getAttributes(){
        if (this.getFromClause() == null) return null;

        return this.getFromClause().getAttributes();

//        relationAttributes.clear();
//        for(TTable table:getRelations()){
//            relationAttributes.addAll(table.getAttributes());
//        }
//
//        if (relationAttributes.size() > 0){
//            TBaseType.log ("relationAttributes.size() in select is :"+relationAttributes.size()
//                    +", relation size: "+getRelations().size()
//                    +", relation 0 type:"+getRelations().get(0).getTableType()
//                    ,1);
//            // System.out.println(this.toString());
//        }
//
//        return relationAttributes;
    }

    ArrayList<TAttributeNode> relationAttributes = new ArrayList<>();

//    private TExpression skipOffset;
//    private TExpression firstMax;
//    private TExpression limitMax;
//
//    public void setSkipOffset(TExpression skipOffset) {
//        this.skipOffset = skipOffset;
//    }
//
//    public void setFirstMax(TExpression firstMax) {
//        this.firstMax = firstMax;
//    }
//
//    public void setLimitMax(TExpression limitMax) {
//        this.limitMax = limitMax;
//    }
//
//    /**
//     * Informix skip offset
//     * @return skip offset
//     */
//    public TExpression getSkipOffset() {
//
//        return skipOffset;
//    }
//
//    /**
//     * Informix first Max
//     * @return first Max
//     */
//    public TExpression getFirstMax() {
//        return firstMax;
//    }
//
//    /**
//     * Informix limit max
//     * @return limit max
//     */
//    public TExpression getLimitMax() {
//        return limitMax;
//    }

    private ArrayList<TSelectSqlStatement> multiSelectStatements;

    /**
     * Hive, from ... select, select,...
     * <br> Multiple select statement in Hive from query syntax
     *
     * @return Multiple select statement in Hive from query syntax
     */
    public ArrayList<TSelectSqlStatement> getMultiSelectStatements() {
        if(multiSelectStatements == null){
            multiSelectStatements = new ArrayList<>();
        }
        return multiSelectStatements;
    }

    private TClusterBy clusterBy;

    public void setClusterBy(TClusterBy clusterBy) {
        this.clusterBy = clusterBy;
    }

    public TClusterBy getClusterBy() {
        return clusterBy;
    }

    private boolean isConsume;

    public void setConsume(boolean consume) {
        isConsume = consume;
    }

    public boolean isConsume() {
        return isConsume;
    }

    private TStatementList hiveBodyList = null;

    /**
     * @deprecated since 2.6.3.5, please use {@link #getMultiSelectStatements()} to retrieve
     * multimple select statement in Hive from query ... select, select, ...
     *
     * @return
     */
    public TStatementList getHiveBodyList() {
        if (hiveBodyList == null)
            hiveBodyList = new TStatementList();
        return hiveBodyList;
    }

    public void setSelectModifiers(ArrayList<TSelectModifier> selectModifiers) {
        this.selectModifiers = selectModifiers;
    }

    public ArrayList<TSelectModifier> getSelectModifiers() {
        return selectModifiers;
    }

    private ArrayList<TSelectModifier> selectModifiers;


    private TTimeTravel timeTravel; // hana
    private THintClause hintClause; //hana

    public void setTimeTravel(TTimeTravel timeTravel) {
        setNewSubNode(this.timeTravel,timeTravel,getAnchorNode());
        this.timeTravel = timeTravel;
    }

    public void setHintClause(THintClause hintClause) {
        setNewSubNode(this.hintClause,hintClause,getAnchorNode());
        this.hintClause = hintClause;
    }


    public TTimeTravel getTimeTravel() {

        return timeTravel;
    }

    public THintClause getHintClause() {
        return hintClause;
    }

    private int parenthesisCount = 0;
    private int parenthesisCountBeforeOrder = 0;

    public void setFetchFirstClause(TFetchFirstClause fetchFirstClause) {
        setNewSubNode(this.fetchFirstClause,fetchFirstClause,getAnchorNode());
        this.fetchFirstClause = fetchFirstClause;
    }


    public void setParenthesisCount(int parenthesisCount) {
        this.parenthesisCount = parenthesisCount;
    }

    public void setParenthesisCountBeforeOrder(int parenthesisCountBeforeOrder) {
        this.parenthesisCountBeforeOrder = parenthesisCountBeforeOrder;
    }

    public void setAll(boolean all) {
        this.all = all;
    }

    public void setSetOperatorType(ESetOperatorType setOperatorType) {
        this.setOperatorType = setOperatorType;
    }

    public void setWindowClause(TWindowClause windowClause) {
        setNewSubNode(this.windowClause,windowClause,getAnchorNode());
        this.windowClause = windowClause;
    }

    public void setLockingClauses(TPTNodeList<TLockingClause> lockingClauses) {
        this.lockingClauses = lockingClauses;
    }

    public void setSelectDistinct(TSelectDistinct selectDistinct) {
        setNewSubNode(this.selectDistinct,selectDistinct,getAnchorNode());
        this.selectDistinct = selectDistinct;
    }

    public void setExpandOnClause(TExpandOnClause expandOnClause) {
        setNewSubNode(this.expandOnClause,expandOnClause,getAnchorNode());
        this.expandOnClause = expandOnClause;
    }


    public void setSetOperator(int setOperator) {
        this.setOperator = setOperator;
    }

    public void setLeftStmt(TSelectSqlStatement leftStmt) {
        this.leftStmt = leftStmt;
    }

    public void setRightStmt(TSelectSqlStatement rightStmt) {
        this.rightStmt = rightStmt;
    }

    public void setValueClause(TValueClause valueClause) {
        setNewSubNode(this.valueClause,valueClause,getAnchorNode());
        this.valueClause = valueClause;
    }

    public void setOracleHint(String oracleHint) {
        this.oracleHint = oracleHint;
    }

    public void setHiveHintClause(THiveHintClause hiveHintClause) {
        setNewSubNode(this.hiveHintClause,hiveHintClause,getAnchorNode());
        this.hiveHintClause = hiveHintClause;
    }


    public void setTransformClause(THiveTransformClause transformClause) {
        setNewSubNode(this.transformClause,transformClause,getAnchorNode());
        this.transformClause = transformClause;
    }

    public void setDistributeBy(TDistributeBy distributeBy) {
        setNewSubNode(this.distributeBy,distributeBy,getAnchorNode());
        this.distributeBy = distributeBy;
    }


    public void setIntoClause(TIntoClause intoClause) {
        setNewSubNode(this.intoClause,intoClause,getAnchorNode());
        this.intoClause = intoClause;
    }

    public void setOrderbyClause(TOrderBy newOrderbyClause) {
        setNewSubNode(this.orderbyClause,newOrderbyClause,getAnchorNode());
        this.orderbyClause = newOrderbyClause;
    }

//    public void setOrderbyClause(TOrderBy newOrderbyClause, TParseTreeNode anchorNode) {
//        if (newOrderbyClause == null){
//            //remove
//            this.orderbyClause.removeTokens();
//            this.orderbyClause = null;
//        }else{
//            if (this.orderbyClause != null){
//                this.orderbyClause.replaceWithNewNode(newOrderbyClause);
//            }else{
//                doAppendNewNode(newOrderbyClause,anchorNode,false);
//            }
//            this.orderbyClause = newOrderbyClause;
//        }
//    }

    public void setQualifyClause(TQualifyClause qualifyClause) {
        setNewSubNode(this.qualifyClause,qualifyClause,getAnchorNode());
        this.qualifyClause = qualifyClause;
    }

    public void setSampleClause(TSampleClause sampleClause) {
        setNewSubNode(this.sampleClause,sampleClause,getAnchorNode());
        this.sampleClause = sampleClause;
    }

    public void setTeradataWithClause(TTeradataWithClause teradataWithClause) {
        setNewSubNode(this.teradataWithClause,teradataWithClause,getAnchorNode());
        this.teradataWithClause = teradataWithClause;
    }

    public void setForUpdateClause(TForUpdate forUpdateClause) {
        setNewSubNode(this.forUpdateClause,forUpdateClause,getAnchorNode());
        this.forUpdateClause = forUpdateClause;
    }


    public void setComputeClause(TComputeClause computeClause) {
        this.computeClause = computeClause;
    }

    public void setGroupByClause(TGroupBy groupByClause) {
        setNewSubNode(this.groupByClause,groupByClause,getAnchorNode());
        this.groupByClause = groupByClause;
    }


    public void setHierarchicalClause(THierarchical hierarchicalClause) {
        setNewSubNode(this.hierarchicalClause,hierarchicalClause,getAnchorNode());
        this.hierarchicalClause = hierarchicalClause;
    }


    public void setLimitClause(TLimitClause limitClause) {
        setNewSubNode(this.limitClause,limitClause,getAnchorNode());
        this.limitClause = limitClause;
    }

    public void setOffsetClause(TOffsetClause offsetClause) {
        setNewSubNode(this.offsetClause,offsetClause,getAnchorNode());
        this.offsetClause = offsetClause;
    }

    public void setOptionClause(TOptionClause optionClause) {
        setNewSubNode(this.optionClause,optionClause,getAnchorNode());
        this.optionClause = optionClause;
    }

    public void setIsolationClause(TIsolationClause isolationClause) {
        setNewSubNode(this.isolationClause,isolationClause,getAnchorNode());
        this.isolationClause = isolationClause;
    }

//    public void setHiveClusterBy(THiveClusterBy hiveClusterBy) {
//        setNewSubNode(this.hiveClusterBy,hiveClusterBy,getAnchorNode());
//        this.hiveClusterBy = hiveClusterBy;
//    }


    public void setSortBy(TSortBy sortBy) {
        setNewSubNode(this.sortBy,sortBy,getAnchorNode());
        this.sortBy = sortBy;
    }

    public void setIntoTableClause(TIntoTableClause intoTableClause) {
        setNewSubNode(this.intoTableClause,intoTableClause,getAnchorNode());
        this.intoTableClause = intoTableClause;
    }

    public int getParenthesisCountBeforeOrder() {
        return parenthesisCountBeforeOrder;
    }

    public int getParenthesisCount() {
        return parenthesisCount;
    }

    private boolean queryOfCTE;

    public void setQueryOfCTE(boolean queryOfCTE) {
        this.queryOfCTE = queryOfCTE;
    }

    public boolean isQueryOfCTE() {
        return queryOfCTE;
    }

    /**
     * The SELECT-list alias of an ENCLOSING SELECT block that {@code reference}, an unqualified name of this block,
     * stands for in SAP IQ and SQL Anywhere (Mantis 4752).
     *
     * <p>SQL Anywhere: "Aliases can be used anywhere in the SELECT block in which they are defined", and an alias
     * "occludes" a column or variable of the same name (<i>Renamed columns in query results</i>). A subquery in the
     * select list, WHERE, GROUP BY, HAVING or ORDER BY of a block is part of that block, so a name the subquery does
     * not resolve itself is the alias of the block around it:</p>
     * <pre>SELECT a AS x, (SELECT x) AS y FROM outer_t      -- the inner x is the alias x, that is a</pre>
     *
     * <p>Only what the SQL and the catalog prove is taken. Walking outward from this block, a block is passed only
     * when it provably has no column of that name: it reads no table, or the catalog knows every table it reads, with
     * all its columns, and none of them has that name. A table with no metadata, a table whose columns are not all
     * known (no column list, or a {@code *} lineage could not expand), a derived table, a CTE or a table function may
     * have it, so the walk stops there and the name stays a column. The walk leaves a block only from a subquery in one of
     * those clauses or from a branch of a set operation, never from a derived table, a join condition or a CTE. In
     * the enclosing block the alias must be defined before the reference (a forward reference is SQLCODE -831), which
     * also keeps a name inside the alias's own definition a column; there the alias wins over a column of the same
     * name.</p>
     *
     * <p>The single definition of this rule for the older resolver ({@code TCustomSqlStatement.linkColumnToTable})
     * and resolver2 ({@code TSQLResolver2.handleSelectListAliasResolution}). An alias of the reference's own block is
     * {@link TResultColumnList#findLateralAliasDefinition}.</p>
     *
     * @param reference an unqualified column reference of this block
     * @param sqlEnv    the catalog to look a table up in when it has no {@link TTable#getResolvedTable() resolved
     *                  table}, or null; it must be in the statement's own context (current database and schema), so
     *                  resolver2, which reads the catalog after the whole script, passes null
     * @return the defining result column of the enclosing block, or null
     */
    public TResultColumn findEnclosingAliasDefinition(TObjectName reference, TSQLEnv sqlEnv) {
        if ((reference == null) || reference.isQualified()) return null;
        if (!TSQLEnv.isAliasOccludingColumn(dbvendor)) return null;
        // A set operation is no block of its own, and while it is parsed its select list is not there yet.
        if (isCombinedQuery()) return null;
        String columnName = reference.getColumnNameOnly();
        if ((columnName == null) || columnName.isEmpty()) return null;
        // An alias or a possible column of this block is this block's own business.
        if (hasAliasMatching(this, reference) || mayExposeColumn(this, columnName, sqlEnv)) return null;

        java.util.Set<TCustomSqlStatement> visited =
                java.util.Collections.newSetFromMap(new java.util.IdentityHashMap<TCustomSqlStatement, Boolean>());
        TSelectSqlStatement block = this;
        while (visited.add(block)) {
            TCustomSqlStatement parent = block.getParentStmt();
            if (!(parent instanceof TSelectSqlStatement)) return null;
            TSelectSqlStatement enclosing = (TSelectSqlStatement) parent;
            if (enclosing.isCombinedQuery()) {
                // A branch of UNION, INTERSECT or EXCEPT: the set operation is not a block of its own.
                if ((enclosing.getLeftStmt() != block) && (enclosing.getRightStmt() != block)) return null;
                block = enclosing;
                continue;
            }
            if (block.isQueryOfCTE() || !isInAliasVisibleClause(block, enclosing)) return null;
            if (hasAliasMatching(enclosing, reference)) {
                // null when the alias is defined after the reference, or around it
                return enclosing.getResultColumnList().findLateralAliasDefinition(dbvendor, reference);
            }
            if (mayExposeColumn(enclosing, columnName, sqlEnv)) return null;
            block = enclosing;
        }
        return null;
    }

    /**
     * Whether the subquery {@code block} is written in the select list, WHERE, GROUP BY, HAVING or ORDER BY of
     * {@code enclosing}, where its aliases are visible; a derived table or a join condition is in the FROM clause.
     * Decided by position: an EXISTS or IN subquery reports no clause of its own.
     */
    private static boolean isInAliasVisibleClause(TSelectSqlStatement block, TSelectSqlStatement enclosing) {
        TSourceToken start = block.getStartToken();
        if (start == null) return false;
        TGroupBy groupBy = enclosing.getGroupByClause();
        return spans(enclosing.getResultColumnList(), start)
                || spans(enclosing.getWhereClause(), start)
                || spans(groupBy, start)
                || ((groupBy != null) && spans(groupBy.getHavingClause(), start))
                || spans(enclosing.getOrderbyClause(), start);
    }

    private static boolean spans(TParseTreeNode clause, TSourceToken token) {
        if ((clause == null) || (clause.getStartToken() == null) || (clause.getEndToken() == null)) return false;
        return (token.posinlist >= clause.getStartToken().posinlist) && (token.posinlist <= clause.getEndToken().posinlist);
    }

    private static boolean hasAliasMatching(TSelectSqlStatement block, TObjectName reference) {
        if (block.isCombinedQuery()) return false;
        TResultColumnList resultColumns = block.getResultColumnList();
        if (resultColumns == null) return false;
        for (int i = 0; i < resultColumns.size(); i++) {
            TResultColumn resultColumn = resultColumns.getResultColumn(i);
            if ((resultColumn != null) && (resultColumn.getAliasClause() != null)
                    && resultColumn.isMatchedUsingAlias(reference)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Whether this block may have a column {@code columnName} of its own: some table it reads may have it (a derived
     * table, a CTE, a table function, a table whose columns the catalog does not all know, or knows to include it).
     * False only when the block provably has none. {@code sqlEnv} as in {@link #findEnclosingAliasDefinition}.
     */
    public boolean mayExposeColumn(String columnName, TSQLEnv sqlEnv) {
        return mayExposeColumn(this, columnName, sqlEnv);
    }

    /** False only when the block provably has no column of that name. */
    private static boolean mayExposeColumn(TSelectSqlStatement block, String columnName, TSQLEnv sqlEnv) {
        if (block.tables == null) return false;
        for (int i = 0; i < block.tables.size(); i++) {
            TTable table = block.tables.getTable(i);
            if ((table == null) || (table.getEffectType() == ETableEffectType.tetSelectInto)) continue;
            if (table.getTableType() == ETableSource.unnest) {
                if (unnestMayExposeColumn(table, columnName)) return true;
                continue;
            }
            TObjectNameList renamed = ((table.getAliasClause() != null) && (table.getAliasClause().getColumns() != null)
                    && (table.getAliasClause().getColumns().size() > 0)) ? table.getAliasClause().getColumns() : null;
            if ((table.getTableType() == ETableSource.subquery) && (table.getSubquery() != null)) {
                if (derivedMayExposeColumn(table.dbvendor, table.getSubquery(), columnName, renamed, null)) return true;
                continue;
            }
            if (table.isCTEName() && (table.getCTE() != null) && (table.getCTE().getSubquery() != null)) {
                if (derivedMayExposeColumn(table.dbvendor, table.getCTE().getSubquery(), columnName, renamed,
                        table.getCTE().getColumnList())) return true;
                continue;
            }
            if (!table.isBaseTable()) return true;
            // The table as bound in its own statement's context (database, schema, a routine's temporary tables), or
            // a table the script declared before this block, while it is parsed (Mantis 4797).
            TSQLTable metadata = tableMetadata(block, table, sqlEnv);
            if (!hasAllColumnsKnown(metadata) || metadata.searchColumn(columnName)) return true;
        }
        return false;
    }

    /**
     * The table of an enclosing query that the unqualified {@code name} in {@code subquery} reads, or null when the name
     * is the subquery's own (Mantis 4797). A SELECT in an expression of a query reads a name from its own tables while
     * they may have it: in {@code (select Jahr from m_version_table2 where Jahr234 = year(now()))} both names are
     * m_version_table2's, though a derived table around the subquery names them too. The name is an enclosing query's
     * when it is compared with a column of the subquery's own tables, the subquery's own tables do not prove it and the
     * enclosing query does: in {@code (SELECT max(v) FROM customfieldvalues WHERE resourceid = resumeid)} under
     * {@code FROM (SELECT id AS resumeid FROM resumes) r}, resumeid is r's. Parse-time linking
     * ({@code TCustomSqlStatement.linkColumnToTable}) and resolver2 ({@code NameResolver}) both decide by this rule.
     *
     * @param sqlEnv the catalog the parse reads, or null when each table's {@link TTable#getResolvedTable()} is what
     *               proves its columns, as after resolver2 bound the tables
     */
    public static TTable outerCorrelationTable(TObjectName name, TSelectSqlStatement subquery, TSQLEnv sqlEnv) {
        if ((name == null) || (subquery == null) || name.isQualified()) return null;
        TSelectSqlStatement root = setOperationRoot(subquery);
        if (!isSubqueryInExpression(root)) return null;
        String column = name.getColumnNameOnly();
        TObjectName partner = comparedColumn(subquery, name);
        if ((partner == null) || (provingTable(subquery, column, sqlEnv) != null)) return null;
        TTable outer = enclosingProvingTable(root, column, sqlEnv);
        if (outer == null) return null;
        if (partner.isQualified()) return namesOwnTable(subquery, partner.getTableString()) ? outer : null;
        String other = partner.getColumnNameOnly();
        if (sameColumn(subquery.dbvendor, other, column) || (enclosingProvingTable(root, other, sqlEnv) != null)) return null;
        return outer;
    }

    /** The statement a branch of a set operation belongs to: the outermost set operation holding it. */
    private static TSelectSqlStatement setOperationRoot(TSelectSqlStatement select) {
        TSelectSqlStatement root = select;
        while (root.getParentStmt() instanceof TSelectSqlStatement) {
            TSelectSqlStatement parent = (TSelectSqlStatement) root.getParentStmt();
            if ((parent.getLeftStmt() != root) && (parent.getRightStmt() != root)) break;
            root = parent;
        }
        return root;
    }

    /** A SELECT written in an expression of a query, which reads that query's FROM clause: not a derived table or CTE. */
    private static boolean isSubqueryInExpression(TSelectSqlStatement root) {
        return !root.isQueryOfCTE() && (root.getLocation() != ESqlClause.join) && (root.getLocation() != ESqlClause.elTable)
                && (root.getParentStmt() instanceof TSelectSqlStatement);
    }

    /**
     * The column {@code name} is compared with in a WHERE, HAVING or ON condition of {@code block}, or null. Read from
     * the parse tree while the statement is parsed: its clauses are attached after their names are linked.
     */
    private static TObjectName comparedColumn(TSelectSqlStatement block, TObjectName name) {
        java.util.Deque<TExpression> pending = new java.util.ArrayDeque<>();
        TSelectSqlNode node = (block.rootNode instanceof TSelectSqlNode) ? (TSelectSqlNode) block.rootNode : null;
        TWhereClause where = (block.getWhereClause() != null) ? block.getWhereClause()
                : ((node != null) ? node.getWhereCondition() : null);
        if ((where != null) && (where.getCondition() != null)) pending.push(where.getCondition());
        TGroupBy groupBy = (block.getGroupByClause() != null) ? block.getGroupByClause()
                : ((node != null) ? node.getGroupByClause() : null);
        if ((groupBy != null) && (groupBy.getHavingClause() != null)) pending.push(groupBy.getHavingClause());
        if (block.getJoins() != null) {
            for (int i = 0; i < block.getJoins().size(); i++) {
                TJoin join = block.getJoins().getJoin(i);
                for (int k = 0; (join != null) && (join.getJoinItems() != null) && (k < join.getJoinItems().size()); k++) {
                    TJoinItem item = join.getJoinItems().getJoinItem(k);
                    if ((item != null) && (item.getOnCondition() != null)) pending.push(item.getOnCondition());
                }
            }
        }
        while (!pending.isEmpty()) {
            TExpression expr = pending.pop();
            if (expr.getExpressionType() == EExpressionType.subquery_t) continue;
            if (expr.getExpressionType() == EExpressionType.simple_comparison_t) {
                TObjectName left = columnOperand(expr.getLeftOperand());
                TObjectName right = columnOperand(expr.getRightOperand());
                if ((left == name) && (right != null)) return right;
                if ((right == name) && (left != null)) return left;
            }
            if (expr.getLeftOperand() != null) pending.push(expr.getLeftOperand());
            if (expr.getRightOperand() != null) pending.push(expr.getRightOperand());
        }
        return null;
    }

    private static TObjectName columnOperand(TExpression operand) {
        return ((operand != null) && (operand.getExpressionType() == EExpressionType.simple_object_name_t))
                ? operand.getObjectOperand() : null;
    }

    /** Whether {@code qualifier} names, by alias or by name, a table of {@code block}'s FROM clause. */
    private static boolean namesOwnTable(TSelectSqlStatement block, String qualifier) {
        if ((block.tables == null) || (qualifier == null) || qualifier.isEmpty()) return false;
        for (int i = 0; i < block.tables.size(); i++) {
            TTable table = block.tables.getTable(i);
            if (table == null) continue;
            String exposed = table.getAliasName().isEmpty() ? table.getName() : table.getAliasName();
            if (gudusoft.gsqlparser.util.SQLUtil.compareIdentifier(block.dbvendor, ESQLDataObjectType.dotTable, exposed, qualifier)) {
                return true;
            }
        }
        return false;
    }

    /**
     * The table of the nearest enclosing query that proves {@code column}, climbing while the queries passed only may
     * have it through tables whose columns are not known; null when there is none, when an enclosing query proves it
     * twice, or when a derived table, CTE or other source there may have it. A derived table or a CTE body sees no
     * query around it.
     */
    private static TTable enclosingProvingTable(TSelectSqlStatement root, String column, TSQLEnv sqlEnv) {
        TSelectSqlStatement block = root;
        while (isSubqueryInExpression(block)) {
            TSelectSqlStatement enclosing = (TSelectSqlStatement) block.getParentStmt();
            TTable proving = provingTable(enclosing, column, sqlEnv);
            if (proving == AMBIGUOUS) return null;
            if (proving != null) return proving;
            if (sourceMayExposeColumn(enclosing, column)) return null;
            block = setOperationRoot(enclosing);
        }
        return null;
    }

    /** Marks a column that two tables of one query prove. */
    private static final TTable AMBIGUOUS = new TTable();

    /**
     * The table of {@code block} that proves {@code column}: a table whose known columns include it, a derived table or
     * CTE naming it in its select or column list, an UNNEST whose value, offset or STRUCT fields are named so. Null
     * when none does; {@link #AMBIGUOUS} when two do.
     */
    private static TTable provingTable(TSelectSqlStatement block, String column, TSQLEnv sqlEnv) {
        if (block.tables == null) return null;
        TTable found = null;
        for (int i = 0; i < block.tables.size(); i++) {
            TTable table = block.tables.getTable(i);
            if ((table == null) || (table.getEffectType() == ETableEffectType.tetSelectInto)
                    || (table.getEffectType() == ETableEffectType.tetImplicitLateralDerivedTable)) {
                continue;
            }
            if (tableNamesColumn(block, table, column, sqlEnv)) {
                if (found != null) return AMBIGUOUS;
                found = table;
            }
        }
        return found;
    }

    private static boolean tableNamesColumn(TSelectSqlStatement block, TTable table, String column, TSQLEnv sqlEnv) {
        EDbVendor vendor = table.dbvendor;
        TObjectNameList renamed = ((table.getAliasClause() != null) && (table.getAliasClause().getColumns() != null)
                && (table.getAliasClause().getColumns().size() > 0)) ? table.getAliasClause().getColumns() : null;
        if (table.getTableType() == ETableSource.unnest) return unnestNamesColumn(table, column);
        if ((table.getTableType() == ETableSource.subquery) && (table.getSubquery() != null)) {
            return derivedNamesColumn(vendor, table.getSubquery(), column, renamed, null);
        }
        if (table.isCTEName() && (table.getCTE() != null) && (table.getCTE().getSubquery() != null)) {
            return derivedNamesColumn(vendor, table.getCTE().getSubquery(), column, renamed, table.getCTE().getColumnList());
        }
        if (!table.isBaseTable()) return false;
        TSQLTable metadata = tableMetadata(block, table, sqlEnv);
        return (metadata != null) && metadata.searchColumn(column);
    }

    /** Whether a derived table, CTE or another source of {@code block} that is not a table may have {@code column}. */
    private static boolean sourceMayExposeColumn(TSelectSqlStatement block, String column) {
        if (block.tables == null) return false;
        for (int i = 0; i < block.tables.size(); i++) {
            TTable table = block.tables.getTable(i);
            if ((table == null) || table.isBaseTable() || (table.getEffectType() == ETableEffectType.tetSelectInto)
                    || (table.getEffectType() == ETableEffectType.tetImplicitLateralDerivedTable)) {
                continue;
            }
            if (table.getTableType() == ETableSource.unnest) {
                if (unnestMayExposeColumn(table, column)) return true;
                continue;
            }
            TObjectNameList renamed = ((table.getAliasClause() != null) && (table.getAliasClause().getColumns() != null)
                    && (table.getAliasClause().getColumns().size() > 0)) ? table.getAliasClause().getColumns() : null;
            if ((table.getTableType() == ETableSource.subquery) && (table.getSubquery() != null)) {
                if (derivedMayExposeColumn(table.dbvendor, table.getSubquery(), column, renamed, null)) return true;
                continue;
            }
            if (table.isCTEName() && (table.getCTE() != null) && (table.getCTE().getSubquery() != null)) {
                if (derivedMayExposeColumn(table.dbvendor, table.getCTE().getSubquery(), column, renamed,
                        table.getCTE().getColumnList())) return true;
                continue;
            }
            return true;
        }
        return false;
    }

    /** Whether a derived table or CTE names {@code column} among its columns (a star names none). */
    private static boolean derivedNamesColumn(EDbVendor vendor, TSelectSqlStatement query, String column,
            TObjectNameList renamed, TObjectNameList declared) {
        if ((renamed != null) && namesColumn(vendor, renamed, column)) return true;
        if ((declared != null) && namesColumn(vendor, declared, column)) return true;
        TSelectSqlStatement first = query;
        while ((first != null) && first.isCombinedQuery()) first = first.getLeftStmt();
        if ((first == null) || (first.getValueClause() != null) || (first.getResultColumnList() == null)) return false;
        int skip = Math.max((renamed == null) ? 0 : renamed.size(), (declared == null) ? 0 : declared.size());
        for (int i = skip; i < first.getResultColumnList().size(); i++) {
            TResultColumn resultColumn = first.getResultColumnList().getResultColumn(i);
            String output = (resultColumn == null) ? null : outputName(resultColumn);
            if ((output != null) && sameColumn(vendor, output, column)) return true;
        }
        return false;
    }

    /** Whether an UNNEST names {@code column}: its alias column list, alias or value, offset, or STRUCT fields. */
    private static boolean unnestNamesColumn(TTable unnest, String column) {
        EDbVendor vendor = unnest.dbvendor;
        TAliasClause alias = unnest.getAliasClause();
        if ((alias != null) && (alias.getColumns() != null) && (alias.getColumns().size() > 0)) {
            return namesColumn(vendor, alias.getColumns(), column);
        }
        if ((alias != null) && (alias.getAliasName() != null)) {
            if (sameColumn(vendor, alias.getAliasName().toString(), column)) return true;
        } else if (sameColumn(vendor, "value", column)) {
            return true;
        }
        TUnnestClause clause = unnest.getUnnestClause();
        if (clause == null) return false;
        if ((clause.getWithOffsetAlais() != null) && (clause.getWithOffsetAlais().getAliasName() != null)
                && sameColumn(vendor, clause.getWithOffsetAlais().getAliasName().toString(), column)) {
            return true;
        }
        if (clause.getDerivedColumnList() != null) return namesColumn(vendor, clause.getDerivedColumnList(), column);
        return unnestHasStructField(unnest, column);
    }

    /** The catalog table of {@code table} as bound, else as the parse reads it ({@code ParseTimeCatalog}, the catalog). */
    private static TSQLTable tableMetadata(TSelectSqlStatement block, TTable table, TSQLEnv sqlEnv) {
        TSQLTable metadata = table.getResolvedTable();
        if ((metadata == null) && (sqlEnv != null)) {
            metadata = gudusoft.gsqlparser.resolver2.metadata.ParseTimeCatalog.searchTable(block,
                    table.getPrefixDatabase(), table.getPrefixSchema(), table.getName());
            if (metadata == null) {
                metadata = sqlEnv.searchTable(nullToEmpty(table.getPrefixDatabase()) + "."
                        + nullToEmpty(table.getPrefixSchema()) + "." + table.getName());
            }
        }
        return metadata;
    }

    /**
     * Whether a derived table or a CTE may have a column {@code columnName}. Its columns are those of the first SELECT
     * of {@code query}, named in order by {@code renamed} (the reference's alias column list), else by {@code declared}
     * (the CTE's column list), else by the SELECT: an alias, or the name of a column it reads. False only when every
     * column's name is known and none is that name; a star, or an expression the vendor names itself, may be anything.
     */
    private static boolean derivedMayExposeColumn(EDbVendor vendor, TSelectSqlStatement query, String columnName,
            TObjectNameList renamed, TObjectNameList declared) {
        TSelectSqlStatement first = query;
        while ((first != null) && first.isCombinedQuery()) first = first.getLeftStmt();
        TResultColumnList projection = ((first == null) || (first.getValueClause() != null)) ? null
                : first.getResultColumnList();
        // The number of columns, or -1 when the SELECT does not show it.
        int width = (projection == null) ? -1 : projection.size();
        for (int i = 0; (width >= 0) && (i < projection.size()); i++) {
            TResultColumn column = projection.getResultColumn(i);
            TObjectName field = (column == null) ? null : column.getFieldAttr();
            boolean star = (field != null) && (field.getPartToken() != null)
                    && (field.getPartToken().tokentype == ETokenType.ttasterisk);
            boolean several = (column != null) && (column.getAliasClause() != null)
                    && (column.getAliasClause().getColumns() != null) && (column.getAliasClause().getColumns().size() > 0);
            if ((column == null) || star || several) width = -1;
        }
        int listed = Math.max((renamed == null) ? 0 : renamed.size(), (declared == null) ? 0 : declared.size());
        int count = Math.max(width, listed);
        for (int i = 0; i < count; i++) {
            String name;
            if ((renamed != null) && (i < renamed.size())) {
                name = renamed.getObjectName(i).toString();
            } else if ((declared != null) && (i < declared.size())) {
                name = declared.getObjectName(i).toString();
            } else {
                name = (i < width) ? outputName(projection.getResultColumn(i)) : null;
                if (name == null) return true;
            }
            if (sameColumn(vendor, name, columnName)) return true;
        }
        return width < 0;
    }

    /** The name a SELECT gives a column of its result: its alias, or the column it reads; null when the vendor names it. */
    private static String outputName(TResultColumn column) {
        if (column.getAliasClause() != null) {
            return (column.getAliasClause().getAliasName() == null) ? null
                    : column.getAliasClause().getAliasName().toString();
        }
        TExpression expr = column.getExpr();
        if ((expr != null) && (expr.getExpressionType() == EExpressionType.simple_object_name_t)
                && (expr.getObjectOperand() != null)) {
            return expr.getObjectOperand().getColumnNameOnly();
        }
        return null;
    }

    /**
     * Whether an UNNEST relation may have a column {@code columnName}: the value column its alias names (GSP names it
     * {@code value} when there is no alias), its offset column, the columns an alias list such as {@code t(x, n)} or the
     * catalog's STRUCT type gives it, and, while its elements may be STRUCTs, any of their fields. In
     * {@code ARRAY(SELECT x FROM UNNEST(some_numbers) AS x WHERE 2 IN UNNEST(some_numbers))} over an array of numbers,
     * the second {@code some_numbers} can only be the enclosing query's column.
     */
    private static boolean unnestMayExposeColumn(TTable unnest, String columnName) {
        EDbVendor vendor = unnest.dbvendor;
        TAliasClause alias = unnest.getAliasClause();
        if ((alias != null) && (alias.getColumns() != null) && (alias.getColumns().size() > 0)) {
            return namesColumn(vendor, alias.getColumns(), columnName);
        }
        if ((alias != null) && (alias.getAliasName() != null)) {
            if (sameColumn(vendor, alias.getAliasName().toString(), columnName)) return true;
        } else if (sameColumn(vendor, "value", columnName)) {
            return true;
        }
        TUnnestClause clause = unnest.getUnnestClause();
        if (clause == null) return true;
        if ((clause.getWithOffsetAlais() != null) && (clause.getWithOffsetAlais().getAliasName() != null)
                && sameColumn(vendor, clause.getWithOffsetAlais().getAliasName().toString(), columnName)) {
            return true;
        }
        if (clause.getDerivedColumnList() != null) return namesColumn(vendor, clause.getDerivedColumnList(), columnName);
        java.util.List<String> fields = structFields(clause);
        if (fields != null) return containsColumn(vendor, fields, columnName);
        return !hasScalarElements(clause);
    }

    /** Whether the arrays an UNNEST reads provably hold no STRUCTs, so it has no column but its value and offset. */
    private static boolean hasScalarElements(TUnnestClause clause) {
        if (clause.getArrayExpr() != null) return hasScalarElements(clause.getArrayExpr(), 0);
        if (clause.getExprList() != null) {
            if (clause.getExprList().size() == 0) return false;
            for (int i = 0; i < clause.getExprList().size(); i++) {
                if (!hasScalarElements(clause.getExprList().getExpression(i), 0)) return false;
            }
            return true;
        }
        return (clause.getColumns() != null) && (clause.getColumns().size() == 1)
                && hasScalarElements(clause.getColumns().getObjectName(0), 0);
    }

    /**
     * Whether an array expression provably holds no STRUCTs: an array literal of literals, a BigQuery GENERATE_ARRAY,
     * GENERATE_DATE_ARRAY, GENERATE_TIMESTAMP_ARRAY or SPLIT, or a column a CTE or derived table defines as one.
     */
    private static boolean hasScalarElements(TExpression array, int depth) {
        if ((array == null) || (depth > 8)) return false;
        switch (array.getExpressionType()) {
            case array_t:
                if ((array.getExprList() == null) || (array.getExprList().size() == 0)) return false;
                for (int i = 0; i < array.getExprList().size(); i++) {
                    TExpression element = array.getExprList().getExpression(i);
                    if ((element.getExpressionType() == EExpressionType.unary_minus_t)
                            || (element.getExpressionType() == EExpressionType.unary_plus_t)) {
                        element = element.getRightOperand();
                    }
                    if ((element == null) || (element.getExpressionType() != EExpressionType.simple_constant_t)) return false;
                }
                return true;
            case function_t:
                TFunctionCall call = array.getFunctionCall();
                if ((call == null) || (array.dbvendor != EDbVendor.dbvbigquery) || (call.getFunctionName() == null)
                        || (call.getFunctionName().getSchemaToken() != null)) {
                    return false;
                }
                String function = call.getFunctionName().toString();
                return function.equalsIgnoreCase("GENERATE_ARRAY") // non-identifier-compare: built-in function names
                        || function.equalsIgnoreCase("GENERATE_DATE_ARRAY") // non-identifier-compare: built-in function name
                        || function.equalsIgnoreCase("GENERATE_TIMESTAMP_ARRAY") // non-identifier-compare: built-in function name
                        || function.equalsIgnoreCase("SPLIT"); // non-identifier-compare: built-in function name
            case simple_object_name_t:
                return hasScalarElements(array.getObjectOperand(), depth + 1);
            default:
                return false;
        }
    }

    /** Whether the column of a CTE or derived table that {@code column} reads is defined as an array of no STRUCTs. */
    private static boolean hasScalarElements(TObjectName column, int depth) {
        TExpression definition = definingExpression(column, depth);
        return (definition != null) && hasScalarElements(definition, depth + 1);
    }

    /** The expression that defines the column of a CTE or derived table {@code column} reads, or null. */
    private static TExpression definingExpression(TObjectName column, int depth) {
        if ((column == null) || (column.getSourceTable() == null) || (depth > 8)) return null;
        TTable source = column.getSourceTable();
        TSelectSqlStatement query = null;
        if (source.isCTEName() && (source.getCTE() != null)) {
            // a column list renames by position; not followed
            if ((source.getCTE().getColumnList() != null) && (source.getCTE().getColumnList().size() > 0)) return null;
            query = source.getCTE().getSubquery();
        } else if (source.getTableType() == ETableSource.subquery) {
            query = source.getSubquery();
        }
        while ((query != null) && query.isCombinedQuery()) query = query.getLeftStmt();
        if ((query == null) || (query.getResultColumnList() == null)) return null;
        for (int i = 0; i < query.getResultColumnList().size(); i++) {
            TResultColumn resultColumn = query.getResultColumnList().getResultColumn(i);
            TExpression expr = resultColumn.getExpr();
            String name = null;
            if ((resultColumn.getAliasClause() != null) && (resultColumn.getAliasClause().getAliasName() != null)) {
                name = resultColumn.getAliasClause().getAliasName().toString();
            } else if ((expr != null) && (expr.getObjectOperand() != null)
                    && (expr.getExpressionType() == EExpressionType.simple_object_name_t)) {
                name = expr.getObjectOperand().getColumnNameOnly();
            }
            if ((name != null) && sameColumn(column.dbvendor, name, column.getColumnNameOnly())) return expr;
        }
        return null;
    }

    /**
     * Whether an UNNEST relation provably has a column {@code columnName} as a field of the STRUCTs its array holds:
     * {@code UNNEST([STRUCT(0 AS a, 1 AS b)])}, or a CTE or derived column defined so, has the columns a and b.
     */
    public static boolean unnestHasStructField(TTable unnest, String columnName) {
        java.util.List<String> fields = unnestStructFieldNames(unnest);
        return (fields != null) && (columnName != null) && containsColumn(unnest.dbvendor, fields, columnName);
    }

    /**
     * The field names of the STRUCTs an UNNEST reads, which are its columns, or null when they are not known or an
     * alias column list names its columns instead. Parse-time linking and resolver2's {@code UnnestNamespace} both
     * read them here.
     */
    public static java.util.List<String> unnestStructFieldNames(TTable unnest) {
        if ((unnest == null) || (unnest.getUnnestClause() == null)) return null;
        TAliasClause alias = unnest.getAliasClause();
        if ((alias != null) && (alias.getColumns() != null) && (alias.getColumns().size() > 0)) return null;
        return structFields(unnest.getUnnestClause());
    }

    /** The field names of the STRUCTs an UNNEST reads, or null when they are not known. */
    private static java.util.List<String> structFields(TUnnestClause clause) {
        if (clause.getArrayExpr() != null) return structFields(clause.getArrayExpr(), 0);
        if (clause.getExprList() != null) {
            return (clause.getExprList().size() == 1) ? structFields(clause.getExprList().getExpression(0), 0) : null;
        }
        if ((clause.getColumns() != null) && (clause.getColumns().size() == 1)) {
            TExpression definition = definingExpression(clause.getColumns().getObjectName(0), 0);
            return (definition == null) ? null : structFields(definition, 1);
        }
        return null;
    }

    /** The field names of an array of STRUCT literals, or of a CTE or derived column defined as one; else null. */
    private static java.util.List<String> structFields(TExpression array, int depth) {
        if ((array == null) || (depth > 8)) return null;
        switch (array.getExpressionType()) {
            case array_t: {
                // a typed array literal, ARRAY<STRUCT<x INT64, y STRING>>[(1, 'a')]: its element type names the fields
                // (plan 09 slice 11)
                java.util.List<String> typed = typedStructFields(array.getTypeName());
                if (typed != null) return typed;
                if ((array.getExprList() == null) || (array.getExprList().size() == 0)) return null;
                java.util.List<String> fields = null;
                for (int i = 0; i < array.getExprList().size(); i++) {
                    java.util.List<String> elementFields = structLiteralFields(array.getExprList().getExpression(i));
                    if (elementFields == null) return null;
                    if (fields == null) fields = elementFields;
                }
                return fields;
            }
            case simple_object_name_t: {
                TExpression definition = definingExpression(array.getObjectOperand(), depth);
                return (definition == null) ? null : structFields(definition, depth + 1);
            }
            default:
                return null;
        }
    }

    /** The field names a STRUCT element type declares ({@code STRUCT<x INT64, y STRING>}); else null. */
    private static java.util.List<String> typedStructFields(TTypeName type) {
        if ((type == null) || (type.getDataType() != EDataType.struct_t) || (type.getColumnDefList() == null)
                || (type.getColumnDefList().size() == 0)) {
            return null;
        }
        java.util.List<String> fields = new java.util.ArrayList<>();
        for (int i = 0; i < type.getColumnDefList().size(); i++) {
            TColumnDefinition definition = type.getColumnDefList().getColumn(i);
            if ((definition == null) || (definition.getColumnName() == null)) return null;
            fields.add(definition.getColumnName().toString());
        }
        return fields;
    }

    /** The field names of a STRUCT literal, {@code STRUCT(0 AS a, 1 AS b)} or {@code STRUCT<a INT64>(0)}; else null. */
    private static java.util.List<String> structLiteralFields(TExpression element) {
        if ((element == null) || (element.getExpressionType() != EExpressionType.function_t)
                || (element.getFunctionCall() == null)
                || (element.getFunctionCall().getFunctionType() != EFunctionType.struct_t)) {
            return null;
        }
        TFunctionCall struct = element.getFunctionCall();
        java.util.List<String> fields = new java.util.ArrayList<>();
        if ((struct.getFieldDefs() != null) && (struct.getFieldDefs().size() > 0)) {
            for (int i = 0; i < struct.getFieldDefs().size(); i++) {
                TColumnDefinition definition = struct.getFieldDefs().getColumn(i);
                if ((definition == null) || (definition.getColumnName() == null)) return null;
                fields.add(definition.getColumnName().toString());
            }
            return fields;
        }
        if ((struct.getFieldValues() == null) || (struct.getFieldValues().size() == 0)) return null;
        for (int i = 0; i < struct.getFieldValues().size(); i++) {
            TResultColumn value = struct.getFieldValues().getResultColumn(i);
            String name = (value == null) ? null : outputName(value);
            if (name == null) return null;
            fields.add(name);
        }
        return fields;
    }

    private static boolean containsColumn(EDbVendor vendor, java.util.List<String> names, String columnName) {
        for (String name : names) {
            if (sameColumn(vendor, name, columnName)) return true;
        }
        return false;
    }

    private static boolean namesColumn(EDbVendor vendor, TObjectNameList names, String columnName) {
        for (int i = 0; i < names.size(); i++) {
            TObjectName name = names.getObjectName(i);
            if ((name != null) && sameColumn(vendor, name.toString(), columnName)) return true;
        }
        return false;
    }

    private static boolean sameColumn(EDbVendor vendor, String a, String b) {
        return gudusoft.gsqlparser.util.SQLUtil.compareIdentifier(vendor, ESQLDataObjectType.dotColumn, a, b);
    }

    /** A catalog table whose columns are all known: an empty list or a star lineage wrote back proves nothing. */
    private static boolean hasAllColumnsKnown(TSQLTable metadata) {
        return (metadata != null) && metadata.hasAllColumnsKnown();
    }

    private static String nullToEmpty(String s) {
        return (s == null) ? "" : s;
    }

    /**
     * Offset clause.
     * <br>
     * <pre>OFFSET 2 ROWS FETCH NEXT 4 ROWS ONLY;</pre>
     * @return {@link TOffsetClause offset clause}
     */
    public TOffsetClause getOffsetClause() {
        return offsetClause;
    }

    /**
     * Fetch first/next clause
     * <br>
     * <pre>OFFSET 2 ROWS FETCH NEXT 4 ROWS ONLY;</pre>
     * @return {@link TFetchFirstClause fetch first/next clause}
     */
    public TFetchFirstClause getFetchFirstClause() {

        return fetchFirstClause;
    }

    private TFetchFirstClause fetchFirstClause;
    private TOffsetClause offsetClause;

    private TOptionClause optionClause;

    /**
     *
     * @return {@link  TOptionClause sql server option clause}
     *
     * @see gudusoft.gsqlparser.nodes.mssql.TOptionClause
     */
    public TOptionClause getOptionClause() {
        return optionClause;
    }


    /**
     *
     * @return {@link TIsolationClause isolation clause}
     */
    public TIsolationClause getIsolationClause() {
        return isolationClause;
    }

    private TIsolationClause isolationClause;

//     private THiveClusterBy hiveClusterBy;
//
//    /**
//     *
//     * @return {@link THiveClusterBy Hive cluster by clause}
//     */
//    public THiveClusterBy getHiveClusterBy() {
//        return hiveClusterBy;
//    }

    private TSortBy sortBy;

    /**
     *
     * @return {@link TSortBy Hive sort by clause}
     */
    public TSortBy getSortBy() {
        return sortBy;
    }

    private TIntoTableClause intoTableClause;

    /**
     *
     * @return {@link TIntoTableClause informix into table clause}
     */
    public TIntoTableClause getIntoTableClause() {
        return intoTableClause;
    }

    public void setSelectToken(TSourceToken selectToken) {
        this.selectToken = selectToken;
    }

    /**
     *
     * @return SELECT token of this query.
     */
    public TSourceToken getSelectToken() {
        return selectToken;
    }

    private TSourceToken selectToken = null;

    private boolean tableQuery = false;

    /**
     * Whether this query was written as {@code TABLE t}, the SQL-standard
     * shorthand for {@code SELECT * FROM t}.
     * <p>
     * Such a query is analyzed as {@code SELECT * FROM t}: t is in
     * {@link #getTables()} and {@link #getJoins()}, and {@link #getResultColumnList()}
     * holds one wildcard result column. That wildcard is synthesized: its tokens
     * are not in the source token list, and the text has no SELECT or FROM
     * keyword, so code that rewrites the token stream (a formatter) must leave
     * the select list and the FROM list of such a query alone.
     *
     * @return true if this query was written as {@code TABLE t}
     */
    public boolean isTableQuery() {
        return tableQuery;
    }

    public static final int SET_OPERATOR_NONE = 0;

    public static final int setOperator_union = 1;
    public static final int setOperator_unionall = 2;
    public static final int SET_OPERATOR_UNIONDISTINCT = 9;

    public static final int setOperator_intersect = 3;
    public static final int setOperator_intersectall = 4;
    public static final int SET_OPERATOR_INTERSECTDISTINCT = 10;

    public static final int setOperator_minus = 5;
    public static final int setOperator_minusall = 6;
    public static final int SET_OPERATOR_MINUSDISTINCT = 11;

    public static final int setOperator_except = 7;
    public static final int setOperator_exceptall = 8;
    public static final int SET_OPERATOR_EXCEPTDISTINCT = 11;

    public boolean isAll() {
        return all;
    }

    private boolean all = false;

    public boolean isSetOpDistinct() {
        return setOpDistinct;
    }

    private boolean setOpDistinct = false;
    private ESetOperatorType setOperatorType = ESetOperatorType.none;

    public ESetOperatorType getSetOperatorType() {
        return setOperatorType;
    }

    private  TWindowClause  windowClause;

    /**
     *
     * @return {@link TWindowClause window clause.}
     */
    public TWindowClause getWindowClause() {
        return windowClause;
    }

    private TPTNodeList <TLockingClause> lockingClauses;

    /**
     *  PostgreSQL, for update of, for read only.
     *  <br>
     * @return list of {@link TLockingClause}
     */
    public TPTNodeList<TLockingClause> getLockingClauses() {
        return lockingClauses;
    }

    /**
     *
     * @return {@link TSelectDistinct distinct clause}
     */
    public TSelectDistinct getSelectDistinct() {
        return selectDistinct;
    }

    private TSelectDistinct selectDistinct = null;

    /**
     *
     * @return {@link gudusoft.gsqlparser.nodes.TIntoClause into clause}
     */
    public TIntoClause getIntoClause() {
        return intoClause;
    }

    private TIntoClause intoClause = null;


    private TOrderBy orderbyClause;

    /**
     * @return {@link TOrderBy order by clause}
     */
    public TOrderBy getOrderbyClause() {
        return orderbyClause;
    }

    public TSelectSqlStatement(EDbVendor dbvendor) {
        super(dbvendor);
        sqlstatementtype = ESqlStatementType.sstselect;
    }

    void buildsql() {
    }

    void clear() {
    }

    String getasprettytext() {
        return "";
    }

    void iterate(TVisitorAbs pvisitor) {
    }

    /**
     *
     * @return {@link TQualifyClause teradata qualify clause}
     */
    public TQualifyClause getQualifyClause() {
        return qualifyClause;
    }

    private TQualifyClause qualifyClause = null;
    private TSampleClause sampleClause = null;
    private TTeradataWithClause teradataWithClause = null;

    /**
     * @return {@link TTeradataWithClause Teradata with clause }
     */
    public TTeradataWithClause getTeradataWithClause() {
        return teradataWithClause;
    }

    /**
     *
     * @return {@link gudusoft.gsqlparser.nodes.TSampleClause SQL Server sample clause}
     */
    public TSampleClause getSampleClause() {
        return sampleClause;
    }

    /**
     * @return {@link gudusoft.gsqlparser.nodes.TForUpdate for update clause}
     */
    public TForUpdate getForUpdateClause() {
        return forUpdateClause;
    }

    private TForUpdate forUpdateClause;

    /**
     *
     * @return {@link TComputeClause SQL Server compute clause}
     */
    public TComputeClause getComputeClause() {
        return computeClause;
    }

    private TComputeClause computeClause = null;

    /**
     * @return  {@link TGroupBy group by clause and having clause}
     */
    public TGroupBy getGroupByClause() {
        return groupByClause;
    }

    private TGroupBy groupByClause = null;


    /**
     * Oracle hierarchical_query_clause
     * @return {@link gudusoft.gsqlparser.nodes.THierarchical Oracle hierarchical_query_clause}
     */
    public THierarchical getHierarchicalClause() {
        return hierarchicalClause;
    }

    private THierarchical hierarchicalClause = null;

    /**
     * MySQL,PostgreSQL limit clause
     * @return {@link TLimitClause MySQL,PostgreSQL limit clause}
     */
    public TLimitClause getLimitClause() {
        return limitClause;
    }

    private TLimitClause limitClause = null;


    private TExpandOnClause expandOnClause;

    /**
     *
     * @return {@link TExpandOnClause Teradata expand on clause}
     */
    public TExpandOnClause getExpandOnClause() {
        return expandOnClause;
    }

    /**
     *
     * The set operators UNION, EXCEPT, and INTERSECT correspond to the relational operators union, difference, and intersection.
     * @return  set operator of this statement.If a set operator is not used, setOperator_none will be returned.
     * otherwise, set operand can be fetched by using getLeftStmt() and getRightStmt().
     *
     * @deprecated As of v1.6.4.2, use {@link #getSetOperatorType()}  and {@link #isAll()} instead.
     */
    public int getSetOperator() {
        return setOperator;
    }

    private int setOperator = 0;

    /**
     * Valid when {@link #getSetOperator} is not setOperator_none.
     * @return left side query expression
     */
    public TSelectSqlStatement getLeftStmt() {
        return leftStmt;
    }

    public TSelectSqlStatement getFarLeftStmt() {
        TSelectSqlStatement current = leftStmt;
        while (current.isCombinedQuery()) {
            current = current.getLeftStmt();
        }
        return current;
    }

    /**
     * Valid when {@link #getSetOperator} is not setOperator_none.
     * @return right side query expression.
     */
    public TSelectSqlStatement getRightStmt() {
        return rightStmt;
    }

    private TSelectSqlStatement leftStmt;
    private TSelectSqlStatement rightStmt;

    private TValueClause valueClause = null;

    private String oracleHint;

    private String hint;

    private boolean isValueClause = false;

    public boolean isValueClause() {
        return isValueClause;
    }

    /**
     * Hint for Oracle and MySQL
     *
     * @return hint string
     */
    public String getHint() {
        return hint;
    }

    /**
     * Hint for Oracle and MySQL
     *
     * @return  hint string.
     */
    /**
     * @deprecated As of 2.0.4.5, replaced by {@link #getHint()}
     */
    public String getOracleHint() {
        return oracleHint;
    }

    private THiveHintClause hiveHintClause;

    /**
     *
     * @return {@link THiveHintClause Hive hint clause}
     */
    public THiveHintClause getHiveHintClause() {
        return hiveHintClause;
    }

    private THiveTransformClause transformClause;

    /**
     *
     * @return {@link THiveTransformClause Hive from clause}
     */
    public THiveTransformClause getTransformClause() {
        return transformClause;
    }

    private TDistributeBy distributeBy;

    /**
     *
     * @return {@link TDistributeBy Hive distribute by clause}
     */
    public TDistributeBy getDistributeBy() {
        return distributeBy;
    }

    /**
     * DB2 value clause
     * @return {@link TValueClause DB2 value clause}
     */
    public TValueClause getValueClause() {
        return valueClause;
    }

    public void setChildOfCombinedQuery(boolean childOfCombinedQuery) {
        this.childOfCombinedQuery = childOfCombinedQuery;
    }

    public boolean isChildOfCombinedQuery() {

        return childOfCombinedQuery;
    }

    private boolean childOfCombinedQuery = false;


    @Override
    public TreeMap<String,TResultColumn> getExpandedResultColumns() {
        if (this.setOperatorType == ESetOperatorType.none){
            return super.getExpandedResultColumns();
        }else{
            return this.getLeftStmt().getExpandedResultColumns();
        }
    }

    private ArrayList<TSelectSqlStatement> flattenSelects = null;

    public ArrayList<TSelectSqlStatement> getFlattenedSelects() {
        if (!isCombinedQuery()) return null;
        if (this.flattenSelects != null) return this.flattenSelects;

        this.flattenSelects = new ArrayList<TSelectSqlStatement>();
        this.flattenSelects.add(this.rightStmt);
        doFlattenCombinedSelect(this.leftStmt,this.flattenSelects);

        Collections.reverse(this.flattenSelects);
        return flattenSelects;
    }

    void doFlattenCombinedSelect(TSelectSqlStatement select, ArrayList<TSelectSqlStatement> container){
        TSelectSqlStatement current = select;
        while (current.isCombinedQuery()){
            container.add(current.getRightStmt());
            current = current.getLeftStmt();
        }
        container.add(current);
    }

    /**
     * This function is used internal. DON'T call it explicitly.
     *
     * @param psql input query.
     * @return  zero means there is no syntax error detected.
     */
    public int doParseStatement(TCustomSqlStatement psql) {
        if (rootNode == null) return -1;

        if ((rootNode instanceof TSelectSqlNode)
                && (this.sourcetokenlist.size() == 0)){
            // subquery nested in other statements.
            TSelectSqlNode selectNode = (TSelectSqlNode)rootNode;
            this.setStartToken(selectNode.getStartToken());
            this.setEndToken(selectNode.getEndToken());
        }

        super.doParseStatement(psql);

        if (!(rootNode instanceof TSelectSqlNode)) {
            return reportInvalidSelectStatement();
        }

        TSelectSqlNode selectNode = (TSelectSqlNode)rootNode;
        // TABLE t is SELECT * FROM t: give it that FROM list and select list
        // before anything reads them, so it is analyzed exactly like that query.
        selectNode.expandTableQuery();
        tableQuery = (selectNode.getRelationExpr() != null) && !selectNode.isCombinedQuery();
        if (hasInvalidResultColumnList(selectNode, psql)) {
            return reportInvalidSelectStatement();
        }

        this.selectToken = selectNode.getSelectToken();
        parenthesisCount = selectNode.getParenthesisCount();
        parenthesisCountBeforeOrder = selectNode.getParenthissisCountBeforeOrder();

        setOperator = selectNode.getSetOperator();
        initSetOperatorFields();

        if(selectNode.isCombinedQuery()){
            TCustomSqlStatement lcParentSql = psql;
            if ((lcParentSql == null)||(!childOfCombinedQuery)){
                lcParentSql = this;
            }

            if (selectNode.cteList != null){
                this.setCteList(selectNode.cteList);
                for(int i=0;i<getCteList().size();i++){
                    getCteList().getCTE(i).doParse(this,ESqlClause.cte);
                }
            }

            // Oracle 12c WITH FUNCTION/PROCEDURE support
            if (selectNode.getWithPlsqlItems() != null){
                this.setWithPlsqlItems(selectNode.getWithPlsqlItems());
            }

            // Iterative construction of the left-recursive UNION/INTERSECT/EXCEPT chain.
            // This avoids StackOverflow for queries with many set operations (e.g., 2000+ UNION ALL).
            // We collect the chain of combined query nodes, set up their properties top-down,
            // then process leaf children and clauses from deepest to shallowest.

            ArrayList<TSelectSqlStatement> stmtChain = new ArrayList<>();
            ArrayList<TSelectSqlNode> nodeChain = new ArrayList<>();

            stmtChain.add(this);
            nodeChain.add(selectNode);

            TSelectSqlStatement currentStmt = this;
            TSelectSqlNode currentNode = selectNode;

            // Walk down the left chain, creating intermediate TSelectSqlStatements
            while (currentNode.getLeftNode() != null && currentNode.getLeftNode().isCombinedQuery()) {
                TSelectSqlNode leftNode = currentNode.getLeftNode();

                TSelectSqlStatement nextStmt = new TSelectSqlStatement(dbvendor);
                nextStmt.rootNode = leftNode;
                nextStmt.setChildOfCombinedQuery(true);

                // Wire up parent's leftStmt
                currentStmt.leftStmt = nextStmt;

                // Inline common setup (equivalent of super.doParseStatement + field init)
                if (nextStmt.sourcetokenlist.size() == 0) {
                    nextStmt.setStartToken(leftNode.getStartToken());
                    nextStmt.setEndToken(leftNode.getEndToken());
                }
                // Equivalent of TCustomSqlStatement.doParseStatement(lcParentSql)
                nextStmt.setParentStmt(lcParentSql);
                nextStmt.setFrameStack(lcParentSql.getFrameStack());
                lcParentSql.getStmtScope().incrementCurrentStmtIndex();
                nextStmt.setQueryId(String.format("%s#stmt_%d_%s",
                        lcParentSql.getQueryId(),
                        lcParentSql.getStmtScope().getCurrentStmtIndex(),
                        nextStmt.sqlstatementtype));
                nextStmt.setStmtScope(new TStmtScope(lcParentSql.getStmtScope(), nextStmt));
                if (nextStmt.getStartToken() == null && nextStmt.rootNode != null) {
                    nextStmt.setStartToken(nextStmt.rootNode.getStartToken());
                }
                if (nextStmt.getEndToken() == null && nextStmt.rootNode != null) {
                    nextStmt.setEndToken(nextStmt.rootNode.getEndToken());
                }
                if (nextStmt.getGsqlparser() == null && nextStmt.rootNode != null) {
                    nextStmt.setGsqlparser(nextStmt.rootNode.getGsqlparser());
                }

                nextStmt.selectToken = leftNode.getSelectToken();
                nextStmt.parenthesisCount = leftNode.getParenthesisCount();
                nextStmt.parenthesisCountBeforeOrder = leftNode.getParenthissisCountBeforeOrder();
                nextStmt.setOperator = leftNode.getSetOperator();
                nextStmt.initSetOperatorFields();

                stmtChain.add(nextStmt);
                nodeChain.add(leftNode);

                currentStmt = nextStmt;
                currentNode = leftNode;
            }

            // Create and process the leftmost leaf (non-combined SELECT)
            TSelectSqlStatement leftmostLeaf = new TSelectSqlStatement(dbvendor);
            leftmostLeaf.rootNode = currentNode.getLeftNode();
            leftmostLeaf.setChildOfCombinedQuery(true);
            currentStmt.leftStmt = leftmostLeaf;
            leftmostLeaf.doParseStatement(lcParentSql);

            // Process right children and clauses from deepest to shallowest
            for (int i = stmtChain.size() - 1; i >= 0; i--) {
                TSelectSqlStatement stmt = stmtChain.get(i);
                TSelectSqlNode node = nodeChain.get(i);

                // Create and process right child (always a leaf for left-recursive grammar)
                stmt.rightStmt = new TSelectSqlStatement(dbvendor);
                stmt.rightStmt.rootNode = node.getRightNode();
                stmt.rightStmt.setChildOfCombinedQuery(true);
                stmt.rightStmt.doParseStatement(lcParentSql);

                // Handle clauses for this level
                if (node.getOrderbyClause() != null) {
                    node.getOrderbyClause().doParse(stmt, ESqlClause.orderby);
                    stmt.orderbyClause = node.getOrderbyClause();
                }
                stmt.limitClause = node.getLimitClause();
                if (node.getForupdateClause() != null) {
                    node.getForupdateClause().doParse(stmt, ESqlClause.forUpdate);
                    stmt.forUpdateClause = node.getForupdateClause();
                }
                if (node.getComputeClause() != null) {
                    node.getComputeClause().doParse(stmt, ESqlClause.compute);
                    stmt.computeClause = node.getComputeClause();
                }
                stmt.optionClause = node.getOptionClause();
                stmt.timeTravel = node.getTimeTravel();
                stmt.hintClause = node.getHintClause();
            }

            return 0;
        }

        if (selectNode.getValueClause() != null){
            // WITH c AS (...) VALUES (...): the rows may read the CTEs, so the list comes first (Mantis 5017); the
            // early return below used to drop it
            if (selectNode.cteList != null){
                this.setCteList(selectNode.cteList);
                this.getCteList().doParse(this,ESqlClause.cte);
            }
            this.valueClause = selectNode.getValueClause();
            this.valueClause.doParse(this,ESqlClause.selectValue);
            isValueClause = true;
            return 0;
        }

        if (selectNode.getTransformClause() != null){
            this.transformClause = selectNode.getTransformClause();
            this.transformClause.doParse(this,ESqlClause.transformClause);
        }

        if (selectNode.cteList != null){
            this.setCteList(selectNode.cteList);
            this.getCteList().doParse(this,ESqlClause.cte);
        }

        // Oracle 12c WITH FUNCTION/PROCEDURE support
        if (selectNode.getWithPlsqlItems() != null){
            this.setWithPlsqlItems(selectNode.getWithPlsqlItems());
        }

        if (selectNode.isHiveFromQuery()){
            if(selectNode.getSelectSqlNodes() != null){
                for(int i=1;i<selectNode.getSelectSqlNodes().size();i++){
                    //start from the second, the first select statement is represented by this class instance.

                    TSelectSqlStatement select = new TSelectSqlStatement(EDbVendor.dbvhive);
                    select.rootNode = selectNode.getSelectSqlNodes().get(i);
                    select.doParseStatement(this);
                    this.getMultiSelectStatements().add(select);
                }
            }

            // Hive: from query insert...
//            if (selectNode.getFromTableList() != null){
//                TFromTable lcFromTable;
//                TJoin lcJoin;
//
//                for(int i=0; i<selectNode.getFromTableList().size();i++){
//                    lcFromTable = selectNode.getFromTableList().getFromTable(i);
//                    TTable lcTable = null;
//
//                    if (lcFromTable.getFromtableType() != ETableSource.join){
//                        lcJoin = new TJoin();
//                        lcTable = analyzeFromTable(lcFromTable,true);
//                        lcTable.setEffectType(ETableEffectType.tetSelect);
//                        lcJoin.setTable(lcTable);
//                        lcJoin.setStartToken(lcJoin.getTable().getStartToken());
//                        lcJoin.setEndToken(lcJoin.getTable().getEndToken());
//                        lcJoin.setGsqlparser(getGsqlparser());
//                    }else{
//                        lcJoin = analyzeJoin(lcFromTable.getJoinExpr(),null,true);
//                        lcJoin.doParse(this, ESqlClause.join);
//
//                        if (lcFromTable.getLateralViewList() != null){
//                            for(TLateralView lateralView:lcFromTable.getLateralViewList()){
//                                addToTables(lateralView.createATable(this));
//                            }
//                        }
//                    }
//
//                    joins.addJoin(lcJoin);
//                }
//            }


//            if (selectNode.getHiveBodyList() != null){
//                for(int i = 0; i<selectNode.getHiveBodyList().size();i++){
//                    TParseTreeNode node1 = selectNode.getHiveBodyList().get(i);
//                    switch (node1.getNodeType()){
//                        case TStatementSqlNode.select:
//                            TSelectSqlStatement select = new TSelectSqlStatement(EDbVendor.dbvhive);
//                            select.rootNode = node1;
//                            select.doParseStatement(this);
//                            this.getHiveBodyList().add(select);
//
//                            break;
//                        case TStatementSqlNode.insert:
//
//                            TInsertSqlStatement insert = new TInsertSqlStatement(EDbVendor.dbvhive);
//                            insert.rootNode = node1;
//                            insert.doParseStatement(this);
//                            this.getHiveBodyList().add(insert);
//                            break;
//                        default:
//                            break;
//                    }
//                }
//            }
           // return 0;
        }

        // get oracle hint
        if((dbvendor == EDbVendor.dbvoracle)||isMySQLDialect()){ // MySQL includes an OceanBase MySQL tenant (Mantis 4813)
            TSourceToken lcnextst = this.selectToken.container.nextsolidtoken(this.selectToken.posinlist,1,true);
            while (lcnextst != null){
                if (!((lcnextst.tokentype == ETokenType.ttsimplecomment) || (lcnextst.tokentype == ETokenType.ttbracketedcomment))) break;

                if (lcnextst.tokentype == ETokenType.ttbracketedcomment){
                    if (lcnextst.toString().startsWith("/*+")){
                       //lcnextst.setDbObjType(TObjectName.ttObjOracleHint);
                       lcnextst.setDbObjectType(EDbObjectType.oracleHint);
                       if (oracleHint == null){
                           oracleHint = lcnextst.toString();
                       }else {
                           oracleHint = oracleHint + " " + lcnextst.toString();
                       }
                    }
                }

                if (lcnextst.tokentype == ETokenType.ttsimplecomment){
                    if (lcnextst.toString().startsWith("--+")){
                       //lcnextst.setDbObjType(TObjectName.ttObjOracleHint);
                        lcnextst.setDbObjectType(EDbObjectType.oracleHint);
                       if (oracleHint == null){
                           oracleHint = lcnextst.toString();
                       }else {
                           oracleHint = oracleHint + " " + lcnextst.toString();
                       }
                    }
                }

                lcnextst = lcnextst.container.nextsolidtoken(lcnextst,1,true);
            }

            hint = oracleHint;
        }

        if (selectNode.getHiveHintClause() != null){
            hiveHintClause = selectNode.getHiveHintClause();
        }

        isConsume = selectNode.isConsume();

        if (selectNode.getTopClause() != null){
           selectNode.getTopClause().doParse(this,ESqlClause.top);
            this.setTopClause(selectNode.getTopClause()); 
        }

 //       this.skipOffset = selectNode.getSkipOffset();
//        this.firstMax = selectNode.getFirstMax();
//        this.limitMax = selectNode.getLimitMax();

        if (selectNode.getSelectDistinct() != null){
            this.selectDistinct = selectNode.getSelectDistinct();
        }

        this.selectModifiers = selectNode.getSelectModifiers();

        TFromTable lcFromTable = null;
        TJoin lcJoin = null;

        if (selectNode.getFromTableList() != null){
            fromClause = new TFromClause(this.getRelations());
            fromClause.setStartToken(selectNode.getFromTableList().getStartToken());
            fromClause.setEndToken(selectNode.getFromTableList().getEndToken());

            for(int i=0; i<selectNode.getFromTableList().size();i++){
                 lcFromTable = selectNode.getFromTableList().getFromTable(i);
                 lcJoin = analyzeTableOrJoin(lcFromTable);
                 joins.addJoin(lcJoin);
            }
        }

        // ClickHouse expression-CTEs (WITH <expr> AS ident) are evaluated in
        // this statement's own scope, so their column references can only
        // link once the FROM clause above has populated tables — the
        // cteList.doParse earlier in this method runs before that.
        if ((dbvendor == EDbVendor.dbvclickhouse) && (this.getCteList() != null)){
            for(int i=0;i<getCteList().size();i++){
                TCTE lcCte = getCteList().getCTE(i);
                if (lcCte.getExpression() != null){
                    lcCte.getExpression().doParse(this,ESqlClause.cte);
                }
            }
        }

        // Publish the hierarchical clause before the select list is parsed.
        // doParse() for the clause itself still runs in its usual place below;
        // this only makes getHierarchicalClause() answer truthfully while the
        // result columns are being linked, which is when
        // TCustomSqlStatement.isOraclePseudoColumnReference() needs to know
        // whether CONNECT_BY_ISLEAF / CONNECT_BY_ISCYCLE are pseudocolumns
        // here or ordinary identifiers (Mantis #4675).
        if (selectNode.getHierarchicalClause() != null){
            this.hierarchicalClause = selectNode.getHierarchicalClause();
        }

        if (selectNode.getResultColumnList() != null){
            this.setResultColumnList(selectNode.getResultColumnList());

//            if ((this.getResultColumnList().size() > 10)
//                    &&(this.getTables().size() == 1)
//                    &&(this.getTables().getTable(0).getTableType() == ETableSource.subquery)
//                    &&( this.getTables().getTable(0).getSubquery().getResultColumnList().size() == this.getResultColumnList().size() )
//            ){
//                TTable t0 = this.getTables().getTable(0);
//                ArrayList<TResultColumn> targetColumnArrayList = this.getResultColumnList().getSortedColumns();
//                ArrayList<TResultColumn> sourceColumnArrayList = t0.getSubquery().getResultColumnList().getSortedColumns();
//                int i=0;
//                for(TResultColumn rc:targetColumnArrayList){
//                    TObjectName targetColumn = rc.getExpr().getObjectOperand();
//                    TResultColumn sourceResultColumn = sourceColumnArrayList.get(i++);
//                    //TObjectName sourceColumn = sourceResultColumn.getExpr().getObjectOperand();
//                    if (targetColumn != null){
//                        //System.out.println(targetColumn+"\t->\t"+sourceResultColumn.getDisplayName());
//                        targetColumn.setSourceTable(t0);
//                        t0.getLinkedColumns().addObjectName(targetColumn);
//                        targetColumn.setSourceColumn(sourceResultColumn);
//                        sourceResultColumn.getTargetColumns().addObjectName(targetColumn);
//                    }
//                }
//            }

            selectNode.getResultColumnList().doParse(this,ESqlClause.selectList);

            // Slice 73: link DISTINCT ON expression list (PostgreSQL /
            // Greenplum `SELECT DISTINCT ON (cols) ...`) so each
            // TObjectName inside gets dbObjectType=column and
            // sourceTable populated. Without this, the expressions
            // remain EDbObjectType.unknown. The legacy column-linker
            // (linkColumnToTable) is invoked here via TExpression.doParse;
            // resolver-2 picks the same expressions up via the
            // TSelectDistinct.acceptChildren descent that slice 73
            // also wires up. Tables are populated by the FROM clause
            // loop above so column linking has a relation list to
            // resolve against. Mirrors the TGroupBy.doParse →
            // items.doParse pattern.
            if (this.selectDistinct != null
                    && this.selectDistinct.getExpressionList() != null) {
                TExpressionList distinctOnExprList =
                        this.selectDistinct.getExpressionList();
                for (int i = 0; i < distinctOnExprList.size(); i++) {
                    TExpression e = distinctOnExprList.getExpression(i);
                    if (e != null) {
                        e.doParse(this, ESqlClause.unknown);
                    }
                }
            }

            for(int i=0;i<selectNode.getResultColumnList().size();i++){
                TResultColumn resultColumn = selectNode.getResultColumnList().getResultColumn(i);
                TExpression expression = resultColumn.getExpr();
                String expressionText = expression.toString();
                if (expressionText.endsWith("*")){
                    TTable starSourceTable = null;
                    //System.out.println(resultColumn.toString()+":"+resultColumn.getStartToken().lineNo+","+resultColumn.getStartToken().columnNo);
                    if (expressionText.startsWith("*")){
                        // add all result columns in from tables
                        for(int j=0;j<getTables().size();j++){
                            if (getTables().getTable(j).getTableType() == ETableSource.subquery){
                                getExpandedResultColumns().putAll(getTables().getTable(j).getSubquery().getExpandedResultColumns());
                            }else{
                                // ToDo for real table
                            }
                            //System.out.println("\t"+getTables().getTable(j).toString()+",\t"+getTables().getTable(j).getTableType()+",\t"+getTables().getTable(j).isCTEName());
                        }
                        if (getTables().size() == 1){
                            starSourceTable = getTables().getTable(0);
                        }

                    }else{
                        for(int j=0;j<getTables().size();j++){
                            if (getTables().getTable(j).getAliasName().equalsIgnoreCase( resultColumn.toString().split("[.]")[0])){
                                if (getTables().getTable(j).getTableType() == ETableSource.subquery){
                                    getExpandedResultColumns().putAll(getTables().getTable(j).getSubquery().getExpandedResultColumns());
                                }else{
                                    // ToDo for real table
                                }
                                starSourceTable = getTables().getTable(j);
                                break;
                            }
                        }
                    }
                    if (starSourceTable != null) {
                        TObjectName objectOperand = expression.getObjectOperand();
                        if (objectOperand == null) {
                            return reportInvalidSelectStatement();
                        }
                        objectOperand.setSourceTable(starSourceTable);
                    }
                }else{
                    String expandedKey = IdentifierService.normalizeStatic(this.dbvendor, ESQLDataObjectType.dotColumn,resultColumn.getDisplayName());
                    if (expandedKey == null){
                        return reportInvalidSelectStatement();
                    }
                    getExpandedResultColumns().put(expandedKey,resultColumn);
                }
            }
        }

        if (selectNode.getIntoClause() != null){
            this.intoClause = selectNode.getIntoClause();
            this.intoClause.doParse(this,ESqlClause.selectInto);
        }


        if (selectNode.getWhereCondition() != null){
            selectNode.getWhereCondition().doParse(this,ESqlClause.where);
            this.setWhereClause( selectNode.getWhereCondition());
        }

        if (selectNode.getHierarchicalClause() != null){
         selectNode.getHierarchicalClause().doParse(this,ESqlClause.hierarchical);
         this.hierarchicalClause = selectNode.getHierarchicalClause();
        }

        if (selectNode.getGroupByClause() != null){
            selectNode.getGroupByClause().doParse(this,ESqlClause.groupby);
            this.groupByClause = selectNode.getGroupByClause(); 
        }

        if (selectNode.getQualifyClause() != null){
            selectNode.getQualifyClause().doParse(this,ESqlClause.qualify);
            this.qualifyClause = selectNode.getQualifyClause(); 
        }

        if (selectNode.getSampleClause() != null){
            selectNode.getSampleClause().doParse(this,ESqlClause.sample);
            this.sampleClause = selectNode.getSampleClause();
        }

        if (selectNode.getExpandOnClause() != null){
            selectNode.getExpandOnClause().doParse(this,ESqlClause.expandOn);
            this.expandOnClause = selectNode.getExpandOnClause();
        }

        if (selectNode.getWithClause() != null){
            selectNode.getWithClause().doParse(this,ESqlClause.teradataWith);
            this.teradataWithClause  = selectNode.getWithClause();
        }

        if (selectNode.getOrderbyClause() != null){
            selectNode.getOrderbyClause().doParse(this,ESqlClause.orderby);
            this.orderbyClause = selectNode.getOrderbyClause(); 
        }

        if (selectNode.getLockingClauses() != null){
           selectNode.getLockingClauses().doParse(this,ESqlClause.lockingClause);
            this.lockingClauses = selectNode.getLockingClauses();
        }

        this.sortBy = selectNode.getSortBy();
        if (this.sortBy != null){
            this.sortBy.doParse(this,ESqlClause.sortby);
        }

        this.clusterBy = selectNode.getClusterBy();
        if (this.clusterBy != null){
            this.clusterBy.doParse(this,ESqlClause.cluster);
        }

        this.windowClause = selectNode.getWindowClause();
        if (this.windowClause != null){
            this.windowClause.doParse(this,ESqlClause.windowClause);
        }
        this.limitClause = selectNode.getLimitClause();
        if (this.limitClause != null){
            this.limitClause.doParse(this,ESqlClause.limit);
        }

       if (selectNode.getForupdateClause() != null){
            selectNode.getForupdateClause().doParse(this,ESqlClause.forUpdate);
            this.forUpdateClause  = selectNode.getForupdateClause();
        }

        if (selectNode.getComputeClause() != null){
            selectNode.getComputeClause().doParse(this,ESqlClause.compute);
            this.computeClause = selectNode.getComputeClause(); 
        }

        this.intoTableClause = selectNode.getIntoTableClause();

        if (selectNode.getDistributeBy() != null){
            this.distributeBy = selectNode.getDistributeBy();
            this.distributeBy.doParse(this,ESqlClause.distributeBy);
        }


        this.isolationClause = selectNode.getIsolationClause();

        this.optionClause = selectNode.getOptionClause();

        this.offsetClause = selectNode.getOffsetClause();
        this.fetchFirstClause = selectNode.getFetchFirstClause();

        this.timeTravel = selectNode.getTimeTravel();
        this.hintClause = selectNode.getHintClause();

        if (selectNode.getForXMLClause() != null){
            if (tables.size() > 0){
                tables.getTable(0).setForXMLClause(selectNode.getForXMLClause());
            }
        }

        // StarRocks pipe operator support
        this.pipeOperators = selectNode.getPipeOperators();
        this.isPipeQuery = selectNode.isPipeQuery();

        return 0;
    }

    private boolean hasInvalidResultColumnList(TSelectSqlNode selectNode,
            TCustomSqlStatement psql) {
        TResultColumnList resultColumns = selectNode.getResultColumnList();
        if (resultColumns == null) {
            return false;
        }

        for (int i = 0; i < resultColumns.size(); i++) {
            TResultColumn resultColumn = resultColumns.getResultColumn(i);
            if ((resultColumn == null) || (resultColumn.getExpr() == null)) {
                return true;
            }

            TExpression expression = resultColumn.getExpr();
            String expressionText = expression.toString();
            if (expressionText == null) {
                return true;
            }
            if (!expressionText.endsWith("*")
                    && (resultColumn.getDisplayName() == null)) {
                return true;
            }
        }

        if (((dbvendor == EDbVendor.dbvmssql)
                || (dbvendor == EDbVendor.dbvoracle))
                && (psql instanceof TInsertSqlStatement)
                && (resultColumns.getEndToken() != null)
                && (resultColumns.getEndToken().container != null)) {
            TSourceToken resultListEnd = resultColumns.getEndToken();
            TSourceToken nextToken = resultListEnd.container
                    .nextsolidtoken(resultListEnd, 1, true);
            if ((nextToken != null) && (nextToken.tokencode == ',')) {
                TSourceToken tokenAfterComma = nextToken.container
                        .nextsolidtoken(nextToken, 1, true);
                if ((tokenAfterComma != null)
                        && (tokenAfterComma.tokencode == TBaseType.rrw_from)) {
                    return true;
                }
            }
        }

        return false;
    }

    private int reportInvalidSelectStatement() {
        TSourceToken errorToken = rootNode.getStartToken();
        if ((errorToken == null) && (sourcetokenlist.size() > 0)) {
            errorToken = sourcetokenlist.get(0);
        }
        if (errorToken != null) {
            parseerrormessagehandle(new TSyntaxError(errorToken,
                    "invalid SELECT statement", EErrorType.sperror,
                    TBaseType.MSG_ERROR_SYNTAX_ERROR, this));
        } else {
            parseerrormessagehandle(new TSyntaxError("SELECT", 0, 0,
                    "invalid SELECT statement", EErrorType.sperror,
                    TBaseType.MSG_ERROR_SYNTAX_ERROR, this, -1));
        }
        return TBaseType.MSG_ERROR_SYNTAX_ERROR;
    }

    /**
     * Determine whether The UNION, EXCEPT and INTERSECT operators were used.
     * @return true if one of those operators were used.
     */
    public boolean isCombinedQuery(){
    // combine multiple queries using the set operators UNION, UNION ALL, INTERSECT, and MINUS.
        return (setOperator > 0);
    }

    /**
     * Initialize setOperatorType, all, and setOpDistinct fields from setOperator value.
     * Used by doParseStatement's iterative combined query construction.
     */
    private void initSetOperatorFields() {
        switch (setOperator) {
            case SET_OPERATOR_NONE:
                setOperatorType = ESetOperatorType.none; all = false; break;
            case setOperator_union:
                setOperatorType = ESetOperatorType.union; all = false; break;
            case setOperator_unionall:
                setOperatorType = ESetOperatorType.union; all = true; break;
            case SET_OPERATOR_UNIONDISTINCT:
                setOperatorType = ESetOperatorType.union; setOpDistinct = true; break;
            case setOperator_intersect:
                setOperatorType = ESetOperatorType.intersect; all = false; break;
            case setOperator_intersectall:
                setOperatorType = ESetOperatorType.intersect; all = true; break;
            case setOperator_except:
                setOperatorType = ESetOperatorType.except; all = false; break;
            case setOperator_exceptall:
                setOperatorType = ESetOperatorType.except; all = true; break;
            case setOperator_minus:
                setOperatorType = ESetOperatorType.minus; all = false; break;
            case setOperator_minusall:
                setOperatorType = ESetOperatorType.minus; all = true; break;
            case SET_OPERATOR_INTERSECTDISTINCT:
                setOperatorType = ESetOperatorType.intersect; setOpDistinct = true; break;
            case SET_OPERATOR_EXCEPTDISTINCT:
                setOperatorType = ESetOperatorType.except; setOpDistinct = true; break;
        }
    }

    public void accept(TParseTreeVisitor v)
    {
        v.preVisit(this);
        v.postVisit(this);
    }

    /**
     * Accept visitor to visit this class.
     * @param v user defined visitor.
     */
    public void acceptChildren(TParseTreeVisitor v)
    {

        if(this.isCombinedQuery()){

            // Iterative traversal for combined queries to avoid StackOverflow
            // on deeply nested left-recursive UNION/INTERSECT/EXCEPT chains.
            // Collect the left-recursive chain of combined query nodes.
            ArrayList<TSelectSqlStatement> chain = new ArrayList<>();
            TSelectSqlStatement current = this;
            while (current.isCombinedQuery()) {
                chain.add(current);
                current = current.getLeftStmt();
            }
            // 'current' is now the leftmost leaf (non-combined SELECT)

            // Phase 1: preVisit all combined nodes and their CTEs, from root to deepest
            for (int i = 0; i < chain.size(); i++) {
                TSelectSqlStatement node = chain.get(i);
                v.preVisit(node);
                if (node.getCteList() != null) {
                    node.getCteList().acceptChildren(v);
                }
            }

            // Phase 2: Visit leftmost leaf SELECT
            current.acceptChildren(v);

            // Phase 3: Visit right branches and postVisit, from deepest to root
            for (int i = chain.size() - 1; i >= 0; i--) {
                TSelectSqlStatement node = chain.get(i);
                node.getRightStmt().acceptChildren(v);

                if (node.getOrderbyClause() != null) {
                    node.getOrderbyClause().acceptChildren(v);
                }
                if (node.getLimitClause() != null) {
                    node.getLimitClause().acceptChildren(v);
                }
                if (node.getForUpdateClause() != null) {
                    node.getForUpdateClause().acceptChildren(v);
                }
                if (node.getComputeClause() != null) {
                    node.getComputeClause().acceptChildren(v);
                }
                v.postVisit(node);
            }

            return ;
        }

        // System.out.println(this.toString().hashCode()+" "+ this.toString().substring(0,50));

        v.preVisit(this);

        if (this.getTransformClause() != null){
            this.getTransformClause().acceptChildren(v);
        }

        if (this.getCteList() != null){
            this.getCteList().acceptChildren(v);
        }

        if (TBaseType.USE_JOINEXPR_INSTEAD_OF_JOIN){
//            fromClause.acceptChildren(v);
            v.preVisit(fromClause);
            for(TTable table:getRelations()){
                table.acceptChildren(v);
            }
            v.postVisit(fromClause);
        }else{
            if (this.getJoins() != null){
                this.getJoins().acceptChildren(v);
            }
        }

        if (this.getHiveHintClause() != null){
            this.getHiveHintClause().acceptChildren(v);
        }


        if (this.getTopClause() != null){
            this.getTopClause().acceptChildren(v);
        }

        if (this.getSelectDistinct() != null){
            this.getSelectDistinct().acceptChildren(v);
        }
        
        if (this.getResultColumnList() != null){
            this.getResultColumnList().acceptChildren(v);
        }

        if (this.getIntoClause() != null){
            this.getIntoClause().acceptChildren(v);
        }


        if (this.getWhereClause() != null){
            this.getWhereClause().acceptChildren(v);
        }

        if (this.getHierarchicalClause() != null){
            this.getHierarchicalClause().acceptChildren(v);
        }

        if (this.getGroupByClause() != null){
            this.getGroupByClause().acceptChildren(v);
        }

        if (this.getQualifyClause() != null){
            this.getQualifyClause().acceptChildren(v);
        }

        if (this.getSampleClause() != null){
            this.getSampleClause().acceptChildren(v);
        }

        if (this.getExpandOnClause() != null){
            this.getExpandOnClause().acceptChildren(v);
        }

        if (this.getTeradataWithClause() != null){
            this.getTeradataWithClause().acceptChildren(v);
        }

        if (this.getOrderbyClause() != null){
            this.getOrderbyClause().acceptChildren(v);
        }

        if (this.getLockingClauses() != null){
            this.getLockingClauses().acceptChildren(v);
        }

        if (this.getSortBy() != null){
            this.getSortBy().acceptChildren(v);
        }

        if (this.getClusterBy() != null){
            this.getClusterBy().acceptChildren(v);
        }

        if (this.getWindowClause() != null){
            this.getWindowClause().acceptChildren(v);
        }

        if (this.getLimitClause() != null){
            this.getLimitClause().acceptChildren(v);
        }

        if (this.getForUpdateClause() != null){
            this.getForUpdateClause().acceptChildren(v);
        }

        if (this.getComputeClause() != null){
            this.getComputeClause().acceptChildren(v);
        }

        if (this.getIntoTableClause() != null){
            this.getIntoTableClause().acceptChildren(v);
        }

        if (this.getDistributeBy() != null){
            this.getDistributeBy().acceptChildren(v);
        }

        if (this.getIsolationClause() != null){
            this.getIsolationClause().acceptChildren(v);
        }

        if (this.getOptionClause() != null){
            this.getOptionClause().acceptChildren(v);
        }

        if (this.getOffsetClause() != null){
            this.getOffsetClause().acceptChildren(v);
        }

        if (this.getFetchFirstClause() != null){
            this.getFetchFirstClause().acceptChildren(v);
        }

        if (this.getTimeTravel() != null){
            this.getTimeTravel().acceptChildren(v);
        }

        if (this.getHintClause() != null){
            this.getHintClause().acceptChildren(v);
        }

        v.postVisit(this);
        return ;

    };

    /**
     *  Add an order by clause to this class.
     * @param orderByStr new order by string
     * @return added order by clause.
     */
    public  TOrderBy addOrderBy(String orderByStr){
        if (this.getOrderbyClause() != null){
            this.getOrderbyClause().addOrderByItem(orderByStr);
        }else{

            TOrderBy orderBy = new TOrderBy();
            orderBy.setGsqlparser(this.getGsqlparser());
            orderBy.setString(" order by "+orderByStr);
            this.orderbyClause = orderBy;
            TSourceToken last_token = null;
            if (this.getGroupByClause() != null){
                last_token = this.getGroupByClause().getEndToken();
            }else if (this.getWhereClause() != null){
                last_token = this.getWhereClause().getEndToken();
            }else{
                last_token = joins.getEndToken();
            }

            orderbyClause.addAllMyTokensToTokenList(last_token.container, last_token.posinlist+1);

           for(int i=0;i<last_token.getNodesEndWithThisToken().size();i++){
               TParseTreeNode node = last_token.getNodesEndWithThisToken().get(i);
               if (node instanceof TSelectSqlStatement)
               {
                   // change all end token of parse tree node except the last order by item
                   node.setEndToken(orderbyClause.getEndToken());
               }
           }
        }

        return this.getOrderbyClause();
    }

    /**
     *  this function is alias of addWhereClause
     * @param condition new condition
     * @return new where clause
     */
    public TWhereClause addCondition(String condition){
        return  addWhereClause(condition);
    }

    public TWhereClause addConditionOR(String condition){
        return  addWhereClauseOR(condition);
    }

    public  TWhereClause addWhereClause(String condition){
       return doAddWhereClause(condition,true);
    }

    public  TWhereClause addWhereClauseOR(String condition){
       return doAddWhereClause(condition,false);
    }

    protected  TWhereClause doAddWhereClause(String condition, boolean isAnd){

        if (this.getWhereClause() != null){
                if (isAnd){
                    this.getWhereClause().getCondition().addANDCondition(condition);
                }else{
                    this.getWhereClause().getCondition().addORCondition(condition);
                }

          }else{
             TWhereClause whereClause = new TWhereClause();
             whereClause.setGsqlparser(this.getGsqlparser());
             whereClause.setString(" where "+condition);
             this.setWhereClause(whereClause);

            TSourceToken last_token = null;
            TJoin lastjoin = joins.getJoin(joins.size()-1);
            if (lastjoin.getJoinItems().size() > 0){
                TJoinItem lastitem = lastjoin.getJoinItems().getJoinItem(lastjoin.getJoinItems().size()-1);
                 last_token = lastitem.getEndToken();
            }else {
                last_token = joins.getEndToken();
            }

             whereClause.addAllMyTokensToTokenList(last_token.container, last_token.posinlist+1);

            for(int i=0;i<last_token.getNodesEndWithThisToken().size();i++){
                TParseTreeNode node = last_token.getNodesEndWithThisToken().get(i);
                if (!((node instanceof TJoinList)
                        ||(node instanceof TJoin)
                        ||(node instanceof TJoinItemList)
                        ||(node instanceof TJoinItem)
                        ))
                {
                    // change all end token of parse tree node except the last order by item
                    node.setEndToken(whereClause.getEndToken());
                }
            }

          }
           return this.getWhereClause();
    }

    private ArrayList<String> columnsInFromClause = null;


    @Override
    public TFromClause getFromClause() {
        // #todo , select union 类型的 sql 语句，需要穿透到低层的各个 子 select 语句，需要进一步完善
        TFromClause ret = super.getFromClause();
        if ((ret == null)&&(isCombinedQuery()&&(this.getRightStmt()!=null))){
            return   this.getRightStmt().getFromClause();
        }else{
            return  ret;
        }
    }

    public TResultColumnList getResultColumnList(boolean useColumnsFromLeftmost) {
        TResultColumnList ret = super.getResultColumnList();
        if (ret != null) return ret;

        if (isCombinedQuery()){
            if (useColumnsFromLeftmost) {
                return this.getFarLeftStmt().getResultColumnList();
            } else {
                return   this.getRightStmt().getResultColumnList();
            }
        }
        return ret;


//        if ((ret == null)&&(isCombinedQuery()&&(this.getRightStmt()!=null))){
//            return   this.getRightStmt().getResultColumnList();
//        }else{
//            return  ret;
//        }
    }

    @Override
    public TResultColumnList getResultColumnList() {
        return getResultColumnList(false);

//        TResultColumnList ret = super.getResultColumnList();
//        if ((ret == null)&&(isCombinedQuery()&&(this.getRightStmt()!=null))){
//            return   this.getRightStmt().getResultColumnList();
//        }else{
//            return  ret;
//        }
    }

    public ArrayList<String> getColumnsInFromClause() {
        if (columnsInFromClause != null) return columnsInFromClause;
        columnsInFromClause = new ArrayList<String>();
        TTable lcTable;
        for(int j=0;j<tables.size();j++){
            lcTable = tables.getTable(j);
            switch (lcTable.getTableType()){
                case objectname:
                    break;
                case subquery:
                    TSelectSqlStatement subQuery = lcTable.getSubquery();
                                        if (subQuery.getResultColumnList() != null)
                                                for(int i=0;i<subQuery.getResultColumnList().size();i++){
                                                        TResultColumn resultColumn = subQuery.getResultColumnList().getResultColumn(i);
                                                        String aliasName = null;
                                                        if (resultColumn.getAliasClause() != null){
                                                                aliasName = resultColumn.getAliasClause().getAliasName().toString();
                                                        }else{
                                                                if (resultColumn.getExpr().getObjectOperand() != null){
                                                                        aliasName = resultColumn.getExpr().getObjectOperand().toString();
                                                                }
                                                        }
                                                        if (aliasName != null){
                                                                columnsInFromClause.add(TSQLEnv.getObjectName(aliasName));
                                                        }
                                                }
                    break;
            }
        }
        return columnsInFromClause;
    }

    public void addColumnInSelectListToSQLEnv(TSQLTable sqlTable){

        if (sqlTable == null) return;
        if (this.getValueClause() != null) return;
                
                if (this.getResultColumnList() != null)
                        for(int i=0;i<this.getResultColumnList().size();i++){
                                TResultColumn resultColumn = this.getResultColumnList().getResultColumn(i);
                                String aliasName = null;
                                if ((resultColumn.getAliasClause() != null) && (resultColumn.getAliasClause().getAliasName() == null)){
                                        // A tuple alias of Hive and Spark SQL, stack(...) AS (k, v): a column of each name.
                                        TObjectNameList tupleColumns = resultColumn.getAliasClause().getColumns();
                                        for (int k = 0; (tupleColumns != null) && (k < tupleColumns.size()); k++){
                                                sqlTable.addColumn(TSQLEnv.getObjectName(tupleColumns.getObjectName(k).toString()));
                                        }
                                        continue;
                                }
                                if (resultColumn.getAliasClause() != null){
                                        aliasName = resultColumn.getAliasClause().getAliasName().toString();
                                }else{
                                        if (resultColumn.getExpr().getObjectOperand() != null){
                                                aliasName = resultColumn.getExpr().getObjectOperand().toString();
                                        }
                                }
                                if (aliasName != null){
                                        TObjectName operand = resultColumn.getAliasClause() == null ? resultColumn.getExpr().getObjectOperand() : null;
                                        if (operand != null && operand.getPartToken() != null
                                                        && operand.getPartToken().tokentype == ETokenType.ttasterisk) {
                                                // The view's width is not known here: a star, not a column named *.
                                                sqlTable.addUnresolvedStar();
                                        } else {
                                                sqlTable.addColumn(TSQLEnv.getObjectName(aliasName));
                                        }
                                }
                        }
    }

    /**
     * search column in the select list
     *
     * Internal function, DON'T call it explicitly.
     * @param pColumn
     * @param pMustIn
     * @return true if found.
     */
    public boolean searchColumnInResultSet(TObjectName pColumn,boolean pMustIn){
        boolean lcResult = false;
        int candidateTableCnt = 0;
        int numOfColumnStar = 0;
        TResultColumn columnStar = null;



        TResultColumn c = null;
        String lookupKey = IdentifierService.normalizeStatic(this.dbvendor, ESQLDataObjectType.dotColumn,pColumn.getColumnNameOnly());
        if ( (lookupKey != null) && (c=  this.getExpandedResultColumns().get(lookupKey)) != null)
        {
            //System.out.println("Found:"+pColumn.toString());
            pColumn.setSourceColumn(c);
            c.getTargetColumns().addObjectName(pColumn);

            return true;
        }else{
           // System.out.println("NotCatch:"+pColumn.toString());
        }

        if (isCombinedQuery()){
            boolean lcResult1;//,lcResult2;
            // search column in all select
            lcResult1 = getFarLeftStmt().searchColumnInResultSet(pColumn,pMustIn);
            if (!lcResult1)
            lcResult1 = rightStmt.searchColumnInResultSet(pColumn,pMustIn);
            return  lcResult1;
        }

        if (getResultColumnList() == null) return  false;

        if (pColumn.toString().endsWith("*")){
            // pColumn here is o1.*
            // select o1.*, o2.c1
            // from (select c123, c345 from some_table) o1, other_table o2
            pColumn.setColumnsLinkedToStar(this.getResultColumnList());
            return true;
        }

        // search columns in select list, skip t.* but count it for later use
        for(int i=0;i<getResultColumnList().size();i++){
            TResultColumn lcField = getResultColumnList().getResultColumn(i);
            if (lcField.toString().endsWith("*")){
                numOfColumnStar++;
                columnStar = lcField;
                continue;
            }
            lcResult = lcField.isMatchedWithResultColumn(this.dbvendor, pColumn);
            if (lcResult){
                pColumn.setSourceColumn(lcField);
                lcField.getTargetColumns().addObjectName(pColumn);
                break;
            }
        }

        if (lcResult) return true;

//        // search in * column, including t.* and *
        for(int i=0;i<getResultColumnList().size();i++){
            TResultColumn lcField = getResultColumnList().getResultColumn(i);
            if (lcField.toString().endsWith("*")){
                // search column in t.*, have to check column in table t
                String prefixTableName = "";
                if (lcField.toString().endsWith(".*")){
                    String[] a = lcField.toString().split("[.]");
                    prefixTableName = a[a.length - 2];
                }
                for(int j=0;j<tables.size();j++){
                    lcResult = tables.getTable(j).searchColumn(this,prefixTableName,pColumn,false);
                    if (lcResult) {
//                        tables.getTable(j).getLinkedColumns().addObjectName(pColumn);
//                        pColumn.setSourceTable(tables.getTable(j));
                        pColumn.setSourceColumn(lcField);
                        lcField.getTargetColumns().addObjectName(pColumn);
                        break;
                    }
                }
            }else{
                continue;
            }
            if (lcResult) break;
        }

        if (lcResult) return true;

        if (pMustIn){
            if (tables.size() == 1){ // only a single table in from clause
                lcResult = true;
                boolean inStarColumn = false;
//                tables.getTable(0).getLinkedColumns().addObjectName(pColumn);
//                pColumn.setSourceTable(tables.getTable(0));
                for(int i=0;i<getResultColumnList().size();i++) {
                    TResultColumn lcField = getResultColumnList().getResultColumn(i);
                    if (lcField.toString().endsWith("*")) {
                        String prefixTableName = "";
                        if (lcField.toString().endsWith(".*")){
                            String[] a = lcField.toString().split("[.]");
                            prefixTableName = a[a.length - 2];
                        }
                        tables.getTable(0).searchColumn(this,prefixTableName,pColumn,true);
                        pColumn.setSourceColumn(lcField);
                        lcField.getTargetColumns().addObjectName(pColumn);
                        inStarColumn = true;
                        break;
                    }
                }
                if (!inStarColumn){

                    if (!locateVariableOrParameter(pColumn)){
                        // check variable before raise error

                        // raise
                        TSyntaxError err = new TSyntaxError(pColumn.getStartToken().toString()
                                ,pColumn.getStartToken().lineNo,pColumn.getStartToken().columnNo
                                ,String.format("Column %s is not found in subquery",pColumn.toString())
                                ,EErrorType.sphint ,TBaseType.MSG_ERROR_COLUMN_NOT_FOUND,this,pColumn.getStartToken().posinlist);
                        this.parseerrormessagehandle( err);
                    }

                }
            }else if (numOfColumnStar == 1){// only a single * column in select list, but more than one table in from clause

                pColumn.setSourceColumn(columnStar);
                columnStar.getTargetColumns().addObjectName(pColumn);
                if (columnStar.toString().endsWith(".*")){
                    lcResult = true;
                    String[] a = columnStar.toString().split("[.]");
                    String prefixTableName = a[a.length - 2];
                    for(int i=0;i<tables.size();i++){
                        if (tables.getTable(i).checkTableByName(prefixTableName)){
                            tables.getTable(i).searchColumn(this,prefixTableName,pColumn,true);
//                            tables.getTable(i).getLinkedColumns().addObjectName(pColumn);
//                            pColumn.setSourceTable(tables.getTable(i));
                            pColumn.setSourceColumn(columnStar);
                            columnStar.getTargetColumns().addObjectName(pColumn);
                            break;
                        }
                    }
                }else{
                    lcResult = false;
                    // * column, no table prefix, this column can only be in one of tables
                    for(int i=0;i<tables.size();i++){
                        lcResult = tables.getTable(i).searchColumn(this,"",pColumn,false);
                        //tables.getTable(i).getLinkedColumns().addObjectName(pColumn);
                        //pColumn.setSourceTable(tables.getTable(i));
                        pColumn.setSourceColumn(columnStar);
                        columnStar.getTargetColumns().addObjectName(pColumn);
                    }
                }
                if (!lcResult) {
                    lcResult = linkToFirstTable(pColumn,0);
                }
            }else{
                // multi tables in from clause and multi * column in select list.
                lcResult = linkToFirstTable(pColumn,0);
            }
        }

        return lcResult;

        //if (lcResult) return true;

        // From now on, let's search in * column, there maybe more than one * column in the select list, such as t1.*, t2.*
//        TResultColumn resultColumn = getResultColumnList().getResultColumn(0);
//        if ((getResultColumnList().size() == 1) &&(resultColumn.toString().equalsIgnoreCase("*") )){
//            // search in * or t1.* in the select list
//            int tableCntInFromClause = 0;
//            TTable tableInFromClause = null;
//            for(int i=0;i<tables.size();i++){
//                TTable tn = tables.getTable(i);
//                if (tn.getEffectType() == ETableEffectType.tetTeradataReference) continue;
//                tableInFromClause = tn;
//                tableCntInFromClause++;
//            }
//            //if (tables.size() == 1){
//            if (tableCntInFromClause == 1){
//                    //TTable t0 = tables.getTable(0);
//                TTable t0 = tableInFromClause;
//
//                if (t0.isBaseTable()){
//                        lcResult = fireOnMetaDatabaseTableColumn(t0.getPrefixServer(),t0.getPrefixDatabase(),t0.getPrefixSchema(),t0.getName(),pColumn.getColumnNameOnly());
//                        if (! lcResult) candidateTableCnt++;
//                    }else{
//                        if (t0.getTableType() == ETableSource.subquery){
//                            if (t0.isIncludeColumnAlias()){
//                                lcResult = t0.searchColumnInAlias(pColumn);
//                            }else{
//                                lcResult = t0.getSubquery().searchColumnInResultSet(pColumn,pMustIn);
//                                if (! lcResult) candidateTableCnt++;
//                            }
//                        }else if (t0.isCTEName()){
//                            lcResult = t0.getCTE().searchColumnInResultSet(this,t0,pColumn,pMustIn);
//                            if (! lcResult) candidateTableCnt++;
//                        }
//                    }
//                    if (pMustIn) lcResult = true;
//                    if (lcResult){
//                        t0.getLinkedColumns().addObjectName(pColumn);
//                        pColumn.setSourceTable(t0);
//                        pColumn.setSourceColumn(resultColumn);
//                        resultColumn.getTargetColumns().addObjectName(pColumn);
//                    }
//            }else{ // more than one table
//                    candidateTableCnt = 0;
//                    for(int i=0;i<tables.size();i++){
//                        TTable tn = tables.getTable(i);
//                        if (tn.isBaseTable()){
//                            lcResult = fireOnMetaDatabaseTableColumn(tn.getPrefixServer(),tn.getPrefixDatabase(),tn.getPrefixSchema(),tn.getName(),pColumn.getColumnNameOnly());
//                            if (!lcResult) candidateTableCnt++;
//                        }else{
//                            if (tn.getTableType() == ETableSource.subquery){
//                                if (tn.isIncludeColumnAlias()){
//                                    lcResult = tn.searchColumnInAlias(pColumn);
//                                }else{
//                                    lcResult = tn.getSubquery().searchColumnInResultSet(pColumn,false);
//                                    if (!lcResult) candidateTableCnt++;
//                                }
//                            }else if (tn.isCTEName()){
//                                lcResult = tn.getCTE().searchColumnInResultSet(this,tn,pColumn,false);
//                                if (!lcResult) candidateTableCnt++;
//                            }
//                        }
//
//                        if (lcResult){
//                            tn.getLinkedColumns().addObjectName(pColumn);
//                            pColumn.setSourceTable(tn);
//                            pColumn.setSourceColumn(resultColumn);
//                            resultColumn.getTargetColumns().addObjectName(pColumn);
//                            break;
//                        }
//                    }
//                    if ((!lcResult) && (pMustIn)) linkToFirstTable(pColumn,candidateTableCnt);
//            }
//           // }
//        }
//
//        if (lcResult) return true;
//
//        // search t.*
//        //int starColumnPos = 0,
//        int numOfTableDotStar=0;
//        for (int i=0;i<getResultColumnList().size();i++){
//            if (getResultColumnList().getResultColumn(i).toString().endsWith(".*")){
//                numOfTableDotStar++;
//            }
//        }
//
//        TResultColumn rc = null;
//        TTable tn = null;
//        for (int i=0;i<getResultColumnList().size();i++){
//            if (!getResultColumnList().getResultColumn(i).toString().endsWith(".*")) continue;
//            rc = getResultColumnList().getResultColumn(i);
//          //  starColumnPos = i;
//
//            for (int j=0;j<tables.size();j++){
//                if (! tables.getTable(j).equalByName(rc.getPrefixTable())) continue;
//                tn = tables.getTable(j);
//
//                if (tn.isBaseTable()){
//                    lcResult = fireOnMetaDatabaseTableColumn(tn.getPrefixServer(),tn.getPrefixDatabase(),tn.getPrefixSchema(),tn.getName(),pColumn.getColumnNameOnly());
//                    if (!lcResult) candidateTableCnt++;
//                }else{
//                    if (tn.getTableType() == ETableSource.subquery){
//                        if (tn.isIncludeColumnAlias()){
//                            lcResult = tn.searchColumnInAlias(pColumn);
//                        }else{
//                            lcResult = tn.getSubquery().searchColumnInResultSet(pColumn,((pMustIn)&&(numOfTableDotStar == 1)));
//                            if (!lcResult) candidateTableCnt++;
//                        }
//                    }else if (tn.isCTEName()){
//                        lcResult = tn.getCTE().searchColumnInResultSet(this,tn,pColumn,((pMustIn)&&(numOfTableDotStar == 1)));
//                        if (!lcResult) candidateTableCnt++;
//                    }
//                }
//
//                if (lcResult){
//                    tn.getLinkedColumns().addObjectName(pColumn);
//                    pColumn.setSourceTable(tn);
//                    pColumn.setSourceColumn(rc);
//                    rc.getTargetColumns().addObjectName(pColumn);
//                    break;
//                }
//            }
//            if (lcResult) break;
//        }
//
//        if (lcResult) return true;
//
//        if ((pMustIn) && (numOfTableDotStar == 1) && (tn != null)){
//            tn.getLinkedColumns().addObjectName(pColumn);
//            pColumn.setSourceTable(tn);
//            pColumn.setSourceColumn(rc);
//            rc.getTargetColumns().addObjectName(pColumn);
//            lcResult = true;
//        }
//
//        if (lcResult) return true;
//
//        if ((pMustIn) && (numOfTableDotStar > 0)) lcResult = linkToFirstTable(pColumn,candidateTableCnt);
//
//        if ((pMustIn)&&(!lcResult)) try {
//            throw new Exception(" column must be found in the select list:"+pColumn.toString());
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//
//        return lcResult;
    }


}