Source code

001
002package gudusoft.gsqlparser.dlineage.dataflow.model;
003
004import gudusoft.gsqlparser.EDbVendor;
005import gudusoft.gsqlparser.ESqlStatementType;
006import gudusoft.gsqlparser.ETableSource;
007import gudusoft.gsqlparser.TCustomSqlStatement;
008import gudusoft.gsqlparser.dlineage.util.DlineageUtil;
009import gudusoft.gsqlparser.dlineage.util.Objects;
010import gudusoft.gsqlparser.dlineage.util.Pair;
011import gudusoft.gsqlparser.nodes.TAliasClause;
012import gudusoft.gsqlparser.nodes.TCaseExpression;
013import gudusoft.gsqlparser.nodes.TConstant;
014import gudusoft.gsqlparser.nodes.TDeclareVariable;
015import gudusoft.gsqlparser.nodes.TExpression;
016import gudusoft.gsqlparser.nodes.TFunctionCall;
017import gudusoft.gsqlparser.nodes.TObjectName;
018import gudusoft.gsqlparser.nodes.TObjectNameList;
019import gudusoft.gsqlparser.nodes.TParameterDeclaration;
020import gudusoft.gsqlparser.nodes.TParseTreeNode;
021import gudusoft.gsqlparser.nodes.TPivotClause;
022import gudusoft.gsqlparser.nodes.TResultColumn;
023import gudusoft.gsqlparser.nodes.TTable;
024import gudusoft.gsqlparser.nodes.TWhenClauseItemList;
025import gudusoft.gsqlparser.sqlenv.TSQLColumn;
026import gudusoft.gsqlparser.sqlenv.TSQLEnv;
027import gudusoft.gsqlparser.sqlenv.TSQLTable;
028import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
029import gudusoft.gsqlparser.stmt.TCreateViewSqlStatement;
030import gudusoft.gsqlparser.stmt.TCursorDeclStmt;
031import gudusoft.gsqlparser.stmt.TForStmt;
032import gudusoft.gsqlparser.stmt.TInsertSqlStatement;
033import gudusoft.gsqlparser.stmt.TLoopStmt;
034import gudusoft.gsqlparser.stmt.TMergeSqlStatement;
035import gudusoft.gsqlparser.stmt.TOpenforStmt;
036import gudusoft.gsqlparser.stmt.TSelectSqlStatement;
037import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;
038import gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare;
039import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
040import gudusoft.gsqlparser.util.SQLUtil;
041
042import java.util.ArrayList;
043import java.util.LinkedHashMap;
044import java.util.List;
045import java.util.Map;
046import java.util.Set;
047
048public class ModelFactory {
049
050        private ModelBindingManager modelManager;
051
052        public ModelFactory(ModelBindingManager modelManager) {
053                this.modelManager = modelManager;
054        }
055
056        public ResultSet createResultSet(TSelectSqlStatement select, boolean isTarget) {
057                if (select.getResultColumnList() != null) {
058                        if (modelManager.getModel(select.getResultColumnList()) instanceof ResultSet) {
059                                return (ResultSet) modelManager.getModel(select.getResultColumnList());
060                        }
061                        SelectResultSet resultSet = new SelectResultSet(select, isTarget);
062                        modelManager.bindModel(select.getResultColumnList(), resultSet);
063                        return resultSet;
064                } else if (select.getTransformClause() != null) {
065                        if (modelManager.getModel(select.getTransformClause()) instanceof ResultSet) {
066                                return (ResultSet) modelManager.getModel(select.getTransformClause());
067                        }
068                        SelectResultSet resultSet = new SelectResultSet(select, isTarget);
069                        modelManager.bindModel(select.getTransformClause(), resultSet);
070                        return resultSet;
071                } else
072                        return null;
073        }
074
075        public ResultSet createResultSet(TParseTreeNode gspObject, boolean isTarget) {
076                if (modelManager.getModel(gspObject) instanceof ResultSet) {
077                        return (ResultSet) modelManager.getModel(gspObject);
078                }
079                ResultSet resultSet = new ResultSet(gspObject, isTarget);
080                modelManager.bindModel(gspObject, resultSet);
081                return resultSet;
082        }
083
084        public ResultColumn createResultColumn(ResultSet resultSet, TResultColumn resultColumn) {
085                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
086                        return (ResultColumn) modelManager.getModel(resultColumn);
087                }
088                ResultColumn column = new ResultColumn(resultSet, resultColumn);
089                modelManager.bindModel(resultColumn, column);
090                return column;
091        }
092
093        public ResultColumn createStarResultColumn(ResultSet resultSetModel, TResultColumn resultColumn,
094                        String refColumnName) {
095                if (modelManager.getModel(resultColumn) instanceof LinkedHashMap) {
096                        LinkedHashMap<String, ResultColumn> resultColumns = (LinkedHashMap<String, ResultColumn>) modelManager
097                                        .getModel(resultColumn);
098                        if (resultColumns.containsKey(refColumnName)) {
099                                return resultColumns.get(refColumnName);
100                        }
101
102                        ResultColumn column = new ResultColumn(resultSetModel, resultColumn, refColumnName);
103                        resultColumns.put(refColumnName, column);
104                        return column;
105                } else {
106                        LinkedHashMap<String, ResultColumn> resultColumns = new LinkedHashMap<String, ResultColumn>();
107                        ResultColumn column = new ResultColumn(resultSetModel, resultColumn, refColumnName);
108                        resultColumns.put(refColumnName, column);
109                        modelManager.bindModel(resultColumn, resultColumns);
110                        return column;
111                }
112        }
113
114        public ResultColumn createSelectSetResultColumn(ResultSet resultSet, ResultColumn resultColumn) {
115                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
116                        return (ResultColumn) modelManager.getModel(resultColumn);
117                }
118                String columnName = DlineageUtil.getIdentifierNormalColumnName(resultColumn.getName());
119                for (int i = 0; i < resultSet.getColumns().size(); i++) {
120                        ResultColumn columnModel = resultSet.getColumns().get(i);
121                        if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
122                                modelManager.bindModel(resultColumn, columnModel);
123                                return columnModel;
124                        }
125                }
126                ResultColumn column = new SelectSetResultColumn(resultSet, resultColumn);
127                if(resultColumn.isStruct()) {
128                        column.setStruct(true);
129                }
130                modelManager.bindModel(resultColumn, column);
131                return column;
132        }
133
134        public ResultColumn createSelectSetResultColumn(ResultSet resultSet, TResultColumn resultColumn, int index) {
135                
136                for (int i = 0; i < resultSet.getColumns().size(); i++) {
137                        ResultColumn columnModel = resultSet.getColumns().get(i);
138                        if(columnModel.getColumnObject() == resultColumn) {
139                                return columnModel;
140                        }
141                }
142                
143                SelectSetResultColumn column = new SelectSetResultColumn(resultSet, resultColumn, index);
144                modelManager.bindModel(resultColumn, column);
145                return column;
146        }
147
148        public ResultColumn createAndBindingSelectSetResultColumn(ResultSet resultSet, TResultColumn resultColumn,
149                        int index) {
150                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
151                        return (ResultColumn) modelManager.getModel(resultColumn);
152                }
153                ResultColumn column = new SelectSetResultColumn(resultSet, resultColumn, index);
154                modelManager.bindModel(resultColumn, column);
155                return column;
156        }
157
158        public ResultColumn createResultColumn(ResultSet resultSet, TObjectName resultColumn) {
159                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
160                        return (ResultColumn) modelManager.getModel(resultColumn);
161                }
162                if(EDbVendor.dbvoracle == ModelBindingManager.getGlobalVendor()){
163                        ResultColumn column = new ResultColumn(resultSet, resultColumn);
164                        modelManager.bindModel(resultColumn, column);
165                        return column;
166                }
167                else {
168                        String columnName = DlineageUtil.getIdentifierNormalColumnName(resultColumn.toString());
169                        for (int i = 0; i < resultSet.getColumns().size(); i++) {
170                                ResultColumn columnModel = resultSet.getColumns().get(i);
171                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
172                                        modelManager.bindModel(resultColumn, columnModel);
173                                        return columnModel;
174                                }
175                        }
176                        ResultColumn column = new ResultColumn(resultSet, resultColumn);
177                        modelManager.bindModel(resultColumn, column);
178                        return column;
179                }
180        }
181        
182        public ResultColumn createDeterminedResultColumn(ResultSet resultSet, TObjectName resultColumn) {
183                ResultColumn column = new ResultColumn(resultSet, resultColumn);
184                modelManager.bindModel(resultColumn, column);
185                return column;
186        }
187
188        public ResultColumn createResultColumn(ResultSet resultSet, TExpression expression) {
189                if (modelManager.getModel(expression) instanceof ResultColumn) {
190                        return (ResultColumn) modelManager.getModel(expression);
191                }
192                ResultColumn column = new ResultColumn(resultSet, expression);
193                modelManager.bindModel(expression, column);
194                return column;
195        }
196
197        public ResultColumn createResultColumn(ResultSet resultSet, TObjectName resultColumn, boolean forceCreate) {
198                if (!forceCreate) {
199                        if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
200                                return (ResultColumn) modelManager.getModel(resultColumn);
201                        }
202                }
203
204                String columnName = DlineageUtil.getIdentifierNormalColumnName(resultColumn.toString());
205                for (int i = 0; i < resultSet.getColumns().size(); i++) {
206                        ResultColumn columnModel = resultSet.getColumns().get(i);
207                        if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
208                                modelManager.bindModel(resultColumn, columnModel);
209                                return columnModel;
210                        }
211                }
212
213                ResultColumn column = new ResultColumn(resultSet, resultColumn);
214                modelManager.bindModel(resultColumn, column);
215                return column;
216        }
217
218        public FunctionResultColumn createFunctionResultColumn(Function function, TObjectName functionName) {
219                if (modelManager.getModel(functionName) instanceof FunctionResultColumn) {
220                        return (FunctionResultColumn) modelManager.getModel(functionName);
221                }
222                FunctionResultColumn column = new FunctionResultColumn(function, function.getFunctionObject(), functionName);
223                modelManager.bindModel(functionName, column);
224                return column;
225        }
226
227        public FunctionResultColumn createFunctionResultColumn(Function function, TWhenClauseItemList caseFunction) {
228                if (modelManager.getModel(caseFunction) instanceof FunctionResultColumn) {
229                        return (FunctionResultColumn) modelManager.getModel(caseFunction);
230                }
231                FunctionResultColumn column = new FunctionResultColumn(function, function.getFunctionObject(), caseFunction);
232                modelManager.bindModel(caseFunction, column);
233                return column;
234        }
235
236        public ResultColumn createMergeResultColumn(ResultSet resultSet, TObjectName resultColumn) {
237                if (modelManager.getMergeModel(resultColumn) instanceof ResultColumn) {
238                        return (ResultColumn) modelManager.getMergeModel(resultColumn);
239                }
240                ResultColumn column = new ResultColumn(resultSet, resultColumn);
241                modelManager.bindMergeModel(resultColumn, column);
242                return column;
243        }
244
245        public ResultColumn createUpdateResultColumn(ResultSet resultSet, TObjectName resultColumn) {
246                if (modelManager.getUpdateModel(resultColumn) instanceof ResultColumn) {
247                        return (ResultColumn) modelManager.getUpdateModel(resultColumn);
248                }
249                ResultColumn column = new ResultColumn(resultSet, resultColumn);
250                modelManager.bindUpdateModel(resultColumn, column);
251                return column;
252        }
253
254        public ResultColumn createResultColumn(QueryTable queryTableModel, TResultColumn resultColumn) {
255                if (modelManager.getModel(resultColumn) instanceof ResultColumn) {
256                        return (ResultColumn) modelManager.getModel(resultColumn);
257                }
258                ResultColumn column = new ResultColumn(queryTableModel, resultColumn);
259                modelManager.bindModel(resultColumn, column);
260                return column;
261        }
262        
263        public Table createTableFromCreateDDL(TTable table, boolean fromDDL, String tableName) {
264                if (modelManager.getCreateModel(table) instanceof Table) {
265                        return (Table) modelManager.getCreateModel(table);
266                }
267                if (modelManager.getModel(table) instanceof Table) {
268                        return (Table) modelManager.getModel(table);
269                }
270                if (modelManager
271                                .getTableByName(DlineageUtil.getTableFullName(tableName.toString())) instanceof Table) {
272                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(tableName.toString()));
273                }
274                if (modelManager.getTableByName(
275                                DlineageUtil.getTableFullNameWithDefaultSchema(tableName.toString())) instanceof Table) {
276                        return (Table) modelManager
277                                        .getTableByName(DlineageUtil.getTableFullNameWithDefaultSchema(tableName.toString()));
278                }
279                Table tableModel = new Table(table, tableName);
280                tableModel.setCreateTable(fromDDL);
281                if (!fromDDL) {
282                        Table existTable = modelManager.getTableByName(DlineageUtil.getTableFullName(tableModel.getName()));
283                        if (existTable != null) {
284                                return existTable;
285                        }
286                }
287                modelManager.bindCreateModel(table, tableModel);
288                if(table.getTableType() == ETableSource.unnest) {
289                        
290                }
291                else {
292                        modelManager.bindTableByName(DlineageUtil.getTableFullName(tableName.toString()), tableModel);
293                }
294                return tableModel;
295        }
296
297        public Table createTableFromCreateDDL(TTable table, boolean fromDDL) {
298                if (modelManager.getCreateModel(table) instanceof Table) {
299                        return (Table) modelManager.getCreateModel(table);
300                }
301                if (modelManager.getModel(table) instanceof Table) {
302                        return (Table) modelManager.getModel(table);
303                }
304                if (modelManager
305                                .getTableByName(DlineageUtil.getTableFullName(table.getTableName().toString())) instanceof Table) {
306                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(table.getTableName().toString()));
307                }
308                if (modelManager.getTableByName(
309                                DlineageUtil.getTableFullNameWithDefaultSchema(table.getTableName().toString())) instanceof Table) {
310                        return (Table) modelManager
311                                        .getTableByName(DlineageUtil.getTableFullNameWithDefaultSchema(table.getTableName().toString()));
312                }
313                Table tableModel = new Table(table);
314                tableModel.setCreateTable(fromDDL, fromDDL);
315                if (!fromDDL) {
316                        Table existTable = modelManager.getTableByName(DlineageUtil.getTableFullName(tableModel.getName()));
317                        if (existTable != null) {
318                                return existTable;
319                        }
320                }
321                modelManager.bindCreateModel(table, tableModel);
322                modelManager.bindTableByName(DlineageUtil.getTableFullName(table.getTableName().toString()), tableModel);
323                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableModel.getName()), tableModel);
324                return tableModel;
325        }
326
327        public Table createJsonTable(TTable table) {
328                String tableName = table.toString();
329                if (tableName.toLowerCase().indexOf("with") != -1) {
330                        tableName = table.toString().substring(0, tableName.toLowerCase().indexOf("with")).trim();
331                }
332
333                if (table.isLinkTable()) {
334                        table = table.getLinkTable();
335                }
336
337                if (modelManager.getCreateTable(table) != null) {
338                        return modelManager.getCreateTable(table);
339                }
340                if (modelManager.getModel(table) instanceof Table) {
341                        return (Table) modelManager.getModel(table);
342                }
343                if (modelManager.getTableByName(DlineageUtil.getTableFullName(tableName)) instanceof Table) {
344                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(tableName));
345                }
346
347                if (modelManager.getTableByName(DlineageUtil.getTableFullNameWithDefaultSchema(tableName)) instanceof Table) {
348                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullNameWithDefaultSchema(tableName));
349                }
350
351                Table tableModel = new Table(table);
352                tableModel.setName(tableName);
353                modelManager.bindModel(table, tableModel);
354                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableName), tableModel);
355                return tableModel;
356        }
357
358        public Table createTable(TTable table, TObjectName tableBinding) {
359                Table tableModel = createTable(table);
360                modelManager.bindModel(table, tableModel);
361                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableBinding.toString()), tableModel);
362                return tableModel;
363        }
364
365        public Table createTable(TTable table) {
366                if (table.isLinkTable()) {
367                        table = table.getLinkTable();
368                }
369
370                Table tableModel = null;
371                if (modelManager.getCreateTable(table) != null) {
372                        tableModel = modelManager.getCreateTable(table);
373                }
374                if (tableModel == null && modelManager.getModel(table) instanceof Table) {
375                        tableModel = (Table) modelManager.getModel(table);
376                }
377
378                String tableName = table.getTableName().toString();
379                if (table.getSubquery() != null && table.getAliasClause() != null) {
380                        tableName = table.getAliasClause().toString();
381                }
382
383                if (tableModel == null
384                                && modelManager.getTableByName(DlineageUtil.getTableFullName(tableName)) instanceof Table) {
385                        tableModel = modelManager.getTableByName(DlineageUtil.getTableFullName(tableName));
386                }
387
388                if (tableModel == null && modelManager
389                                .getTableByName(DlineageUtil.getTableFullNameWithDefaultSchema(tableName)) instanceof Table) {
390                        tableModel = modelManager.getTableByName(DlineageUtil.getTableFullNameWithDefaultSchema(tableName));
391                }
392
393                if (tableModel != null) {
394                        if (table.getAliasClause() != null) {
395                                tableModel.setAlias(table.getAliasName());
396                        }
397                        tableModel.setCurrentAlias(table.getAliasName());
398                        modelManager.updateTableAliasMap(table);
399                        return tableModel;
400                }
401
402                tableModel = new Table(table);
403                Table existTable = modelManager.getTableByName(DlineageUtil.getTableFullName(tableModel.getName()));
404                if (existTable != null) {
405                        return existTable;
406                }
407                modelManager.bindModel(table, tableModel);
408                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableName), tableModel);
409                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableModel.getName()), tableModel);
410
411                appendTableColumns(tableModel);
412
413                return tableModel;
414        }
415
416        protected void appendTableColumns(Table tableModel) {
417                TCustomSqlStatement stmt = ModelBindingManager.getGlobalStmtStack().peek();
418                if (stmt instanceof TCreateTableSqlStatement || stmt instanceof TCreateViewSqlStatement) {
419                        return;
420                }
421                if (stmt instanceof TInsertSqlStatement && ((TInsertSqlStatement) stmt).getColumnList() != null) {
422                        return;
423                }
424                if (ModelBindingManager.getGlobalSQLEnv() != null) {
425                        ArrayList<String> columns = ModelBindingManager.getGlobalSQLEnv()
426                                        .getColumnsInTable(DlineageUtil.getTableFullName(tableModel.getName()), true);
427                        if (columns != null && !columns.isEmpty()) {
428                                for (String column : columns) {
429                                        if (SQLUtil.isEmpty(column)) {
430                                                continue;
431                                        }
432                                        createInsertTableColumn(tableModel, column);
433                                }
434                                tableModel.setFromDDL(true);
435                                tableModel.setCreateTable(true);
436                        }
437                }
438        }
439
440        public Table createTriggerOnTable(TTable table) {
441                if (modelManager.getCreateTable(table) != null) {
442                        return modelManager.getCreateTable(table);
443                }
444                if (modelManager.getModel(table) instanceof Table) {
445                        return (Table) modelManager.getModel(table);
446                }
447                if (modelManager
448                                .getTableByName(DlineageUtil.getTableFullName(table.getTableName().toString())) instanceof Table) {
449                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(table.getTableName().toString()));
450                }
451                if (modelManager.getTableByName(
452                                DlineageUtil.getTableFullNameWithDefaultSchema(table.getTableName().toString())) instanceof Table) {
453                        return (Table) modelManager
454                                        .getTableByName(DlineageUtil.getTableFullNameWithDefaultSchema(table.getTableName().toString()));
455                }
456                Table tableModel = new Table(table);
457                Table existTable = modelManager.getTableByName(DlineageUtil.getTableFullName(tableModel.getName()));
458                if (existTable != null) {
459                        return existTable;
460                }
461                modelManager.bindModel(table, tableModel);
462                modelManager.bindTableByName(DlineageUtil.getTableFullName(table.getTableName().toString()), tableModel);
463                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableModel.getName()), tableModel);
464                return tableModel;
465        }
466
467        public Table createTableByName(TObjectName tableName) {
468                return createTableByName(tableName, false);
469        }
470
471        public Table createTableByName(TObjectName tableName, boolean create) {
472                if (modelManager.getTableByName(DlineageUtil.getTableFullName(tableName.toString())) instanceof Table) {
473                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(tableName.toString()));
474                }
475                Table tableModel = new Table(tableName);
476                Table existTable = modelManager.getTableByName(DlineageUtil.getTableFullName(tableModel.getName()));
477                if (existTable != null) {
478                        return existTable;
479                }
480                if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
481                        tableModel.addColumnsFromSQLEnv();
482                }
483                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableName.toString()), tableModel);
484                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableModel.getName()), tableModel);
485                if (create) {
486                        modelManager.bindCreateModel(tableName, tableModel);
487                }
488                return tableModel;
489        }
490
491        public Table createTableByName(String tableName, boolean create) {
492                if (modelManager.getTableByName(DlineageUtil.getTableFullName(tableName.toString())) instanceof Table) {
493                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(tableName.toString()));
494                }
495                Table tableModel = new Table(tableName);
496                Table existTable = modelManager.getTableByName(DlineageUtil.getTableFullName(tableModel.getName()));
497                if (existTable != null) {
498                        return existTable;
499                }
500                if (tableModel.getColumns() == null || tableModel.getColumns().isEmpty()) {
501                        tableModel.addColumnsFromSQLEnv();
502                }
503                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableName.toString()), tableModel);
504                modelManager.bindTableByName(DlineageUtil.getTableFullName(tableModel.getName()), tableModel);
505                if (create) {
506                        modelManager.bindCreateModel(tableName, tableModel);
507                }
508                return tableModel;
509        }
510
511        public Table createStage(TObjectName stageName) {
512                if (modelManager.getTableByName(DlineageUtil.getTableFullName(stageName.toString())) instanceof Table) {
513                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(stageName.toString()));
514                }
515                Table tableModel = new Table(stageName);
516                modelManager.bindTableByName(DlineageUtil.getTableFullName(stageName.toString()), tableModel);
517                modelManager.bindCreateModel(stageName, tableModel);
518
519                TObjectName stageVariableName = new TObjectName();
520                stageVariableName.setString("@" + stageName.getColumnNameOnly());
521                modelManager.bindCreateModel(stageVariableName, tableModel);
522
523                return tableModel;
524        }
525
526        public Table createDataSource(TObjectName dataSourceName) {
527                if (modelManager.getTableByName(DlineageUtil.getTableFullName(dataSourceName.toString())) instanceof Table) {
528                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(dataSourceName.toString()));
529                }
530                Table tableModel = new Table(dataSourceName);
531                tableModel.setDataSource(true);
532                modelManager.bindTableByName(DlineageUtil.getTableFullName(dataSourceName.toString()), tableModel);
533                modelManager.bindCreateModel(dataSourceName, tableModel);
534
535                return tableModel;
536        }
537
538        public Table createStream(TObjectName streamName) {
539                if (modelManager.getTableByName(DlineageUtil.getTableFullName(streamName.toString())) instanceof Table) {
540                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(streamName.toString()));
541                }
542                Table tableModel = new Table(streamName);
543                tableModel.setStream(true);
544                modelManager.bindTableByName(DlineageUtil.getTableFullName(streamName.toString()), tableModel);
545                modelManager.bindCreateModel(streamName, tableModel);
546                return tableModel;
547        }
548
549        public Table createConstantsTable(TCustomSqlStatement stmt) {
550                stmt = DlineageUtil.getTopStmt(stmt);
551                String sqlHash = String.valueOf(stmt.hashCode());
552                if (modelManager.getTableByName(sqlHash) instanceof Table) {
553                        return (Table) modelManager.getTableByName(sqlHash);
554                }
555                Table tableModel = new Table("SQL_CONSTANTS");
556                tableModel.setConstant(true);
557                modelManager.bindTableByName(sqlHash, tableModel);
558                modelManager.bindCreateModel(sqlHash, tableModel);
559                return tableModel;
560        }
561        
562        public Table createConstantsTable(String sqlHash) {
563                if (modelManager.getTableByName(sqlHash) instanceof Table) {
564                        return (Table) modelManager.getTableByName(sqlHash);
565                }
566                Table tableModel = new Table("SQL_CONSTANTS");
567                tableModel.setConstant(true);
568                modelManager.bindTableByName(sqlHash, tableModel);
569                modelManager.bindCreateModel(sqlHash, tableModel);
570                return tableModel;
571        }
572
573        public Table createJsonVariable(TObjectName jsonVariable) {
574                if (modelManager.getTableByName(DlineageUtil.getTableFullName(jsonVariable.toString())) instanceof Table) {
575                        return (Table) modelManager.getTableByName(DlineageUtil.getTableFullName(jsonVariable.toString()));
576                }
577                Table tableModel = new Table(jsonVariable);
578                modelManager.bindTableByName(DlineageUtil.getTableFullName(jsonVariable.toString()), tableModel);
579                modelManager.bindCreateModel(jsonVariable, tableModel);
580
581                modelManager.bindCreateModel(jsonVariable, tableModel);
582
583                return tableModel;
584        }
585
586        public Alias createAlias(TAliasClause aliasClause) {
587                if (modelManager.getModel(aliasClause) instanceof Alias) {
588                        return (Alias) modelManager.getModel(aliasClause);
589                }
590
591                Alias alias = new Alias(aliasClause);
592                modelManager.bindModel(aliasClause, alias);
593
594                return alias;
595        }
596
597        public Function createFunction(TFunctionCall functionCall) {
598                if (modelManager.getModel(functionCall) instanceof Function) {
599                        return (Function) modelManager.getModel(functionCall);
600                }
601
602                Function function = new Function(functionCall);
603                function.setDetermined(false);
604                modelManager.bindModel(functionCall, function);
605
606                return function;
607        }
608
609        public Function createFunction(TObjectName functionName) {
610                if (modelManager.getModel(functionName) instanceof Function) {
611                        return (Function) modelManager.getModel(functionName);
612                }
613
614                Function function = new Function(functionName);
615                function.setDetermined(false);
616                modelManager.bindModel(functionName, function);
617
618                return function;
619        }
620
621        public Function createFunction(TCaseExpression caseExpression) {
622                if (modelManager.getModel(caseExpression) instanceof Function) {
623                        return (Function) modelManager.getModel(caseExpression);
624                }
625
626                Function function = new Function(caseExpression);
627                modelManager.bindModel(caseExpression, function);
628
629                return function;
630        }
631
632        public QueryTable createQueryTable(TTable table) {
633                QueryTable tableModel = null;
634
635                if (table.getCTE() != null) {
636                        if (modelManager.getModel(table.getCTE()) instanceof QueryTable) {
637                                return (QueryTable) modelManager.getModel(table.getCTE());
638                        }
639
640                        tableModel = new QueryTable(table);
641
642                        modelManager.bindModel(table.getCTE(), tableModel);
643                } else if (table.getAliasClause() != null && table.getAliasClause().getColumns() != null) {
644                        if (modelManager.getModel(table.getAliasClause().getColumns()) instanceof QueryTable) {
645                                return (QueryTable) modelManager.getModel(table.getAliasClause().getColumns());
646                        }
647
648                        tableModel = new QueryTable(table);
649                        TObjectNameList columns = table.getAliasClause().getColumns();
650                        modelManager.bindModel(columns, tableModel);
651                        for (int i = 0; i < columns.size(); i++) {
652                                createResultColumn(tableModel, columns.getObjectName(i));
653                        }
654                        modelManager.bindModel(table, tableModel);
655                } else if (table.getSubquery() != null && !table.getSubquery().isCombinedQuery()) {
656                        if (modelManager.getModel(table.getSubquery().getResultColumnList()) instanceof QueryTable) {
657                                return (QueryTable) modelManager.getModel(table.getSubquery().getResultColumnList());
658                        }
659
660                        tableModel = new QueryTable(table);
661                        if (table.getSubquery().getResultColumnList() != null) {
662                                modelManager.bindModel(table.getSubquery().getResultColumnList(), tableModel);
663                        } else if (table.getSubquery().getTransformClause() != null) {
664                                modelManager.bindModel(table.getSubquery().getTransformClause(), tableModel);
665                        }
666                        modelManager.bindModel(table, tableModel);
667                } else if (table.getOutputMerge() != null) {
668                        if (modelManager
669                                        .getModel(table.getOutputMerge().getOutputClause().getSelectItemList()) instanceof QueryTable) {
670                                return (QueryTable) modelManager.getModel(table.getOutputMerge().getOutputClause().getSelectItemList());
671                        }
672
673                        tableModel = new QueryTable(table);
674                        modelManager.bindModel(table.getOutputMerge().getOutputClause().getSelectItemList(), tableModel);
675                        modelManager.bindModel(table, tableModel);
676                } else {
677                        if (modelManager.getModel(table) instanceof QueryTable) {
678                                return (QueryTable) modelManager.getModel(table);
679                        }
680                        
681                        if(ModelBindingManager.getGlobalStmtStack().peek() instanceof TMergeSqlStatement) {
682                                TMergeSqlStatement mergeStmt = (TMergeSqlStatement)ModelBindingManager.getGlobalStmtStack().peek();
683                                if (modelManager.getModel(mergeStmt) instanceof QueryTable) {
684                                        return (QueryTable) modelManager.getModel(mergeStmt);
685                                }
686                                tableModel = new QueryTable(mergeStmt);
687                                modelManager.bindModel(mergeStmt, tableModel);
688                        }
689                        else {
690                                tableModel = new QueryTable(table);
691                                modelManager.bindModel(table, tableModel);
692                        }
693                }
694                return tableModel;
695        }
696
697        /**
698         * Check if a column reference is a standard qualified table.column reference
699         * (not a struct field access). Returns true when tableToken matches the source table's name.
700         */
701        private boolean isQualifiedColumnReference(TObjectName column) {
702                if (column.getSourceTable() == null || column.getTableToken() == null) {
703                        return false;
704                }
705                String tableTokenStr = column.getTableToken().getAstext();
706                TTable src = column.getSourceTable();
707                String tableName = src.getTableName() != null ? src.getTableName().getTableString() : "";
708                java.util.List<String> parts = gudusoft.gsqlparser.util.SQLUtil.parseNames(tableName);
709                String simpleTableName = parts.isEmpty() ? tableName : parts.get(parts.size() - 1);
710                if (tableTokenStr.equalsIgnoreCase(simpleTableName)) {
711                        return true;
712                }
713                String aliasName = src.getAliasName();
714                if (aliasName != null && tableTokenStr.equalsIgnoreCase(aliasName)) {
715                        return true;
716                }
717                return false;
718        }
719
720        public TableColumn createTableColumn(Table table, TObjectName column, boolean fromCreateTable) {
721                if (modelManager.getModel(new Pair<Table, TObjectName>(table, column)) instanceof TableColumn) {
722                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, column));
723                }
724
725                if (table.isCreateTable() && !fromCreateTable) {
726                        String columnName = DlineageUtil.getColumnName(column);
727                        for (int i = 0; i < table.getColumns().size(); i++) {
728                                TableColumn columnModel = table.getColumns().get(i);
729                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
730                                        return columnModel;
731                                }
732                        }
733
734                        for (int i = 0; i < table.getColumns().size(); i++) {
735                                TableColumn columnModel = table.getColumns().get(i);
736                                if (columnModel.isVariant()) {
737                                        columnModel.bindStarLinkColumn(column);
738                                        return columnModel;
739                                }
740                                if (columnModel.hasStarLinkColumn()) {
741                                        columnModel.bindStarLinkColumn(column);
742                                        return columnModel;
743                                }
744                        }
745                        
746                        if(table.isDetermined()) {
747                                return null;
748                        }
749                } else {
750                        String columnName = DlineageUtil.getColumnName(column);
751                        // For BigQuery/Redshift struct fields, use full struct path for lookup
752                        // to prevent collision between base column and struct field (e.g., "customer" vs "customer.name")
753                        if (ModelBindingManager.getGlobalVendor() == EDbVendor.dbvbigquery
754                                        || ModelBindingManager.getGlobalVendor() == EDbVendor.dbvredshift) {
755                                String structName = null;
756                                gudusoft.gsqlparser.resolver2.model.ColumnSource cs = column.getColumnSource();
757                                if (cs != null && cs.isStructFieldAccess() && cs.hasFieldPath()) {
758                                        structName = cs.getFieldPath().toFullReference(cs.getExposedName());
759                                }
760                                if (structName == null) {
761                                        gudusoft.gsqlparser.resolver2.model.StructFieldHint hint = column.getStructFieldHint();
762                                        if (hint != null && hint.getFieldPath() != null
763                                                        && !isQualifiedColumnReference(column)) {
764                                                structName = hint.toFullReference();
765                                        }
766                                }
767                                if (structName == null && column.getPropertyToken() != null) {
768                                        structName = column.getPartToken().getAstext() + "." + column.getPropertyToken().getAstext();
769                                }
770                                if (structName != null) {
771                                        columnName = DlineageUtil.getIdentifierNormalColumnName(structName);
772                                }
773                        }
774                        for (int i = 0; i < table.getColumns().size(); i++) {
775                                TableColumn columnModel = table.getColumns().get(i);
776                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
777                                        return columnModel;
778                                }
779                        }
780                }
781
782                if ("*".equals(column.toString())) {
783                        if (!fromCreateTable && table.isCreateTable()) {
784                                return null;
785                        }
786                        for (int i = 0; i < table.getColumns().size(); i++) {
787                                TableColumn columnModel = table.getColumns().get(i);
788                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals("*")) {
789                                        return columnModel;
790                                }
791                        }
792                }
793
794                if (table.isCreateTable() && !fromCreateTable && "*".equals(column.getColumnNameOnly())) {
795                        return null;
796                }
797
798                if (table.isDetermined() && "*".equals(column.getColumnNameOnly())) {
799                        return null;
800                }
801
802                TableColumn columnModel = new TableColumn(table, column);
803                modelManager.bindModel(new Pair<Table, TObjectName>(table, column), columnModel);
804
805                if ("*".equals(column.getColumnNameOnly())) {
806                        TSQLEnv sqlenv = ModelBindingManager.getGlobalSQLEnv();
807                        if (sqlenv != null && sqlenv.searchTable(getQualifiedTableName(table)) != null) {
808                                table.setHasSQLEnv(true);
809                                TSQLTable sqlTable = sqlenv.searchTable(getQualifiedTableName(table));
810                                if (sqlTable.getColumnList() != null) {
811                                        boolean isDetermine = true;
812                                        for (TSQLColumn sqlColumn : sqlTable.getColumnList()) {
813                                                TObjectName objectName = new TObjectName();
814                                                if(sqlColumn.getName() == null){
815                                                        System.err.println("sqlevn table " + getQualifiedTableName(table) + " sqlColumn getName() returns null.");
816                                                        continue;
817                                                }
818                                                if(sqlColumn.getName().endsWith("*")) {
819                                                        isDetermine = false;
820                                                        continue;
821                                                }
822                                                objectName.setString(sqlColumn.getName());
823                                                columnModel.bindStarLinkColumn(objectName);
824                                        }
825                                        if (isDetermine) {
826                                                columnModel.setShowStar(false);
827                                                columnModel.setExpandStar(true);
828                                        }
829                                }
830                        } else if (column.getSourceTable() != null) {
831                                TObjectNameList columns = column.getSourceTable().getLinkedColumns();
832                                Map<String, TObjectName> columnMap = new LinkedHashMap<String, TObjectName>();
833                                for (int i = 0; i < columns.size(); i++) {
834                                        TObjectName item = columns.getObjectName(i);
835                                        String columnName = item.getColumnNameOnly();
836                                        if (Objects.equal(item.getSourceTable(), column.getSourceTable()) && !"*".equals(columnName)) {
837                                                columnMap.put(DlineageUtil.getIdentifierNormalColumnName(columnName), item);
838                                        }
839                                }
840                                for (int i = 0; i < columns.size(); i++) {
841                                        TObjectName item = columns.getObjectName(i);
842                                        String columnName = item.getColumnNameOnly();
843                                        if (!Objects.equal(item.getSourceTable(), column.getSourceTable()) && !"*".equals(columnName)) {
844                                                String key = DlineageUtil.getIdentifierNormalColumnName(columnName);
845                                                if (!columnMap.containsKey(key)) {
846                                                        columnMap.put(key, item);
847                                                }
848                                        }
849                                }
850                                columnModel.bindStarLinkColumns(new LinkedHashMap<String, Set<TObjectName>>());
851                        }
852                }
853
854                return columnModel;
855        }
856
857        public static String getQualifiedTableName(Table table) {
858                List<String> segments = SQLUtil.parseNames(table.name);
859                boolean supportCatalog = TSQLEnv.supportCatalog(ModelBindingManager.getGlobalVendor());
860                boolean supportSchema = TSQLEnv.supportSchema(ModelBindingManager.getGlobalVendor());
861                if (segments.size() < 2) {
862                        if (supportCatalog && supportSchema) {
863                                return getDefaultDatabase() + "." + getDefaultSchema() + "." + table.name;
864                        } else if (supportCatalog) {
865                                return TSQLEnv.DEFAULT_DB_NAME + "." + getDefaultDatabase() + "." + table.name;
866                        } else {
867                                return TSQLEnv.DEFAULT_DB_NAME + "." + getDefaultSchema() + "." + table.name;
868                        }
869                } else if (segments.size() < 3) {
870                        if (supportCatalog && supportSchema) {
871                                return getDefaultDatabase() + "." + table.name;
872                        } else {
873                                return TSQLEnv.DEFAULT_DB_NAME + "." + table.name;
874                        }
875                } else {
876                        return table.name;
877                }
878        }
879
880        protected static String getDefaultSchema() {
881                String defaultSchema = null;
882                if (ModelBindingManager.getGlobalSQLEnv() != null) {
883                        defaultSchema = ModelBindingManager.getGlobalSQLEnv().getDefaultSchemaName();
884                }
885                if (!SQLUtil.isEmpty(defaultSchema))
886                        return defaultSchema;
887                return TSQLEnv.DEFAULT_SCHEMA_NAME;
888        }
889
890        protected static String getDefaultDatabase() {
891                String defaultDatabase = null;
892                if (ModelBindingManager.getGlobalSQLEnv() != null) {
893                        defaultDatabase = ModelBindingManager.getGlobalSQLEnv().getDefaultCatalogName();
894                }
895                if (!SQLUtil.isEmpty(defaultDatabase))
896                        return defaultDatabase;
897                return TSQLEnv.DEFAULT_DB_NAME;
898        }
899
900        public TableColumn createStageLocation(Table table, TObjectName location) {
901                if (modelManager.getModel(new Pair<Table, TObjectName>(table, location)) instanceof TableColumn) {
902                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, location));
903                }
904
905                StageLocation columnModel = new StageLocation(table, location);
906                modelManager.bindModel(new Pair<Table, TObjectName>(table, location), columnModel);
907                return columnModel;
908        }
909
910        public TableColumn createFileUri(Table table, TObjectName fileUri) {
911                if (modelManager.getModel(new Pair<Table, TObjectName>(table, fileUri)) instanceof TableColumn) {
912                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, fileUri));
913                }
914
915                FileUri columnModel = new FileUri(table, fileUri);
916                modelManager.bindModel(new Pair<Table, TObjectName>(table, fileUri), columnModel);
917                return columnModel;
918        }
919
920        public TableColumn createVariableProperty(Table variableTable, TDeclareVariable variable) {
921                if (modelManager.getModel(new Pair<Table, TDeclareVariable>(variableTable, variable)) instanceof TableColumn) {
922                        return (TableColumn) modelManager.getModel(new Pair<Table, TDeclareVariable>(variableTable, variable));
923                }
924
925                TObjectName variableName = new TObjectName();
926                variableName.setString("property");
927                VariableProperty columnModel = new VariableProperty(variableTable, variableName, variable);
928                modelManager.bindModel(new Pair<Table, TDeclareVariable>(variableTable, variable), columnModel);
929                return columnModel;
930        }
931
932        public TableColumn createJsonTableColumn(Table table, TObjectName column) {
933                if (modelManager.getModel(new Pair<Table, TObjectName>(table, column)) instanceof TableColumn) {
934                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, column));
935                }
936
937                JsonTableColumn columnModel = new JsonTableColumn(table, column);
938                modelManager.bindModel(new Pair<Table, TObjectName>(table, column), columnModel);
939                return columnModel;
940        }
941
942        public DataFlowRelationship createDataFlowRelation() {
943                DataFlowRelationship relation = new DataFlowRelationship();
944                modelManager.addRelation(relation);
945                return relation;
946        }
947
948        public CallRelationship createCallRelation() {
949                CallRelationship relation = new CallRelationship();
950                modelManager.addRelation(relation);
951                return relation;
952        }
953        
954        public CrudRelationship createCrudRelation() {
955                CrudRelationship relation = new CrudRelationship();
956                modelManager.addRelation(relation);
957                return relation;
958        }
959
960        public ERRelationship createERRelation() {
961                ERRelationship relation = new ERRelationship();
962                modelManager.addRelation(relation);
963                return relation;
964        }
965
966        public TableColumn createTableColumn(Table table, TResultColumn column) {
967                if (column.getAliasClause() != null && column.getAliasClause().getAliasName() != null) {
968                        TableColumn columnModel = new TableColumn(table, column.getAliasClause().getAliasName());
969                        modelManager.bindModel(column, columnModel);
970                        return columnModel;
971                } else if (column.getFieldAttr() != null) {
972                        TableColumn columnModel = new TableColumn(table, column.getFieldAttr());
973                        modelManager.bindModel(column, columnModel);
974                        return columnModel;
975                }
976                return null;
977        }
978
979        public TableColumn createTableColumn(Table table, TConstant constant) {
980                if (modelManager.getModel(new Pair<Table, TConstant>(table, constant)) instanceof TableColumn) {
981                        return (TableColumn) modelManager.getModel(new Pair<Table, TConstant>(table, constant));
982                }
983
984                TableColumn columnModel = new TableColumn(table, constant);
985                modelManager.bindModel(new Pair<Table, TConstant>(table, constant), columnModel);
986                return columnModel;
987        }
988
989        public TableColumn createTableColumn(Table table, TFunctionCall constantFunction) {
990                if (modelManager.getModel(new Pair<Table, TFunctionCall>(table, constantFunction)) instanceof TableColumn) {
991                        return (TableColumn) modelManager.getModel(new Pair<Table, TFunctionCall>(table, constantFunction));
992                }
993
994                TableColumn columnModel = new TableColumn(table, constantFunction);
995                modelManager.bindModel(new Pair<Table, TFunctionCall>(table, constantFunction), columnModel);
996                return columnModel;
997        }
998
999        public RecordSetRelationship createRecordSetRelation() {
1000                RecordSetRelationship relation = new RecordSetRelationship();
1001                modelManager.addRelation(relation);
1002                return relation;
1003        }
1004
1005        public ImpactRelationship createImpactRelation() {
1006                ImpactRelationship relation = new ImpactRelationship();
1007                modelManager.addRelation(relation);
1008                return relation;
1009        }
1010
1011        public IndirectImpactRelationship createIndirectImpactRelation() {
1012                IndirectImpactRelationship relation = new IndirectImpactRelationship();
1013                modelManager.addRelation(relation);
1014                return relation;
1015        }
1016
1017        public JoinRelationship createJoinRelation() {
1018                JoinRelationship relation = new JoinRelationship();
1019                modelManager.addRelation(relation);
1020                return relation;
1021        }
1022
1023        public Table createView(TCustomSqlStatement viewStmt, TObjectName viewName) {
1024                return createView(viewStmt, viewName, false);
1025        }
1026
1027        public Table createView(TCustomSqlStatement viewStmt, TObjectName viewName, boolean fromCreateView) {
1028                if (modelManager.getViewModel(viewStmt) instanceof Table) {
1029                        Table table = (Table) modelManager.getViewModel(viewStmt);
1030                        table.setView(true);
1031                        return table;
1032                }
1033
1034                if (modelManager.getTableByName(DlineageUtil.getTableFullName(viewName.toString())) != null) {
1035                        Table table = modelManager.getTableByName(DlineageUtil.getTableFullName(viewName.toString()));
1036                        table.setView(true);
1037                        return table;
1038                }
1039
1040                Table viewModel = new Table(viewStmt, viewName);
1041                viewModel.setCreateTable(fromCreateView);
1042                viewModel.setView(true);
1043                modelManager.bindViewModel(viewStmt, viewModel);
1044                modelManager.bindTableByName(DlineageUtil.getTableFullName(viewName.toString()), viewModel);
1045                return viewModel;
1046        }
1047
1048        public Process createProcess(TCustomSqlStatement processStmt) {
1049                if (modelManager.getProcessModel(processStmt) instanceof Process) {
1050                        Process process = (Process) modelManager.getProcessModel(processStmt);
1051                        return process;
1052                }
1053
1054                Process processModel = new Process(processStmt);
1055                modelManager.bindProcessModel(processStmt, processModel);
1056                return processModel;
1057        }
1058
1059        public Process createProcess(TFunctionCall functionCall) {
1060                if (modelManager.getProcessModel(functionCall) instanceof Process) {
1061                        Process process = (Process) modelManager.getProcessModel(functionCall);
1062                        return process;
1063                }
1064
1065                Process processModel = new Process(functionCall);
1066                modelManager.bindProcessModel(functionCall, processModel);
1067                return processModel;
1068        }
1069
1070        public TableColumn createViewColumn(Table viewModel, TObjectName column, int index, boolean fromCreateView) {
1071                Pair<Table, TObjectName> bindingModel = new Pair<Table, TObjectName>(viewModel, column);
1072                if (modelManager.getViewModel(bindingModel) instanceof TableColumn) {
1073                        return (TableColumn) modelManager.getViewModel(bindingModel);
1074                }
1075
1076                if (viewModel.isCreateTable() && !fromCreateView) {
1077                        if (index < viewModel.getColumns().size()) {
1078                                return (TableColumn) viewModel.getColumns().get(index);
1079                        } else {
1080                                return null;
1081                        }
1082                }
1083
1084                TableColumn columnModel = new TableColumn(viewModel, column, index);
1085                modelManager.bindViewModel(bindingModel, columnModel);
1086                return columnModel;
1087        }
1088
1089        public TableColumn createInsertTableColumn(Table tableModel, String columnName) {
1090                TObjectName columnNameObject = new TObjectName();
1091                columnNameObject.setString(columnName);
1092                Pair<Table, String> bindingModel = new Pair<Table, String>(tableModel, columnName);
1093
1094                if (tableModel.isCreateTable()) {
1095                        for (int i = 0; i < tableModel.getColumns().size(); i++) {
1096                                TableColumn columnModel = tableModel.getColumns().get(i);
1097                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
1098                                        modelManager.bindInsertModel(bindingModel, columnModel);
1099                                        return columnModel;
1100                                }
1101                        }
1102                }
1103
1104                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1105                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1106                }
1107                TableColumn columnModel = new TableColumn(tableModel, columnNameObject);
1108                modelManager.bindInsertModel(bindingModel, columnModel);
1109                return columnModel;
1110        }
1111
1112        public TableColumn createInsertTableColumn(Table tableModel, TObjectName column) {
1113                Pair<Table, TObjectName> bindingModel = new Pair<Table, TObjectName>(tableModel, column);
1114
1115                if (tableModel.isCreateTable()) {
1116                        String columnName = DlineageUtil.getColumnName(column);
1117                        for (int i = 0; i < tableModel.getColumns().size(); i++) {
1118                                TableColumn columnModel = tableModel.getColumns().get(i);
1119                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
1120                                        modelManager.bindInsertModel(bindingModel, columnModel);
1121                                        return columnModel;
1122                                }
1123                        }
1124                }
1125
1126                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1127                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1128                }
1129                TableColumn columnModel = new TableColumn(tableModel, column);
1130                modelManager.bindInsertModel(bindingModel, columnModel);
1131                return columnModel;
1132        }
1133
1134        public TableColumn createInsertTableColumn(Table tableModel, TExpression column, int columnIndex) {
1135                Pair<Table, TExpression> bindingModel = new Pair<Table, TExpression>(tableModel, column);
1136
1137                if (tableModel.isCreateTable()) {
1138                        if (columnIndex < tableModel.getColumns().size()) {
1139                                TableColumn columnModel = tableModel.getColumns().get(columnIndex);
1140                                modelManager.bindInsertModel(bindingModel, columnModel);
1141                                return columnModel;
1142                        } else {
1143                                return null;
1144                        }
1145                }
1146
1147                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1148                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1149                }
1150                TableColumn columnModel = new TableColumn(tableModel, column, columnIndex);
1151                modelManager.bindInsertModel(bindingModel, columnModel);
1152                return columnModel;
1153        }
1154
1155        public TableColumn createInsertTableColumn(Table tableModel, TConstant column, int columnIndex) {
1156                Pair<Table, TConstant> bindingModel = new Pair<Table, TConstant>(tableModel, column);
1157
1158                if (tableModel.isCreateTable()) {
1159                        if (columnIndex < tableModel.getColumns().size()) {
1160                                TableColumn columnModel = tableModel.getColumns().get(columnIndex);
1161                                modelManager.bindInsertModel(bindingModel, columnModel);
1162                                return columnModel;
1163                        } else {
1164                                return null;
1165                        }
1166                }
1167
1168                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1169                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1170                }
1171                TableColumn columnModel = new TableColumn(tableModel, column, columnIndex);
1172                modelManager.bindInsertModel(bindingModel, columnModel);
1173                return columnModel;
1174        }
1175
1176        public SelectSetResultSet createSelectSetResultSet(TSelectSqlStatement stmt) {
1177                if (modelManager.getModel(stmt) instanceof SelectSetResultSet) {
1178                        return (SelectSetResultSet) modelManager.getModel(stmt);
1179                }
1180                SelectSetResultSet resultSet = new SelectSetResultSet(stmt, stmt.getParentStmt() == null);
1181                modelManager.bindModel(stmt, resultSet);
1182                return resultSet;
1183        }
1184
1185        public ResultColumn createStarResultColumn(SelectResultSet resultSet,
1186                        Pair<TResultColumn, TObjectName> starColumnPair) {
1187                if (modelManager.getModel(starColumnPair) instanceof ResultColumn) {
1188                        return (ResultColumn) modelManager.getModel(starColumnPair);
1189                }
1190                ResultColumn column = new ResultColumn(resultSet, starColumnPair);
1191                modelManager.bindModel(starColumnPair, column);
1192                return column;
1193        }
1194
1195        public Variable createCursor(TCursorDeclStmt stmt) {
1196                String variableName = stmt.getCursorName().toString();
1197                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1198                String variableString = variableName.toString();
1199                if (variableString.startsWith(":")) {
1200                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1201                }
1202                if (!SQLUtil.isEmpty(procedureName)) {
1203                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1204                }
1205                
1206                if (modelManager
1207                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1208                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1209                }
1210                Cursor tableModel = new Cursor(stmt);
1211                if (!SQLUtil.isEmpty(procedureName)) {
1212                        tableModel.setParent(procedureName);
1213                }
1214                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1215                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1216                return tableModel;
1217        }
1218
1219        public Variable createCursor(TMssqlDeclare stmt) {
1220                String variableName = stmt.getCursorName().toString();
1221                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1222                String variableString = variableName.toString();
1223                if (variableString.startsWith(":")) {
1224                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1225                }
1226                if (!SQLUtil.isEmpty(procedureName)) {
1227                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1228                }
1229                
1230                if (modelManager
1231                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1232                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1233                }
1234                Cursor tableModel = new Cursor(stmt);
1235                if (!SQLUtil.isEmpty(procedureName)) {
1236                        tableModel.setParent(procedureName);
1237                }
1238                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1239                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1240                return tableModel;
1241        }
1242
1243        public Variable createCursor(TLoopStmt stmt) {
1244                String variableName = stmt.getRecordName().toString();
1245                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1246                String variableString = variableName.toString();
1247                if (variableString.startsWith(":")) {
1248                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1249                }
1250                if (!SQLUtil.isEmpty(procedureName)) {
1251                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1252                }
1253                
1254                if (modelManager
1255                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1256                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1257                }
1258                Cursor tableModel = new Cursor(stmt);
1259                if (!SQLUtil.isEmpty(procedureName)) {
1260                        tableModel.setParent(procedureName);
1261                }
1262                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1263                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1264                return tableModel;
1265        }
1266
1267        public Variable createCursor(TForStmt stmt) {
1268                String variableName = stmt.getLoopName().toString();
1269                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1270                String variableString = variableName.toString();
1271                if (variableString.startsWith(":")) {
1272                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1273                }
1274                if (!SQLUtil.isEmpty(procedureName)) {
1275                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1276                }
1277                
1278                if (modelManager
1279                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1280                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1281                }
1282                Cursor tableModel = new Cursor(stmt);
1283                if (!SQLUtil.isEmpty(procedureName)) {
1284                        tableModel.setParent(procedureName);
1285                }
1286                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1287                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1288                return tableModel;
1289        }
1290
1291        public Variable createCursor(TOpenforStmt stmt) {
1292                String variableName = stmt.getCursorVariableName().toString();
1293                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1294                String variableString = variableName.toString();
1295                if (variableString.startsWith(":")) {
1296                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1297                }
1298                if (!SQLUtil.isEmpty(procedureName)) {
1299                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1300                }
1301                
1302                if (modelManager.getTableByName(
1303                                DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1304                        return (Variable) modelManager
1305                                        .getTableByName(DlineageUtil.getTableFullName(variableString));
1306                }
1307                Cursor tableModel = new Cursor(stmt);
1308                if (!SQLUtil.isEmpty(procedureName)) {
1309                        tableModel.setParent(procedureName);
1310                }
1311                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString),
1312                                tableModel);
1313                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1314                return tableModel;
1315        }
1316
1317        public Variable createVariable(TObjectName variableName) {
1318                TCustomSqlStatement stmt = modelManager.getGlobalStmtStack().peek();
1319                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1320                String variableString = variableName.toString();
1321                if (variableString.startsWith(":")) {
1322                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1323                }
1324                if (variableString.indexOf(".") != -1) {
1325                        variableString = variableString.substring(0, variableString.indexOf("."));
1326                }
1327                
1328                if (!SQLUtil.isEmpty(procedureName)) {
1329                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1330                }
1331                
1332                if (modelManager.getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1333                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1334                }
1335                Variable variable = new Variable(variableName);
1336                if (!SQLUtil.isEmpty(procedureName)) {
1337                        variable.setParent(procedureName);
1338                }
1339                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), variable);
1340                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), variable);
1341//              modelManager.bindTableByName(DlineageUtil.getTableFullName(variableName.toString()), variable);
1342//              modelManager.bindModel(DlineageUtil.getTableFullName(variableName.toString()), variable);
1343                return variable;
1344        }
1345
1346        public Variable createVariable(String variableName) {
1347                return createVariable(variableName, true);
1348        }
1349        
1350        public Variable createVariable(String variableName, boolean create) {
1351                TCustomSqlStatement stmt = modelManager.getGlobalStmtStack().peek();
1352                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1353                String variableString = variableName.toString();
1354                if (variableString.startsWith(":")) {
1355                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1356                }
1357                if (!SQLUtil.isEmpty(procedureName)) {
1358                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1359                }
1360                
1361                if (modelManager.getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1362                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1363                }
1364                
1365                if (create) {
1366                        Variable variable = new Variable(variableName);
1367                        if (!SQLUtil.isEmpty(procedureName)) {
1368                                variable.setParent(procedureName);
1369                        }
1370                        modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), variable);
1371                        modelManager.bindModel(DlineageUtil.getTableFullName(variableString), variable);
1372//                      modelManager.bindTableByName(DlineageUtil.getTableFullName(variableName.toString()), variable);
1373//                      modelManager.bindModel(DlineageUtil.getTableFullName(variableName.toString()), variable);
1374                        return variable;
1375                }
1376                else {
1377                        return null;
1378                }
1379        }
1380
1381        public Variable createVariable(Procedure procedure, String variableName, boolean create) {
1382                String procedureName = procedure.getName();
1383                String variableString = variableName.toString();
1384                if (variableString.startsWith(":")) {
1385                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1386                }
1387                if (!SQLUtil.isEmpty(procedureName)) {
1388                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1389                }
1390
1391                if (modelManager.getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1392                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1393                }
1394
1395                if (create) {
1396                        Variable variable = new Variable(variableName);
1397                        if (!SQLUtil.isEmpty(procedureName)) {
1398                                variable.setParent(procedureName);
1399                        }
1400                        modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), variable);
1401                        modelManager.bindModel(DlineageUtil.getTableFullName(variableString), variable);
1402//                      modelManager.bindTableByName(DlineageUtil.getTableFullName(variableName.toString()), variable);
1403//                      modelManager.bindModel(DlineageUtil.getTableFullName(variableName.toString()), variable);
1404                        return variable;
1405                }
1406                else {
1407                        return null;
1408                }
1409        }
1410
1411        public Database createDatabase(TObjectName databaseName) {
1412                if (modelManager.getTableByName(DlineageUtil.getTableFullName(databaseName.toString())) instanceof Database) {
1413                        return (Database) modelManager.getTableByName(DlineageUtil.getTableFullName(databaseName.toString()));
1414                }
1415                Database database = new Database(databaseName);
1416                modelManager.bindTableByName(DlineageUtil.getTableFullName(databaseName.toString()), database);
1417                modelManager.bindModel(DlineageUtil.getTableFullName(databaseName.toString()), database);
1418                return database;
1419        }
1420
1421        public Schema createSchema(TObjectName schemaName) {
1422                if (modelManager
1423                                .getTableByName(DlineageUtil.getIdentifierNormalTableName(schemaName.toString())) instanceof Schema) {
1424                        return (Schema) modelManager
1425                                        .getTableByName(DlineageUtil.getIdentifierNormalTableName(schemaName.toString()));
1426                }
1427                Schema schema = new Schema(schemaName);
1428                modelManager.bindTableByName(DlineageUtil.getIdentifierNormalTableName(schemaName.toString()), schema);
1429                modelManager.bindModel(DlineageUtil.getIdentifierNormalTableName(schemaName.toString()), schema);
1430                return schema;
1431        }
1432
1433        public PivotedTable createPivotdTable(TPivotClause pivotedTable) {
1434                if (modelManager.getModel(pivotedTable) instanceof PivotedTable) {
1435                        return (PivotedTable) modelManager.getModel(pivotedTable);
1436                }
1437                PivotedTable resultSet = new PivotedTable(pivotedTable);
1438                modelManager.bindModel(pivotedTable, resultSet);
1439                if (pivotedTable.getPivotTable() != null) {
1440                        modelManager.bindModel(pivotedTable.getPivotTable(), resultSet);
1441                }
1442                return resultSet;
1443        }
1444
1445        public Procedure createProcedure(TStoredProcedureSqlStatement stmt) {
1446                if (stmt == null || stmt.getStoredProcedureName() == null) {
1447                        return null;
1448                }
1449                String procedureNameWithArgs = DlineageUtil
1450                                .getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgs(stmt));
1451                String procedureNameWithArgNum = DlineageUtil
1452                                .getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgNum(stmt));
1453                String procedureNameWithInputArgNum = DlineageUtil
1454                                .getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithInputArgNum(stmt));
1455                if (ModelBindingManager.getGlobalOraclePackage() != null) {
1456                        procedureNameWithArgs = ModelBindingManager.getGlobalOraclePackage().getName() + "."
1457                                        + procedureNameWithArgs;
1458                        procedureNameWithArgNum = ModelBindingManager.getGlobalOraclePackage().getName() + "."
1459                                        + procedureNameWithArgNum;
1460                        procedureNameWithInputArgNum = ModelBindingManager.getGlobalOraclePackage().getName() + "."
1461                                        + procedureNameWithInputArgNum;
1462                }
1463                if (this.modelManager.getModel(stmt) instanceof Procedure) {
1464                        return (Procedure) this.modelManager.getModel(stmt);
1465                } else if (this.modelManager.getProcedureByName(procedureNameWithArgs) != null) {
1466                        return (Procedure) this.modelManager.getProcedureByName(procedureNameWithArgs);
1467                } else if (this.modelManager.getProcedureByName(procedureNameWithArgNum) != null) {
1468                        return (Procedure) this.modelManager.getProcedureByName(procedureNameWithArgNum);
1469                } else if (this.modelManager.getProcedureByName(procedureNameWithInputArgNum) != null) {
1470                        return (Procedure) this.modelManager.getProcedureByName(procedureNameWithInputArgNum);
1471                } else {
1472                        Procedure procedure = new Procedure(stmt);
1473                        this.modelManager.bindModel(stmt, procedure);
1474                        this.modelManager.bindProcedureByName(procedureNameWithArgs, procedure);
1475                        this.modelManager.bindProcedureByName(procedureNameWithArgNum, procedure);
1476                        this.modelManager.bindProcedureByName(procedureNameWithInputArgNum, procedure);
1477                        return procedure;
1478                }
1479        }
1480
1481        public OraclePackage createOraclePackage(TPlsqlCreatePackage stmt) {
1482                if (this.modelManager.getModel(stmt) instanceof OraclePackage) {
1483                        return (OraclePackage) this.modelManager.getModel(stmt);
1484                } else {
1485                        OraclePackage oraclePackage = new OraclePackage(stmt);
1486                        this.modelManager.bindModel(stmt, oraclePackage);
1487                        this.modelManager.bindOraclePackageByName(
1488                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgs(stmt)),
1489                                        oraclePackage);
1490                        this.modelManager.bindOraclePackageByName(
1491                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgNum(stmt)),
1492                                        oraclePackage);
1493                        this.modelManager.bindOraclePackageByName(
1494                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithInputArgNum(stmt)),
1495                                        oraclePackage);
1496                        return oraclePackage;
1497                }
1498        }
1499
1500        public Procedure createProcedureFromFunctionCall(TFunctionCall function) {
1501                if (this.modelManager.getModel(function) instanceof Procedure) {
1502                        return (Procedure) this.modelManager.getModel(function);
1503                } else {
1504                        Procedure procedure = new Procedure(function);
1505                        procedure.setType(ESqlStatementType.sstcreateprocedure);
1506                        this.modelManager.bindModel(function, procedure);
1507                        this.modelManager.bindProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedure.getName()),
1508                                        procedure);
1509                        return procedure;
1510                }
1511        }
1512        
1513//      public Procedure createProcedureByName(TObjectName procedureName) {
1514//              if (this.modelManager.getModel(procedureName) instanceof Procedure) {
1515//                      return (Procedure) this.modelManager.getModel(procedureName);
1516//              }
1517//              else if (this.modelManager
1518//                              .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureName.toString())) != null) {
1519//                      return modelManager.getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureName.toString()));
1520//              }
1521//              else {
1522//                      Procedure procedure = new Procedure(procedureName);
1523//                      procedure.setType(ESqlStatementType.sstcreateprocedure);
1524//                      this.modelManager.bindModel(procedureName, procedure);
1525//                      this.modelManager.bindProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedure.getName()),
1526//                                      procedure);
1527//                      return procedure;
1528//              }
1529//      }
1530
1531        public Procedure createProcedureByName(TObjectName procedureName, int argumentSize) {
1532                String procedureNameWithArgSize = procedureName.toString() + "(" + argumentSize + ")";
1533                if (argumentSize <= 0 || !DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
1534                        procedureNameWithArgSize = procedureName.toString();
1535                }
1536                if (this.modelManager.getModel(procedureName) instanceof Procedure) {
1537                        return (Procedure) this.modelManager.getModel(procedureName);
1538                }
1539                else if (this.modelManager
1540                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureNameWithArgSize)) != null) {
1541                        return modelManager.getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureNameWithArgSize));
1542                }
1543                else {
1544                        Procedure procedure = new Procedure(procedureName);
1545                        procedure.setType(ESqlStatementType.sstcreateprocedure);
1546                        this.modelManager.bindModel(procedureName, procedure);
1547                        this.modelManager.bindProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureNameWithArgSize),
1548                                        procedure);
1549                        return procedure;
1550                }
1551        }
1552
1553        public Argument createProcedureArgument(Procedure procedure, TParameterDeclaration parameter, int index) {
1554                if (this.modelManager.getModel(parameter) instanceof Argument) {
1555                        return (Argument) this.modelManager.getModel(parameter);
1556                } else {
1557                        if (procedure.getArguments() != null) {
1558                                for (Argument argument : procedure.getArguments()) {
1559                                        if (parameter.getParameterName() == null) {
1560                                                continue;
1561                                        }
1562                                        if (argument.getName().equals(parameter.getParameterName().toString())) {
1563                                                return argument;
1564                                        }
1565                                }
1566                        }
1567                        Argument argumentModel = new Argument(procedure, parameter, index);
1568                        this.modelManager.bindModel(parameter, argumentModel);
1569                        this.modelManager.bindModel(procedure.getName() + ":" + argumentModel.getName(), argumentModel);
1570                        return argumentModel;
1571                }
1572        }
1573
1574        public Argument createProcedureArgument(OraclePackage oraclePackage, TParameterDeclaration parameter, int index) {
1575                if (this.modelManager.getModel(parameter) instanceof Argument) {
1576                        return (Argument) this.modelManager.getModel(parameter);
1577                } else {
1578                        Argument argumentModel = new Argument(oraclePackage, parameter, index);
1579                        this.modelManager.bindModel(parameter, argumentModel);
1580                        return argumentModel;
1581                }
1582        }
1583
1584}