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;
    }

    /**
     * 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;
    
    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;
        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){
            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)||(dbvendor == EDbVendor.dbvmysql)){
            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){
                                        aliasName = resultColumn.getAliasClause().getAliasName().toString();
                                }else{
                                        if (resultColumn.getExpr().getObjectOperand() != null){
                                                aliasName = resultColumn.getExpr().getObjectOperand().toString();
                                        }
                                }
                                if (aliasName != null){
                                        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;
    }


}