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