package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.compiler.TStmtScope;
import gudusoft.gsqlparser.nodes.hive.THiveKeyValueProperty;
import gudusoft.gsqlparser.nodes.mssql.TForXMLClause;
import gudusoft.gsqlparser.nodes.snowflake.TAtBeforeClause;
import gudusoft.gsqlparser.nodes.snowflake.TStageReference;
import gudusoft.gsqlparser.nodes.teradata.THashByClause;
import gudusoft.gsqlparser.nodes.teradata.TTDUnpivot;
import gudusoft.gsqlparser.resolver.TResolverHelpUtils;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLTable;
import gudusoft.gsqlparser.stmt.TMergeSqlStatement;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
import gudusoft.gsqlparser.stmt.hive.THiveFromQuery;

import java.util.ArrayList;

/**
 * Represents various kinds of table source in from clause. Can also be a simple table/view name in create table and all other places.
 * result of {@link #getTableType} can be one of:
 *<ul>
 * <li>ftt_objectname, in from clause, a simple table/view name, reference: {@link TTable#tableName}<li>
 * <li>ftt_subquery, is a subquery that retrieves rows from the database, also known as derived table. reference: {@link TTable#subquery}</li>
 * <li>ftt_tableExpr,it's usually a table-valued expression., reference: {@link TTable#tableExpr}</li>
 * <li>ftt_function, it's usually a table-valued function., reference: {@link TTable#funcCall}</li>
 * <li>{@link ETableSource#rowList}, it's constructed rows, reference: {@link TTable#rowList}</li>
 * <li>ftt_containsTable, CONTAINSTABLE clause of sql server. reference: {@link TTable#containsTable}, type of {@link TContainsTable}</li>
 * <li>ftt_freetextTable, FREETEXTTABLE  clause of sql server. reference: {@link TTable#containsTable}, type of {@link TContainsTable}</li>
 * <li>ftt_openrowset, OPENROWSET clause of sql server. reference: {@link TTable#openRowSet}, type of {@link TOpenRowSet}</li>
 * <li>ftt_openxml, OPENXML clause of sql server. reference: {@link TTable#openXML}, type of {@link TOpenXML }</li>
 * <li>ftt_opendatasource, OPENDATASOURCE clause of sql server. reference: {@link TTable#openDatasource}, type of {@link TOpenDatasource}</li>
 * <li>ftt_openquery, OPENQUERY clause of sql server. reference: {@link TTable#openquery}, type of (@link TOpenQuery)</li>
 * </ul>
 *
 *
*/

public class TTable extends TNodeWithAliasClause implements IRelation {
    private ArrayList<TAttributeNode> relationAttributes;

    /**
     * @deprecated ,  this method is deprecated since version 3.3.1.0, don't use it in TSQLResolver2
     * @return
     */
    @Override
    public ArrayList<TAttributeNode> getAttributes(){
        if (relationAttributes == null) {
            relationAttributes = new ArrayList<>();
        }
        return relationAttributes;
    }

    @Override
    public String getRelationName(){
        return this.getName();
    }

    @Override
    public int size(){
        return relationAttributes != null ? relationAttributes.size() : 0;
    }

    public void setStageReference(TStageReference stageReference) {
        this.stageReference = stageReference;
    }

    private TStageReference stageReference;

    public TStageReference getStageReference() {
        return stageReference;
    }
    private TAtBeforeClause timeTravelClause;

    public void setTimeTravelClause(TAtBeforeClause timeTravelClause) {
        this.timeTravelClause = timeTravelClause;
    }

    public TAtBeforeClause getTimeTravelClause() {
        return timeTravelClause;
    }

    private TCaseJoinClause caseJoin;

    public void setCaseJoin(TCaseJoinClause caseJoin) {
        this.caseJoin = caseJoin;
    }

    public TCaseJoinClause getCaseJoin() {
        return caseJoin;
    }

    public String getStageName(){
        if (this.getTableName() == null) return null;
        if (this.getTableName().getDbObjectType() != EDbObjectType.stage) return null;
        return this.getTableName().getObjectString();
    }
    public final static String PIVOT_CLAUSE_ALIAS = "(pivot_table)";
    public final static String UNPIVOT_CLAUSE_ALIAS = "(unpivot_table)";
    public final static String TABLE_COLLECTION_ALIAS = "(table_collection)";


    boolean isAttributesInitialized = false;

    /**
     * Initialize a star attribute node (tableName.*) for this table.
     * This is used for regular tables (without DDL/metadata) in contexts where
     * they need to compete with subqueries that have star columns.
     * For example, in MERGE statements, the target table needs a star attribute
     * so that unqualified columns in the ON clause can be resolved to it
     * instead of being incorrectly pushed down through the source subquery's star column.
     */
    public void initStarAttribute(){
        if (isAttributesInitialized) return;
        TAttributeNode.addNodeToList(new TAttributeNode( getDisplayName()+".*",this),getAttributes());
        isAttributesInitialized = true;
    }

    public void initAttributeForXMLTable(){
       // if (isAttributesInitialized) return;
            //relationAttributes.add(new TAttributeNode( getDisplayName()+".*",this));
        TAttributeNode.addNodeToList(new TAttributeNode( getDisplayName()+".*",this),getAttributes());
        isAttributesInitialized = true;
    }

    public void initAttributeForTableFunction(){
       // if (isAttributesInitialized) return;
           //relationAttributes.add( new TAttributeNode( getDisplayName()+".value",this));
        TAttributeNode.addNodeToList(new TAttributeNode( getDisplayName()+".value",this),getAttributes());
        if (this.getName().equals("STRING_SPLIT")){ 
            // TRING_SPLIT函数生成的表只有两个字段：value和可选的ordinal
            TAttributeNode.addNodeToList(new TAttributeNode( getDisplayName()+".ordinal",this),getAttributes());
        }
        isAttributesInitialized = true;
    }

    public void initAttributeForRowList(){
       // if (isAttributesInitialized) return;
       // relationAttributes.add( new TAttributeNode( getDisplayName()+".value",this));
        if (getValueClause() == null) return;
        if (getValueClause().getRows().size() == 0) return;

        int i = 0;
        String columnName = "";
        TObjectNameList aliasColumnNameList = null;
        // 1. 如果有 table alias 中指定 column, 遍历alias column
        // 2. 如果 table alias 没有指定column， 遍历 subquery or  values() 中的 resultcolumn
        // 如果遍历alias column，可能存在 alias column 中column 数量和  subquery or  values() 中的 resultcolumn 中不等的现象
        // 例如 subquery or  values() 中的 resultcolumn 中为 * column，
        // 或者 snowflake 中的 pivot clause.(c:\prg\gsp_sqlfiles\TestCases\private\dataflow\snowflake\pivot_clause_1.sql)

        TAliasClause aliasClause = this.getAliasClause();
        if (aliasClause != null){
            aliasColumnNameList = aliasClause.getColumns();
        }
        for(TResultColumn resultColumn:getValueClause().getRows().get(0)){
            columnName = resultColumn.getDisplayName();
            if ((aliasColumnNameList != null)&&(aliasColumnNameList.size()>i)){
                columnName = aliasColumnNameList.getObjectName(i).getColumnNameOnly();
            }
            TAttributeNode newNode = new TAttributeNode(this.getDisplayName() + "." + columnName, this, resultColumn);
            //newNode.setAttributeCreatedFromAliasColumn(true);
            //relationAttributes.add(newNode);
            TAttributeNode.addNodeToList(newNode,relationAttributes);
            i++;
        }

        TBaseType.log(String.format("Prepare attributes (num = %d) for rowList (values) : <%s>",this.getAttributes().size() ,this.getDisplayName()),TLog.DEBUG,this.getTableName());
        int c = 0;
        for(TAttributeNode node: this.getAttributes()){
            TBaseType.log(String.format("\tAttribute: <%s>, result column: <%s>",node.getName(), node.getSubLevelResultColumn()!=null?node.getSubLevelResultColumn().toString():"N/A" ),TLog.DEBUG);
            c++;
            if (c > TLog.OUTPUT_ATTRIBUTES_MAX){
                TBaseType.log(String.format("\t...skipped after output %d attributes",c-1),TLog.DEBUG,this.getTableName().getStartToken());
                break;
            }
        }


        isAttributesInitialized = true;
    }


