Source code

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