Source code

001package gudusoft.gsqlparser.nodes;
002
003import gudusoft.gsqlparser.*;
004import gudusoft.gsqlparser.nodes.hive.THiveFromQuerySqlNode;
005import gudusoft.gsqlparser.nodes.hive.THiveKeyValueProperty;
006import gudusoft.gsqlparser.nodes.hive.THivePartitionedTableFunction;
007import gudusoft.gsqlparser.nodes.snowflake.TAtBeforeClause;
008import gudusoft.gsqlparser.nodes.snowflake.TStageReference;
009import gudusoft.gsqlparser.nodes.teradata.TTDUnpivot;
010
011import java.util.ArrayList;
012
013/**
014* Represents table source in from clause of select/delete statement, and update table clause of update statement.    
015*
016*/
017public class TFromTable extends TNodeWithAliasClause{
018
019//    private TPartitionClause partitionClause;
020//
021//    public void setPartitionClause(TPartitionClause partitionClause) {
022//
023//        this.partitionClause = partitionClause;
024//    }
025//
026//    public TPartitionClause getPartitionClause() {
027//        return partitionClause;
028//    }
029
030    private TStageReference stageReference;
031
032    public TStageReference getStageReference() {
033        return stageReference;
034    }
035
036    private TAtBeforeClause timeTravelClause;
037
038    public void setTimeTravelClause(TAtBeforeClause timeTravelClause) {
039        this.timeTravelClause = timeTravelClause;
040    }
041
042    public TAtBeforeClause getTimeTravelClause() {
043        return timeTravelClause;
044    }
045    private TCaseJoinClause caseJoin;
046
047    public TCaseJoinClause getCaseJoin() {
048        return caseJoin;
049    }
050
051    private TExpression joinCondition;
052
053    public void setJoinCondition(TExpression joinCondition) {
054        this.joinCondition = joinCondition;
055    }
056
057    /**
058     * used in couchbase only
059     * @return
060     */
061    public TExpression getJoinCondition() {
062
063        return joinCondition;
064    }
065
066    private int parenthesisCount = 0;
067    private int parenthesisAfterAliasCount = 0;
068
069    public TPxGranule getPxGranule() {
070        return pxGranule;
071    }
072
073    public void incParenthesisCount(){
074        parenthesisCount++;
075    }
076
077    public void incParenthesisAfterAliasCount(){
078        parenthesisAfterAliasCount++;
079    }
080
081    public int getParenthesisCount() {
082        return parenthesisCount;
083    }
084
085    public int getParenthesisAfterAliasCount() {
086        return parenthesisAfterAliasCount;
087    }
088
089    public void setTableProperties(TPTNodeList<THiveKeyValueProperty> tableProperties) {
090        this.tableProperties = tableProperties;
091    }
092
093    /**
094     *
095     * @return hive table property list
096     */
097    public TPTNodeList<THiveKeyValueProperty> getTableProperties() {
098
099        return tableProperties;
100    }
101
102    private TPTNodeList<THiveKeyValueProperty> tableProperties;
103
104    private THiveFromQuerySqlNode fromQuerySqlNode;
105
106    private TPartitionExtensionClause partitionExtensionClause;
107
108    public TPartitionExtensionClause getPartitionExtensionClause() {
109        return partitionExtensionClause;
110    }
111
112    public void setPartitionExtensionClause(TPartitionExtensionClause partitionExtensionClause) {
113
114        this.partitionExtensionClause = partitionExtensionClause;
115    }
116
117    private TColumnDefinitionList columnDefinitions;
118
119    public TColumnDefinitionList getColumnDefinitions() {
120        return columnDefinitions;
121    }
122
123    private TValueClause valueClause;
124
125    public TValueClause getValueClause() {
126        return valueClause;
127    }
128
129    private TJsonTable jsonTable;
130
131    public TJsonTable getJsonTable() {
132        return jsonTable;
133    }
134
135    private TXmlTable xmlTable;
136
137    public TXmlTable getXmlTable() {
138        return xmlTable;
139    }
140
141    public TObjectName getTableObjectName() {
142        return tableObjectName;
143    }
144
145    public TExpression getTableExpr() {
146        return tableExpr;
147    }
148
149    public void setTableObjectName(TObjectName tableObjectName) {
150        //tableObjectName.parseTablename();
151        this.tableObjectName = tableObjectName;
152        this.tableObjectName.setObjectType(TObjectName.ttobjTable);
153        this.tableObjectName.setDbObjectType(EDbObjectType.table);
154    }
155
156    private TObjectName tableObjectName;
157
158    public TOpenQuery getOpenQuery() {
159        return openQuery;
160    }
161
162    private TPTNodeList<TTableHint> tableHintList;
163
164    public void setTableHintList(TPTNodeList<TTableHint> tableHintList) {
165        this.tableHintList = tableHintList;
166    }
167
168    public TPTNodeList<TTableHint> getTableHintList() {
169
170        return tableHintList;
171    }
172
173    public TSelectSqlNode getSubquerynode() {
174        return subquerynode;
175    }
176
177    private TSelectSqlNode subquerynode;
178    private TExpression tableExpr;
179
180    private TMultiTargetList rowList;
181
182    public TMultiTargetList getRowList() {
183        return rowList;
184    }
185
186    private TSourceToken tableonly;
187
188    private boolean tableKeyword = false;
189    private boolean onlyKeyword = false;
190
191    public boolean isTableKeyword() {
192        return tableKeyword;
193    }
194
195    public boolean isOnlyKeyword() {
196        return onlyKeyword;
197    }
198
199    public TJoinExpr getJoinExpr() {
200        return joinExpr;
201    }
202
203    private TJoinExpr joinExpr;
204
205    public ETableSource getFromtableType() {
206        return fromtableType;
207
208    }
209
210    private ETableSource fromtableType;
211
212
213    public TOpenDatasource getOpenDatasource() {
214        return openDatasource;
215    }
216
217    private TOpenDatasource openDatasource = null;
218
219    public TOpenRowSet getOpenRowSet() {
220        return openRowSet;
221    }
222
223    public TOpenXML getOpenXML() {
224        return openXML;
225    }
226
227    private TOpenXML openXML = null;
228
229    private TOpenRowSet openRowSet = null;
230
231    private TOpenQuery openQuery = null;
232    
233    public TContainsTable getContainsTable() {
234        return containsTable;
235    }
236
237    private TContainsTable containsTable = null;
238
239    public void setTableonly(TSourceToken tableonly) {
240        this.tableonly = tableonly;
241        if (tableonly.toString().equalsIgnoreCase("only")){
242            onlyKeyword = true;
243        }else if(tableonly.toString().equalsIgnoreCase("table")){
244            tableKeyword = true;
245            if (tableExpr != null){
246                fromtableType = ETableSource.tableExpr;
247            }
248        }
249    }
250
251    public void setTableSample(TTableSample tableSample) {
252        this.tableSample = tableSample;
253    }
254
255    public void setPxGranule(TPxGranule pxGranule) {
256        this.pxGranule = pxGranule;
257    }
258
259    public void setFlashback(TFlashback flashback) {
260        this.flashback = flashback;
261    }
262
263    private TTableSample tableSample;
264    private TPxGranule pxGranule;
265
266    public TFlashback getFlashback() {
267        return flashback;
268    }
269
270    private TFlashback flashback;
271
272    public TTableSample getTableSample() {
273        return tableSample;
274    }
275
276    private TDataChangeTable datachangeTable = null;
277    private TRelationExpr relationExpr;
278
279    /**
280     * Postgresql relation expr
281     * @return
282     */
283    public TRelationExpr getRelationExpr() {
284        return relationExpr;
285    }
286
287    /**
288     * DB2 data change
289     * @return
290     */
291    public TDataChangeTable getDatachangeTable() {
292        return datachangeTable;
293    }
294
295
296    public TMergeSqlNode getMergeSqlNode() {
297        return mergeSqlNode;
298    }
299
300    private TMergeSqlNode mergeSqlNode;
301    private TPivotedTable pivotedTable;
302
303    public TPivotedTable getPivotedTable() {
304        return pivotedTable;
305    }
306
307    public void setPivotClause(TPivotClause pivotClause) {
308        this.pivotClause = pivotClause;
309    }
310
311    public TPivotClause getPivotClause() {
312
313        return pivotClause;
314    }
315
316    private TPivotClause pivotClause = null;
317
318    /**
319     * a table-valued function, in SQL Server, Postgresql
320     * @return
321     */
322    public TFunctionCall getFuncCall() {
323        return funcCall;
324    }
325
326    private TFunctionCall funcCall = null;
327
328    private TInformixOuterClause outerClause;
329
330    private TFromTableList fromTableList;
331
332    public TFromTableList getFromTableList() {
333        return fromTableList;
334    }
335
336    public TInformixOuterClause getOuterClause() {
337        return outerClause;
338    }
339
340    private THivePartitionedTableFunction partitionedTableFunction;
341
342
343    public THivePartitionedTableFunction getPartitionedTableFunction() {
344        return partitionedTableFunction;
345    }
346
347    private ArrayList<TLateralView> lateralViewList;
348
349    public void setLateralViewList(ArrayList<TLateralView> lateralViewList) {
350        this.lateralViewList = lateralViewList;
351    }
352
353    /**
354     *
355     * @return hive lateral view list
356     */
357    public ArrayList<TLateralView> getLateralViewList() {
358
359        return lateralViewList;
360    }
361
362    private TExpressionList joinExprList;
363
364    public void setJoinExprList(TExpressionList joinExprList) {
365        this.joinExprList = joinExprList;
366    }
367
368    /**
369     *
370     * @return hive uniqueJoinExpr list
371     */
372    public TExpressionList getJoinExprList() {
373
374        return joinExprList;
375    }
376
377    public THiveFromQuerySqlNode getFromQuerySqlNode() {
378        return fromQuerySqlNode;
379    }
380
381    public void setColumnDefinitions(TColumnDefinitionList columnDefinitions) {
382        this.columnDefinitions = columnDefinitions;
383        if (this.columnDefinitions != null){
384            fromtableType = ETableSource.externalTable;
385        }
386    }
387
388    private TDummy tableFunctionReturn;
389
390    public void setTableFunctionReturn(TDummy tableFunctionReturn) {
391        if (tableFunctionReturn == null) return;
392        this.tableFunctionReturn = tableFunctionReturn;
393        if (this.tableFunctionReturn.list1 != null){
394            this.columnDefinitions = (TColumnDefinitionList)this.tableFunctionReturn.list1;
395        }
396    }
397
398    // Constants for type codes
399    private static final int TYPE_OBJECT_NAME = 1;
400    private static final int TYPE_SELECT_SQL_NODE = 2;
401    private static final int TYPE_EXPRESSION = 3;
402    private static final int TYPE_JOIN_EXPR = 4;
403    private static final int TYPE_DUMMY = 5;
404    private static final int TYPE_CONTAINS_TABLE = 6;
405    private static final int TYPE_OPEN_ROW_SET = 7;
406    private static final int TYPE_OPEN_XML = 8;
407    private static final int TYPE_OPEN_DATASOURCE = 9;
408    private static final int TYPE_OPEN_QUERY = 10;
409    private static final int TYPE_DATA_CHANGE_TABLE = 11;
410    private static final int TYPE_RELATION_EXPR = 12;
411    private static final int TYPE_JSON_TABLE = 13;
412    private static final int TYPE_FUNCTION_CALL = 14;
413    private static final int TYPE_XML_TABLE = 15;
414    private static final int TYPE_INFORMIX_OUTER_CLAUSE = 16;
415    private static final int TYPE_FROM_TABLE_LIST = 17;
416    private static final int TYPE_HIVE_PARTITIONED_TABLE_FUNCTION = 18;
417    private static final int TYPE_HIVE_FROM_QUERY_SQL_NODE = 19;
418    private static final int TYPE_PIVOTED_TABLE = 20;
419    private static final int TYPE_MERGE_SQL_NODE = 21;
420    private static final int TYPE_TD_UNPIVOT = 22;
421    private static final int TYPE_UNNEST_CLAUSE = 23;
422    private static final int TYPE_VALUE_CLAUSE = 24;
423    private static final int TYPE_CASE_JOIN_CLAUSE = 25;
424    private static final int TYPE_STAGE_REFERENCE = 26;
425
426    public void init(Object arg1) {
427        if (arg1 == null) return;
428
429        int typeCode = getTypeCode(arg1);
430
431        switch (typeCode) {
432            case TYPE_OBJECT_NAME:
433                setTableObjectName((TObjectName) arg1);
434                fromtableType = ETableSource.objectname;
435                break;
436            case TYPE_SELECT_SQL_NODE:
437                subquerynode = (TSelectSqlNode) arg1;
438                fromtableType = ETableSource.subquery;
439                setStartToken(subquerynode.getStartToken());
440                setEndToken(subquerynode.getEndToken());
441                break;
442            case TYPE_EXPRESSION:
443                initExpression((TExpression) arg1);
444                break;
445            case TYPE_JOIN_EXPR:
446                joinExpr = (TJoinExpr) arg1;
447                fromtableType = ETableSource.join;
448                break;
449            case TYPE_DUMMY:
450                initTableDefInDummyNode((TDummy) arg1);
451                break;
452            case TYPE_CONTAINS_TABLE:
453                containsTable = (TContainsTable) arg1;
454                fromtableType = ETableSource.containsTable;
455                break;
456            case TYPE_OPEN_ROW_SET:
457                openRowSet = (TOpenRowSet) arg1;
458                fromtableType = ETableSource.openrowset;
459                break;
460            case TYPE_OPEN_XML:
461                openXML = (TOpenXML) arg1;
462                fromtableType = ETableSource.openxml;
463                break;
464            case TYPE_OPEN_DATASOURCE:
465                openDatasource = (TOpenDatasource) arg1;
466                fromtableType = ETableSource.opendatasource;
467                break;
468            case TYPE_OPEN_QUERY:
469                openQuery = (TOpenQuery) arg1;
470                fromtableType = ETableSource.openquery;
471                break;
472            case TYPE_DATA_CHANGE_TABLE:
473                datachangeTable = (TDataChangeTable) arg1;
474                fromtableType = ETableSource.datachangeTable;
475                break;
476            case TYPE_RELATION_EXPR:
477                initRelationExpr((TRelationExpr) arg1);
478                break;
479            case TYPE_JSON_TABLE:
480                jsonTable = (TJsonTable) arg1;
481                fromtableType = ETableSource.jsonTable;
482                break;
483            case TYPE_FUNCTION_CALL:
484                // This will handle TFunctionCall and all its subclasses
485                funcCall = (TFunctionCall) arg1;
486                fromtableType = ETableSource.function;
487                break;
488            case TYPE_XML_TABLE:
489                xmlTable = (TXmlTable) arg1;
490                fromtableType = ETableSource.xmltable;
491                break;
492            case TYPE_INFORMIX_OUTER_CLAUSE:
493                outerClause = (TInformixOuterClause) arg1;
494                fromtableType = ETableSource.informixOuter;
495                break;
496            case TYPE_FROM_TABLE_LIST:
497                fromTableList = (TFromTableList) arg1;
498                fromtableType = ETableSource.table_ref_list;
499                break;
500            case TYPE_HIVE_PARTITIONED_TABLE_FUNCTION:
501                partitionedTableFunction = (THivePartitionedTableFunction) arg1;
502                break;
503            case TYPE_HIVE_FROM_QUERY_SQL_NODE:
504                fromQuerySqlNode = (THiveFromQuerySqlNode) arg1;
505                fromtableType = ETableSource.hiveFromQuery;
506                break;
507            case TYPE_PIVOTED_TABLE:
508                pivotedTable = (TPivotedTable) arg1;
509                fromtableType = ETableSource.pivoted_table;
510                break;
511            case TYPE_MERGE_SQL_NODE:
512                mergeSqlNode = (TMergeSqlNode) arg1;
513                fromtableType = ETableSource.output_merge;
514                break;
515            case TYPE_TD_UNPIVOT:
516                tdUnpivot = (TTDUnpivot) arg1;
517                fromtableType = ETableSource.td_unpivot;
518                break;
519            case TYPE_UNNEST_CLAUSE:
520                unnestClause = (TUnnestClause) arg1;
521                fromtableType = ETableSource.unnest;
522                break;
523            case TYPE_VALUE_CLAUSE:
524                valueClause = (TValueClause) arg1;
525                fromtableType = ETableSource.rowList;
526                break;
527            case TYPE_CASE_JOIN_CLAUSE:
528                caseJoin = (TCaseJoinClause) arg1;
529                fromtableType = ETableSource.caseJoin;
530                break;
531            case TYPE_STAGE_REFERENCE:
532                stageReference = (TStageReference) arg1;
533                fromtableType = ETableSource.stageReference;
534                break;
535            default:
536                // Handle unexpected types or throw an exception
537                throw new IllegalArgumentException("Unexpected argument type: " + arg1.getClass().getSimpleName());
538        }
539    }
540
541    private int getTypeCode(Object arg1) {
542        if (arg1 instanceof TObjectName) return TYPE_OBJECT_NAME;
543        if (arg1 instanceof TSelectSqlNode) return TYPE_SELECT_SQL_NODE;
544        if (arg1 instanceof TExpression) return TYPE_EXPRESSION;
545        if (arg1 instanceof TJoinExpr) return TYPE_JOIN_EXPR;
546        if (arg1 instanceof TDummy) return TYPE_DUMMY;
547        if (arg1 instanceof TContainsTable) return TYPE_CONTAINS_TABLE;
548        if (arg1 instanceof TOpenRowSet) return TYPE_OPEN_ROW_SET;
549        if (arg1 instanceof TOpenXML) return TYPE_OPEN_XML;
550        if (arg1 instanceof TOpenDatasource) return TYPE_OPEN_DATASOURCE;
551        if (arg1 instanceof TOpenQuery) return TYPE_OPEN_QUERY;
552        if (arg1 instanceof TDataChangeTable) return TYPE_DATA_CHANGE_TABLE;
553        if (arg1 instanceof TRelationExpr) return TYPE_RELATION_EXPR;
554        if (arg1 instanceof TJsonTable) return TYPE_JSON_TABLE;
555        if (arg1 instanceof TFunctionCall) return TYPE_FUNCTION_CALL;
556        if (arg1 instanceof TXmlTable) return TYPE_XML_TABLE;
557        if (arg1 instanceof TInformixOuterClause) return TYPE_INFORMIX_OUTER_CLAUSE;
558        if (arg1 instanceof TFromTableList) return TYPE_FROM_TABLE_LIST;
559        if (arg1 instanceof THivePartitionedTableFunction) return TYPE_HIVE_PARTITIONED_TABLE_FUNCTION;
560        if (arg1 instanceof THiveFromQuerySqlNode) return TYPE_HIVE_FROM_QUERY_SQL_NODE;
561        if (arg1 instanceof TPivotedTable) return TYPE_PIVOTED_TABLE;
562        if (arg1 instanceof TMergeSqlNode) return TYPE_MERGE_SQL_NODE;
563        if (arg1 instanceof TTDUnpivot) return TYPE_TD_UNPIVOT;
564        if (arg1 instanceof TUnnestClause) return TYPE_UNNEST_CLAUSE;
565        if (arg1 instanceof TValueClause) return TYPE_VALUE_CLAUSE;
566        if (arg1 instanceof TCaseJoinClause) return TYPE_CASE_JOIN_CLAUSE;
567        if (arg1 instanceof TStageReference) return TYPE_STAGE_REFERENCE;
568        return 0; // Unknown type
569    }
570    private void initExpression(TExpression expr) {
571        tableExpr = expr;
572        fromtableType = ETableSource.tableExpr;
573        if (tableExpr.getExpressionType() == EExpressionType.simple_object_name_t) {
574            setTableObjectName(tableExpr.getObjectOperand());
575            fromtableType = ETableSource.objectname;
576        }
577    }
578
579    private void initRelationExpr(TRelationExpr expr) {
580        relationExpr = expr;
581        setTableObjectName(relationExpr.getRelationName());
582        fromtableType = ETableSource.objectname;
583    }
584    private TUnnestClause unnestClause;
585
586    public TUnnestClause getUnnestClause() {
587        return unnestClause;
588    }
589
590    private TTDUnpivot tdUnpivot;
591
592    public TTDUnpivot getTdUnpivot() {
593        return tdUnpivot;
594    }
595
596    private TPTNodeList <TTableHint> nameListToTableHint(Object arg1,boolean isSybaseIndexHint){
597        TPTNodeList<TTableHint> hints = new TPTNodeList<TTableHint>();
598        if (arg1 instanceof TObjectNameList){
599            TObjectNameList columns = (TObjectNameList)arg1;
600            for (int i=0;i<columns.size();i++){
601                TObjectName column = columns.getObjectName(i);
602                if ((isSybaseIndexHint)||(isSQLServerHint(column.toString()))){
603                    TTableHint tableHint = new TTableHint();
604                    tableHint.setHint(column);
605                    if (i == 0)
606                      tableHint.setStartToken(column.getStartToken());
607                    if (i == columns.size() - 1)
608                      tableHint.setEndToken(column.getStartToken());
609                    hints.addElement(tableHint);
610                }else {
611                    hints.removeAllElements();
612                    break;
613                }
614            }
615        }else if (arg1 instanceof TExpressionList){
616            TExpressionList expressionList = (TExpressionList)arg1;
617            for(int i=0;i<expressionList.size();i++){
618                TExpression expression = expressionList.getExpression(i);
619                if ((isSybaseIndexHint)||(isSQLServerHint(expression.toString()))){
620                    TTableHint tableHint = new TTableHint();
621                    tableHint.setHint(expression.getObjectOperand());
622                    if (i == 0)
623                      tableHint.setStartToken(expression.getStartToken());
624                    if (i == expressionList.size() - 1)
625                      tableHint.setEndToken(expression.getStartToken());
626                    hints.addElement(tableHint);
627                }else {
628                    hints.removeAllElements();
629                    break;
630                }
631            }
632        }
633
634        if (hints.size() > 0)
635            return hints;
636        else
637            return null;
638    }
639
640    private boolean isSQLServerHint(String pstr){
641        boolean retval = false;
642        String[] hints = new String[] {
643        "fastfirstrow","holdlock","nolock","nowait","paglock",
644       "readcommitted","readcommittedlock","readpast","readuncommitted","repeatableread",
645       "rowlock","serializable","tablock","tablockx","updlock",
646       "xlock","keepidentity","keepdefaults","ignore_constraints","ignore_triggers",
647       "index"
648        };
649
650        for(int i=0;i<21;i++)
651        {
652            if (hints[i].compareToIgnoreCase(pstr) == 0){
653                retval = true;
654                break;
655            }
656        }
657
658        return retval;
659    }
660    
661    private void initTableDefInDummyNode(TDummy pdummy){
662        fromtableType = ETableSource.objectname; //default, may change to ftt_function later
663
664       if (pdummy.int1 == 0){
665           setTableObjectName((TObjectName)(pdummy.node1));
666       }else if (pdummy.int1 == 1){
667           if (pdummy.list1 == null){
668               //it's a function
669               funcCall =  new TFunctionCall();//(TFunctionCall)createNode(ENodeType.T_FunctionCall.getId(),((TObjectName)pdummy.node1));
670               funcCall.init(((TObjectName) pdummy.node1),EFunctionType.udf_t);
671               //((TObjectName)pdummy.node1).parseFunctionName();
672               // ((TObjectName)pdummy.node1).setObjectType(TObjectName.ttobjFunctionName);
673               funcCall.setStartToken(pdummy.getStartToken());
674               funcCall.setEndToken(pdummy.getEndToken());
675               funcCall.setArgs(null);
676               fromtableType = ETableSource.function;
677           }else{
678               tableHintList = nameListToTableHint(((TExpressionList)pdummy.list1),false);
679              if ( tableHintList != null){
680              //if (isSQLServerHint(((TExpressionList)pdummy.list1).getExpression(0).toString())){
681                  //this is sql server hint, not a function, so set table name
682                  setTableObjectName((TObjectName)(pdummy.node1));
683              }else{
684                  //it's a function
685                  funcCall =  new TFunctionCall();//(TFunctionCall)createNode(ENodeType.T_FunctionCall.getId(),((TObjectName)pdummy.node1));
686                  funcCall.init(((TObjectName)pdummy.node1),EFunctionType.udf_t);
687                  //((TObjectName)pdummy.node1).parseFunctionName();
688                 // ((TObjectName)pdummy.node1).setObjectType(TObjectName.ttobjFunctionName);
689                  funcCall.setArgs((TExpressionList)pdummy.list1);
690                  fromtableType = ETableSource.function;
691                  funcCall.setStartToken(pdummy.getStartToken());
692                  funcCall.setEndToken(pdummy.getEndToken());
693              }
694           }
695       }else if (pdummy.int1 == 2){
696           setTableObjectName((TObjectName)(pdummy.node1));
697           tableHintList = nameListToTableHint(pdummy.list1,false); //sql server only, maybe deleted in future
698       }else if (pdummy.int1 == 3){
699           setTableObjectName((TObjectName)(pdummy.node1));
700           tableHintList = (TPTNodeList)(pdummy.node3); //sybase index table hint
701       }
702
703       if (pdummy.node2 != null){
704           this.setAliasClause((TAliasClause)(pdummy.node2));
705           if (this.getAliasClause().isSybaseIndexHint()){
706             tableHintList = this.getAliasClause().getTableHints();
707             this.getAliasClause().setEndToken(this.getAliasClause().getAliasName().getEndToken());
708           }else
709               if (this.getAliasClause().getColumns() != null){
710                   tableHintList = nameListToTableHint(this.getAliasClause().getColumns(),this.getAliasClause().isSybaseIndexHint());
711                   if (tableHintList != null){
712                       //this is not column list of table alias, this is table hint like NOLOCK in this sql:
713                       // SELECT COUNT(DISTINCT(SD_KEY)) FROM SHORTWINDOW PAST (NOLOCK)
714                       this.getAliasClause().setEndToken(this.getAliasClause().getAliasName().getEndToken());
715                   }
716               }
717
718       }
719
720    }
721
722    public void init(Object arg1,Object arg2)
723    {
724        init(arg1);
725        if (arg2 != null){
726            this.setAliasClause((TAliasClause)arg2);
727            // this is table alias
728            this.getAliasClause().setDBObjectToAlias(EDbObjectType.table_alias);
729        }
730    }
731
732    public void setTableProperties(TDummyList tableProperties){
733        for(int i=0;i<tableProperties.size();i++){
734            TDummy dummy = tableProperties.getDummyItem(i);
735            TParseTreeNode node = dummy.node1;
736            if (node instanceof TAliasClause){
737                this.setAliasClause( (TAliasClause)node);
738            }
739        }
740    }
741
742    public void setParenthesisCount(int parenthesisCount) {
743        this.parenthesisCount = parenthesisCount;
744    }
745
746    public void setParenthesisAfterAliasCount(int parenthesisAfterAliasCount) {
747        this.parenthesisAfterAliasCount = parenthesisAfterAliasCount;
748    }
749
750    public void setXmlTable(TXmlTable xmlTable) {
751        this.xmlTable = xmlTable;
752    }
753
754    public void setTableExpr(TExpression tableExpr) {
755        this.tableExpr = tableExpr;
756    }
757
758    public void setRowList(TMultiTargetList rowList) {
759        this.rowList = rowList;
760    }
761
762    public void setTableKeyword(boolean tableKeyword) {
763        this.tableKeyword = tableKeyword;
764    }
765
766    public void setOnlyKeyword(boolean onlyKeyword) {
767        this.onlyKeyword = onlyKeyword;
768    }
769
770    public void setJoinExpr(TJoinExpr joinExpr) {
771        this.joinExpr = joinExpr;
772    }
773
774    public void setFromtableType(ETableSource fromtableType) {
775        this.fromtableType = fromtableType;
776    }
777
778    public void setOpenDatasource(TOpenDatasource openDatasource) {
779        this.openDatasource = openDatasource;
780    }
781
782    public void setOpenXML(TOpenXML openXML) {
783        this.openXML = openXML;
784    }
785
786    public void setOpenRowSet(TOpenRowSet openRowSet) {
787        this.openRowSet = openRowSet;
788    }
789
790    public void setOpenQuery(TOpenQuery openQuery) {
791        this.openQuery = openQuery;
792    }
793
794    public void setContainsTable(TContainsTable containsTable) {
795        this.containsTable = containsTable;
796    }
797
798    public void setDatachangeTable(TDataChangeTable datachangeTable) {
799        this.datachangeTable = datachangeTable;
800    }
801
802    public void setRelationExpr(TRelationExpr relationExpr) {
803        this.relationExpr = relationExpr;
804    }
805
806    public void setPivotedTable(TPivotedTable pivotedTable) {
807        this.pivotedTable = pivotedTable;
808    }
809
810    public void setFuncCall(TFunctionCall funcCall) {
811        this.funcCall = funcCall;
812    }
813
814    public void setOuterClause(TInformixOuterClause outerClause) {
815        this.outerClause = outerClause;
816    }
817
818    public void setFromTableList(TFromTableList fromTableList) {
819        this.fromTableList = fromTableList;
820    }
821
822    public void setPartitionedTableFunction(THivePartitionedTableFunction partitionedTableFunction) {
823        this.partitionedTableFunction = partitionedTableFunction;
824    }
825
826    public void accept(TParseTreeVisitor v){
827        v.preVisit(this);
828        v.postVisit(this);
829    }
830
831    public void acceptChildren(TParseTreeVisitor v) {
832        v.preVisit(this);
833        switch (fromtableType){
834            case objectname:
835                tableObjectName.acceptChildren(v);
836                break;
837            case subquery:
838                // subquerynode
839                break;
840            case tableExpr:
841                tableExpr.acceptChildren(v);
842                break;
843            case join:
844                joinExpr.acceptChildren(v);
845                break;
846            case function:
847                funcCall.acceptChildren(v);
848                break;
849            case containsTable:
850                containsTable.acceptChildren(v);
851                break;
852            case openrowset:
853                openRowSet.acceptChildren(v);
854                break;
855            case openxml:
856                openXML.acceptChildren(v);
857                break;
858            case opendatasource:
859                openDatasource.acceptChildren(v);
860                break;
861            case openquery:
862                openQuery.acceptChildren(v);
863                break;
864            case datachangeTable:
865                datachangeTable.acceptChildren(v);
866                break;
867            case xmltable:
868                xmlTable.acceptChildren(v);
869                break;
870            case informixOuter:
871                outerClause.acceptChildren(v);
872                break;
873            case table_ref_list:
874                fromTableList.acceptChildren(v);
875                break;
876            case hiveFromQuery:
877                fromQuerySqlNode.acceptChildren(v);
878                break;
879            case pivoted_table:
880                pivotedTable.acceptChildren(v);
881                break;
882            case output_merge:
883                mergeSqlNode.acceptChildren(v);
884                break;
885            case td_unpivot:
886                tdUnpivot.acceptChildren(v);
887                break;
888            case unnest:
889                unnestClause.acceptChildren(v);
890                break;
891            case jsonTable:
892                jsonTable.acceptChildren(v);
893                break;
894            case rowList:
895                valueClause.acceptChildren(v);
896                break;
897        }
898
899        v.postVisit(this);
900    }
901}