    public void initAttributesFromCTE(TCTE cte){
       // if (isAttributesInitialized) return;

        for (TAttributeNode node1 : cte.getAttributes()) {
            TAttributeNode newNode = new TAttributeNode(this.getDisplayName() + "." + node1.getLastPartOfName(), this, node1.getSqlColumn(), node1.getSubLevelResultColumn());
            if (node1.getAccompaniedAttributeNodes().size() > 0){
                for(TAttributeNode n:node1.getAccompaniedAttributeNodes()){
                    newNode.getAccompaniedAttributeNodes().add(n);
                }
            }
            //relationAttributes.add(newNode);
            TAttributeNode.addNodeToList(newNode,relationAttributes);
        }

        TBaseType.log(String.format("Prepare attributes (num = %d) for cte ref: <%s>",this.getAttributes().size() ,this.getTableName().toString()),TLog.DEBUG,this.getTableName());
        int c = 0;
        for(TAttributeNode node: this.getAttributes()){
            if (node.getSqlColumn() != null){
                TBaseType.log(String.format("\tAttribute: <%s>, SQL column: <%s>",node.getName(), node.getSqlColumn()!=null?node.getSqlColumn().toString():"N/A" ),TLog.DEBUG);
            }else{
                TBaseType.log(String.format("\tAttribute: <%s>, Select list column: <%s>",node.getName(), node.getSubLevelResultColumn()!=null?node.getSubLevelResultColumn().toString():"N/A" ),TLog.DEBUG);
            }
            c++;
            if (c > TLog.OUTPUT_ATTRIBUTES_MAX){
                TBaseType.log(String.format("\t...skipped after output %d attributes",c-1),TLog.DEBUG,this.getTableName().getStartToken());
                break;
            }
        }

        isAttributesInitialized = true;
    }
    public void  initAttributesFromSubquery(TSelectSqlStatement subquery, String prefix){
        // TODO, not thread safe?
      //  if ((isAttributesInitialized) && (!relationAttributes.isEmpty())) return;
        if (subquery.getResultColumnList() == null) return;
        int i = 0;
        if (subquery.getResultColumnList() != null) {
            TResultColumnList resultColumnListFromSubQuery = subquery.getResultColumnList(true);
            for(TResultColumn column: resultColumnListFromSubQuery){
                if (column.getAliasNameList().size() > 0){
                    // 如果 column 有 alias name list， 则遍历 alias name list， 并把每个 alias name 作为 attribute node 添加到 relationAttributes 中
                    // as (b1, b2, b3, b4, b5)
                    // select t.a1, t.a2, stack(2, 'T', t.a1, t.a2, t.a3/t.a4, t.a5/t.a6,   'T+0', t.a7, t.a8, t.a9/t.a10, t.a11/t.a12) as (b1, b2, b3, b4, b5)  from db1.table1 t

                    for(TObjectName aliasName: column.getAliasNameList()){
                        this.addAttribute(new TAttributeNode(prefix + TBaseType.removeQuoteChar(aliasName.toString()),this,column,i));
                        i++;
                    }
                }else {
                    if (column.getDisplayName().endsWith("*")){
                        TObjectName objectName = column.getExpr().getObjectOperand();
                        if (objectName.getAttributeNodesDerivedFromFromClause().size() > 0){
                            for(TAttributeNode attributeNode:objectName.getAttributeNodesDerivedFromFromClause()){
                                //relationAttributes.add(new TAttributeNode( prefix + attributeNode.getLastPartOfName() ,this, attributeNode.getSqlColumn(), column,i));
                                this.addAttribute(new TAttributeNode( prefix + attributeNode.getLastPartOfName() ,this, attributeNode.getSqlColumn(), column,i));
                            }
                        }else{
                            // no attribute node derived from from clause, add the object name directly
                            //relationAttributes.add(new TAttributeNode(prefix +"*",this,column,i));
                            this.addAttribute(new TAttributeNode(prefix +"*",this,column,i));
                        }
                    }else{
                        //relationAttributes.add(new TAttributeNode(prefix +column.getDisplayName(),this,column,i));
                        this.addAttribute(new TAttributeNode(prefix +column.getDisplayName(),this,column,i));
                    }
                    i++;
                }
            }
        }

        //  如果 subQuery 是 combined query， 需要把所有 query 中的 select list 都加入进来。上面处理的仅仅为最右面的那个 subQuery
        if (subquery.isCombinedQuery()){
            TSelectSqlStatement left = subquery.getLeftStmt();
            addNewAttributeFromSubQuery(left.getResultColumnList(true),getAttributes(),prefix);
            while (left.isCombinedQuery()){
                left = left.getLeftStmt();
                addNewAttributeFromSubQuery(left.getResultColumnList(true),getAttributes(),prefix);
            }
        }
        isAttributesInitialized = true;
    }

    void addNewAttributeFromSubQuery(TResultColumnList resultColumnList, ArrayList<TAttributeNode> attributeNodes, String prefix){
        addNewAttributeFromSubQuery(resultColumnList,attributeNodes,prefix,null);
    }

    /**
     * 当 subQuery 为 combined query 时，不仅仅把 right most 那个 subQuery 的 select list 作为 子查询的 attribute node list 添加上来
     * 还需要把 其他 combined query 中的 subQuery 加入进来
     *
     *
     *
     * @param resultColumnList  subQuery 中的 select list
     * @param attributeNodes  需要在该 attribute node 的 getAccompaniedAttributeNodes() 中添加新 node
     * @param prefix  该前缀为 subQuery 的 alias，或 CTE 的 name 决定
     * @param specifiedColumnList 当 table 为 CTE 时，并且 CTE 自己指定了 column list， 那么 attribute node 的 name 由该 column list 决定，
     *                            而不是 subQuery 中的 select list 确定
     *
     */
    void addNewAttributeFromSubQuery(TResultColumnList resultColumnList, ArrayList<TAttributeNode> attributeNodes, String prefix, TObjectNameList specifiedColumnList){
        if (resultColumnList == null) return;
        if (resultColumnList.size() !=  attributeNodes.size()){ 
            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                TBaseType.log(String.format("When add attribute from subQuery, the size of select list and attributes is not the same: %d <> %d",resultColumnList.size(),attributeNodes.size())
                        ,TLog.ERROR,resultColumnList.getStartToken());
            }
            return;
        }
        int i = 0;
        for(TResultColumn column: resultColumnList){
            TAttributeNode node = attributeNodes.get(i); // 根据 i 的值，找到原来对应位置的 attribute node，用来添加 accompanied node

            if (column.getDisplayName().endsWith("*")){
                TObjectName objectName = column.getExpr().getObjectOperand();
                for(TAttributeNode attributeNode:objectName.getAttributeNodesDerivedFromFromClause()){
                    if (specifiedColumnList == null){
                        node.getAccompaniedAttributeNodes().add(new TAttributeNode( prefix + attributeNode.getLastPartOfName() ,this, attributeNode.getSqlColumn(), column,i));
                    }else{
                        TObjectName c = specifiedColumnList.getObjectName(i);
                        node.getAccompaniedAttributeNodes().add(new TAttributeNode( prefix + c.toString() ,this, attributeNode.getSqlColumn(), column,i));
                    }
                }
            }else{
                if (specifiedColumnList == null){
                    node.getAccompaniedAttributeNodes().add(new TAttributeNode(prefix +column.getDisplayName(),this,column,i));
                }else{
                    TObjectName c = specifiedColumnList.getObjectName(i);
                    node.getAccompaniedAttributeNodes().add(new TAttributeNode(prefix + c.toString(),this,column,i));
                }
            }
            i++;
        }
    }

    public String getDisplayName(){
        if (getAliasClause() != null) return getAliasName();
        String ret = null;
        switch (getTableType()){
            case objectname:
                ret = getFullName();
                break;
            case tableExpr:
                ret = TTable.TABLE_COLLECTION_ALIAS;
                break;
            default:
                ret = toString();
                break;
        }
        return ret;
    }

    public String getDisplayName(boolean removeDBLink){
        if (!removeDBLink) return getDisplayName();
        if (dbvendor != EDbVendor.dbvoracle) return getDisplayName();
        // DM_MINING.FATURA_ODEME_SEGMENTASYONU@dblinkx
        String ret = getDisplayName();
        int atIndex = ret.indexOf('@');
        if (atIndex > 0){
            ret = ret.substring(0,atIndex);
        }
        return ret;
    }


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

