package gudusoft.gsqlparser.nodes;

import gudusoft.gsqlparser.*;
import gudusoft.gsqlparser.nodes.hive.THiveFromQuerySqlNode;
import gudusoft.gsqlparser.nodes.hive.THiveKeyValueProperty;
import gudusoft.gsqlparser.nodes.hive.THivePartitionedTableFunction;
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 java.util.ArrayList;

/**
* Represents table source in from clause of select/delete statement, and update table clause of update statement.    
*
*/
public class TFromTable extends TNodeWithAliasClause{

//    private TPartitionClause partitionClause;
//
//    public void setPartitionClause(TPartitionClause partitionClause) {
//
//        this.partitionClause = partitionClause;
//    }
//
//    public TPartitionClause getPartitionClause() {
//        return partitionClause;
//    }

    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 TCaseJoinClause getCaseJoin() {
        return caseJoin;
    }

    private TExpression joinCondition;

    public void setJoinCondition(TExpression joinCondition) {
        this.joinCondition = joinCondition;
    }

    /**
     * used in couchbase only
     * @return
     */
    public TExpression getJoinCondition() {

        return joinCondition;
    }

    private int parenthesisCount = 0;
    private int parenthesisAfterAliasCount = 0;

    public TPxGranule getPxGranule() {
        return pxGranule;
    }

    public void incParenthesisCount(){
        parenthesisCount++;
    }

    public void incParenthesisAfterAliasCount(){
        parenthesisAfterAliasCount++;
    }

    public int getParenthesisCount() {
        return parenthesisCount;
    }

    public int getParenthesisAfterAliasCount() {
        return parenthesisAfterAliasCount;
    }

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

    /**
     *
     * @return hive table property list
     */
    public TPTNodeList<THiveKeyValueProperty> getTableProperties() {

        return tableProperties;
    }

    private TPTNodeList<THiveKeyValueProperty> tableProperties;

    private THiveFromQuerySqlNode fromQuerySqlNode;

    private TPartitionExtensionClause partitionExtensionClause;

    public TPartitionExtensionClause getPartitionExtensionClause() {
        return partitionExtensionClause;
    }

    public void setPartitionExtensionClause(TPartitionExtensionClause partitionExtensionClause) {

        this.partitionExtensionClause = partitionExtensionClause;
    }

    private TColumnDefinitionList columnDefinitions;

    public TColumnDefinitionList getColumnDefinitions() {
        return columnDefinitions;
    }

    private TValueClause valueClause;

    public TValueClause getValueClause() {
        return valueClause;
    }

    private TJsonTable jsonTable;

    public TJsonTable getJsonTable() {
        return jsonTable;
    }

    private TXmlTable xmlTable;

    public TXmlTable getXmlTable() {
        return xmlTable;
    }

    public TObjectName getTableObjectName() {
        return tableObjectName;
    }

    public TExpression getTableExpr() {
        return tableExpr;
    }

    public void setTableObjectName(TObjectName tableObjectName) {
        //tableObjectName.parseTablename();
        this.tableObjectName = tableObjectName;
        this.tableObjectName.setObjectType(TObjectName.ttobjTable);
        this.tableObjectName.setDbObjectType(EDbObjectType.table);
    }

    private TObjectName tableObjectName;

    public TOpenQuery getOpenQuery() {
        return openQuery;
    }

    private TPTNodeList<TTableHint> tableHintList;

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

    public TPTNodeList<TTableHint> getTableHintList() {

        return tableHintList;
    }

    public TSelectSqlNode getSubquerynode() {
        return subquerynode;
    }

    private TSelectSqlNode subquerynode;
    private TExpression tableExpr;

    private TMultiTargetList rowList;

    public TMultiTargetList getRowList() {
        return rowList;
    }

    private TSourceToken tableonly;

    private boolean tableKeyword = false;
    private boolean onlyKeyword = false;

