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                String defaultDatabase = null;
966                if (ModelBindingManager.getGlobalSQLEnv() != null) {
967                        defaultDatabase = ModelBindingManager.getGlobalSQLEnv().getDefaultCatalogName();
968                }
969                if (!SQLUtil.isEmpty(defaultDatabase))
970                        return defaultDatabase;
971                return TSQLEnv.DEFAULT_DB_NAME;
972        }
973
974        public TableColumn createStageLocation(Table table, TObjectName location) {
975                if (modelManager.getModel(new Pair<Table, TObjectName>(table, location)) instanceof TableColumn) {
976                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, location));
977                }
978
979                StageLocation columnModel = new StageLocation(table, location);
980                modelManager.bindModel(new Pair<Table, TObjectName>(table, location), columnModel);
981                return columnModel;
982        }
983
984        public TableColumn createFileUri(Table table, TObjectName fileUri) {
985                if (modelManager.getModel(new Pair<Table, TObjectName>(table, fileUri)) instanceof TableColumn) {
986                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, fileUri));
987                }
988
989                FileUri columnModel = new FileUri(table, fileUri);
990                modelManager.bindModel(new Pair<Table, TObjectName>(table, fileUri), columnModel);
991                return columnModel;
992        }
993
994        public TableColumn createVariableProperty(Table variableTable, TDeclareVariable variable) {
995                if (modelManager.getModel(new Pair<Table, TDeclareVariable>(variableTable, variable)) instanceof TableColumn) {
996                        return (TableColumn) modelManager.getModel(new Pair<Table, TDeclareVariable>(variableTable, variable));
997                }
998
999                TObjectName variableName = new TObjectName();
1000                variableName.setString("property");
1001                VariableProperty columnModel = new VariableProperty(variableTable, variableName, variable);
1002                modelManager.bindModel(new Pair<Table, TDeclareVariable>(variableTable, variable), columnModel);
1003                return columnModel;
1004        }
1005
1006        public TableColumn createJsonTableColumn(Table table, TObjectName column) {
1007                if (modelManager.getModel(new Pair<Table, TObjectName>(table, column)) instanceof TableColumn) {
1008                        return (TableColumn) modelManager.getModel(new Pair<Table, TObjectName>(table, column));
1009                }
1010
1011                JsonTableColumn columnModel = new JsonTableColumn(table, column);
1012                modelManager.bindModel(new Pair<Table, TObjectName>(table, column), columnModel);
1013                return columnModel;
1014        }
1015
1016        public DataFlowRelationship createDataFlowRelation() {
1017                DataFlowRelationship relation = new DataFlowRelationship();
1018                modelManager.addRelation(relation);
1019                return relation;
1020        }
1021
1022        public CallRelationship createCallRelation() {
1023                CallRelationship relation = new CallRelationship();
1024                modelManager.addRelation(relation);
1025                return relation;
1026        }
1027        
1028        public CrudRelationship createCrudRelation() {
1029                CrudRelationship relation = new CrudRelationship();
1030                modelManager.addRelation(relation);
1031                return relation;
1032        }
1033
1034        public ERRelationship createERRelation() {
1035                ERRelationship relation = new ERRelationship();
1036                modelManager.addRelation(relation);
1037                return relation;
1038        }
1039
1040        public TableColumn createTableColumn(Table table, TResultColumn column) {
1041                if (column.getAliasClause() != null && column.getAliasClause().getAliasName() != null) {
1042                        TableColumn columnModel = new TableColumn(table, column.getAliasClause().getAliasName());
1043                        modelManager.bindModel(column, columnModel);
1044                        return columnModel;
1045                } else if (column.getFieldAttr() != null) {
1046                        TableColumn columnModel = new TableColumn(table, column.getFieldAttr());
1047                        modelManager.bindModel(column, columnModel);
1048                        return columnModel;
1049                }
1050                return null;
1051        }
1052
1053        public TableColumn createTableColumn(Table table, TConstant constant) {
1054                if (modelManager.getModel(new Pair<Table, TConstant>(table, constant)) instanceof TableColumn) {
1055                        return (TableColumn) modelManager.getModel(new Pair<Table, TConstant>(table, constant));
1056                }
1057
1058                TableColumn columnModel = new TableColumn(table, constant);
1059                modelManager.bindModel(new Pair<Table, TConstant>(table, constant), columnModel);
1060                return columnModel;
1061        }
1062
1063        public TableColumn createTableColumn(Table table, TFunctionCall constantFunction) {
1064                if (modelManager.getModel(new Pair<Table, TFunctionCall>(table, constantFunction)) instanceof TableColumn) {
1065                        return (TableColumn) modelManager.getModel(new Pair<Table, TFunctionCall>(table, constantFunction));
1066                }
1067
1068                TableColumn columnModel = new TableColumn(table, constantFunction);
1069                modelManager.bindModel(new Pair<Table, TFunctionCall>(table, constantFunction), columnModel);
1070                return columnModel;
1071        }
1072
1073        public TableColumn createTableColumn(Table table, String columnName) {
1074                for (TableColumn col : table.getColumns()) {
1075                        if (col.getName().equals(columnName)) {
1076                                return col;
1077                        }
1078                }
1079                TableColumn columnModel = new TableColumn(table, columnName);
1080                return columnModel;
1081        }
1082
1083        public RecordSetRelationship createRecordSetRelation() {
1084                RecordSetRelationship relation = new RecordSetRelationship();
1085                modelManager.addRelation(relation);
1086                return relation;
1087        }
1088
1089        public ImpactRelationship createImpactRelation() {
1090                ImpactRelationship relation = new ImpactRelationship();
1091                modelManager.addRelation(relation);
1092                return relation;
1093        }
1094
1095        public IndirectImpactRelationship createIndirectImpactRelation() {
1096                IndirectImpactRelationship relation = new IndirectImpactRelationship();
1097                modelManager.addRelation(relation);
1098                return relation;
1099        }
1100
1101        public JoinRelationship createJoinRelation() {
1102                JoinRelationship relation = new JoinRelationship();
1103                modelManager.addRelation(relation);
1104                return relation;
1105        }
1106
1107        public Table createView(TCustomSqlStatement viewStmt, TObjectName viewName) {
1108                return createView(viewStmt, viewName, false);
1109        }
1110
1111        public Table createView(TCustomSqlStatement viewStmt, TObjectName viewName, boolean fromCreateView) {
1112                if (modelManager.getViewModel(viewStmt) instanceof Table) {
1113                        Table table = (Table) modelManager.getViewModel(viewStmt);
1114                        table.setView(true);
1115                        table.setPosition(viewStmt);
1116                        return table;
1117                }
1118
1119                if (modelManager.getTableByName(DlineageUtil.getTableFullName(viewName.toString())) != null) {
1120                        Table table = modelManager.getTableByName(DlineageUtil.getTableFullName(viewName.toString()));
1121                        table.setView(true);
1122                        table.setPosition(viewStmt);
1123                        return table;
1124                }
1125
1126                Table viewModel = new Table(viewStmt, viewName);
1127                viewModel.setCreateTable(fromCreateView);
1128                viewModel.setView(true);
1129                modelManager.bindViewModel(viewStmt, viewModel);
1130                modelManager.bindTableByName(DlineageUtil.getTableFullName(viewName.toString()), viewModel);
1131                return viewModel;
1132        }
1133
1134        public Process createProcess(TCustomSqlStatement processStmt) {
1135                if (modelManager.getProcessModel(processStmt) instanceof Process) {
1136                        Process process = (Process) modelManager.getProcessModel(processStmt);
1137                        return process;
1138                }
1139
1140                Process processModel = new Process(processStmt);
1141                modelManager.bindProcessModel(processStmt, processModel);
1142                return processModel;
1143        }
1144
1145        public Process createProcess(TFunctionCall functionCall) {
1146                if (modelManager.getProcessModel(functionCall) instanceof Process) {
1147                        Process process = (Process) modelManager.getProcessModel(functionCall);
1148                        return process;
1149                }
1150
1151                Process processModel = new Process(functionCall);
1152                modelManager.bindProcessModel(functionCall, processModel);
1153                return processModel;
1154        }
1155
1156        public TableColumn createViewColumn(Table viewModel, TObjectName column, int index, boolean fromCreateView) {
1157                Pair<Table, TObjectName> bindingModel = new Pair<Table, TObjectName>(viewModel, column);
1158                if (modelManager.getViewModel(bindingModel) instanceof TableColumn) {
1159                        return (TableColumn) modelManager.getViewModel(bindingModel);
1160                }
1161
1162                if (viewModel.isCreateTable() && !fromCreateView) {
1163                        if (index < viewModel.getColumns().size()) {
1164                                return (TableColumn) viewModel.getColumns().get(index);
1165                        } else {
1166                                return null;
1167                        }
1168                }
1169
1170                TableColumn columnModel = new TableColumn(viewModel, column, index);
1171                modelManager.bindViewModel(bindingModel, columnModel);
1172                return columnModel;
1173        }
1174
1175        public TableColumn createInsertTableColumn(Table tableModel, String columnName) {
1176                TObjectName columnNameObject = new TObjectName();
1177                columnNameObject.setString(columnName);
1178                Pair<Table, String> bindingModel = new Pair<Table, String>(tableModel, columnName);
1179
1180                if (tableModel.isCreateTable()) {
1181                        for (int i = 0; i < tableModel.getColumns().size(); i++) {
1182                                TableColumn columnModel = tableModel.getColumns().get(i);
1183                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
1184                                        modelManager.bindInsertModel(bindingModel, columnModel);
1185                                        return columnModel;
1186                                }
1187                        }
1188                }
1189
1190                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1191                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1192                }
1193                TableColumn columnModel = new TableColumn(tableModel, columnNameObject);
1194                modelManager.bindInsertModel(bindingModel, columnModel);
1195                return columnModel;
1196        }
1197
1198        public TableColumn createInsertTableColumn(Table tableModel, TObjectName column) {
1199                Pair<Table, TObjectName> bindingModel = new Pair<Table, TObjectName>(tableModel, column);
1200
1201                if (tableModel.isCreateTable()) {
1202                        String columnName = DlineageUtil.getColumnName(column);
1203                        for (int i = 0; i < tableModel.getColumns().size(); i++) {
1204                                TableColumn columnModel = tableModel.getColumns().get(i);
1205                                if (DlineageUtil.getIdentifierNormalColumnName(columnModel.getName()).equals(columnName)) {
1206                                        modelManager.bindInsertModel(bindingModel, columnModel);
1207                                        return columnModel;
1208                                }
1209                        }
1210                }
1211
1212                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1213                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1214                }
1215                TableColumn columnModel = new TableColumn(tableModel, column);
1216                modelManager.bindInsertModel(bindingModel, columnModel);
1217                return columnModel;
1218        }
1219
1220        public TableColumn createInsertTableColumn(Table tableModel, TExpression column, int columnIndex) {
1221                Pair<Table, TExpression> bindingModel = new Pair<Table, TExpression>(tableModel, column);
1222
1223                if (tableModel.isCreateTable()) {
1224                        if (columnIndex < tableModel.getColumns().size()) {
1225                                TableColumn columnModel = tableModel.getColumns().get(columnIndex);
1226                                modelManager.bindInsertModel(bindingModel, columnModel);
1227                                return columnModel;
1228                        } else {
1229                                return null;
1230                        }
1231                }
1232
1233                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1234                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1235                }
1236                TableColumn columnModel = new TableColumn(tableModel, column, columnIndex);
1237                modelManager.bindInsertModel(bindingModel, columnModel);
1238                return columnModel;
1239        }
1240
1241        public TableColumn createInsertTableColumn(Table tableModel, TConstant column, int columnIndex) {
1242                Pair<Table, TConstant> bindingModel = new Pair<Table, TConstant>(tableModel, column);
1243
1244                if (tableModel.isCreateTable()) {
1245                        if (columnIndex < tableModel.getColumns().size()) {
1246                                TableColumn columnModel = tableModel.getColumns().get(columnIndex);
1247                                modelManager.bindInsertModel(bindingModel, columnModel);
1248                                return columnModel;
1249                        } else {
1250                                return null;
1251                        }
1252                }
1253
1254                if (modelManager.getInsertModel(bindingModel) instanceof TableColumn) {
1255                        return (TableColumn) modelManager.getInsertModel(bindingModel);
1256                }
1257                TableColumn columnModel = new TableColumn(tableModel, column, columnIndex);
1258                modelManager.bindInsertModel(bindingModel, columnModel);
1259                return columnModel;
1260        }
1261
1262        public SelectSetResultSet createSelectSetResultSet(TSelectSqlStatement stmt) {
1263                if (modelManager.getModel(stmt) instanceof SelectSetResultSet) {
1264                        return (SelectSetResultSet) modelManager.getModel(stmt);
1265                }
1266                SelectSetResultSet resultSet = new SelectSetResultSet(stmt, stmt.getParentStmt() == null);
1267                modelManager.bindModel(stmt, resultSet);
1268                return resultSet;
1269        }
1270
1271        public ResultColumn createStarResultColumn(SelectResultSet resultSet,
1272                        Pair<TResultColumn, TObjectName> starColumnPair) {
1273                if (modelManager.getModel(starColumnPair) instanceof ResultColumn) {
1274                        return (ResultColumn) modelManager.getModel(starColumnPair);
1275                }
1276                ResultColumn column = new ResultColumn(resultSet, starColumnPair);
1277                modelManager.bindModel(starColumnPair, column);
1278                return column;
1279        }
1280
1281        public Variable createCursor(TCursorDeclStmt stmt) {
1282                String variableName = stmt.getCursorName().toString();
1283                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1284                String variableString = variableName.toString();
1285                if (variableString.startsWith(":")) {
1286                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1287                }
1288                if (!SQLUtil.isEmpty(procedureName)) {
1289                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1290                }
1291                
1292                if (modelManager
1293                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1294                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1295                }
1296                Cursor tableModel = new Cursor(stmt);
1297                if (!SQLUtil.isEmpty(procedureName)) {
1298                        tableModel.setParent(procedureName);
1299                }
1300                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1301                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1302                return tableModel;
1303        }
1304
1305        public Variable createCursor(TMssqlDeclare stmt) {
1306                String variableName = stmt.getCursorName().toString();
1307                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1308                String variableString = variableName.toString();
1309                if (variableString.startsWith(":")) {
1310                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1311                }
1312                if (!SQLUtil.isEmpty(procedureName)) {
1313                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1314                }
1315                
1316                if (modelManager
1317                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1318                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1319                }
1320                Cursor tableModel = new Cursor(stmt);
1321                if (!SQLUtil.isEmpty(procedureName)) {
1322                        tableModel.setParent(procedureName);
1323                }
1324                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1325                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1326                return tableModel;
1327        }
1328
1329        public Variable createCursor(TLoopStmt stmt) {
1330                String variableName = stmt.getRecordName().toString();
1331                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1332                String variableString = variableName.toString();
1333                if (variableString.startsWith(":")) {
1334                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1335                }
1336                if (!SQLUtil.isEmpty(procedureName)) {
1337                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1338                }
1339                
1340                if (modelManager
1341                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1342                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1343                }
1344                Cursor tableModel = new Cursor(stmt);
1345                if (!SQLUtil.isEmpty(procedureName)) {
1346                        tableModel.setParent(procedureName);
1347                }
1348                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1349                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1350                return tableModel;
1351        }
1352
1353        public Variable createCursor(TForStmt stmt) {
1354                String variableName = stmt.getLoopName().toString();
1355                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1356                String variableString = variableName.toString();
1357                if (variableString.startsWith(":")) {
1358                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1359                }
1360                if (!SQLUtil.isEmpty(procedureName)) {
1361                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1362                }
1363                
1364                if (modelManager
1365                                .getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1366                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1367                }
1368                Cursor tableModel = new Cursor(stmt);
1369                if (!SQLUtil.isEmpty(procedureName)) {
1370                        tableModel.setParent(procedureName);
1371                }
1372                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), tableModel);
1373                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1374                return tableModel;
1375        }
1376
1377        public Variable createCursor(TOpenforStmt stmt) {
1378                String variableName = stmt.getCursorVariableName().toString();
1379                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1380                String variableString = variableName.toString();
1381                if (variableString.startsWith(":")) {
1382                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1383                }
1384                if (!SQLUtil.isEmpty(procedureName)) {
1385                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1386                }
1387                
1388                if (modelManager.getTableByName(
1389                                DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1390                        return (Variable) modelManager
1391                                        .getTableByName(DlineageUtil.getTableFullName(variableString));
1392                }
1393                Cursor tableModel = new Cursor(stmt);
1394                if (!SQLUtil.isEmpty(procedureName)) {
1395                        tableModel.setParent(procedureName);
1396                }
1397                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString),
1398                                tableModel);
1399                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), tableModel);
1400                return tableModel;
1401        }
1402
1403        public Variable createVariable(TObjectName variableName) {
1404                TCustomSqlStatement stmt = modelManager.getGlobalStmtStack().peek();
1405                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1406                String variableString = variableName.toString();
1407                if (variableString.startsWith(":")) {
1408                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1409                }
1410                if (variableString.indexOf(".") != -1) {
1411                        variableString = variableString.substring(0, variableString.indexOf("."));
1412                }
1413                
1414                if (!SQLUtil.isEmpty(procedureName)) {
1415                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1416                }
1417                
1418                if (modelManager.getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1419                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1420                }
1421                Variable variable = new Variable(variableName);
1422                if (!SQLUtil.isEmpty(procedureName)) {
1423                        variable.setParent(procedureName);
1424                }
1425                modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), variable);
1426                modelManager.bindModel(DlineageUtil.getTableFullName(variableString), variable);
1427//              modelManager.bindTableByName(DlineageUtil.getTableFullName(variableName.toString()), variable);
1428//              modelManager.bindModel(DlineageUtil.getTableFullName(variableName.toString()), variable);
1429                return variable;
1430        }
1431
1432        public Variable createVariable(String variableName) {
1433                return createVariable(variableName, true);
1434        }
1435        
1436        public Variable createVariable(String variableName, boolean create) {
1437                TCustomSqlStatement stmt = modelManager.getGlobalStmtStack().peek();
1438                String procedureName = DlineageUtil.getProcedureParentName(stmt);
1439                String variableString = variableName.toString();
1440                if (variableString.startsWith(":")) {
1441                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1442                }
1443                if (!SQLUtil.isEmpty(procedureName)) {
1444                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1445                }
1446                
1447                if (modelManager.getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1448                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1449                }
1450                
1451                if (create) {
1452                        Variable variable = new Variable(variableName);
1453                        if (!SQLUtil.isEmpty(procedureName)) {
1454                                variable.setParent(procedureName);
1455                        }
1456                        modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), variable);
1457                        modelManager.bindModel(DlineageUtil.getTableFullName(variableString), variable);
1458//                      modelManager.bindTableByName(DlineageUtil.getTableFullName(variableName.toString()), variable);
1459//                      modelManager.bindModel(DlineageUtil.getTableFullName(variableName.toString()), variable);
1460                        return variable;
1461                }
1462                else {
1463                        return null;
1464                }
1465        }
1466
1467        public Variable createVariable(Procedure procedure, String variableName, boolean create) {
1468                String procedureName = procedure.getName();
1469                String variableString = variableName.toString();
1470                if (variableString.startsWith(":")) {
1471                        variableString = variableString.substring(variableString.indexOf(":") + 1);
1472                }
1473                if (!SQLUtil.isEmpty(procedureName)) {
1474                        variableString = DlineageUtil.getTableFullName(procedureName) + "." + SQLUtil.getIdentifierNormalTableName(variableString);
1475                }
1476
1477                if (modelManager.getTableByName(DlineageUtil.getTableFullName(variableString)) instanceof Variable) {
1478                        return (Variable) modelManager.getTableByName(DlineageUtil.getTableFullName(variableString));
1479                }
1480
1481                if (create) {
1482                        Variable variable = new Variable(variableName);
1483                        if (!SQLUtil.isEmpty(procedureName)) {
1484                                variable.setParent(procedureName);
1485                        }
1486                        modelManager.bindTableByName(DlineageUtil.getTableFullName(variableString), variable);
1487                        modelManager.bindModel(DlineageUtil.getTableFullName(variableString), variable);
1488//                      modelManager.bindTableByName(DlineageUtil.getTableFullName(variableName.toString()), variable);
1489//                      modelManager.bindModel(DlineageUtil.getTableFullName(variableName.toString()), variable);
1490                        return variable;
1491                }
1492                else {
1493                        return null;
1494                }
1495        }
1496
1497        public Database createDatabase(TObjectName databaseName) {
1498                if (modelManager.getTableByName(DlineageUtil.getTableFullName(databaseName.toString())) instanceof Database) {
1499                        return (Database) modelManager.getTableByName(DlineageUtil.getTableFullName(databaseName.toString()));
1500                }
1501                Database database = new Database(databaseName);
1502                modelManager.bindTableByName(DlineageUtil.getTableFullName(databaseName.toString()), database);
1503                modelManager.bindModel(DlineageUtil.getTableFullName(databaseName.toString()), database);
1504                return database;
1505        }
1506
1507        public Schema createSchema(TObjectName schemaName) {
1508                if (modelManager
1509                                .getTableByName(DlineageUtil.getIdentifierNormalTableName(schemaName.toString())) instanceof Schema) {
1510                        return (Schema) modelManager
1511                                        .getTableByName(DlineageUtil.getIdentifierNormalTableName(schemaName.toString()));
1512                }
1513                Schema schema = new Schema(schemaName);
1514                modelManager.bindTableByName(DlineageUtil.getIdentifierNormalTableName(schemaName.toString()), schema);
1515                modelManager.bindModel(DlineageUtil.getIdentifierNormalTableName(schemaName.toString()), schema);
1516                return schema;
1517        }
1518
1519        public PivotedTable createPivotdTable(TPivotClause pivotedTable) {
1520                if (modelManager.getModel(pivotedTable) instanceof PivotedTable) {
1521                        return (PivotedTable) modelManager.getModel(pivotedTable);
1522                }
1523                PivotedTable resultSet = new PivotedTable(pivotedTable);
1524                modelManager.bindModel(pivotedTable, resultSet);
1525                if (pivotedTable.getPivotTable() != null) {
1526                        modelManager.bindModel(pivotedTable.getPivotTable(), resultSet);
1527                }
1528                return resultSet;
1529        }
1530
1531        public Procedure createProcedure(TStoredProcedureSqlStatement stmt) {
1532                if (stmt == null || stmt.getStoredProcedureName() == null) {
1533                        return null;
1534                }
1535                String procedureNameWithArgs = DlineageUtil
1536                                .getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgs(stmt));
1537                String procedureNameWithArgNum = DlineageUtil
1538                                .getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgNum(stmt));
1539                String procedureNameWithInputArgNum = DlineageUtil
1540                                .getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithInputArgNum(stmt));
1541                if (ModelBindingManager.getGlobalOraclePackage() != null) {
1542                        procedureNameWithArgs = ModelBindingManager.getGlobalOraclePackage().getName() + "."
1543                                        + procedureNameWithArgs;
1544                        procedureNameWithArgNum = ModelBindingManager.getGlobalOraclePackage().getName() + "."
1545                                        + procedureNameWithArgNum;
1546                        procedureNameWithInputArgNum = ModelBindingManager.getGlobalOraclePackage().getName() + "."
1547                                        + procedureNameWithInputArgNum;
1548                }
1549                if (this.modelManager.getModel(stmt) instanceof Procedure) {
1550                        return (Procedure) this.modelManager.getModel(stmt);
1551                } else if (this.modelManager.getProcedureByName(procedureNameWithArgs) != null) {
1552                        return (Procedure) this.modelManager.getProcedureByName(procedureNameWithArgs);
1553                } else if (this.modelManager.getProcedureByName(procedureNameWithArgNum) != null) {
1554                        return (Procedure) this.modelManager.getProcedureByName(procedureNameWithArgNum);
1555                } else if (this.modelManager.getProcedureByName(procedureNameWithInputArgNum) != null) {
1556                        return (Procedure) this.modelManager.getProcedureByName(procedureNameWithInputArgNum);
1557                } else {
1558                        Procedure procedure = new Procedure(stmt);
1559                        this.modelManager.bindModel(stmt, procedure);
1560                        this.modelManager.bindProcedureByName(procedureNameWithArgs, procedure);
1561                        this.modelManager.bindProcedureByName(procedureNameWithArgNum, procedure);
1562                        this.modelManager.bindProcedureByName(procedureNameWithInputArgNum, procedure);
1563                        return procedure;
1564                }
1565        }
1566
1567        public OraclePackage createOraclePackage(TPlsqlCreatePackage stmt) {
1568                if (this.modelManager.getModel(stmt) instanceof OraclePackage) {
1569                        return (OraclePackage) this.modelManager.getModel(stmt);
1570                } else {
1571                        OraclePackage oraclePackage = new OraclePackage(stmt);
1572                        this.modelManager.bindModel(stmt, oraclePackage);
1573                        this.modelManager.bindOraclePackageByName(
1574                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgs(stmt)),
1575                                        oraclePackage);
1576                        this.modelManager.bindOraclePackageByName(
1577                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithArgNum(stmt)),
1578                                        oraclePackage);
1579                        this.modelManager.bindOraclePackageByName(
1580                                        DlineageUtil.getIdentifierNormalTableName(DlineageUtil.getProcedureNameWithInputArgNum(stmt)),
1581                                        oraclePackage);
1582                        return oraclePackage;
1583                }
1584        }
1585
1586        public Procedure createProcedureFromFunctionCall(TFunctionCall function) {
1587                if (this.modelManager.getModel(function) instanceof Procedure) {
1588                        return (Procedure) this.modelManager.getModel(function);
1589                } else {
1590                        Procedure procedure = new Procedure(function);
1591                        procedure.setType(ESqlStatementType.sstcreateprocedure);
1592                        this.modelManager.bindModel(function, procedure);
1593                        this.modelManager.bindProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedure.getName()),
1594                                        procedure);
1595                        return procedure;
1596                }
1597        }
1598        
1599//      public Procedure createProcedureByName(TObjectName procedureName) {
1600//              if (this.modelManager.getModel(procedureName) instanceof Procedure) {
1601//                      return (Procedure) this.modelManager.getModel(procedureName);
1602//              }
1603//              else if (this.modelManager
1604//                              .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureName.toString())) != null) {
1605//                      return modelManager.getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureName.toString()));
1606//              }
1607//              else {
1608//                      Procedure procedure = new Procedure(procedureName);
1609//                      procedure.setType(ESqlStatementType.sstcreateprocedure);
1610//                      this.modelManager.bindModel(procedureName, procedure);
1611//                      this.modelManager.bindProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedure.getName()),
1612//                                      procedure);
1613//                      return procedure;
1614//              }
1615//      }
1616
1617        public Procedure createProcedureByName(TObjectName procedureName, int argumentSize) {
1618                String procedureNameWithArgSize = procedureName.toString() + "(" + argumentSize + ")";
1619                if (argumentSize <= 0 || !DlineageUtil.supportFunctionOverride(ModelBindingManager.getGlobalVendor())) {
1620                        procedureNameWithArgSize = procedureName.toString();
1621                }
1622                if (this.modelManager.getModel(procedureName) instanceof Procedure) {
1623                        return (Procedure) this.modelManager.getModel(procedureName);
1624                }
1625                else if (this.modelManager
1626                                .getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureNameWithArgSize)) != null) {
1627                        return modelManager.getProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureNameWithArgSize));
1628                }
1629                else {
1630                        Procedure procedure = new Procedure(procedureName);
1631                        procedure.setType(ESqlStatementType.sstcreateprocedure);
1632                        this.modelManager.bindModel(procedureName, procedure);
1633                        this.modelManager.bindProcedureByName(DlineageUtil.getIdentifierNormalTableName(procedureNameWithArgSize),
1634                                        procedure);
1635                        return procedure;
1636                }
1637        }
1638
1639        public Argument createProcedureArgument(Procedure procedure, TParameterDeclaration parameter, int index) {
1640                if (this.modelManager.getModel(parameter) instanceof Argument) {
1641                        return (Argument) this.modelManager.getModel(parameter);
1642                } else {
1643                        if (procedure.getArguments() != null) {
1644                                for (Argument argument : procedure.getArguments()) {
1645                                        if (parameter.getParameterName() == null) {
1646                                                continue;
1647                                        }
1648                                        if (argument.getName().equals(parameter.getParameterName().toString())) {
1649                                                return argument;
1650                                        }
1651                                }
1652                        }
1653                        Argument argumentModel = new Argument(procedure, parameter, index);
1654                        this.modelManager.bindModel(parameter, argumentModel);
1655                        this.modelManager.bindModel(procedure.getName() + ":" + argumentModel.getName(), argumentModel);
1656                        return argumentModel;
1657                }
1658        }
1659
1660        public Argument createProcedureArgument(OraclePackage oraclePackage, TParameterDeclaration parameter, int index) {
1661                if (this.modelManager.getModel(parameter) instanceof Argument) {
1662                        return (Argument) this.modelManager.getModel(parameter);
1663                } else {
1664                        Argument argumentModel = new Argument(oraclePackage, parameter, index);
1665                        this.modelManager.bindModel(parameter, argumentModel);
1666                        return argumentModel;
1667                }
1668        }
1669
1670}