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