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