001package gudusoft.gsqlparser.sqlenv;
002
003import gudusoft.gsqlparser.EDbVendor;
004import gudusoft.gsqlparser.EExpressionType;
005import gudusoft.gsqlparser.TCustomSqlStatement;
006import gudusoft.gsqlparser.TGSqlParser;
007import gudusoft.gsqlparser.dlineage.util.DlineageUtil;
008import gudusoft.gsqlparser.dlineage.util.Pair3;
009import gudusoft.gsqlparser.nodes.TColumnDefinition;
010import gudusoft.gsqlparser.nodes.TDeclareVariable;
011import gudusoft.gsqlparser.nodes.TDeclareVariableList;
012import gudusoft.gsqlparser.nodes.TFunctionCall;
013import gudusoft.gsqlparser.nodes.TObjectName;
014import gudusoft.gsqlparser.nodes.TParseTreeNode;
015import gudusoft.gsqlparser.nodes.TResultColumn;
016import gudusoft.gsqlparser.nodes.TTableElement;
017import gudusoft.gsqlparser.nodes.TTableElementList;
018import gudusoft.gsqlparser.nodes.TTypeName;
019import gudusoft.gsqlparser.nodes.TViewAliasItem;
020import gudusoft.gsqlparser.stmt.TCreateFunctionStmt;
021import gudusoft.gsqlparser.stmt.TCreateProcedureStmt;
022import gudusoft.gsqlparser.stmt.TCreateSchemaSqlStatement;
023import gudusoft.gsqlparser.stmt.TCreateSynonymStmt;
024import gudusoft.gsqlparser.stmt.TCreateTableSqlStatement;
025import gudusoft.gsqlparser.stmt.TCreateTriggerStmt;
026import gudusoft.gsqlparser.stmt.TCreateViewSqlStatement;
027import gudusoft.gsqlparser.stmt.TStoredProcedureSqlStatement;
028import gudusoft.gsqlparser.stmt.TUseDatabase;
029import gudusoft.gsqlparser.stmt.mssql.TMssqlCreateFunction;
030import gudusoft.gsqlparser.stmt.mssql.TMssqlDeclare;
031import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateFunction;
032import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage;
033import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateProcedure;
034import gudusoft.gsqlparser.stmt.oracle.TPlsqlCreateTrigger;
035import gudusoft.gsqlparser.stmt.teradata.TTeradataCreateProcedure;
036import gudusoft.gsqlparser.util.SQLUtil;
037
038import java.io.ByteArrayInputStream;
039import java.io.IOException;
040import java.util.ArrayList;
041import java.util.List;
042import java.util.Properties;
043import java.util.Stack;
044
045public class TDDLSQLEnv extends TSQLEnv {
046
047    private String sql;
048
049    private TSQLEnv metadataSQLEnv;
050
051    private String globalDatabase = null;
052
053    private String globalSchema = null;
054
055    private boolean init = false;
056    
057    private Stack<TCustomSqlStatement> stmtStack = new Stack<TCustomSqlStatement>();
058
059    public boolean isInit() {
060        return init;
061    }
062
063    public TDDLSQLEnv(String defaultServer, String defaultDatabase, String defaultSchema, EDbVendor dbVendor, String sql) {
064        super(dbVendor);
065        if(!SQLUtil.isEmpty(defaultServer) && !defaultServer.equals(TSQLEnv.DEFAULT_SERVER_NAME)) {
066                        setDefaultServerName(defaultServer);
067                }
068                if(!SQLUtil.isEmpty(defaultDatabase) && !defaultDatabase.equals(TSQLEnv.DEFAULT_DB_NAME)) {
069                        setDefaultCatalogName(defaultDatabase);
070                }
071                if(!SQLUtil.isEmpty(defaultSchema) && !defaultSchema.equals(TSQLEnv.DEFAULT_SCHEMA_NAME)) {
072                        setDefaultSchemaName(defaultSchema);
073                }
074        this.sql = sql;
075    }
076
077    public TDDLSQLEnv(String defaultServer, String defaultDatabase, String defaultSchema, TSQLEnv metadataSQLEnv, EDbVendor dbVendor, String sql) {
078        super(dbVendor);
079        if(!SQLUtil.isEmpty(defaultServer) && !defaultServer.equals(TSQLEnv.DEFAULT_SERVER_NAME)) {
080                        setDefaultServerName(defaultServer);
081                }
082                if(!SQLUtil.isEmpty(defaultDatabase) && !defaultDatabase.equals(TSQLEnv.DEFAULT_DB_NAME)) {
083                        setDefaultCatalogName(defaultDatabase);
084                }
085                if(!SQLUtil.isEmpty(defaultSchema) && !defaultSchema.equals(TSQLEnv.DEFAULT_SCHEMA_NAME)) {
086                        setDefaultSchemaName(defaultSchema);
087                }
088        this.sql = sql;
089        this.metadataSQLEnv = metadataSQLEnv;
090        if(metadataSQLEnv!=null) {
091                this.setDefaultServerName(metadataSQLEnv.getDefaultServerName());
092        }
093    }
094
095    @Override
096    public void initSQLEnv() {
097        synchronized (this) {
098            if (sql == null || init)
099                return;
100                        TGSqlParser sqlparser = new TGSqlParser(getDBVendor());
101                        try {
102                                sqlparser.setSqlEnv(metadataSQLEnv);
103                                sqlparser.sqltext = sql;
104                                sqlparser.parse();
105                        } catch (Exception e) {
106                                // Parse failure - log and continue with whatever statements were parsed
107                        }
108            List<TCustomSqlStatement> stmts = new ArrayList<TCustomSqlStatement>();
109            if (sqlparser.sqlstatements != null) {
110                for (int j = 0; j < sqlparser.sqlstatements.size(); j++) {
111                    TCustomSqlStatement stmt = sqlparser.sqlstatements.get(j);
112                    extractDDLStmts(stmts, stmt);
113                }
114            }
115
116            if (!stmts.isEmpty()) {
117                for (int j = 0; j < stmts.size(); j++) {
118                    TCustomSqlStatement stmt = stmts.get(j);
119                    analyzeSQLEnv(stmt);
120                }
121                init = true;
122            }
123            stmts.clear();
124            sql = null;
125        }
126    }
127
128    private void extractDDLStmts(List<TCustomSqlStatement> stmts, TCustomSqlStatement stmt) {
129        if (stmt instanceof TUseDatabase || stmt instanceof TCreateSchemaSqlStatement
130                || stmt instanceof TCreateTableSqlStatement || stmt instanceof TMssqlDeclare
131                || stmt instanceof TStoredProcedureSqlStatement
132                || (stmt instanceof TMssqlCreateFunction
133                && ((TMssqlCreateFunction) stmt).getReturnTableDefinitions() != null)) {
134            stmts.add(stmt);
135        } else if (stmt instanceof TCreateViewSqlStatement) {
136            stmts.add(stmt);
137        } else if (stmt instanceof TCreateSynonymStmt) {
138            stmts.add(stmt);
139        } else if (stmt.getStatements() != null && stmt.getStatements().size() > 0) {
140            for (int i = 0; i < stmt.getStatements().size(); i++) {
141                extractDDLStmts(stmts, stmt.getStatements().get(i));
142            }
143        }
144    }
145
146    private void analyzeSQLEnv(TCustomSqlStatement stmt) {
147        stmtStack.push(stmt);
148        if (stmt instanceof TUseDatabase) {
149            TUseDatabase useDatabase = (TUseDatabase) stmt;
150            analyzeUseDatabase(useDatabase);
151        } else if (stmt instanceof TMssqlDeclare) {
152            TMssqlDeclare declare = (TMssqlDeclare) stmt;
153            analyzeMssqlDeclare(declare);
154        } else if (stmt instanceof TMssqlCreateFunction) {
155            TMssqlCreateFunction createFunction = (TMssqlCreateFunction) stmt;
156            analyzeMssqlCreateFunction(createFunction);
157        } else if (stmt instanceof TCreateSchemaSqlStatement) {
158            TCreateSchemaSqlStatement createSchema = (TCreateSchemaSqlStatement) stmt;
159            analyzeCreateSchema(createSchema);
160        } else if (stmt instanceof TCreateTableSqlStatement) {
161            TCreateTableSqlStatement createTable = (TCreateTableSqlStatement) stmt;
162            analyzeCreateTable(createTable);
163        } else if (stmt instanceof TCreateViewSqlStatement) {
164            TCreateViewSqlStatement createView = (TCreateViewSqlStatement) stmt;
165            analyzeCreateView(createView);
166        } else if (stmt instanceof TCreateSynonymStmt) {
167            TCreateSynonymStmt createSynonym = (TCreateSynonymStmt) stmt;
168            analyzeCreateSynonym(createSynonym);
169        } else if (stmt instanceof TStoredProcedureSqlStatement) {
170            TStoredProcedureSqlStatement procedure = (TStoredProcedureSqlStatement) stmt;
171            analyzeStoredProcedureStmt(procedure);
172        }
173        stmtStack.pop();
174    }
175
176    private void analyzeStoredProcedureStmt(TStoredProcedureSqlStatement procedure) {
177        if (procedure instanceof TPlsqlCreatePackage) {
178            analyzeProcedure(procedure, ESQLDataObjectType.dotOraclePackage);
179            return;
180        }
181        if (procedure instanceof TCreateTriggerStmt) {
182            analyzeProcedure(procedure, ESQLDataObjectType.dotTrigger);
183            return;
184        }
185        if (procedure instanceof TCreateFunctionStmt) {
186            analyzeProcedure(procedure, ESQLDataObjectType.dotFunction);
187            return;
188        }
189        if (procedure instanceof TCreateProcedureStmt) {
190            analyzeProcedure(procedure, ESQLDataObjectType.dotProcedure);
191            return;
192        }
193    }
194
195    private void analyzeProcedure(TStoredProcedureSqlStatement procedure, ESQLDataObjectType type) {
196        TObjectName procedureName = getProcedureName(procedure);
197        if(procedureName == null){
198            return;
199        }
200        TSQLRoutine sqlProcedure = addSQLRoutineToSQLEnv(procedureName, type);
201        sqlProcedure.setDefinition(procedure.toString());
202        
203        if(procedure instanceof TPlsqlCreatePackage) {
204                TPlsqlCreatePackage oraclePackage = (TPlsqlCreatePackage)procedure;
205                if (oraclePackage.getDeclareStatements() != null) {
206                                for (int i = 0; i < oraclePackage.getDeclareStatements().size(); ++i) {
207                                        TCustomSqlStatement stmt = oraclePackage.getDeclareStatements().get(i);
208                                        if (stmt instanceof TPlsqlCreateTrigger) {
209                                                analyzePackageProcedure((TSQLOraclePackage) sqlProcedure, (TStoredProcedureSqlStatement)stmt,
210                                                                ESQLDataObjectType.dotTrigger);
211                                        }
212                                        if (stmt instanceof TPlsqlCreateFunction) {
213                                                analyzePackageProcedure((TSQLOraclePackage) sqlProcedure, (TStoredProcedureSqlStatement)stmt,
214                                                                ESQLDataObjectType.dotFunction);
215                                        }
216                                        if (stmt instanceof TPlsqlCreateProcedure) {
217                                                analyzePackageProcedure((TSQLOraclePackage) sqlProcedure, (TStoredProcedureSqlStatement)stmt,
218                                                                ESQLDataObjectType.dotProcedure);
219                                        }
220                                }
221                        }
222        }
223    }
224    
225    private void analyzePackageProcedure(TSQLOraclePackage oraclePackage, TStoredProcedureSqlStatement procedure, ESQLDataObjectType type) {
226        TObjectName procedureName = getProcedureName(procedure);
227        if(procedureName == null){
228            return;
229        }
230                TSQLProcedure object = (TSQLProcedure) oraclePackage
231                                .createSchemaObject(getQualifiedTableName(procedureName), type);
232        object.setDefinition(procedure.toString());
233    }
234
235
236    private TObjectName getProcedureName(TParseTreeNode procedureObject) {
237        if(procedureObject instanceof TTeradataCreateProcedure)
238        {
239            return ((TTeradataCreateProcedure)procedureObject).getProcedureName();
240        }
241        if(procedureObject instanceof TStoredProcedureSqlStatement)
242        {
243            return ((TStoredProcedureSqlStatement)procedureObject).getStoredProcedureName();
244        }
245        if(procedureObject instanceof TFunctionCall)
246        {
247            return ((TFunctionCall)procedureObject).getFunctionName();
248        }
249        return null;
250    }
251
252    private void analyzeCreateTable(TCreateTableSqlStatement createTable) {
253        if (createTable.getTables() != null && createTable.getTables().size() > 0) {
254            if (createTable.getColumnList() != null && createTable.getColumnList().size() > 0) {
255                TObjectName tableName = createTable.getTableName();
256                TSQLTable table = addTableToSQLEnv(tableName);
257                for (int i = 0; i < createTable.getColumnList().size(); i++) {
258                    TColumnDefinition column = createTable.getColumnList().getColumn(i);
259                    if (column != null && column.getColumnName() != null) {
260                        TObjectName columnName = column.getColumnName();
261                        addTableColumnToSQLEnv(table, columnName, column.getDatatype());
262                    }
263                }
264                table.setPriority(2);
265            } else if (createTable.getSubQuery() != null && createTable.getSubQuery().getResultColumnList() != null) {
266                if(createTable.getSubQuery().getResultColumnList().toString().indexOf("*") != -1) {
267                        return;
268                }
269                TSQLTable table = addTableToSQLEnv(createTable.getTargetTable().getTableName());
270                if (table.getColumns(true) == null || table.getColumns(true).isEmpty()) {
271                    for (int i = 0; i < createTable.getSubQuery().getResultColumnList().size(); i++) {
272                        TResultColumn resultColumn = createTable.getSubQuery().getResultColumnList().getResultColumn(i);
273                        addTableColumnToSQLEnv(table, getObjectName(resultColumn));
274                    }
275                }
276            }
277        }
278    }
279
280    private void analyzeCreateView(TCreateViewSqlStatement createView) {
281        if (createView.getViewName() != null) {
282            if (createView.getViewAliasClause() != null) {
283                TSQLTable table = addTableToSQLEnv(createView.getViewName());
284                table.setView(true);
285                for (int i = 0; i < createView.getViewAliasClause().getViewAliasItemList().size(); i++) {
286                    TViewAliasItem column = createView.getViewAliasClause().getViewAliasItemList().getViewAliasItem(i);
287                    if (column != null && column.getAlias() != null) {
288                        TObjectName columnName = column.getAlias();
289                        addTableColumnToSQLEnv(table, columnName);
290                    }
291                }
292                table.setPriority(2);
293            } else if (createView.getSubquery().getResultColumnList() != null) {
294                if(createView.getSubquery().getResultColumnList().toString().indexOf("*") != -1) {
295                        return;
296                }
297                                TSQLTable table = addTableToSQLEnv(createView.getViewName());
298                                table.setView(true);
299                                for (int i = 0; i < createView.getSubquery().getResultColumnList().size(); i++) {
300                                        TResultColumn resultColumn = createView.getSubquery().getResultColumnList().getResultColumn(i);
301                                        addTableColumnToSQLEnv(table, getObjectName(resultColumn));
302                                }
303            }
304        }
305    }
306
307    private void analyzeCreateSynonym(TCreateSynonymStmt createSynonym) {
308        TObjectName synonymName = createSynonym.getSynonymName();
309        TObjectName forName = createSynonym.getForName();
310        if (synonymName == null || forName == null) {
311            return;
312        }
313        // Register the synonym as a table alias pointing to the target object.
314        TSQLTable synonymTable = addTableToSQLEnv(synonymName);
315        if (synonymTable == null) {
316            return;
317        }
318        // Try to resolve the target object so that the synonym can inherit its columns.
319        TSQLTable targetTable = searchTable(buildFullyQualifiedTableName(forName));
320        if (targetTable == null) {
321            targetTable = searchTable(forName);
322        }
323        if (targetTable == null && metadataSQLEnv != null) {
324            targetTable = metadataSQLEnv.searchTable(forName);
325        }
326        if (targetTable != null) {
327            if (targetTable.isView()) {
328                synonymTable.setView(true);
329            }
330            List<String> columns = targetTable.getColumns(true);
331            if (columns != null) {
332                for (int i = 0; i < columns.size(); i++) {
333                    String column = columns.get(i);
334                    if (!SQLUtil.isEmpty(column)) {
335                        synonymTable.addColumn(column);
336                    }
337                }
338            }
339            synonymTable.setPriority(2);
340        }
341    }
342
343    private TObjectName getObjectName(TResultColumn resultColumn) {
344        if (resultColumn.getAliasClause() != null && resultColumn.getAliasClause().getAliasName() != null) {
345            return resultColumn.getAliasClause().getAliasName();
346        }
347        if (resultColumn.getFieldAttr() != null) {
348            return resultColumn.getFieldAttr();
349        }
350        if (resultColumn.getExpr() != null
351                && resultColumn.getExpr().getExpressionType() == EExpressionType.simple_object_name_t) {
352            return resultColumn.getExpr().getObjectOperand();
353        } else if (!SQLUtil.isEmpty(resultColumn.getColumnNameOnly())) {
354            TObjectName objectName = new TObjectName();
355            objectName.setString(resultColumn.getColumnNameOnly());
356            return objectName;
357        } else {
358            return null;
359        }
360    }
361
362    private void analyzeUseDatabase(TUseDatabase useDatabase) {
363        TObjectName databaseName = useDatabase.getDatabaseName();
364
365        if (databaseName == null) {
366            return;
367        }
368
369        String qualifiedSchemaName = databaseName.toString();
370        if (getNumberOfPart(databaseName) == 1) {
371            qualifiedSchemaName = getCurrentDatabaseName() + "." + qualifiedSchemaName;
372        }
373        if (getSQLSchema(qualifiedSchemaName, false) != null) {
374            globalSchema = databaseName.toString();
375        } else {
376            String catalogName = databaseName.toString();
377            getSQLCatalog(catalogName, true);
378            globalDatabase = catalogName;
379        }
380    }
381
382    private int getNumberOfPart(TObjectName name) {
383        return SQLUtil.parseNames(name.toString()).size();
384    }
385
386    private int getNumberOfPart(String tableName) {
387        return SQLUtil.parseNames(tableName).size();
388    }
389
390    private void analyzeCreateSchema(TCreateSchemaSqlStatement createSchema) {
391        TObjectName schemaName = createSchema.getSchemaName();
392        if (schemaName != null) {
393            String qualifiedSchemaName = schemaName.toString();
394            if (getNumberOfPart(schemaName) == 1) {
395                qualifiedSchemaName = getCurrentDatabaseName() + "." + qualifiedSchemaName;
396            }
397            getSQLSchema(qualifiedSchemaName, true);
398        }
399    }
400
401    private String getCurrentDatabaseName() {
402        Pair3<String, String, String> info = fillSchemaInfo();
403        if(!SQLUtil.isEmpty(info.second)) {
404                return info.second;
405        }
406        if (!SQLUtil.isEmpty(globalDatabase)) {
407            return globalDatabase;
408        } else if (!SQLUtil.isEmpty(getDefaultCatalogName())) {
409            return getDefaultCatalogName();
410        } else
411            getSQLCatalog(DEFAULT_DB_NAME, true);
412        return DEFAULT_DB_NAME;
413    }
414
415    private String getCurrentSchemaName() {
416        Pair3<String, String, String> info = fillSchemaInfo();
417        if(!SQLUtil.isEmpty(info.third)) {
418                return info.third;
419        }
420        if (!SQLUtil.isEmpty(globalSchema)) {
421            return globalSchema;
422        } else if (!SQLUtil.isEmpty(getDefaultSchemaName())) {
423            return getDefaultSchemaName();
424        } else
425            return DEFAULT_SCHEMA_NAME;
426    }
427    
428        private Pair3<String, String, String> fillSchemaInfo() {
429                String server = null;
430                String database = null;
431                String schema = null;
432
433                TCustomSqlStatement stmt = DlineageUtil.getTopStmt(stmtStack.peek());
434                String sqlComment = null;
435                try {
436                        sqlComment = stmt.getCommentBeforeNode();
437                } catch (Exception e) {
438                        // e.printStackTrace();
439                }
440                if (!SQLUtil.isEmpty(sqlComment) && (sqlComment.indexOf("db") != -1 || sqlComment.indexOf("schema") != -1)) {
441                        Properties properties = new Properties();
442                        try {
443                                properties.load(
444                                                new ByteArrayInputStream(sqlComment.replace("--", "").trim().replace(",", "\n").getBytes()));
445                                if (SQLUtil.isEmpty(server) && properties.containsKey("db-instance")) {
446                                        server = properties.getProperty("db-instance");
447                                        if (!SQLUtil.isEmpty(server) && !server.equals(TSQLEnv.DEFAULT_SERVER_NAME)) {
448                                                if (SQLUtil.isEmpty(this.getDefaultServerName())
449                                                                || this.getDefaultServerName().equals(TSQLEnv.DEFAULT_SERVER_NAME)) {
450                                                        this.setDefaultServerName(server);
451                                                }
452                                        }
453                                }
454                                if (SQLUtil.isEmpty(database) && properties.containsKey("db")) {
455                                        database = properties.getProperty("db");
456                                        if (database.indexOf(".") != -1) {
457                                                String delimitedChar = TSQLEnv.delimitedChar(getDBVendor());
458                                                database = delimitedChar + SQLUtil.trimColumnStringQuote(database) + delimitedChar;
459                                        }
460                                }
461                                if (SQLUtil.isEmpty(schema) && properties.containsKey("schema")) {
462                                        schema = properties.getProperty("schema");
463                                        if (schema.indexOf(".") != -1) {
464                                                String delimitedChar = TSQLEnv.delimitedChar(getDBVendor());
465                                                schema = delimitedChar + SQLUtil.trimColumnStringQuote(schema) + delimitedChar;
466                                        }
467                                }
468                        } catch (IOException e) {
469                                e.printStackTrace();
470                        }
471                }
472
473                Pair3<String, String, String> info = new Pair3<String, String, String>(server, database, schema);
474                return info;
475        }
476
477
478    private void analyzeMssqlCreateFunction(TMssqlCreateFunction createFunction) {
479        if (createFunction.getReturnTableVaraible() != null && createFunction.getReturnTableDefinitions() != null) {
480            TObjectName tableName = createFunction.getReturnTableVaraible();
481            TSQLTable table = addTableToSQLEnv(tableName);
482
483            for (int j = 0; j < createFunction.getReturnTableDefinitions().size(); j++) {
484                TTableElement tableElement = createFunction.getReturnTableDefinitions().getTableElement(j);
485                TColumnDefinition column = tableElement.getColumnDefinition();
486                if (column != null && column.getColumnName() != null) {
487                    TObjectName columnName = column.getColumnName();
488                    addTableColumnToSQLEnv(table, columnName);
489                }
490            }
491        }
492    }
493
494    private void addTableColumnToSQLEnv(TSQLTable table, TObjectName columnName) {
495        if (columnName == null) {
496            return;
497        }
498        String column = columnName.getColumnNameOnly();
499        if (!SQLUtil.isEmpty(column)) {
500            table.addColumn(column);
501        } else {
502            column = columnName.toString();
503            if (column.indexOf(".") != -1) {
504                List<String> splits = SQLUtil.parseNames(column);
505                column = splits.get(splits.size() - 1);
506            }
507            table.addColumn(column);
508        }
509    }
510    
511    private void addTableColumnToSQLEnv(TSQLTable table, TObjectName columnName, TTypeName dataType) {
512        if(columnName == null){
513            return;
514        }
515        String column = columnName.getColumnNameOnly();
516        if (!SQLUtil.isEmpty(column)) {
517            table.addColumn(column, dataType);
518        } else {
519            column = columnName.toString();
520            if (column.indexOf(".") != -1) {
521                List<String> splits = SQLUtil.parseNames(column);
522                column = splits.get(splits.size() - 1);
523            }
524            table.addColumn(column, dataType);
525        }
526    }
527
528    private TSQLTable addTableToSQLEnv(TObjectName tableName) {
529        return addTable(buildFullyQualifiedTableName(tableName), true);
530    }
531
532    private String buildFullyQualifiedTableName(TObjectName tableName) {
533        String qualifiedTableName = getQualifiedTableName(tableName);
534        if (getNumberOfPart(qualifiedTableName) == 1) {
535            if(!TSQLEnv.supportSchema(getDBVendor())){
536                qualifiedTableName = TSQLEnv.DEFAULT_DB_NAME + "." + getCurrentDatabaseName() + "." + qualifiedTableName;
537            }
538            else {
539                qualifiedTableName = getCurrentDatabaseName() + "." + getCurrentSchemaName() + "." + qualifiedTableName;
540            }
541        } else if (getNumberOfPart(qualifiedTableName) == 2) {
542            if(!TSQLEnv.supportSchema(getDBVendor())){
543                qualifiedTableName = TSQLEnv.DEFAULT_DB_NAME + "." + qualifiedTableName;
544            }
545            else {
546                qualifiedTableName = getCurrentDatabaseName() + "." + qualifiedTableName;
547            }
548        }
549        return qualifiedTableName;
550    }
551
552    private TSQLRoutine addSQLRoutineToSQLEnv(TObjectName procedureName, ESQLDataObjectType type) {
553        String qualifiedProcedureName = getQualifiedTableName(procedureName);
554        if (getNumberOfPart(qualifiedProcedureName) == 1) {
555            if(!TSQLEnv.supportSchema(getDBVendor())){
556                qualifiedProcedureName = TSQLEnv.DEFAULT_DB_NAME + "." + getCurrentDatabaseName() + "." + qualifiedProcedureName;
557            }
558            else {
559                qualifiedProcedureName = getCurrentDatabaseName() + "." + getCurrentSchemaName() + "." + qualifiedProcedureName;
560            }
561        } else if (getNumberOfPart(qualifiedProcedureName) == 2) {
562            if(!TSQLEnv.supportSchema(getDBVendor())){
563                qualifiedProcedureName = TSQLEnv.DEFAULT_DB_NAME + "." + qualifiedProcedureName;
564            }
565            else {
566                qualifiedProcedureName = getCurrentDatabaseName() + "." + qualifiedProcedureName;
567            }
568        }
569        return addSQLRoutine(qualifiedProcedureName, true, type);
570    }
571
572    private String getQualifiedTableName(TObjectName table) {
573        String tableName = table.toString();
574        if (metadataSQLEnv == null) {
575            return tableName;
576        }
577        List<String> segments = SQLUtil.parseNames(tableName);
578        if (segments.size() > 2) {
579            return tableName;
580        }
581        String schemaName = null;
582        if (segments.size() > 1) {
583            schemaName = segments.get(segments.size() - 2);
584        }
585        int occurrence = 0;
586        int maxPriority = -1;
587        String tableDatabase = null;
588        String tableSchema = null;
589        String simpleTableName = DlineageUtil.getSimpleTableName(tableName);
590        for (TSQLCatalog catalog : metadataSQLEnv.getCatalogList()) {
591            if (SQLUtil.isEmpty(schemaName)) {
592                for (TSQLSchema schema : catalog.getSchemaList()) {
593                    TSQLTable tsqlTable = schema.findTable(simpleTableName);
594                    if (tsqlTable != null) {
595                        occurrence += 1;
596                        if (tsqlTable.getPriority() > maxPriority) {
597                            tableDatabase = catalog.getName();
598                            tableSchema = schema.getName();
599                            maxPriority = tsqlTable.getPriority();
600                        }
601                    }
602                }
603                if (occurrence > 1) {
604                    break;
605                }
606            } else {
607                TSQLSchema schema = catalog.getSchema(schemaName, false);
608                if (schema != null) {
609                    TSQLTable tsqlTable = schema.findTable(simpleTableName);
610                    if (tsqlTable != null) {
611                        occurrence += 1;
612                        if (tsqlTable.getPriority() > maxPriority) {
613                            tableDatabase = catalog.getName();
614                            tableSchema = schema.getName();
615                            maxPriority = tsqlTable.getPriority();
616                        }
617                    }
618                }
619            }
620        }
621        if (occurrence == 1 || maxPriority > 0) {
622            StringBuilder qualifiedTableName = new StringBuilder();
623            if (tableDatabase != null && !TSQLEnv.DEFAULT_DB_NAME.equalsIgnoreCase(tableDatabase)) {
624                qualifiedTableName.append(tableDatabase).append(".");
625            }
626            if (tableSchema != null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(tableSchema)) {
627                qualifiedTableName.append(tableSchema).append(".");
628            }
629            return qualifiedTableName.append(simpleTableName).toString();
630        }
631        return tableName;
632    }
633
634    private void analyzeMssqlDeclare(TMssqlDeclare declare) {
635        TDeclareVariableList variables = declare.getVariables();
636        if (variables == null) {
637            return;
638        }
639        for (int i = 0; i < variables.size(); i++) {
640            TDeclareVariable variable = variables.getDeclareVariable(i);
641            if (variable.getTableTypeDefinitions() == null || variable.getTableTypeDefinitions().size() == 0) {
642                continue;
643            }
644
645            TObjectName tableName = variable.getVariableName();
646            TSQLTable table = addTableToSQLEnv(tableName);
647
648            TTableElementList columns = variable.getTableTypeDefinitions();
649            for (int j = 0; j < columns.size(); j++) {
650                TTableElement tableElement = columns.getTableElement(j);
651                TColumnDefinition column = tableElement.getColumnDefinition();
652                if (column != null && column.getColumnName() != null) {
653                    TObjectName columnName = column.getColumnName();
654                    addTableColumnToSQLEnv(table, columnName);
655                }
656            }
657        }
658    }
659
660    public static void main(String[] args) {
661                TSQLEnv sqlenv = new TDDLSQLEnv("deawirddap001", "mio", "public", EDbVendor.dbvredshift, SQLUtil.getFileContent("C:\\Users\\KK\\Desktop\\ddl.sql"));
662                sqlenv.initSQLEnv();
663                System.out.println(sqlenv.toString());
664    }
665}