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