//    public ArrayList<TObjectName> getReferenceAttributes(){
//        return null;
//    }

    public void initAttributesForPivotTable(){
       // if (isAttributesInitialized) return;
        TPivotClause pivotClause = this.getPivotedTable().getPivotClauseList().getElement(0);
        if (pivotClause.getType() == TPivotClause.pivot){

            // 先添加 pivot clause 中的 attribute，以防止 先处理 [p].[3] -> p.*, 而导致 [p].[3] -> [p].[3] 没能正确匹配

            // SELECT [p].[ADDRESS_ID]
            //                      ,[p].[3] AS ADDRESS_LINE3
            //                      ,[p].[2] AS ADDRESS_LINE2
            //                      ,[p].[1] AS ADDRESS_LINE1 FROM [ADDRESS_LINES_CTE]
            //                          PIVOT(MAX(value) FOR id IN ([1],[2],[3])) p

            //relationAttributes.addAll(pivotClause.getAttributes());
            TAttributeNode.addAllNodesToList(pivotClause.getAttributes(),getAttributes());

            TTable sourceTable = this.getPivotedTable().getRelations().get(0);
            // 如果 pivot alias clause 不为空，整个table的 prefix 都用这个alias
            //  否则使用当前table的display name
            String prefix;
            if (pivotClause.getAliasClause() != null){
                prefix = pivotClause.getDisplayName();
            }else{
                prefix = sourceTable.getDisplayName();
            }

            for(TAttributeNode node: sourceTable.getAttributes()){
                    //relationAttributes.add(new TAttributeNode(prefix+"."+ TBaseType.getLastPartOfQualifiedName(node.getName()),sourceTable,node.getSubLevelResultColumn()));
                TAttributeNode.addNodeToList(new TAttributeNode(prefix+"."+ TBaseType.getLastPartOfQualifiedName(node.getName()),sourceTable,node.getSubLevelResultColumn()),getAttributes());
            }


        }

        isAttributesInitialized = true;
    }

    /**
     * 主要是在处理列级别的信息，
     * 它的主要目的是确保 JOIN 操作后的表对象包含所有参与 JOIN 的表的列信息，这对于后续的查询处理（特别是列引用解析）是必要的。
     */
    public void initAttributesForJoin(){
        //if (isAttributesInitialized) return;
        //relationAttributes.addAll(getJoinExpr().getAttributes());
        TAttributeNode.addAllNodesToList(getJoinExpr().getAttributes(),getAttributes());
        isAttributesInitialized = true;
    }

    public void initAttributesForUnnest(TSQLEnv sqlEnv, TSelectSqlStatement select ){
       // if (isAttributesInitialized) return;
        if (this.getAliasClause() != null){
            if (this.getAliasClause().getColumns() != null){
                for(TObjectName pColumn:this.getAliasClause().getColumns()){
                       //relationAttributes.add( new TAttributeNode( this.getDisplayName()+"."+pColumn.toString() ,this));
                    TAttributeNode.addNodeToList(new TAttributeNode( this.getDisplayName()+"."+pColumn.toString() ,this),getAttributes());
                }
            }else if (this.getAliasClause().getAliasName() != null){
//                       SELECT *
//                               FROM UNNEST(['foo', 'bar', 'baz', 'qux', 'corge', 'garply', 'waldo', 'fred']) AS element
//                       WITH OFFSET AS offset
                // add element as column of unnest table.
                if (this.getUnnestClause().getColumns() != null){
                    //   UNCOVERED_MOVE_Stage1 AS
                    //  (SELECT
                    //     Instrument_Partition_Key ,
                    //     Consolidation_Entity_Levels ,
                    //     FOTC_UDF_calc_uncovered_roll_off(ARRAY_AGG(STRUCT<Partition_Key STRING , Order_Number INT64 , Movement_In_Short FLOAT64 , Short_Increase_Uncovered FLOAT64 , Short_Increase_Covered_CS FLOAT64 , Short_Increase_Covered_RR FLOAT64> (Instrument_Partition_Key , Order_Number , Movement_In_Short_Balance_LCY , Short_Increase_Uncovered , Maturing_CS_Covering_Short_Increase , Maturing_RR_Covering_Short_Increase)
                    //                                                ORDER BY Order_Number)) AS result_uncovered_moves ,
                    //     FOTC_UDF_calc_uncovered_roll_off(ARRAY_AGG(STRUCT<Partition_Key STRING , Order_Number INT64 , Movement_In_Short FLOAT64 , Short_Increase_Uncovered FLOAT64 , Short_Increase_Covered_CS FLOAT64 , Short_Increase_Covered_RR FLOAT64> (Instrument_Partition_Key , Order_Number , Movement_In_Short_Balance_LCY , Short_Increase_Uncovered_By_Settled_RR , Maturing_CS_Covering_Short_Increase , Maturing_Settled_RR_Covering_Short_Increase)
                    //                                                ORDER BY Order_Number)) AS result_uncovered_by_settled_moves
                    //   FROM SHORTS_COVERING_RR
                    //   GROUP BY
                    //     Instrument_Partition_Key ,
                    //     Consolidation_Entity_Levels) ,
                    //  UNCOVERED_MOVE AS
                    //  (SELECT
                    //     Consolidation_Entity_Levels ,
                    //     X.* ,
                    //     Y.uncovered_move AS Move_Uncovered_By_Settled_RR_Short ,
                    //     Y.covered_cs_move AS Move_Covered_By_Settled_CS_Short ,
                    //     Y.covered_rr_move AS Move_Covered_By_Settled_RR_Short
                    //   FROM
                    //     UNCOVERED_MOVE_Stage1 ,
                    //     UNNEST(result_uncovered_moves) AS X
                    //   JOIN UNNEST(result_uncovered_by_settled_moves) AS Y ON X.Partition_Key = Y.Partition_Key
                    //   AND X.order_key= Y.order_key)

                    // UNNEST(result_uncovered_moves) 中的 result_uncovered_moves 来自 ARRAY_AGG(),
                    // 这时候因为还没有进行 column resolver，所以无法知道 result_uncovered_moves 到底包含哪些 column
                    // 因为 UNNEST(result_uncovered_moves) AS X 指定了 X 作为 Alias， 因此增加 X.* 作为 attributeNode
                    // 不会导致问题。

                    ArrayList<String> tf = null;
                    TObjectName objectName = this.getUnnestClause().getColumns().getObjectName(0);
                    for(TTable table: select.getRelations()){
                        if (TParseTreeNode.subNodeInNode(this,table)) break;
                        for(TAttributeNode attributeNode:table.getAttributes()){
                            int matchResult = TStmtScope.matchAttribute(objectName.toString(), attributeNode.getName(),0,select);
                            if (matchResult == TBaseType.MATCH_COLUMN_RESULT_MATCHED ) {
                                objectName.setSourceTableBySQLResolver(select,attributeNode,table);
                                objectName.setSourceAttributeNode(attributeNode);
                                break;
                            }
                        }
                        if (objectName.getSourceAttributeNode() != null){
                            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                                TBaseType.log(String.format("Unnest table from source column: <%s>, linked to attribute node: <%s>"
                                        ,objectName.toString(),objectName.getSourceAttributeNode().getName()),TLog.DEBUG,objectName);
                            }

                            // unnest(column), 其中的 column 可能对应array, 或者是 struct
                            // 找一下看看是否有 struct

                             tf = TResolverHelpUtils.searchTypedStruct(sqlEnv, objectName.getSourceAttributeNode().getSubLevelResultColumn());
                            break;
                        }
                    }
                    if (tf != null){
                        if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                            TBaseType.log(String.format("Prepare attribute node for unnest %s",this.getDisplayName()),TLog.DEBUG,this.getStartToken());
                        }
                        for(String columnName:tf){
                            TAttributeNode newNode = new TAttributeNode(String.format("%s.%s",this.getDisplayName(),columnName),this,objectName.getSourceAttributeNode().getSubLevelResultColumn());
                            //relationAttributes.add(newNode);
                            TAttributeNode.addNodeToList(newNode,relationAttributes);
                            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                                TBaseType.log(String.format("\t attribute node from struct: %s.%s with source column: %s"
                                            , this.getDisplayName(),columnName, objectName.getSourceAttributeNode().getSubLevelResultColumn()==null?"N/A":objectName.getSourceAttributeNode().getSubLevelResultColumn().toString() ),TLog.DEBUG,this.getStartToken());
                            }
                        }
                    }else{
                           //relationAttributes.add( new TAttributeNode( this.getDisplayName()+".*",this));
                        TAttributeNode.addNodeToList(new TAttributeNode( this.getDisplayName()+".*",this),getAttributes());
                    }

                }else{
                       //relationAttributes.add( new TAttributeNode( this.getDisplayName()+"."+this.getAliasClause().getAliasName().toString() ,this));
                    TAttributeNode.addNodeToList(new TAttributeNode( this.getDisplayName()+"."+this.getAliasClause().getAliasName().toString() ,this),getAttributes());
                }
            }
        }else{
            //SELECT value FROM UNNEST(nested_attribute)
            // #TODO, 未处理 UNNEST 中的 nested_attribute,  nested_attribute 一般是一个 struct，那么应该把 struct 中的 column 也加入进来
            // 没有指定输出 column 的name，默认为 value
               //relationAttributes.add( new TAttributeNode( this.getDisplayName()+"."+"value" ,this));
            TAttributeNode.addNodeToList(new TAttributeNode( this.getDisplayName()+"."+"value" ,this),getAttributes());
        }

        for(int i=0;i<getAttributes().size();i++){
            TAttributeNode node = getAttributes().get(i);
            if (TBaseType.DUMP_RESOLVER_LOG_TO_CONSOLE){
                TBaseType.log(String.format("Prepare attribute node <%d> for unnest %s: %s",i+1,this.getDisplayName(),node.getName()),TLog.DEBUG,this.getStartToken());
            }
        }

        isAttributesInitialized = true;
    }

   


