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