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        if (!isEnableGetMetadataFromDDL()) {
314            return;
315        }
316        String qualifiedSynonymName = buildFullyQualifiedTableName(synonymName);
317        TSQLSchemaObject schemaObject = doAddSchemaObject(qualifiedSynonymName, ESQLDataObjectType.dotSynonyms);
318        if (!(schemaObject instanceof TSQLSynonyms)) {
319            return;
320        }
321        TSQLSynonyms synonym = (TSQLSynonyms) schemaObject;
322        synonym.setBaseTarget(
323                TSQLEnv.getDatabaseName(forName),
324                TSQLEnv.getSchemaName(forName),
325                TSQLEnv.getObjectName(forName));
326        synonym.setPriority(2);
327    }
328
329    private TObjectName getObjectName(TResultColumn resultColumn) {
330        if (resultColumn.getAliasClause() != null && resultColumn.getAliasClause().getAliasName() != null) {
331            return resultColumn.getAliasClause().getAliasName();
332        }
333        if (resultColumn.getFieldAttr() != null) {
334            return resultColumn.getFieldAttr();
335        }
336        if (resultColumn.getExpr() != null
337                && resultColumn.getExpr().getExpressionType() == EExpressionType.simple_object_name_t) {
338            return resultColumn.getExpr().getObjectOperand();
339        } else if (!SQLUtil.isEmpty(resultColumn.getColumnNameOnly())) {
340            TObjectName objectName = new TObjectName();
341            objectName.setString(resultColumn.getColumnNameOnly());
342            return objectName;
343        } else {
344            return null;
345        }
346    }
347
348    private void analyzeUseDatabase(TUseDatabase useDatabase) {
349        TObjectName databaseName = useDatabase.getDatabaseName();
350
351        if (databaseName == null) {
352            return;
353        }
354
355        String qualifiedSchemaName = databaseName.toString();
356        if (getNumberOfPart(databaseName) == 1) {
357            qualifiedSchemaName = getCurrentDatabaseName() + "." + qualifiedSchemaName;
358        }
359        if (getSQLSchema(qualifiedSchemaName, false) != null) {
360            globalSchema = databaseName.toString();
361        } else {
362            String catalogName = databaseName.toString();
363            getSQLCatalog(catalogName, true);
364            globalDatabase = catalogName;
365        }
366    }
367
368    private int getNumberOfPart(TObjectName name) {
369        return SQLUtil.parseNames(name.toString()).size();
370    }
371
372    private int getNumberOfPart(String tableName) {
373        return SQLUtil.parseNames(tableName).size();
374    }
375
376    private void analyzeCreateSchema(TCreateSchemaSqlStatement createSchema) {
377        TObjectName schemaName = createSchema.getSchemaName();
378        if (schemaName != null) {
379            String qualifiedSchemaName = schemaName.toString();
380            if (getNumberOfPart(schemaName) == 1) {
381                qualifiedSchemaName = getCurrentDatabaseName() + "." + qualifiedSchemaName;
382            }
383            getSQLSchema(qualifiedSchemaName, true);
384        }
385    }
386
387    private String getCurrentDatabaseName() {
388        Pair3<String, String, String> info = fillSchemaInfo();
389        if(!SQLUtil.isEmpty(info.second)) {
390                return info.second;
391        }
392        if (!SQLUtil.isEmpty(globalDatabase)) {
393            return globalDatabase;
394        } else if (!SQLUtil.isEmpty(getDefaultCatalogName())) {
395            return getDefaultCatalogName();
396        } else
397            getSQLCatalog(DEFAULT_DB_NAME, true);
398        return DEFAULT_DB_NAME;
399    }
400
401    private String getCurrentSchemaName() {
402        Pair3<String, String, String> info = fillSchemaInfo();
403        if(!SQLUtil.isEmpty(info.third)) {
404                return info.third;
405        }
406        if (!SQLUtil.isEmpty(globalSchema)) {
407            return globalSchema;
408        } else if (!SQLUtil.isEmpty(getDefaultSchemaName())) {
409            return getDefaultSchemaName();
410        } else
411            return DEFAULT_SCHEMA_NAME;
412    }
413    
414        private Pair3<String, String, String> fillSchemaInfo() {
415                String server = null;
416                String database = null;
417                String schema = null;
418
419                TCustomSqlStatement stmt = DlineageUtil.getTopStmt(stmtStack.peek());
420                String sqlComment = null;
421                try {
422                        sqlComment = stmt.getCommentBeforeNode();
423                } catch (Exception e) {
424                        // e.printStackTrace();
425                }
426                if (!SQLUtil.isEmpty(sqlComment) && (sqlComment.indexOf("db") != -1 || sqlComment.indexOf("schema") != -1)) {
427                        Properties properties = new Properties();
428                        try {
429                                properties.load(
430                                                new ByteArrayInputStream(sqlComment.replace("--", "").trim().replace(",", "\n").getBytes()));
431                                if (SQLUtil.isEmpty(server) && properties.containsKey("db-instance")) {
432                                        server = properties.getProperty("db-instance");
433                                        if (!SQLUtil.isEmpty(server) && !server.equals(TSQLEnv.DEFAULT_SERVER_NAME)) {
434                                                if (SQLUtil.isEmpty(this.getDefaultServerName())
435                                                                || this.getDefaultServerName().equals(TSQLEnv.DEFAULT_SERVER_NAME)) {
436                                                        this.setDefaultServerName(server);
437                                                }
438                                        }
439                                }
440                                if (SQLUtil.isEmpty(database) && properties.containsKey("db")) {
441                                        database = properties.getProperty("db");
442                                        if (database.indexOf(".") != -1) {
443                                                String delimitedChar = TSQLEnv.delimitedChar(getDBVendor());
444                                                database = delimitedChar + SQLUtil.trimColumnStringQuote(database) + delimitedChar;
445                                        }
446                                }
447                                if (SQLUtil.isEmpty(schema) && properties.containsKey("schema")) {
448                                        schema = properties.getProperty("schema");
449                                        if (schema.indexOf(".") != -1) {
450                                                String delimitedChar = TSQLEnv.delimitedChar(getDBVendor());
451                                                schema = delimitedChar + SQLUtil.trimColumnStringQuote(schema) + delimitedChar;
452                                        }
453                                }
454                        } catch (IOException e) {
455                                e.printStackTrace();
456                        }
457                }
458
459                Pair3<String, String, String> info = new Pair3<String, String, String>(server, database, schema);
460                return info;
461        }
462
463
464    private void analyzeMssqlCreateFunction(TMssqlCreateFunction createFunction) {
465        if (createFunction.getReturnTableVaraible() != null && createFunction.getReturnTableDefinitions() != null) {
466            TObjectName tableName = createFunction.getReturnTableVaraible();
467            TSQLTable table = addTableToSQLEnv(tableName);
468
469            for (int j = 0; j < createFunction.getReturnTableDefinitions().size(); j++) {
470                TTableElement tableElement = createFunction.getReturnTableDefinitions().getTableElement(j);
471                TColumnDefinition column = tableElement.getColumnDefinition();
472                if (column != null && column.getColumnName() != null) {
473                    TObjectName columnName = column.getColumnName();
474                    addTableColumnToSQLEnv(table, columnName);
475                }
476            }
477        }
478    }
479
480    private void addTableColumnToSQLEnv(TSQLTable table, TObjectName columnName) {
481        if (columnName == null) {
482            return;
483        }
484        String column = columnName.getColumnNameOnly();
485        if (!SQLUtil.isEmpty(column)) {
486            table.addColumn(column);
487        } else {
488            column = columnName.toString();
489            if (column.indexOf(".") != -1) {
490                List<String> splits = SQLUtil.parseNames(column);
491                column = splits.get(splits.size() - 1);
492            }
493            table.addColumn(column);
494        }
495    }
496    
497    private void addTableColumnToSQLEnv(TSQLTable table, TObjectName columnName, TTypeName dataType) {
498        if(columnName == null){
499            return;
500        }
501        String column = columnName.getColumnNameOnly();
502        if (!SQLUtil.isEmpty(column)) {
503            table.addColumn(column, dataType);
504        } else {
505            column = columnName.toString();
506            if (column.indexOf(".") != -1) {
507                List<String> splits = SQLUtil.parseNames(column);
508                column = splits.get(splits.size() - 1);
509            }
510            table.addColumn(column, dataType);
511        }
512    }
513
514    private TSQLTable addTableToSQLEnv(TObjectName tableName) {
515        return addTable(buildFullyQualifiedTableName(tableName), true);
516    }
517
518    private String buildFullyQualifiedTableName(TObjectName tableName) {
519        String qualifiedTableName = getQualifiedTableName(tableName);
520        if (getNumberOfPart(qualifiedTableName) == 1) {
521            if(!TSQLEnv.supportSchema(getDBVendor())){
522                qualifiedTableName = TSQLEnv.DEFAULT_DB_NAME + "." + getCurrentDatabaseName() + "." + qualifiedTableName;
523            }
524            else {
525                qualifiedTableName = getCurrentDatabaseName() + "." + getCurrentSchemaName() + "." + qualifiedTableName;
526            }
527        } else if (getNumberOfPart(qualifiedTableName) == 2) {
528            if(!TSQLEnv.supportSchema(getDBVendor())){
529                qualifiedTableName = TSQLEnv.DEFAULT_DB_NAME + "." + qualifiedTableName;
530            }
531            else {
532                qualifiedTableName = getCurrentDatabaseName() + "." + qualifiedTableName;
533            }
534        }
535        return qualifiedTableName;
536    }
537
538    private TSQLRoutine addSQLRoutineToSQLEnv(TObjectName procedureName, ESQLDataObjectType type) {
539        String qualifiedProcedureName = getQualifiedTableName(procedureName);
540        if (getNumberOfPart(qualifiedProcedureName) == 1) {
541            if(!TSQLEnv.supportSchema(getDBVendor())){
542                qualifiedProcedureName = TSQLEnv.DEFAULT_DB_NAME + "." + getCurrentDatabaseName() + "." + qualifiedProcedureName;
543            }
544            else {
545                qualifiedProcedureName = getCurrentDatabaseName() + "." + getCurrentSchemaName() + "." + qualifiedProcedureName;
546            }
547        } else if (getNumberOfPart(qualifiedProcedureName) == 2) {
548            if(!TSQLEnv.supportSchema(getDBVendor())){
549                qualifiedProcedureName = TSQLEnv.DEFAULT_DB_NAME + "." + qualifiedProcedureName;
550            }
551            else {
552                qualifiedProcedureName = getCurrentDatabaseName() + "." + qualifiedProcedureName;
553            }
554        }
555        return addSQLRoutine(qualifiedProcedureName, true, type);
556    }
557
558    private String getQualifiedTableName(TObjectName table) {
559        String tableName = table.toString();
560        if (metadataSQLEnv == null) {
561            return tableName;
562        }
563        List<String> segments = SQLUtil.parseNames(tableName);
564        if (segments.size() > 2) {
565            return tableName;
566        }
567        String schemaName = null;
568        if (segments.size() > 1) {
569            schemaName = segments.get(segments.size() - 2);
570        }
571        int occurrence = 0;
572        int maxPriority = -1;
573        String tableDatabase = null;
574        String tableSchema = null;
575        String simpleTableName = DlineageUtil.getSimpleTableName(tableName);
576        for (TSQLCatalog catalog : metadataSQLEnv.getCatalogList()) {
577            if (SQLUtil.isEmpty(schemaName)) {
578                for (TSQLSchema schema : catalog.getSchemaList()) {
579                    TSQLTable tsqlTable = schema.findTable(simpleTableName);
580                    if (tsqlTable != null) {
581                        occurrence += 1;
582                        if (tsqlTable.getPriority() > maxPriority) {
583                            tableDatabase = catalog.getName();
584                            tableSchema = schema.getName();
585                            maxPriority = tsqlTable.getPriority();
586                        }
587                    }
588                }
589                if (occurrence > 1) {
590                    break;
591                }
592            } else {
593                TSQLSchema schema = catalog.getSchema(schemaName, false);
594                if (schema != null) {
595                    TSQLTable tsqlTable = schema.findTable(simpleTableName);
596                    if (tsqlTable != null) {
597                        occurrence += 1;
598                        if (tsqlTable.getPriority() > maxPriority) {
599                            tableDatabase = catalog.getName();
600                            tableSchema = schema.getName();
601                            maxPriority = tsqlTable.getPriority();
602                        }
603                    }
604                }
605            }
606        }
607        if (occurrence == 1 || maxPriority > 0) {
608            StringBuilder qualifiedTableName = new StringBuilder();
609            if (tableDatabase != null && !TSQLEnv.DEFAULT_DB_NAME.equalsIgnoreCase(tableDatabase)) {
610                qualifiedTableName.append(tableDatabase).append(".");
611            }
612            if (tableSchema != null && !TSQLEnv.DEFAULT_SCHEMA_NAME.equalsIgnoreCase(tableSchema)) {
613                qualifiedTableName.append(tableSchema).append(".");
614            }
615            return qualifiedTableName.append(simpleTableName).toString();
616        }
617        return tableName;
618    }
619
620    private void analyzeMssqlDeclare(TMssqlDeclare declare) {
621        TDeclareVariableList variables = declare.getVariables();
622        if (variables == null) {
623            return;
624        }
625        for (int i = 0; i < variables.size(); i++) {
626            TDeclareVariable variable = variables.getDeclareVariable(i);
627            if (variable.getTableTypeDefinitions() == null || variable.getTableTypeDefinitions().size() == 0) {
628                continue;
629            }
630
631            TObjectName tableName = variable.getVariableName();
632            TSQLTable table = addTableToSQLEnv(tableName);
633
634            TTableElementList columns = variable.getTableTypeDefinitions();
635            for (int j = 0; j < columns.size(); j++) {
636                TTableElement tableElement = columns.getTableElement(j);
637                TColumnDefinition column = tableElement.getColumnDefinition();
638                if (column != null && column.getColumnName() != null) {
639                    TObjectName columnName = column.getColumnName();
640                    addTableColumnToSQLEnv(table, columnName);
641                }
642            }
643        }
644    }
645
646    public static void main(String[] args) {
647                TSQLEnv sqlenv = new TDDLSQLEnv("deawirddap001", "mio", "public", EDbVendor.dbvredshift, SQLUtil.getFileContent("C:\\Users\\KK\\Desktop\\ddl.sql"));
648                sqlenv.initSQLEnv();
649                System.out.println(sqlenv.toString());
650    }
651}