    /**
     * Redshift array-unnesting positional index alias.
     * <p>
     * In Redshift you can iterate over an array column in the FROM clause and
     * bind a name to the element as well as to its ordinal position, e.g.
     * <pre>FROM schema.tbl t, t.array_col AS element AT idx</pre>
     * Here {@code element} becomes the table/element alias (the regular
     * {@link #getAliasClause() aliasClause}) and {@code idx} is 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 from-clause item, e.g.
     * <pre>FROM c.c_orders AS o, UNPIVOT o AS val AT attr</pre>
     * When {@code true} this from item unpivots the SUPER expression: the
     * regular {@link #getAliasClause() aliasClause} is the value alias and
     * {@link #getArrayIndexAlias() arrayIndexAlias} (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;
    }

    public boolean isTableKeyword() {
        return tableKeyword;
    }

    public boolean isOnlyKeyword() {
        return onlyKeyword;
    }

    public TJoinExpr getJoinExpr() {
        return joinExpr;
    }

    private TJoinExpr joinExpr;

    public ETableSource getFromtableType() {
        return fromtableType;

    }

    private ETableSource fromtableType;


    public TOpenDatasource getOpenDatasource() {
        return openDatasource;
    }

    private TOpenDatasource openDatasource = null;

    public TOpenRowSet getOpenRowSet() {
        return openRowSet;
    }

    public TOpenXML getOpenXML() {
        return openXML;
    }

    private TOpenXML openXML = null;

    private TOpenRowSet openRowSet = null;

    private TOpenQuery openQuery = null;
    
    public TContainsTable getContainsTable() {
        return containsTable;
    }

    private TContainsTable containsTable = null;

    public void setTableonly(TSourceToken tableonly) {
        this.tableonly = tableonly;
        if (tableonly.toString().equalsIgnoreCase("only")){
            onlyKeyword = true;
        }else if(tableonly.toString().equalsIgnoreCase("table")){
            tableKeyword = true;
            if (tableExpr != null){
                fromtableType = ETableSource.tableExpr;
            }
        }
    }

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

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

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

    private TTableSample tableSample;
    private TPxGranule pxGranule;

    public TFlashback getFlashback() {
        return flashback;
    }

    private TFlashback flashback;

    public TTableSample getTableSample() {
        return tableSample;
    }

    private TDataChangeTable datachangeTable = null;
    private TRelationExpr relationExpr;

    /**
     * Postgresql relation expr
     * @return
     */
    public TRelationExpr getRelationExpr() {
        return relationExpr;
    }

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


    public TMergeSqlNode getMergeSqlNode() {
        return mergeSqlNode;
    }

    private TMergeSqlNode mergeSqlNode;
    private TPivotedTable pivotedTable;

    public TPivotedTable getPivotedTable() {
        return pivotedTable;
    }

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

    public TPivotClause getPivotClause() {

        return pivotClause;
    }

    private TPivotClause pivotClause = null;

    /**
     * a table-valued function, in SQL Server, Postgresql
     * @return
     */
    public TFunctionCall getFuncCall() {
        return funcCall;
    }

    private TFunctionCall funcCall = null;

    private TInformixOuterClause outerClause;

    private TFromTableList fromTableList;

    public TFromTableList getFromTableList() {
        return fromTableList;
    }

    public TInformixOuterClause getOuterClause() {
        return outerClause;
    }

    private THivePartitionedTableFunction partitionedTableFunction;


    public THivePartitionedTableFunction getPartitionedTableFunction() {
        return partitionedTableFunction;
    }

    private ArrayList<TLateralView> lateralViewList;

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

    /**
     *
     * @return hive lateral view list
     */
    public ArrayList<TLateralView> getLateralViewList() {

        return lateralViewList;
    }

    private TExpressionList joinExprList;

    public void setJoinExprList(TExpressionList joinExprList) {
        this.joinExprList = joinExprList;
    }

    /**
     *
     * @return hive uniqueJoinExpr list
     */
    public TExpressionList getJoinExprList() {

        return joinExprList;
    }

    public THiveFromQuerySqlNode getFromQuerySqlNode() {
        return fromQuerySqlNode;
    }

