001package gudusoft.gsqlparser.nodes;
002/*
003 * Date: 2010-1-27
004 * Time: 11:30:12
005 */
006
007import gudusoft.gsqlparser.*;
008import gudusoft.gsqlparser.nodes.hive.THiveVariable;
009import gudusoft.gsqlparser.nodes.mssql.TForXMLClause;
010import gudusoft.gsqlparser.nodes.mssql.TMssqlStmtStubSqlNode;
011import gudusoft.gsqlparser.nodes.oracle.TStorageItem;
012import gudusoft.gsqlparser.nodes.snowflake.*;
013import gudusoft.gsqlparser.stmt.TCursorDeclStmt;
014import gudusoft.gsqlparser.stmt.TVarDeclStmt;
015import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateType;
016import gudusoft.gsqlparser.util.functionChecker;
017
018import java.util.concurrent.ConcurrentHashMap;
019import java.util.Map;
020import java.util.function.Supplier;
021
022public class TNodeFactory {
023
024    // Cache of Class objects to avoid repeated lookups - made thread-safe
025    private static final Map<Integer, Class<? extends TParseTreeNode>> NODE_TYPE_CLASSES = new ConcurrentHashMap<>();
026    
027    // Factory methods for frequently used node types to avoid reflection entirely - made thread-safe
028    private static final Map<Integer, Supplier<TParseTreeNode>> NODE_FACTORIES = new ConcurrentHashMap<>();
029    
030    static {
031        // Pre-populate cache for all known node types
032        // for (ENodeType nodeType : ENodeType.values()) {
033        //     try {
034        //         NODE_TYPE_CLASSES.put(nodeType.getId(), 
035        //             (Class<? extends TParseTreeNode>) Class.forName(nodeType.toString()));
036        //     } catch (ClassNotFoundException e) {
037        //         // Log error but continue - handle during runtime if needed
038        //         System.out.println("Failed to preload class for node type: " + nodeType + ": " + e.getMessage());
039        //     }
040        // }
041        
042        // Add specialized factory methods for common node types
043        NODE_FACTORIES.put(ENodeType.T_AliasClause.getId(), () -> new TAliasClause());
044        NODE_FACTORIES.put(ENodeType.T_AlterIndexSqlNode.getId(), () -> new TAlterIndexSqlNode());
045        NODE_FACTORIES.put(ENodeType.T_AlterTableOption.getId(), () -> new TAlterTableOption());
046        NODE_FACTORIES.put(ENodeType.T_AlterTriggerSqlNode.getId(), () -> new TAlterTriggerSqlNode());
047        NODE_FACTORIES.put(ENodeType.T_AlterTypeOption.getId(), () -> new TAlterTypeOption());
048        NODE_FACTORIES.put(ENodeType.T_BlockSqlNode.getId(), () -> new TBlockSqlNode());
049        NODE_FACTORIES.put(ENodeType.T_ColumnDefinition.getId(), () -> new TColumnDefinition());
050        NODE_FACTORIES.put(ENodeType.T_ColumnDefinitionList.getId(), () -> new TColumnDefinitionList());
051        NODE_FACTORIES.put(ENodeType.T_ColumnReference.getId(), () -> new TColumnReference());
052        NODE_FACTORIES.put(ENodeType.T_CommentSqlNode.getId(), () -> new TCommentSqlNode());
053        NODE_FACTORIES.put(ENodeType.T_Constant.getId(), () -> new TConstant());
054        NODE_FACTORIES.put(ENodeType.T_Constraint.getId(), () -> new TConstraint());
055        NODE_FACTORIES.put(ENodeType.T_CreateFunctionSqlNode.getId(), () -> new TCreateFunctionSqlNode());
056        NODE_FACTORIES.put(ENodeType.T_CreateProcedureSqlNode.getId(), () -> new TCreateProcedureSqlNode());
057        NODE_FACTORIES.put(ENodeType.T_CreateTableSqlNode.getId(), () -> new TCreateTableSqlNode());
058        NODE_FACTORIES.put(ENodeType.T_CTE.getId(), () -> new TCTE());
059        NODE_FACTORIES.put(ENodeType.T_CTEList.getId(), () -> new TCTEList());
060        NODE_FACTORIES.put(ENodeType.T_CursorDeclStmt.getId(), () -> new TCursorDeclStmt());
061        NODE_FACTORIES.put(ENodeType.T_DeclareVariable.getId(), () -> new TDeclareVariable());
062        NODE_FACTORIES.put(ENodeType.T_DdlEventItem.getId(), () -> new TDdlEventItem());
063        NODE_FACTORIES.put(ENodeType.T_Dummy.getId(), () -> new TDummy());
064        NODE_FACTORIES.put(ENodeType.T_DummyList.getId(), () -> new TDummyList());
065        NODE_FACTORIES.put(ENodeType.T_ExecuteSqlNode.getId(), () -> new TExecuteSqlNode());
066        NODE_FACTORIES.put(ENodeType.T_Expression.getId(), () -> new TExpression());
067        NODE_FACTORIES.put(ENodeType.T_ExpressionList.getId(), () -> new TExpressionList());
068        NODE_FACTORIES.put(ENodeType.T_FromTable.getId(), () -> new TFromTable());
069        NODE_FACTORIES.put(ENodeType.T_FunctionCall.getId(), () -> new TFunctionCall());
070        NODE_FACTORIES.put(ENodeType.T_ForUpdate.getId(), () -> new TForUpdate());
071        NODE_FACTORIES.put(ENodeType.T_ForXMLClause.getId(), () -> new TForXMLClause());
072        NODE_FACTORIES.put(ENodeType.T_GruopBy.getId(), () -> new TGroupBy());
073        NODE_FACTORIES.put(ENodeType.T_InsertSqlNode.getId(), () -> new TInsertSqlNode());
074        NODE_FACTORIES.put(ENodeType.T_JoinExpr.getId(), () -> new TJoinExpr());
075        NODE_FACTORIES.put(ENodeType.T_Join.getId(), () -> new TJoin());
076        NODE_FACTORIES.put(ENodeType.T_MssqlStmtStubSqlNode.getId(), () -> new TMssqlStmtStubSqlNode());
077        NODE_FACTORIES.put(ENodeType.T_ObjectName.getId(), () -> new TObjectName());
078        NODE_FACTORIES.put(ENodeType.T_ObjectNameList.getId(), () -> new TObjectNameList());
079        NODE_FACTORIES.put(ENodeType.T_OrderBy.getId(), () -> new TOrderBy());
080        NODE_FACTORIES.put(ENodeType.T_OrderByItem.getId(), () -> new TOrderByItem());
081        NODE_FACTORIES.put(ENodeType.T_OrderByItemList.getId(), () -> new TOrderByItemList());
082        NODE_FACTORIES.put(ENodeType.T_PlsqlCreateType.getId(), () -> new TPlsqlCreateType());
083        NODE_FACTORIES.put(ENodeType.T_QueryHint.getId(), () -> new TQueryHint());
084        NODE_FACTORIES.put(ENodeType.T_ResultColumn.getId(), () -> new TResultColumn());
085        NODE_FACTORIES.put(ENodeType.T_ResultColumnList.getId(), () -> new TResultColumnList());
086        NODE_FACTORIES.put(ENodeType.T_SelectSqlNode.getId(), () -> new TSelectSqlNode());
087        NODE_FACTORIES.put(ENodeType.T_SequenceOption.getId(), () -> new TSequenceOption());
088        NODE_FACTORIES.put(ENodeType.T_SetSqlNode.getId(), () -> new TSetSqlNode());
089        NODE_FACTORIES.put(ENodeType.T_StatementSqlNode.getId(), () -> new TStatementSqlNode());
090        NODE_FACTORIES.put(ENodeType.T_StorageItem.getId(), () -> new TStorageItem());
091        NODE_FACTORIES.put(ENodeType.T_Table.getId(), () -> new TTable());
092        NODE_FACTORIES.put(ENodeType.T_TableElementList.getId(), () -> new TTableElementList());
093        NODE_FACTORIES.put(ENodeType.T_TableReference.getId(), () -> new TTableReference());
094        NODE_FACTORIES.put(ENodeType.T_Typename.getId(), () -> new TTypeName());
095        NODE_FACTORIES.put(ENodeType.T_VarDeclStmt.getId(), () -> new TVarDeclStmt());
096        NODE_FACTORIES.put(ENodeType.T_ViewAliasItem.getId(), () -> new TViewAliasItem());
097        NODE_FACTORIES.put(ENodeType.T_WhereClause.getId(), () -> new TWhereClause());
098        NODE_FACTORIES.put(ENodeType.T_WindowFrameBoundary.getId(), () -> new TWindowFrameBoundary());
099
100        // Snowflake Semantic View nodes
101        NODE_FACTORIES.put(ENodeType.T_CreateSemanticViewSqlNode.getId(), () -> new TCreateSemanticViewSqlNode());
102        NODE_FACTORIES.put(ENodeType.T_SemanticViewClause.getId(), () -> new TSemanticViewClause());
103        NODE_FACTORIES.put(ENodeType.T_SemanticTableDef.getId(), () -> new TSemanticTableDef());
104        NODE_FACTORIES.put(ENodeType.T_SemanticTableDefList.getId(), () -> new TSemanticTableDefList());
105        NODE_FACTORIES.put(ENodeType.T_SemanticRelationshipDef.getId(), () -> new TSemanticRelationshipDef());
106        NODE_FACTORIES.put(ENodeType.T_SemanticRelationshipDefList.getId(), () -> new TSemanticRelationshipDefList());
107        NODE_FACTORIES.put(ENodeType.T_SemanticAttributeDef.getId(), () -> new TSemanticAttributeDef());
108        NODE_FACTORIES.put(ENodeType.T_SemanticAttributeDefList.getId(), () -> new TSemanticAttributeDefList());
109        NODE_FACTORIES.put(ENodeType.T_SemanticViewClauseList.getId(), () -> new TSemanticViewClauseList());
110
111    }
112
113    public TNodeFactory(){
114    }
115
116    public TNodeFactory(EDbVendor dbVendor){
117        this.dbVendor = dbVendor;
118    }
119
120    public EDbVendor getDbVendor() {
121        return dbVendor;
122    }
123
124    public synchronized void setDbVendor(EDbVendor dbVendor) {
125        this.dbVendor = dbVendor;
126    }
127
128
129    private volatile EDbVendor dbVendor = EDbVendor.dbvgeneric;
130
131    public synchronized void setGsqlParser(TGSqlParser parser) {
132        this.gsqlparser = parser;
133    }
134
135    private volatile TGSqlParser gsqlparser = null;
136
137    public TColumnReference createColumnReference(TObjectName objectname){
138        TColumnReference retval = (TColumnReference)createNode(ENodeType.T_ColumnReference.getId(),objectname);
139        return retval;
140    }
141
142    public TColumnReference createColumnReference(TSourceToken objectname){
143        TColumnReference retval = (TColumnReference)createNode(ENodeType.T_ColumnReference.getId(),objectname);
144        return retval;
145    }
146
147    public TTableReference createTableReference(TObjectName objectname){
148        TTableReference retval = (TTableReference)createNode(ENodeType.T_TableReference.getId(),objectname);
149        return retval;
150    }
151
152    public TObjectReference createObjectReference(TObjectName objectname, int objecttype){
153        TObjectReference retval = (TObjectReference)createNode(ENodeType.T_ObjectReference.getId(),objectname);
154        retval.setObjectType(objecttype);
155        return retval;
156    }
157
158    public TParseTreeNode createIntervalExpression(){
159        TIntervalExpression retval = (TIntervalExpression)createNode(ENodeType.T_IntervalExression.getId());
160        return retval;
161    }
162
163    public TParseTreeNode createDatetimeExpression(){
164        TDatetimeExpression retval = (TDatetimeExpression)createNode(ENodeType.T_DatetimeExression.getId());
165        return retval;
166    }
167
168    public TParseTreeNode createFunctionCall(EFunctionType eFunctionType, TObjectName functionName){
169        TFunctionCall retval = (TFunctionCall)createNode(ENodeType.T_FunctionCall.getId(),functionName,eFunctionType);
170     //   functionName.parseFunctionName();
171        return retval;
172    }
173
174    public TParseTreeNode createSelectSqlNode(){
175        TSelectSqlNode retval = (TSelectSqlNode)createNode(ENodeType.T_SelectSqlNode.getId());
176        return retval;
177    }
178    
179
180
181    public TParseTreeNode createExpression(EExpressionType operatorType){
182        TExpression retval = (TExpression)createNode(ENodeType.T_Expression.getId(),operatorType);
183        //retval.setExpressionType(operatorType);
184        //retval.setExprType(operatorType);
185        return retval;
186    }
187
188    public TParseTreeNode createExpression(EExpressionType operatorType,TExpression leftOperand,TExpression rightOperand){
189        TExpression retval = (TExpression)createNode(ENodeType.T_Expression.getId(),operatorType);
190        //retval.setExpressionType(operatorType);
191        //retval.setExprType(operatorType);
192        retval.setLeftOperand(leftOperand);
193        retval.setRightOperand(rightOperand);
194        return retval;
195    }
196
197    public TParseTreeNode createCompoundExpression(EExpressionType operatorType,TExpression leftOperand,TExpression rightOperand ){
198        EExpressionType lcOperatorType = operatorType;
199        if (lcOperatorType == EExpressionType.group_comparison_t){
200            if (leftOperand.getExpressionType() == EExpressionType.list_t){
201
202            }else{
203                lcOperatorType = EExpressionType.simple_comparison_t;
204            }
205        }
206       TExpression retval = (TExpression)createNode(ENodeType.T_Expression.getId(),lcOperatorType);
207        //retval.setExpressionType(operatorType);
208        //retval.setExprType(operatorType);
209        retval.setLeftOperand(leftOperand);
210        retval.setRightOperand(rightOperand);
211        return retval;
212    }
213
214    public TExpression createSimpleExpression(TObjectName or){
215       boolean isOracleDBMS_package_call = false;
216        TExpression retval;
217
218        if ((dbVendor == EDbVendor.dbvoracle) && (or.getNumberOfPart() == 2)){
219           // 检查是否为oracle DBMS_ package, 如果是的话，需要转为function_t, 而不是simple_object_name_t
220            isOracleDBMS_package_call = functionChecker.isOraclePredefinedPackageFunction(or.toString());
221       }
222        if (isOracleDBMS_package_call){
223            retval = (TExpression)createNode(ENodeType.T_Expression.getId(),EExpressionType.function_t);
224            retval.setFunctionCall((TFunctionCall) this.createFunctionCall(EFunctionType.oracle_dbms_package_t,or));
225        }else{
226            retval = (TExpression)createNode(ENodeType.T_Expression.getId(),EExpressionType.simple_object_name_t);
227            retval.setObjectOperand(or);
228        }
229
230        //retval.setExpressionType(TExpression.simpleObjectname);
231        //retval.setExprType(EExpressionType.simple_object_name_t);
232
233        retval.setStartToken(or);
234        retval.setEndToken(or);
235        return retval;
236    }
237
238    public TObjectName createObjectNameWithType(EDbObjectType dbObjectType, TSourceToken part) {
239        if ((part == null)) return null;
240        TObjectName retval = (TObjectName)createNode(ENodeType.T_ObjectName.getId(),dbObjectType,part);
241        retval.setStartToken(part);
242        retval.setEndToken(part);
243        return retval;
244    }
245
246    public TObjectName createObjectNameWithType(EDbObjectType dbObjectType, TSourceToken object,TSourceToken part) {
247        if ((object == null)&&(part == null)) return null;
248        TObjectName retval = (TObjectName)createNode(ENodeType.T_ObjectName.getId(),dbObjectType,object,part);
249
250        if (part != null){
251            retval.setEndToken(part);
252        }else {
253            if(object != null){
254                retval.setEndToken(object);
255            } else {
256            }
257        }
258
259
260        if(object != null){
261            retval.setStartToken(object);
262        } else {
263            if(part != null){
264                retval.setStartToken(part);
265            }
266        }
267
268        return retval;
269    }
270
271    public TObjectName createObjectNameWithType(EDbObjectType dbObjectType, TSourceToken schema,TSourceToken object,TSourceToken part) {
272        if ((object == null)&&(part == null)) return null;
273        TObjectName retval = (TObjectName)createNode(ENodeType.T_ObjectName.getId(),dbObjectType,schema,object,part);
274        retval.setStartToken(schema);
275        retval.setEndToken(part);
276
277        return retval;
278    }
279
280    public TObjectName createObjectName(EDbObjectType dbObjectType, TSourceToken schema,TSourceToken object,TSourceToken part){
281        if ((schema == null)&&(object == null)&&(part == null)) return null;
282        TObjectName retval = (TObjectName)createNode(ENodeType.T_ObjectName.getId(),dbObjectType,schema,object,part);
283
284        if (part != null){
285            retval.setEndToken(part);
286        }else {
287            if(object != null){
288                retval.setEndToken(object);
289            } else {
290                if(schema != null){
291                    retval.setEndToken(schema);
292                }
293            }
294        }
295
296        if (schema != null){
297            retval.setStartToken(schema);
298        }else {
299            if(object != null){
300                retval.setStartToken(object);
301            } else {
302                if(part != null){
303                    retval.setStartToken(part);
304                }
305            }
306        }
307
308        return retval;
309
310    }
311
312    /**
313     *  create a database object with schema, object and part name, type of this object will be
314     *  determined later in the context where it appears.
315     * @param schema schema name of this object.
316     * @param object object name such as table, view, function and etc.
317     * @param part part of object, depends on object, if object is table, then part will be column name; will be null if object is function
318     * @return
319     */
320    public TObjectName createObjectName(TSourceToken schema,TSourceToken object,TSourceToken part){
321        if ((schema == null)&&(object == null)&&(part == null)) return null;
322        TObjectName retval = (TObjectName)createNode(ENodeType.T_ObjectName.getId(),schema,object,part);
323
324        if (part != null){
325            retval.setEndToken(part);
326        }else {
327            if(object != null){
328                retval.setEndToken(object);
329            } else {
330                if(schema != null){
331                    retval.setEndToken(schema);
332                }
333            }
334        }
335
336        if (schema != null){
337            retval.setStartToken(schema);
338        }else {
339            if(object != null){
340                retval.setStartToken(object);
341            } else {
342                if(part != null){
343                    retval.setStartToken(part);
344                }
345            }
346        }
347
348        return retval;
349    }
350
351    public TObjectName createObjectNameWithPart(TSourceToken part){
352        return createObjectName(null,null,part);
353    }
354
355    public TObjectName createObjectNameWithObject(TSourceToken object){
356        return createObjectName(null,object,null);
357    }
358
359    public TObjectName createObjectNameWithPartAndObject(TSourceToken object,TSourceToken part){
360        return createObjectName(null,object,part);
361    }
362
363    public TParseTreeNode createSimpleExpression(TConstant cnt){
364        if (cnt.getLiteralType() == ELiteralType.etFakeDate){
365
366            TFunctionCall functionCall = (TFunctionCall)createFunctionCall(EFunctionType.date_t,TObjectName.createObjectName ( this.dbVendor, EDbObjectType.function,cnt.getStartToken()));
367            TExpression expression = (TExpression)createExpression(EExpressionType.function_t);
368            expression.setFunctionCall(functionCall);
369            expression.setStartToken(functionCall.getStartToken());
370            expression.setEndToken(functionCall.getEndToken());
371            return expression;
372
373        }else{
374            TExpression retval = (TExpression)createNode(ENodeType.T_Expression.getId(),EExpressionType.simple_constant_t);
375            //retval.setExpressionType(TExpression.simpleConstant);
376            //retval.setExprType(EExpressionType.simple_constant_t);
377            retval.setConstantOperand(cnt);
378            retval.setStartToken(cnt.getStartToken());
379            retval.setEndToken(cnt.getEndToken());
380            return retval;
381        }
382    }
383
384    public TParseTreeNode createSimpleExpression(TSourceToken st){
385       TExpression retval = (TExpression)createNode(ENodeType.T_Expression.getId(),EExpressionType.simple_source_token_t);
386       //retval.setExpressionType(TExpression.simpleSourcetoken);
387       //retval.setExprType(EExpressionType.simple_source_token_t);
388       retval.setSourcetokenOperand(st);
389        retval.setStartToken(st);
390        retval.setObjectOperand(createObjectNameWithPart(st));
391        retval.setEndToken(st);
392       return retval;
393    }
394
395    public TParseTreeNode createSimpleExpression(THiveVariable variable){
396       TExpression retval = (TExpression)createNode(ENodeType.T_Expression.getId(),EExpressionType.hive_variable_t);
397       retval.setHive_variable(variable);
398        retval.setStartToken(variable);
399        retval.setEndToken(variable);
400       return retval;
401    }
402
403    private ELiteralType getETByNT(ENodeType ent){
404        ELiteralType et = ELiteralType.etString;
405        switch (ent){
406            case T_Constant:
407                et = ELiteralType.etString;
408                break;
409            case T_Constant_Double:
410            case T_Constant_Float:
411                et = ELiteralType.etFloat;
412                break;
413            case T_Constant_Integer:
414                et = ELiteralType.etNumber;
415                break;
416            case T_Constant_String:
417                et = ELiteralType.etString;
418                break;
419            case T_Constant_BindV:
420                break;
421            case T_Constant_Boolean:
422                et = ELiteralType.bool;
423                break;
424            case T_Constant_Date:
425                et = ELiteralType.datetime_date;
426                break;
427            case T_Constant_Interval:
428                et = ELiteralType.interval;
429                break;
430            case T_Constant_Null:
431                et = ELiteralType.character_string;
432                break;
433            case T_Constant_Time:
434                et = ELiteralType.datetime_time;
435                break;
436            case T_Constant_Timestamp:
437                et = ELiteralType.datetime_timestamp;
438                break;
439            default:
440                break;
441        }
442        return et;
443    }
444    public TParseTreeNode createConstant(TSourceToken st,ENodeType ent){
445         TConstant retval = (TConstant)createNode(ENodeType.T_Constant.getId(),getETByNT(ent)); //(TConstant) createNode(ent.getId());
446         retval.setStartToken(st);
447         retval.setEndToken(st);
448         retval.setValueToken(st);
449         return retval;
450    }
451
452//    public TParseTreeNode createConstant(TParseTreeNode node,ENodeType ent){
453//         TConstant retval = (TConstant)createNode(ENodeType.T_Constant.getId(),getETByNT(ent));//(TConstant) createNode(ent.getId());
454//        retval.setStartToken(node);
455//        retval.setEndToken(node);
456//         return retval;
457//    }
458
459    private Class<? extends TParseTreeNode> getNodeClass(int nodeType) {
460        // ConcurrentHashMap.computeIfAbsent is thread-safe, but we add extra safety
461        return NODE_TYPE_CLASSES.computeIfAbsent(nodeType, id -> {
462            try {
463                ENodeType type = ENodeType.fromId(id);
464                if (type != null) {
465                    return (Class<? extends TParseTreeNode>) Class.forName(type.toString());
466                }
467                return null;
468            } catch (ClassNotFoundException e) {
469                // Log the error but return null to indicate class not found
470                System.err.println("Failed to load class for node type " + id + ": " + e.getMessage());
471                return null;
472            }
473        });
474    }
475
476    /**
477     * Get a node that takes no initializer arguments.
478     *
479     * @param nodeType          Identifier for the type of node.
480     *
481     * @return  A new ParseTree node.
482     */
483    public TParseTreeNode createNode(int nodeType) {
484        TParseTreeNode retval = null;
485        
486        // First check for a specialized factory method
487        Supplier<TParseTreeNode> factory = NODE_FACTORIES.get(nodeType);
488        if (factory != null) {
489            // Use direct instantiation without reflection
490            retval = factory.get();
491        } else {
492            // Get from class cache - this method handles thread-safe caching internally
493            Class<? extends TParseTreeNode> nodeClass = getNodeClass(nodeType);
494            
495            if (nodeClass == null) {
496                System.err.println("Unable to find or load class for nodeType: " + nodeType);
497                return null;
498            }
499
500            try {
501                retval = nodeClass.newInstance();
502            } catch (Exception iae) {
503                System.err.println("Failed to instantiate node: " + iae.toString() + ", nodeType: " + nodeType);
504                return null;
505            }
506        }
507
508        if (retval == null) {
509            return null;
510        }
511
512        // Thread-safe initialization of the created node
513        retval.setNodeType(nodeType);
514        if (nodeType != 25) {
515            // T_Typename(25,"gudusoft.gsqlparser.nodes.TTypeName"),
516            // don't sqlparser instance to a ttypename to avoid memory leak
517            TGSqlParser currentParser = this.gsqlparser; // Read volatile field once
518            if (currentParser != null) {
519                retval.setGsqlparser(currentParser);
520            }
521        }
522        
523        EDbVendor currentDbVendor = this.dbVendor; // Read volatile field once
524        if ((retval.dbvendor == EDbVendor.dbvgeneric) && (currentDbVendor != EDbVendor.dbvgeneric)){
525            // not already set in retval.setGsqlparser(this.gsqlparser);
526            retval.dbvendor = currentDbVendor;
527        }
528
529        return retval;
530    }
531
532    public <T>  TPTNodeList<T> createPTNodeList(T c) {
533        int nodeType = ENodeType.T_PTNodeList.getId(); // T_PTNodeList(14,"gudusoft.gsqlparser.nodes.TPTNodeList"),
534        TPTNodeList<T> retval = new gudusoft.gsqlparser.nodes.TPTNodeList<T>();
535        retval.setNodeType(nodeType);
536        
537        // Thread-safe access to volatile field
538        TGSqlParser currentParser = this.gsqlparser;
539        if (currentParser != null) {
540            retval.setGsqlparser(currentParser);
541        }
542        
543        retval.init(c);
544        return retval;
545    }
546
547
548    /**
549     * Translate a node type to a class name
550     *
551     * @param nodeType  A node type identifier 
552     *
553     */
554    protected String nodeName(int nodeType)
555    {
556       return ENodeType.fromId(nodeType).toString();
557    }
558
559    /**
560     * Get a node that takes one initializer argument.
561     *
562     * @param nodeType          Identifier for the type of node.
563     * @param arg1      The initializer argument
564     *
565     * @return  A new ParseTree node.
566     *
567     */
568    public final TParseTreeNode createNode(int nodeType, Object arg1)
569    {
570        TParseTreeNode retval = createNode(nodeType);
571
572        retval.init(arg1);
573
574        return  retval;
575    }
576
577    /**
578     * Get a node that takes one initializer argument.
579     *
580     * @param nodeType          Identifier for the type of node.
581     * @param arg1      The initializer argument
582     * @param arg2      The initializer argument
583     *
584     * @return  A new ParseTreeNode node.
585     *
586     */
587    public final TParseTreeNode createNode(int nodeType, Object arg1, Object arg2)
588    {
589        TParseTreeNode retval = createNode(nodeType);
590
591        retval.init(arg1,arg2);
592
593        return  retval;
594    }
595
596    /**
597     * Get a node that takes one initializer argument.
598     *
599     * @param nodeType          Identifier for the type of node.
600     * @param arg1      The initializer argument
601     * @param arg2      The initializer argument
602     * @param arg3      The initializer argument
603     *
604     * @return  A new ParseTreeNode node.
605     *
606     */
607    public final TParseTreeNode createNode(int nodeType, Object arg1, Object arg2, Object arg3)
608    {
609        TParseTreeNode retval = createNode(nodeType);
610
611        retval.init(arg1,arg2,arg3);
612
613        return  retval;
614    }
615
616    public final TParseTreeNode createNode(int nodeType, Object arg1, Object arg2, Object arg3, Object arg4)
617    {
618        TParseTreeNode retval = createNode(nodeType);
619
620        retval.init(arg1,arg2,arg3,arg4);
621
622        return  retval;
623    }
624
625    public final TParseTreeNode createNode(int nodeType, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5)
626    {
627        TParseTreeNode retval = createNode(nodeType);
628
629        retval.init(arg1,arg2,arg3,arg4,arg5);
630
631        return  retval;
632    }
633
634    public final TParseTreeNode createNode(int nodeType, Object arg1, Object arg2, Object arg3, Object arg4, Object arg5, Object arg6)
635    {
636        TParseTreeNode retval = createNode(nodeType);
637
638        retval.init(arg1,arg2,arg3,arg4,arg5,arg6);
639
640        return  retval;
641    }
642
643
644}