//    private ArrayList<String> expandedAttributes = new ArrayList<>();
//
//    public ArrayList<String> getExpandedAttributes() {
//        return expandedAttributes;
//    }


    public void addAttribute(TAttributeNode node) {
        if (node == null) return;
        
        // 检查是否已存在同名节点
        for (TAttributeNode existing : getAttributes()) {
            if (existing.getName().equals(node.getName())) {
                return;
            }
        }
        
        //relationAttributes.add(node);
        TAttributeNode.addNodeToList(node,relationAttributes);
    }

    private ArrayList<TObjectName> attributesReferenceToThisRelation = new ArrayList<>();

    public ArrayList<TObjectName> getAttributesReferenceToThisRelation() {
        return attributesReferenceToThisRelation;
    }

//    public boolean resolveAttribute(TObjectName attribute){
//        boolean result = false;
//        if (attribute.isQualified()) {
//            result = attribute.resolveWithThisTable(this);
//            if (result) {
//                attributesReferenceToThisRelation.add(attribute);
//                attribute.setResolvedRelation(this);
//            }
//            return result;
//        }
//        if (this.getResolvedTable() != null){
//            result = this.getResolvedTable().searchColumn(attribute.toString());
//            if (result){
//                attribute.setResolvedRelation(this);
//                return result;
//            }
//        }
//        return result;
//    }

    private TSQLTable resolvedTable = null;
    private boolean isResolved = false;

    public void setResolvedTable(TSQLTable resolvedTable) {
        this.resolvedTable = resolvedTable;
        isResolved = true;
    }

    public void setResolved(boolean resolved) {
        isResolved = resolved;
    }

    public TSQLTable getResolvedTable() {
        return resolvedTable;
    }

    public boolean isResolved() {
        return isResolved;
    }

    private ArrayList<TObjectName> columnsFromSQLEnv;

    public ArrayList<TObjectName> getColumnsFromSQLEnv(TSQLEnv sqlEnv) {
        if (columnsFromSQLEnv == null){
            columnsFromSQLEnv = new ArrayList<>();
        }

        ArrayList<String> columns = sqlEnv.getColumnsInTable(this.tableName.toString(),true);
        if (columns == null) return null;

        for(String s:columns){
            TObjectName column = TObjectName.createObjectName(this.dbvendor, EDbObjectType.column,new TSourceToken(s));
            columnsFromSQLEnv.add(column);
        }

        return columnsFromSQLEnv;
    }

    private TJoinExpr joinExpr;

    public void setJoinExpr(TJoinExpr joinExpr) {
        this.joinExpr = joinExpr;
    }

    public TJoinExpr getJoinExpr() {
        return joinExpr;
    }

    /**
     *  该 table 对应的 sqlenv 中的 table 定义，包含具体的字段信息，有字段名称、数据类型等。
     *
     */