    public void setColumnDefinitions(TColumnDefinitionList columnDefinitions) {
        this.columnDefinitions = columnDefinitions;
        if (this.columnDefinitions != null){
            fromtableType = ETableSource.externalTable;
        }
    }

    private TDummy tableFunctionReturn;

    public void setTableFunctionReturn(TDummy tableFunctionReturn) {
        if (tableFunctionReturn == null) return;
        this.tableFunctionReturn = tableFunctionReturn;
        if (this.tableFunctionReturn.list1 != null){
            this.columnDefinitions = (TColumnDefinitionList)this.tableFunctionReturn.list1;
        }
    }

    /** Input correlation name inside a Teradata table operator's ON clause. */
    private TAliasClause tableOperatorInputAlias;
    /** Partition expressions over the ON input, separate from its output alias. */
    private TPartitionClause tableOperatorPartitionBy;
    /** Ordering of rows supplied to a Teradata table operator. */
    private TOrderBy tableOperatorOrderBy;

    public TAliasClause getTableOperatorInputAlias() { return tableOperatorInputAlias; }
    public void setTableOperatorInputAlias(TAliasClause value) { tableOperatorInputAlias = value; }
    public TPartitionClause getTableOperatorPartitionBy() { return tableOperatorPartitionBy; }
    public void setTableOperatorPartitionBy(TPartitionClause value) { tableOperatorPartitionBy = value; }
    public TOrderBy getTableOperatorOrderBy() { return tableOperatorOrderBy; }
    public void setTableOperatorOrderBy(TOrderBy value) { tableOperatorOrderBy = value; }

