Source code

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