//    private TSQLTable sqlTable;
//
//    public void setSqlTable(TSQLTable sqlTable) {
//        this.sqlTable = sqlTable;
//    }
//
//    public TSQLTable getSqlTable() {
//        return sqlTable;
//    }



    private TForXMLClause forXMLClause;

    public void setForXMLClause(TForXMLClause forXMLClause) {
        this.forXMLClause = forXMLClause;
    }

    /**
     * SQL Server for xml clause
     * @return SQL Server for xml clause
     */
    public TForXMLClause getForXMLClause() {
        return forXMLClause;
    }

    private TColumnDefinitionList columnDefinitions;

    public TColumnDefinitionList getColumnDefinitions() {
        return columnDefinitions;
    }

    /**
     * Teradata HASH BY clause for table functions.
     */
    private THashByClause hashByClause;

    /**
     * Gets the HASH BY clause for Teradata table functions.
     *
     * @return the HASH BY clause, or null if not specified
     */
    public THashByClause getHashByClause() {
        return hashByClause;
    }

    /**
     * Sets the HASH BY clause for Teradata table functions.
     *
     * @param hashByClause the HASH BY clause
     */
    public void setHashByClause(THashByClause hashByClause) {
        this.hashByClause = hashByClause;
    }

    /**
     * Teradata LOCAL ORDER BY clause for table functions.
     */
    private TOrderBy localOrderBy;

    /**
     * Gets the LOCAL ORDER BY clause for Teradata table functions.
     *
     * @return the LOCAL ORDER BY clause, or null if not specified
     */
    public TOrderBy getLocalOrderBy() {
        return localOrderBy;
    }

    /**
     * Sets the LOCAL ORDER BY clause for Teradata table functions.
     *
     * @param localOrderBy the LOCAL ORDER BY clause
     */
    public void setLocalOrderBy(TOrderBy localOrderBy) {
        this.localOrderBy = localOrderBy;
    }

    private TSQLEnv sqlEnv;

    public void setSqlEnv(TSQLEnv sqlEnv) {
        this.sqlEnv = sqlEnv;
    }

    public TSQLEnv getSqlEnv() {
        return sqlEnv;
    }

    private TValueClause valueClause;

    public TValueClause getValueClause() {
        return valueClause;
    }

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

    private TTable sourceTableOfPivot;

    public void setSourceTableOfPivot(TTable sourceTableOfPivot) {
        this.sourceTableOfPivot = sourceTableOfPivot;
    }

    public TTable getSourceTableOfPivot() {
        return sourceTableOfPivot;
    }

    private TJsonTable jsonTable;

    public void setJsonTable(TJsonTable jsonTable) {
        this.jsonTable = jsonTable;
    }

    public TJsonTable getJsonTable() {
        return jsonTable;
    }

    public void  setPropertyFromObjectName(TObjectName objectName, ETableEffectType tableEffectType){
        setStartToken(objectName.getStartToken());
        setEndToken(objectName.getEndToken());
        setGsqlparser(objectName.getGsqlparser());
        setEffectType(tableEffectType);
        setTableType(ETableSource.objectname);
    }
    private TTDUnpivot tdUnpivot;

    public void setTdUnpivot(TTDUnpivot tdUnpivot) {
        this.tdUnpivot = tdUnpivot;
    }

    public TTDUnpivot getTdUnpivot() {

        return tdUnpivot;
    }

    private TUnnestClause unnestClause;

    public void setUnnestClause(TUnnestClause unnestClause) {
        this.unnestClause = unnestClause;
    }

    public TUnnestClause getUnnestClause() {

        return unnestClause;
    }
    //select b.TemaTakipNo, b.SevkID, db.FromDepo, db.ToDepo, d.UrunID UrunID1, r.UrunID2, d.Miktar AsortiMiktar, r.Miktar ReceteMiktar
    //into #tmpIrsaliye
    /**
     * list of columns in select list, used as metadata to determine whether a column belong to this temp table in TCustomSqlStatement.linkColumnToTable
     */
    private TResultColumnList columnListInTempTable;

    public void setColumnListInTempTable(TResultColumnList columnListInTempTable) {
        this.columnListInTempTable = columnListInTempTable;
    }

    public TResultColumnList getColumnListInTempTable() {

        return columnListInTempTable;
    }

    public void setPxGranule(TPxGranule pxGranule) {
        this.pxGranule = pxGranule;
    }

    public TPxGranule getPxGranule() {

        return pxGranule;
    }

    private TPxGranule pxGranule;
    private TFlashback flashback;

    public void setFlashback(TFlashback flashback) {
        this.flashback = flashback;
    }

    public TFlashback getFlashback() {
        return flashback;
    }

    private int parenthesisCount = 0;
    private int parenthesisAfterAliasCount = 0;
    private boolean tableKeyword = false;
    private boolean onlyKeyword = false;
    private boolean npathOnClauseTable = false;

    /**
     * Redshift array-unnesting positional index alias.
     * <p>
     * When a Redshift array column is unnested in the FROM clause with a
     * positional index, e.g.
     * <pre>FROM schema.tbl t, t.array_col AS element AT idx</pre>
     * this table represents {@code t.array_col} with element alias
     * {@code element} (the regular {@link #getAliasClause() aliasClause}) and
     * {@code idx} captured here as the array index alias.
     */
    private TObjectName arrayIndexAlias;

    public TObjectName getArrayIndexAlias() {
        return arrayIndexAlias;
    }

    public void setArrayIndexAlias(TObjectName arrayIndexAlias) {
        this.arrayIndexAlias = arrayIndexAlias;
    }

    /**
     * Redshift SUPER object unpivoting source, e.g.
     * <pre>FROM c.c_orders AS o, UNPIVOT o AS val AT attr</pre>
     * When {@code true} this table represents the unpivoted SUPER expression:
     * the regular alias is the value alias and {@link #getArrayIndexAlias()}
     * (from {@code AT}) is the attribute-name alias.
     */
    private boolean superUnpivot = false;

    public boolean isSuperUnpivot() {
        return superUnpivot;
    }

    public void setSuperUnpivot(boolean superUnpivot) {
        this.superUnpivot = superUnpivot;
    }

    /**
     * Marks this table as coming from a Teradata NPath function's ON clause.
     * This is used for data lineage to trace back to the source table inside NPath.
     */
    public void setNPathOnClauseTable(boolean npathOnClauseTable) {
        this.npathOnClauseTable = npathOnClauseTable;
    }

    /**
     * Returns true if this table comes from a Teradata NPath function's ON clause.
     */
    public boolean isNPathOnClauseTable() {
        return npathOnClauseTable;
    }

    public void setTableKeyword(boolean tableKeyword) {
        this.tableKeyword = tableKeyword;
    }

    public void setOnlyKeyword(boolean onlyKeyword) {
        this.onlyKeyword = onlyKeyword;
    }

    public boolean isTableKeyword() {

        return tableKeyword;
    }

    public boolean isOnlyKeyword() {
        return onlyKeyword;
    }

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

    public void setParenthesisAfterAliasCount(int parenthesisAfterAliasCount) {
        this.parenthesisAfterAliasCount = parenthesisAfterAliasCount;
    }

    public int getParenthesisCount() {

        return parenthesisCount;
    }

    public int getParenthesisAfterAliasCount() {
        return parenthesisAfterAliasCount;
    }

    private TMergeSqlStatement outputMerge;

    public void setOutputMerge(TMergeSqlStatement outputMerge) {
        this.outputMerge = outputMerge;
    }

    public TMergeSqlStatement getOutputMerge() {

        return outputMerge;
    }

    private TPivotedTable pivotedTable;

    public void setPivotedTable(TPivotedTable pivotedTable) {
        this.pivotedTable = pivotedTable;
    }

    public TPivotedTable getPivotedTable() {

        return pivotedTable;
    }

    private ETableEffectType effectType;

    public void setEffectType(ETableEffectType effectType) {
        this.effectType = effectType;
    }

    public ETableEffectType getEffectType() {

        return effectType;
    }

    private TTable linkTable;

    public void setLinkTable(TTable linkTable) {
        this.linkTable = linkTable;
        isLinkTable = (this.linkTable != null);
    }

    public TTable getLinkTable() {

        return linkTable;
    }

    public boolean isLinkTable() {
        return isLinkTable;
    }

    /**
     * @deprecated As of v1.8.4.6, set in {@link #setLinkTable}
     */
    public void setLinkTable(boolean isLinkTable) {

        this.isLinkTable = isLinkTable;
    }

    private boolean isLinkTable;


    public String getAliasName(){
        if (getAliasClause() == null) return "";
        TObjectName aliasName = getAliasClause().getAliasName();
        return (aliasName == null) ? "" : aliasName.toString();
    }

    public boolean equalByName(String pTableName){
        if (getAliasClause() != null){
            return getAliasClause().getAliasName().toString().equalsIgnoreCase(pTableName);
        }else{
            return getName().equalsIgnoreCase(pTableName);
        }
    }

    private TPTNodeList<THiveKeyValueProperty> tableProperties;

    public void setTableProperties(TPTNodeList<THiveKeyValueProperty> tableProperties) {
        this.tableProperties = tableProperties;
    }

    /**
      *
      * @return hive table property list
      */

    public TPTNodeList<THiveKeyValueProperty> getTableProperties() {
        return tableProperties;
    }

    private ArrayList<TLateralView> lateralViewList = null;

    public void setLateralViewList(ArrayList<TLateralView> lateralViewList) {
        this.lateralViewList = lateralViewList;
    }

    public ArrayList<TLateralView> getLateralViewList() {
        return lateralViewList;

    }

    private TTableSample tableSample;

    public void setTableSample(TTableSample tableSample) {
        this.tableSample = tableSample;
    }

    public TTableSample getTableSample() {

        return tableSample;
    }

    public void setPartitionExtensionClause(TPartitionExtensionClause partitionExtensionClause) {
        this.partitionExtensionClause = partitionExtensionClause;
    }

    private TPartitionExtensionClause partitionExtensionClause;

    public TPartitionExtensionClause getPartitionExtensionClause() {
        return partitionExtensionClause;
    }

    public void setOuterClause(TInformixOuterClause outerClause) {
        this.outerClause = outerClause;
    }

    public TInformixOuterClause getOuterClause() {

        return outerClause;
    }

    private TInformixOuterClause outerClause;

    private TXmlTable xmlTable;

    private TFromTableList fromTableList;

    public void setFromTableList(TFromTableList fromTableList) {
        this.fromTableList = fromTableList;
    }

    public TFromTableList getFromTableList() {

        return fromTableList;
    }

    public TXmlTable getXmlTable() {
        return xmlTable;
    }

    public void setXmlTable(TXmlTable xmlTable) {

        this.xmlTable = xmlTable;
    }

    private TOpenQuery openquery = null;

    public void setTableHintList(TPTNodeList<TTableHint> tableHintList) {
        this.tableHintList = tableHintList;
    }


    public TPTNodeList<TTableHint> getTableHintList() {

        return tableHintList;
    }

    private TPTNodeList<TTableHint> tableHintList;

    public TOpenQuery getOpenquery() {
        return openquery;
    }

    public TSelectSqlStatement getSubquery() {
        return subquery;
    }

    public void setOpenquery(TOpenQuery openquery) {

        this.openquery = openquery;
    }

    public void setOpenDatasource(TOpenDatasource openDatasource) {
        this.openDatasource = openDatasource;
    }

    /**
     * Valid when {@link #tableType} is ftt_opendatasource.
     * @return
     */
    public TOpenDatasource getOpenDatasource() {

        return openDatasource;
    }

    private TOpenDatasource openDatasource = null;

    public void setOpenXML(TOpenXML openXML) {
        this.openXML = openXML;
    }

    public TOpenXML getOpenXML() {

        return openXML;
    }

    private TOpenXML openXML = null;

    public TOpenRowSet getOpenRowSet() {
        return openRowSet;
    }

    public void setOpenRowSet(TOpenRowSet openRowSet) {

        this.openRowSet = openRowSet;
    }

    private TOpenRowSet openRowSet = null;

    public TContainsTable getContainsTable() {
        return containsTable;
    }

    public void setContainsTable(TContainsTable containsTable) {
        this.containsTable = containsTable;
    }

    private TContainsTable containsTable = null;

    public TFunctionCall getFuncCall() {
        return funcCall;
    }

    public void setFuncCall(TFunctionCall funcCall) {
        this.funcCall = funcCall;
    }


    private TFunctionCall funcCall = null;

    private TMultiTargetList rowList;

    /**
     * @deprecated As of v2.3.6.9, please use {@link #getValueClause()} instead
     *
     * row constructor like this: '(' RW_VALUES MultiTargets ')'
     * @return     TMultiTargetList
     */
    public TMultiTargetList getRowList() {
        return rowList;
    }

    public boolean isBaseTable(){
       boolean retval = (tableType == ETableSource.objectname);
       if (retval){
          if (isCTEName()){
              retval = false;
          }
       }

       if (retval){
           if (getFullName().startsWith("@")) {
               retval = false;
           }
       }
        return retval;
    }
    
    public void setCteColomnReferences(TObjectNameList cteColomnReferences) {
        this.cteColomnReferences = cteColomnReferences;
    }

    private TObjectNameList cteColomnReferences = null;

    public TObjectNameList getCteColomnReferences() {
        return cteColomnReferences;
    }

    public void setObjectNameReferences(TObjectNameList objectNameReferences) {

        this.objectNameReferences = objectNameReferences;
    }

   private TCTE CTE;

    public boolean setCTE(TCTE pCTE) {
        if (pCTE == null){
            this.CTE = null;
            return true;
        }

        if ((!pCTE.isRecursive()) && (pCTE.getSubquery() != null) && (TParseTreeNode.subNodeInNode(this,pCTE.getSubquery()))){
            // 如果这个table是属于一个CTE的子查询，那么不再设置CTE，因为该table不可能是该CTE的引用, 但前提条件是
            // 1. 该 subquery 非 combined query
            // 2. 如果该 subquery 是 combined query , 该 table 属于第一个subquery 中的 table

            // 如果不是以上两种情况，那么该table就是该CTE的引用,需要返回 true
            // refer to: public void testSearchTable1()

            if (!pCTE.getSubquery().isCombinedQuery()) return false;

            if (TParseTreeNode.subNodeInNode(this,pCTE.getSubquery().getLeftStmt())){
                return false;
            }

        }

        this.CTE = pCTE;
        return true;
    }

    public TCTE getCTE() {

        return CTE;
    }

    public boolean isCTEName() {

        return isCTEName;
    }

    public void setCTEName(boolean CTEName) {
        isCTEName = CTEName;
    }

    private boolean isCTEName = false;

    public TSelectSqlStatement subquery = null;
    private THiveFromQuery hiveFromQuery;

    public void setHiveFromQuery(THiveFromQuery hiveFromQuery) {
        this.hiveFromQuery = hiveFromQuery;
    }

    /**
     * @deprecated As of v2.1.0.0, please use {@link #getSubquery()}
     * @return
     */
    public THiveFromQuery getHiveFromQuery() {

        return hiveFromQuery;
    }

    public TExpression getTableExpr() {
        return tableExpr;
    }

    public void setTableExpr(TExpression tableExpr) {
        this.tableExpr = tableExpr;
    }

    private TExpression tableExpr;

    public void setTableType(ETableSource tableType) {
        this.tableType = tableType;
    }

    /**
     *
     * @return what's kind of type this table is.
     *<ul>
     * <li>{@link ETableSource#objectname}, in from clause, a simple table/view name, reference: {@link TTable#tableName}<li>
     * <li>{@link ETableSource#subquery}, is a subquery that retrieves rows from the database, also known as derived table. reference: {@link TTable#subquery}</li>
     * <li>{@link ETableSource#tableExpr},it's usually a table-valued expression., reference: {@link TTable#tableExpr}</li>
     * <li>{@link ETableSource#function}, it's usually a table-valued function., reference: {@link TTable#funcCall}</li>
     * <li>{@link ETableSource#rowList}, it's constructed rows, reference: {@link TTable#rowList}</li>
     * <li>{@link ETableSource#containsTable}, CONTAINSTABLE clause of sql server. reference: {@link TTable#containsTable}, type of {@link TContainsTable}</li>
     * <li>{@link ETableSource#freetextTable}, FREETEXTTABLE  clause of sql server. reference: {@link TTable#containsTable}, type of {@link TContainsTable}</li>
     * <li>{@link ETableSource#openrowset}, OPENROWSET clause of sql server. reference: {@link TTable#openRowSet}, type of {@link TOpenRowSet}</li>
     * <li>{@link ETableSource#openxml}, OPENXML clause of sql server. reference: {@link TTable#openXML}, type of {@link TOpenXML }</li>
     * <li>{@link ETableSource#opendatasource}, OPENDATASOURCE clause of sql server. reference: {@link TTable#openDatasource}, type of {@link TOpenDatasource}</li>
     * <li>{@link ETableSource#openquery}, OPENQUERY clause of sql server. reference: {@link TTable#openquery}, type of (@link TOpenQuery)</li>
     * </ul>
     */
    public ETableSource getTableType() {

        return tableType;
    }

    private ETableSource tableType;
    
    public void setTableName(TObjectName tableName) {
        this.tableName = tableName;
        tableType = ETableSource.objectname;
        this.tableName.splitNameInQuotedIdentifier();
        if (this.getStartToken() == null){
            this.setStartToken(tableName.getStartToken());
        }

        if (this.getEndToken() == null){
            this.setEndToken(tableName.getEndToken());
        }
    }

    public TObjectName getTableName() {
        TObjectName ret = tableName;

        if (tableType == null) return ret;

        switch (tableType){
            case tableExpr:
                if (tableExpr.getExpressionType() == EExpressionType.function_t){
                    ret = tableExpr.getFunctionCall().getFunctionName();
                }
                break;
            case function:
                ret = getFuncCall().getFunctionName();
                break;
            case openrowset:
                ret = TObjectName.createObjectName (this.dbvendor, EDbObjectType.table,new TSourceToken("openrowset"));
                break;
            case rowList:
                ret = TObjectName.createObjectName (this.dbvendor, EDbObjectType.table,new TSourceToken("(values_table)"));
                break;
            case subquery:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("subquery"));
                break;
            case td_unpivot:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("td_unpivot"));
                break;
            case pivoted_table:
                // Check if this is an UNPIVOT to use the correct suffix
                String pivotSuffix = "(piviot_table)";
                if (getPivotedTable() != null && getPivotedTable().getPivotClause() != null
                    && getPivotedTable().getPivotClause().getType() == TPivotClause.unpivot) {
                    pivotSuffix = "(unpivot_table)";
                }
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken(tableName+pivotSuffix));
                break;
            case xmltable:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("xmltable"));
                break;
            case jsonTable:
                ret = getJsonTable().getFunctionName();// TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("jsontable"));//
                break;
            case containsTable:
                if (containsTable.getType() == TContainsTable.containstable){
                    ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("containsTable"));
                }else {
                    ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("freetexttable"));
                }
                break;
            case opendatasource:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("opendatasource"));
                break;
            case unnest:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken(getAliasName()+"(unnest table)"));
                break;
            case openxml:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("openxml"));
                break;
            case openquery:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("openquery"));
                break;
            case output_merge:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("merge"));
                break;
            case externalTable:
                ret = this.tableName;
                break;
            case join:
                ret = TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("join_expr"));
                break;
        }
        if (ret == null) {
            return TObjectName.createObjectName (this.dbvendor,EDbObjectType.table,new TSourceToken("unknown"));
        }
        else  return ret;
    }

    private TObjectName tableName;

    public TTable(TObjectName pobjectname){
           this.tableName = pobjectname;
           this.setStartToken(this.tableName.getStartToken());
           this.setEndToken(this.tableName.getEndToken());
    }


    public TTable(){
           this.tableName = null;
    }

    public String getName() {
        if (tableName != null)
            return tableName.getObjectString();
        else
            return getTableName().toString();
    }


    public String getPrefixServer(){
       if (tableName != null) return tableName.getServerString();
       else return "";
    }
    public  String getPrefixDatabase(){
        if (tableName != null) return tableName.getDatabaseString();
        else return "";
    }
    public String getPrefixSchema(){
        if (tableName != null) return tableName.getSchemaString();
        else return "";
    }

    public boolean isIncludeColumnAlias(){
       //  return (this.getAliasClause() != null);
        return false;
        // ToDo
    }


    public int searchColumnInAlias(TObjectName pColumn){
        if (getAliasClause() == null) return -1;
        return getAliasClause().searchColumn(pColumn);
    }

    public boolean checkTableByName(String pTablename){
        boolean lcResult = false;
        String a,b,c;
        b = TBaseType.getTextWithoutQuoted(pTablename);
        if (this.getAliasClause() != null){
            a = TBaseType.getTextWithoutQuoted(this.getAliasName());
            lcResult = a.equalsIgnoreCase(b);
        }
        if (lcResult) return true;
        c = TBaseType.getTextWithoutQuoted(this.getTableName().toString());
        lcResult = c.equalsIgnoreCase(b);
        return lcResult;
    }

    public boolean searchColumn(TSelectSqlStatement select, String tableName, TObjectName pColumn, boolean pMustIn){
        // pColumn maybe qualified, so check the table name at first
        boolean lcResult = false, isSameTable = false;
        if ( tableName.length() == 0){
            isSameTable = true;
        }else {
            isSameTable = checkTableByName(tableName);
        }

        if (!isSameTable) return lcResult;

        if (this.isBaseTable()){
            lcResult = select.fireOnMetaDatabaseTableColumn(this.getPrefixServer(),this.getPrefixDatabase(),this.getPrefixSchema(),this.getName(),pColumn.getColumnNameOnly());
        }else{
            if (this.getTableType() == ETableSource.subquery){
                if (this.isIncludeColumnAlias()){
                    lcResult = this.searchColumnInAlias(pColumn)>=0;
                }else{
                    lcResult = this.getSubquery().searchColumnInResultSet(pColumn,pMustIn);
                }
            }else if (this.isCTEName()){
                lcResult = this.getCTE().searchColumnInResultSet(select,this,pColumn,pMustIn);
            }
        }

        if (lcResult){
            this.getLinkedColumns().addObjectName(pColumn);
            pColumn.setSourceTable(this);
        }else if (pMustIn){
            this.getLinkedColumns().addObjectName(pColumn);
            pColumn.setSourceTable(this);
            lcResult = true;
        }

        if (!lcResult){
            if (this.getTableType() == ETableSource.pivoted_table){
                if (this.getLinkedColumns().size() > 0){
                    for(TObjectName c: this.getLinkedColumns()){
                        lcResult = c.toString().equalsIgnoreCase(pColumn.getColumnNameOnly());
                        if (lcResult) break;
                    }
                }
            }
        }

        return lcResult;
    }

    private TObjectNameList linkedColumns = null;

    /**
     * @deprecated , this method is deprecated since version 3.3.1.0, don't use it in TSQLResolver2
     * @return
     */
    public TObjectNameList getLinkedColumns() {
        if (linkedColumns == null) {
            linkedColumns = new TObjectNameList();
            linkedColumns.setObjectType(TObjectName.ttobjColumn);
        }
        return linkedColumns;
    }



    public String getFullNameWithAliasString() {
        if (getAliasClause() != null){
            return getFullName()+" "+getAliasClause().toString();
        }else{
            return getFullName();
        }
    }

    public String getFullName() {
        if (tableName == null) return  null;
        return tableName.toString();
        /*
        if (tableName.getSchemaString() == null)
        {return this.getName();}
        else{
            return tableName.getSchemaString()+"."+this.getName();
        }
          */

    }

    /**
     *
     * @return column name related to this table.
     * @deprecated As of v1.6.0.1, use  {@link #getLinkedColumns()} instead
     */
    public TObjectNameList getObjectNameReferences() {
        if (objectNameReferences == null){
            objectNameReferences = new TObjectNameList();
            objectNameReferences.setObjectType(TObjectName.ttobjColumn);
        }
        return objectNameReferences;
    }

    private TPivotClause pivotClause = null;

    public void setPivotClause(TPivotClause pivotClause) {
        this.pivotClause = pivotClause;
    }

    /**
     * @deprecated As of v1.6.2.4, replaced by {@link gudusoft.gsqlparser.nodes.TPivotedTable}
     * @return
     */
    public TPivotClause getPivotClause() {

        return pivotClause;
    }

    /**
     * Stored all column names that belong to this table.
     */
    private TObjectNameList objectNameReferences = null;

    public TTableReferenceList tablerefs = new TTableReferenceList();

    private TDataChangeTable datachangeTable = null;

    public void setDatachangeTable(TDataChangeTable datachangeTable) {
        this.datachangeTable = datachangeTable;
    }

    /**
     * DB2 data change
     * @return
     */
    public TDataChangeTable getDatachangeTable() {
        return datachangeTable;
    }


    public boolean isTableRefBelongToThisTable(TTableReference tableref){

        boolean retval = (this.tableName == tableref.objectname);
        if (retval) {return retval;}
        if (this.tableName.getObjectString().equalsIgnoreCase(tableref.objectname.getObjectString())){
            if ((this.tableName.getSchemaString() == null)
                ||(tableref.objectname.getSchemaString() == null)
                    ) {
                retval = true;
            }else{
                retval = (this.tableName.getSchemaString().equalsIgnoreCase(tableref.objectname.getSchemaString()));
            }
        }
        return retval;
    }

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

        v.postVisit(this);
    }

    public void setColumnDefinitions(TColumnDefinitionList columnDefinitions) {
        this.columnDefinitions = columnDefinitions;
    }

    public void acceptChildren(TParseTreeVisitor v){
        v.preVisit(this);

        switch(getTableType()){
            case objectname:{
                getTableName().acceptChildren(v);
                if (getFlashback() != null){
                    getFlashback().acceptChildren(v);
                }
                break;
            }
            case tableExpr:{
                getTableExpr().acceptChildren(v);
                break;
            }
            case subquery:{
                getSubquery().acceptChildren(v);
                break;
            }
            case function:{
                getFuncCall().acceptChildren(v);
                break;
            }
            case pivoted_table:{
                if (this.getEffectType() == ETableEffectType.tetPivot) break;
                getPivotedTable().acceptChildren(v);
                break;
            }
            case output_merge:{
                if (getOutputMerge() != null) getOutputMerge().acceptChildren(v);
                //e_table_reference.setTextContent(node.getOutputMerge().toString());
                break;
            }
            case containsTable:{
                getContainsTable().acceptChildren(v);
                break;
            }

            case openrowset:{
                getOpenRowSet().acceptChildren(v);
                break;
            }

            case openxml:{
                getOpenXML().acceptChildren(v);
                break;
            }

            case opendatasource:{
                getOpenDatasource().acceptChildren(v);
                break;
            }

            case openquery:{
                getOpenquery().acceptChildren(v);
                break;
            }

            case datachangeTable:{
                getDatachangeTable().acceptChildren(v);
                break;
            }
            case rowList:{
                getValueClause().acceptChildren(v);
                break;
            }
            case xmltable:{
                getXmlTable().acceptChildren(v);
                break;
            }
            case jsonTable:{
                getJsonTable().acceptChildren(v);
                break;
            }
            case informixOuter:{
                getOuterClause().acceptChildren(v);
                break;
            }

            case table_ref_list:{
                getFromTableList().acceptChildren(v);
                break;
            }
            case hiveFromQuery:{
                getHiveFromQuery().acceptChildren(v);
                break;
            }
            case externalTable:
                this.columnDefinitions.acceptChildren(v);
                break;
            case join:
                this.joinExpr.acceptChildren(v);
                break;
            case unnest:
                this.getUnnestClause().acceptChildren(v);
                break;
            default:
                //sb.append(node.toString().replace(">","&#62;").replace("<","&#60;"));
                break;

        }


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

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

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


        if (getTableHintList() != null){
            for(int i=0;i<getTableHintList().size();i++){
                TTableHint tableHint = getTableHintList().getElement(i);
                tableHint.acceptChildren(v);
            }
        }

        if (getLateralViewList() != null){
            for(TLateralView lateralView:getLateralViewList()){
                lateralView.acceptChildren(v);
            }
        }


        v.postVisit(this);
    }

    public void setRowList(TMultiTargetList rowList) {
        this.rowList = rowList;
    }

    public void setSubquery(TSelectSqlStatement subquery) {
        this.subquery = subquery;
    }

    public void setLinkedColumns(TObjectNameList linkedColumns) {
        this.linkedColumns = linkedColumns;
    }

    public void setTablerefs(TTableReferenceList tablerefs) {
        this.tablerefs = tablerefs;
    }

    private boolean starColumnExpanded = false;

    private ArrayList<String> expandedStarColumns = new ArrayList<String>();

    private void getExpandStarColumnsFromSubquery(TSelectSqlStatement subquery, ArrayList<String> expandedStarColumns){

        for(TResultColumn resultColumn:subquery.getResultColumnList()){
            if (resultColumn.toString().endsWith("*")){
                TTable srcTable  = resultColumn.getExpr().getObjectOperand().getSourceTable();
                if ( srcTable!= null){
                    ArrayList<String> list = srcTable.getExpandedStarColumns();
                    expandedStarColumns.addAll(list);
                }
            }else{
                expandedStarColumns.add(resultColumn.getDisplayName());
            }
        }
    }

    /**
     * If a star column is linked to this table, use this method to returns all underlying columns that represented by
     * the star column.
     * <br>
     * <br> The returned column always prefixed with
     * <br> 1. the table alias.
     * <br> 2. the table name
     * <br> 3. the alias of query (if the table is a subquery)
     * <br> 4. empty if the no alias is specified for a subquery
     *
     * @return a list of columns
     */
    public ArrayList<String> getExpandedStarColumns(){
        if (starColumnExpanded) return expandedStarColumns;

        switch (getTableType()){
            case objectname:
                if (this.isCTEName()){
                    if (this.getCteColomnReferences()!=null){
                        for(TObjectName n:this.getCteColomnReferences()){
                            expandedStarColumns.add(n.toString());
                        }
                    }else if (this.getCTE().getSubquery() != null){
                        this.getExpandStarColumnsFromSubquery(this.getCTE().getSubquery(),this.expandedStarColumns);
                    }
                }else{
                    if (this.getSqlEnv() != null){
                        ArrayList<String> columns = this.getSqlEnv().getColumnsInTable(this.getPrefixDatabase() +"."+this.getPrefixSchema()+"."+this.getName(),false);
                        if (columns != null) expandedStarColumns = columns;
                        if (this.getAliasClause() != null){
                            //replace table name with alias
                        }
                    }
                    if ((expandedStarColumns.size() == 0)&&(getLinkedColumns().size()>0)){
                        for(TObjectName linkColumn:getLinkedColumns()){
                            if (linkColumn.toString().endsWith("*")) continue;
                            String s = linkColumn.getColumnNameOnly();
                            if (this.getAliasClause() != null){
                                s = this.getAliasName()+"."+s;
                            }else{
                                s = this.getName()+"."+s;
                            }
                            if (expandedStarColumns.indexOf(s) == -1) expandedStarColumns.add(s);
                        }
                    }
                }

                break;
            case subquery:
                this.getExpandStarColumnsFromSubquery(this.getSubquery(),this.expandedStarColumns);
                break;
            default:
                break;
        }

        starColumnExpanded = true;
        return expandedStarColumns;
    }

//    @Override
//    public String toString(){
//        if (getAliasClause() != null) return getAliasClause().toString();
//
//        switch (getTableType()){
//            case objectname:
//                return getName().toString();
//                break;
//            default:
//
//                break;
//        }
//    }

    @Override
    public String toString(){
        String ret = super.toString();
        if (ret != null) return  ret;
        if (tableName != null) return tableName.getObjectString();
        return null;
    }

}