    /**
     * Teradata HASH BY clause for table functions.
     * <p>
     * Example: HASH BY col1, col2
     */
    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.
     * <p>
     * Example: LOCAL ORDER BY col1, col2
     */
    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;
    }

    // Constants for type codes
    private static final int TYPE_OBJECT_NAME = 1;
    private static final int TYPE_SELECT_SQL_NODE = 2;
    private static final int TYPE_EXPRESSION = 3;
    private static final int TYPE_JOIN_EXPR = 4;
    private static final int TYPE_DUMMY = 5;
    private static final int TYPE_CONTAINS_TABLE = 6;
    private static final int TYPE_OPEN_ROW_SET = 7;
    private static final int TYPE_OPEN_XML = 8;
    private static final int TYPE_OPEN_DATASOURCE = 9;
    private static final int TYPE_OPEN_QUERY = 10;
    private static final int TYPE_DATA_CHANGE_TABLE = 11;
    private static final int TYPE_RELATION_EXPR = 12;
    private static final int TYPE_JSON_TABLE = 13;
    private static final int TYPE_FUNCTION_CALL = 14;
    private static final int TYPE_XML_TABLE = 15;
    private static final int TYPE_INFORMIX_OUTER_CLAUSE = 16;
    private static final int TYPE_FROM_TABLE_LIST = 17;
    private static final int TYPE_HIVE_PARTITIONED_TABLE_FUNCTION = 18;
    private static final int TYPE_HIVE_FROM_QUERY_SQL_NODE = 19;
    private static final int TYPE_PIVOTED_TABLE = 20;
    private static final int TYPE_MERGE_SQL_NODE = 21;
    private static final int TYPE_TD_UNPIVOT = 22;
    private static final int TYPE_UNNEST_CLAUSE = 23;
    private static final int TYPE_VALUE_CLAUSE = 24;
    private static final int TYPE_CASE_JOIN_CLAUSE = 25;
    private static final int TYPE_STAGE_REFERENCE = 26;

    public void init(Object arg1) {
        if (arg1 == null) return;

        int typeCode = getTypeCode(arg1);

        switch (typeCode) {
            case TYPE_OBJECT_NAME:
                setTableObjectName((TObjectName) arg1);
                fromtableType = ETableSource.objectname;
                break;
            case TYPE_SELECT_SQL_NODE:
                subquerynode = (TSelectSqlNode) arg1;
                fromtableType = ETableSource.subquery;
                setStartToken(subquerynode.getStartToken());
                setEndToken(subquerynode.getEndToken());
                break;
            case TYPE_EXPRESSION:
                initExpression((TExpression) arg1);
                break;
            case TYPE_JOIN_EXPR:
                joinExpr = (TJoinExpr) arg1;
                fromtableType = ETableSource.join;
                break;
            case TYPE_DUMMY:
                initTableDefInDummyNode((TDummy) arg1);
                break;
            case TYPE_CONTAINS_TABLE:
                containsTable = (TContainsTable) arg1;
                fromtableType = ETableSource.containsTable;
                break;
            case TYPE_OPEN_ROW_SET:
                openRowSet = (TOpenRowSet) arg1;
                fromtableType = ETableSource.openrowset;
                break;
            case TYPE_OPEN_XML:
                openXML = (TOpenXML) arg1;
                fromtableType = ETableSource.openxml;
                break;
            case TYPE_OPEN_DATASOURCE:
                openDatasource = (TOpenDatasource) arg1;
                fromtableType = ETableSource.opendatasource;
                break;
            case TYPE_OPEN_QUERY:
                openQuery = (TOpenQuery) arg1;
                fromtableType = ETableSource.openquery;
                break;
            case TYPE_DATA_CHANGE_TABLE:
                datachangeTable = (TDataChangeTable) arg1;
                fromtableType = ETableSource.datachangeTable;
                break;
            case TYPE_RELATION_EXPR:
                initRelationExpr((TRelationExpr) arg1);
                break;
            case TYPE_JSON_TABLE:
                jsonTable = (TJsonTable) arg1;
                fromtableType = ETableSource.jsonTable;
                break;
            case TYPE_FUNCTION_CALL:
                // This will handle TFunctionCall and all its subclasses
                funcCall = (TFunctionCall) arg1;
                fromtableType = ETableSource.function;
                break;
            case TYPE_XML_TABLE:
                xmlTable = (TXmlTable) arg1;
                fromtableType = ETableSource.xmltable;
                break;
            case TYPE_INFORMIX_OUTER_CLAUSE:
                outerClause = (TInformixOuterClause) arg1;
                fromtableType = ETableSource.informixOuter;
                break;
            case TYPE_FROM_TABLE_LIST:
                fromTableList = (TFromTableList) arg1;
                fromtableType = ETableSource.table_ref_list;
                break;
            case TYPE_HIVE_PARTITIONED_TABLE_FUNCTION:
                partitionedTableFunction = (THivePartitionedTableFunction) arg1;
                break;
            case TYPE_HIVE_FROM_QUERY_SQL_NODE:
                fromQuerySqlNode = (THiveFromQuerySqlNode) arg1;
                fromtableType = ETableSource.hiveFromQuery;
                break;
            case TYPE_PIVOTED_TABLE:
                pivotedTable = (TPivotedTable) arg1;
                fromtableType = ETableSource.pivoted_table;
                break;
            case TYPE_MERGE_SQL_NODE:
                mergeSqlNode = (TMergeSqlNode) arg1;
                fromtableType = ETableSource.output_merge;
                break;
            case TYPE_TD_UNPIVOT:
                tdUnpivot = (TTDUnpivot) arg1;
                fromtableType = ETableSource.td_unpivot;
                break;
            case TYPE_UNNEST_CLAUSE:
                unnestClause = (TUnnestClause) arg1;
                fromtableType = ETableSource.unnest;
                break;
            case TYPE_VALUE_CLAUSE:
                valueClause = (TValueClause) arg1;
                fromtableType = ETableSource.rowList;
                break;
            case TYPE_CASE_JOIN_CLAUSE:
                caseJoin = (TCaseJoinClause) arg1;
                fromtableType = ETableSource.caseJoin;
                break;
            case TYPE_STAGE_REFERENCE:
                stageReference = (TStageReference) arg1;
                fromtableType = ETableSource.stageReference;
                break;
            default:
                // Handle unexpected types or throw an exception
                throw new IllegalArgumentException("Unexpected argument type: " + arg1.getClass().getSimpleName());
        }
    }

    private int getTypeCode(Object arg1) {
        if (arg1 instanceof TObjectName) return TYPE_OBJECT_NAME;
        if (arg1 instanceof TSelectSqlNode) return TYPE_SELECT_SQL_NODE;
        if (arg1 instanceof TExpression) return TYPE_EXPRESSION;
        if (arg1 instanceof TJoinExpr) return TYPE_JOIN_EXPR;
        if (arg1 instanceof TDummy) return TYPE_DUMMY;
        if (arg1 instanceof TContainsTable) return TYPE_CONTAINS_TABLE;
        if (arg1 instanceof TOpenRowSet) return TYPE_OPEN_ROW_SET;
        if (arg1 instanceof TOpenXML) return TYPE_OPEN_XML;
        if (arg1 instanceof TOpenDatasource) return TYPE_OPEN_DATASOURCE;
        if (arg1 instanceof TOpenQuery) return TYPE_OPEN_QUERY;
        if (arg1 instanceof TDataChangeTable) return TYPE_DATA_CHANGE_TABLE;
        if (arg1 instanceof TRelationExpr) return TYPE_RELATION_EXPR;
        if (arg1 instanceof TJsonTable) return TYPE_JSON_TABLE;
        if (arg1 instanceof TFunctionCall) return TYPE_FUNCTION_CALL;
        if (arg1 instanceof TXmlTable) return TYPE_XML_TABLE;
        if (arg1 instanceof TInformixOuterClause) return TYPE_INFORMIX_OUTER_CLAUSE;
        if (arg1 instanceof TFromTableList) return TYPE_FROM_TABLE_LIST;
        if (arg1 instanceof THivePartitionedTableFunction) return TYPE_HIVE_PARTITIONED_TABLE_FUNCTION;
        if (arg1 instanceof THiveFromQuerySqlNode) return TYPE_HIVE_FROM_QUERY_SQL_NODE;
        if (arg1 instanceof TPivotedTable) return TYPE_PIVOTED_TABLE;
        if (arg1 instanceof TMergeSqlNode) return TYPE_MERGE_SQL_NODE;
        if (arg1 instanceof TTDUnpivot) return TYPE_TD_UNPIVOT;
        if (arg1 instanceof TUnnestClause) return TYPE_UNNEST_CLAUSE;
        if (arg1 instanceof TValueClause) return TYPE_VALUE_CLAUSE;
        if (arg1 instanceof TCaseJoinClause) return TYPE_CASE_JOIN_CLAUSE;
        if (arg1 instanceof TStageReference) return TYPE_STAGE_REFERENCE;
        return 0; // Unknown type
    }
    private void initExpression(TExpression expr) {
        tableExpr = expr;
        fromtableType = ETableSource.tableExpr;
        if (tableExpr.getExpressionType() == EExpressionType.simple_object_name_t) {
            setTableObjectName(tableExpr.getObjectOperand());
            fromtableType = ETableSource.objectname;
        }
    }

    private void initRelationExpr(TRelationExpr expr) {
        relationExpr = expr;
        setTableObjectName(relationExpr.getRelationName());
        fromtableType = ETableSource.objectname;
        // FROM ONLY t / TABLE ONLY t: the table without its inheritance children
        if (relationExpr.getOnly() != null) {
            onlyKeyword = true;
        }
    }
    private TUnnestClause unnestClause;

    public TUnnestClause getUnnestClause() {
        return unnestClause;
    }

    private TTDUnpivot tdUnpivot;

    public TTDUnpivot getTdUnpivot() {
        return tdUnpivot;
    }

    private TPTNodeList <TTableHint> nameListToTableHint(Object arg1,boolean isSybaseIndexHint){
        TPTNodeList<TTableHint> hints = new TPTNodeList<TTableHint>();
        if (arg1 instanceof TObjectNameList){
            TObjectNameList columns = (TObjectNameList)arg1;
            for (int i=0;i<columns.size();i++){
                TObjectName column = columns.getObjectName(i);
                if ((isSybaseIndexHint)||(isSQLServerHint(column.toString()))){
                    TTableHint tableHint = new TTableHint();
                    tableHint.setHint(column);
                    if (i == 0)
                      tableHint.setStartToken(column.getStartToken());
                    if (i == columns.size() - 1)
                      tableHint.setEndToken(column.getStartToken());
                    hints.addElement(tableHint);
                }else {
                    hints.removeAllElements();
                    break;
                }
            }
        }else if (arg1 instanceof TExpressionList){
            TExpressionList expressionList = (TExpressionList)arg1;
            for(int i=0;i<expressionList.size();i++){
                TExpression expression = expressionList.getExpression(i);
                if ((isSybaseIndexHint)||(isSQLServerHint(expression.toString()))){
                    TTableHint tableHint = new TTableHint();
                    tableHint.setHint(expression.getObjectOperand());
                    if (i == 0)
                      tableHint.setStartToken(expression.getStartToken());
                    if (i == expressionList.size() - 1)
                      tableHint.setEndToken(expression.getStartToken());
                    hints.addElement(tableHint);
                }else {
                    hints.removeAllElements();
                    break;
                }
            }
        }

        if (hints.size() > 0)
            return hints;
        else
            return null;
    }

    private boolean isSQLServerHint(String pstr){
        boolean retval = false;
        String[] hints = new String[] {
        "fastfirstrow","holdlock","nolock","nowait","paglock",
       "readcommitted","readcommittedlock","readpast","readuncommitted","repeatableread",
       "rowlock","serializable","tablock","tablockx","updlock",
       "xlock","keepidentity","keepdefaults","ignore_constraints","ignore_triggers",
       "index"
        };

        for(int i=0;i<21;i++)
        {
            if (hints[i].compareToIgnoreCase(pstr) == 0){
                retval = true;
                break;
            }
        }

        return retval;
    }
    
    private void initTableDefInDummyNode(TDummy pdummy){
        fromtableType = ETableSource.objectname; //default, may change to ftt_function later

       if (pdummy.int1 == 0){
           setTableObjectName((TObjectName)(pdummy.node1));
       }else if (pdummy.int1 == 1){
           if (pdummy.list1 == null){
               //it's a function
               funcCall =  new TFunctionCall();//(TFunctionCall)createNode(ENodeType.T_FunctionCall.getId(),((TObjectName)pdummy.node1));
               funcCall.init(((TObjectName) pdummy.node1),EFunctionType.udf_t);
               //((TObjectName)pdummy.node1).parseFunctionName();
               // ((TObjectName)pdummy.node1).setObjectType(TObjectName.ttobjFunctionName);
               funcCall.setStartToken(pdummy.getStartToken());
               funcCall.setEndToken(pdummy.getEndToken());
               funcCall.setArgs(null);
               fromtableType = ETableSource.function;
           }else{
               tableHintList = nameListToTableHint(((TExpressionList)pdummy.list1),false);
              if ( tableHintList != null){
              //if (isSQLServerHint(((TExpressionList)pdummy.list1).getExpression(0).toString())){
                  //this is sql server hint, not a function, so set table name
                  setTableObjectName((TObjectName)(pdummy.node1));
              }else{
                  //it's a function
                  funcCall =  new TFunctionCall();//(TFunctionCall)createNode(ENodeType.T_FunctionCall.getId(),((TObjectName)pdummy.node1));
                  funcCall.init(((TObjectName)pdummy.node1),EFunctionType.udf_t);
                  //((TObjectName)pdummy.node1).parseFunctionName();
                 // ((TObjectName)pdummy.node1).setObjectType(TObjectName.ttobjFunctionName);
                  funcCall.setArgs((TExpressionList)pdummy.list1);
                  fromtableType = ETableSource.function;
                  funcCall.setStartToken(pdummy.getStartToken());
                  funcCall.setEndToken(pdummy.getEndToken());
              }
           }
       }else if (pdummy.int1 == 2){
           setTableObjectName((TObjectName)(pdummy.node1));
           tableHintList = nameListToTableHint(pdummy.list1,false); //sql server only, maybe deleted in future
       }else if (pdummy.int1 == 3){
           setTableObjectName((TObjectName)(pdummy.node1));
           tableHintList = (TPTNodeList)(pdummy.node3); //sybase index table hint
       }

       if (pdummy.node2 != null){
           this.setAliasClause((TAliasClause)(pdummy.node2));
           if (this.getAliasClause().isSybaseIndexHint()){
             tableHintList = this.getAliasClause().getTableHints();
             this.getAliasClause().setEndToken(this.getAliasClause().getAliasName().getEndToken());
           }else
               if (this.getAliasClause().getColumns() != null){
                   tableHintList = nameListToTableHint(this.getAliasClause().getColumns(),this.getAliasClause().isSybaseIndexHint());
                   if (tableHintList != null){
                       //this is not column list of table alias, this is table hint like NOLOCK in this sql:
                       // SELECT COUNT(DISTINCT(SD_KEY)) FROM SHORTWINDOW PAST (NOLOCK)
                       this.getAliasClause().setEndToken(this.getAliasClause().getAliasName().getEndToken());
                   }
               }

       }

    }

    public void init(Object arg1,Object arg2)
    {
        init(arg1);
        if (arg2 != null){
            this.setAliasClause((TAliasClause)arg2);
            // this is table alias
            this.getAliasClause().setDBObjectToAlias(EDbObjectType.table_alias);
        }
    }

    public void setTableProperties(TDummyList tableProperties){
        for(int i=0;i<tableProperties.size();i++){
            TDummy dummy = tableProperties.getDummyItem(i);
            TParseTreeNode node = dummy.node1;
            if (node instanceof TAliasClause){
                this.setAliasClause( (TAliasClause)node);
            }
        }
    }

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

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

    public void setXmlTable(TXmlTable xmlTable) {
        this.xmlTable = xmlTable;
    }

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

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

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

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

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

    public void setFromtableType(ETableSource fromtableType) {
        this.fromtableType = fromtableType;
    }

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

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

    public void setOpenRowSet(TOpenRowSet openRowSet) {
        this.openRowSet = openRowSet;
    }

    public void setOpenQuery(TOpenQuery openQuery) {
        this.openQuery = openQuery;
    }

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

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

    public void setRelationExpr(TRelationExpr relationExpr) {
        this.relationExpr = relationExpr;
    }

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

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

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

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

    public void setPartitionedTableFunction(THivePartitionedTableFunction partitionedTableFunction) {
        this.partitionedTableFunction = partitionedTableFunction;
    }

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

    public void acceptChildren(TParseTreeVisitor v) {
        v.preVisit(this);
        switch (fromtableType){
            case objectname:
                tableObjectName.acceptChildren(v);
                break;
            case subquery:
                // subquerynode
                break;
            case tableExpr:
                tableExpr.acceptChildren(v);
                break;
            case join:
                joinExpr.acceptChildren(v);
                break;
            case function:
                funcCall.acceptChildren(v);
                break;
            case containsTable:
                containsTable.acceptChildren(v);
                break;
            case openrowset:
                openRowSet.acceptChildren(v);
                break;
            case openxml:
                openXML.acceptChildren(v);
                break;
            case opendatasource:
                openDatasource.acceptChildren(v);
                break;
            case openquery:
                openQuery.acceptChildren(v);
                break;
            case datachangeTable:
                datachangeTable.acceptChildren(v);
                break;
            case xmltable:
                xmlTable.acceptChildren(v);
                break;
            case informixOuter:
                outerClause.acceptChildren(v);
                break;
            case table_ref_list:
                fromTableList.acceptChildren(v);
                break;
            case hiveFromQuery:
                fromQuerySqlNode.acceptChildren(v);
                break;
            case pivoted_table:
                pivotedTable.acceptChildren(v);
                break;
            case output_merge:
                mergeSqlNode.acceptChildren(v);
                break;
            case td_unpivot:
                tdUnpivot.acceptChildren(v);
                break;
            case unnest:
                unnestClause.acceptChildren(v);
                break;
            case jsonTable:
                jsonTable.acceptChildren(v);
                break;
            case rowList:
                valueClause.acceptChildren(v);
                break;
        }

        v.postVisit(this);
    }
}