001package gudusoft.gsqlparser.sqlenv.parser.sqlflow;
002
003import gudusoft.gsqlparser.EDbVendor;
004import gudusoft.gsqlparser.sqlenv.*;
005import gudusoft.gsqlparser.sqlenv.parser.sqldep.MultipleSQLDepSQLEnv;
006import gudusoft.gsqlparser.util.SQLUtil;
007
008import java.util.ArrayList;
009import java.util.List;
010import java.util.Map;
011import java.util.logging.Level;
012import java.util.logging.Logger;
013
014@SuppressWarnings("rawtypes")
015public class SqlflowSQLEnv extends TSQLEnv {
016
017        private Map server;
018
019        private Boolean init = false;
020
021        public SqlflowSQLEnv(String defaultServer, String defaultDatabase, String defaultSchema, EDbVendor dbVendor, Map server) {
022                super(dbVendor);
023                if(!SQLUtil.isEmpty(defaultServer) && !defaultServer.equals(TSQLEnv.DEFAULT_SERVER_NAME)) {
024                        setDefaultServerName(defaultServer);
025                }
026                if(!SQLUtil.isEmpty(defaultDatabase) && !defaultDatabase.equals(TSQLEnv.DEFAULT_DB_NAME)) {
027                        setDefaultCatalogName(defaultDatabase);
028                }
029                if(!SQLUtil.isEmpty(defaultSchema) && !defaultSchema.equals(TSQLEnv.DEFAULT_SCHEMA_NAME)) {
030                        setDefaultSchemaName(defaultSchema);
031                }
032                this.server = server;
033                initSQLEnv();
034        }
035
036        @Override
037        public void initSQLEnv() {
038                synchronized (init) {
039                        if (init)
040                                return;
041                        String dbVendor = (String) server.get("dbVendor");
042                        if (!SQLUtil.isEmpty((String) server.get("name"))) {
043                                this.setDefaultServerName((String) server.get("name"));
044                        }
045                        EDbVendor vendor = getDBVendor();
046                        if (dbVendor != null) {
047                                vendor = EDbVendor.valueOf(dbVendor);
048                        }
049
050                        boolean supportsCatalogs = TSQLEnv.supportCatalog(vendor);
051                        boolean supportsSchemas = TSQLEnv.supportSchema(vendor);
052
053                        try {
054                                if (supportsCatalogs && supportsSchemas) {
055                                        List databases = (List) server.get("databases");
056                                        if (databases != null) {
057                                                for (int i = 0; i < databases.size(); i++) {
058                                                        Map jsonDatabase = (Map) databases.get(i);
059                                                        String databaseName = (String) jsonDatabase.get("name");
060                                                        List schemas = (List) jsonDatabase.get("schemas");
061                                                        if (schemas == null) {
062                                                                continue;
063                                                        }
064                                                        TSQLCatalog sqlCatalog = getSQLCatalog(databaseName, true);
065                                                        for (int j = 0; j < schemas.size(); j++) {
066                                                                Map jsonSchema = (Map) schemas.get(j);
067                                                                String schemaName = (String) jsonSchema.get("name");
068                                                                TSQLSchema sqlSchema = sqlCatalog.getSchema(schemaName, true);
069                                                                appendTables(jsonSchema, sqlSchema);
070                                                                appendPackages(jsonSchema, sqlSchema);
071                                                                appendProcedures(jsonSchema, sqlSchema, null);
072                                                        }
073                                                }
074                                        }
075                                } else if (supportsCatalogs) {
076                                        List databases = (List) server.get("databases");
077                                        if (databases != null) {
078                                                for (int i = 0; i < databases.size(); i++) {
079                                                        Map jsonDatabase = (Map) databases.get(i);
080                                                        String databaseName = (String) jsonDatabase.get("name");
081                                                        TSQLCatalog sqlCatalog = getSQLCatalog(TSQLEnv.DEFAULT_DB_NAME, true);
082                                                        TSQLSchema sqlSchema = sqlCatalog.getSchema(databaseName, true);
083                                                        appendTables(jsonDatabase, sqlSchema);
084                                                        appendPackages(jsonDatabase, sqlSchema);
085                                                        appendProcedures(jsonDatabase, sqlSchema, null);
086                                                }
087                                        }
088                                } else if (supportsSchemas) {
089                                        List schemas = (List) server.get("schemas");
090                                        if (schemas != null) {
091                                                for (int i = 0; i < schemas.size(); i++) {
092                                                        Map jsonSchema = (Map) schemas.get(i);
093                                                        String schemaName = (String) jsonSchema.get("name");
094                                                        TSQLCatalog sqlCatalog = getSQLCatalog(TSQLEnv.DEFAULT_DB_NAME, true);
095                                                        TSQLSchema sqlSchema = sqlCatalog.getSchema(schemaName, true);
096                                                        appendTables(jsonSchema, sqlSchema);
097                                                        appendPackages(jsonSchema, sqlSchema);
098                                                        appendProcedures(jsonSchema, sqlSchema, null);
099                                                }
100                                        }
101                                }
102                        } catch (Exception e) {
103                                Logger.getLogger(MultipleSQLDepSQLEnv.class.getName()).log(Level.WARNING, "Parse json failed.", e);
104                        }
105                        init = true;
106                }
107        }
108
109        private void appendTables(Map jsonSchema, TSQLSchema sqlSchema) {
110                List tables = (List) jsonSchema.get("tables");
111                List views = (List) jsonSchema.get("views");
112                List dbObjs = new ArrayList();
113                if (tables != null) {
114                        dbObjs.addAll(tables);
115                }
116                if (views != null) {
117                        dbObjs.addAll(views);
118                }
119                for (int k = 0; k < dbObjs.size(); k++) {
120                        Map jsonTable = (Map) dbObjs.get(k);
121                        String tableName = (String) jsonTable.get("name");
122                        TSQLTable sqlTable = sqlSchema.createTable(tableName, 3);
123                        String type = (String) jsonTable.get("type");
124                        if (type != null && type.toLowerCase().indexOf("view") != -1) {
125                                sqlTable.setView(true);
126                        }
127                        List columns = (List) jsonTable.get("columns");
128                        if(columns!=null) {
129                                for (int l = 0; l < columns.size(); l++) {
130                                        Map jsonColumn = (Map) columns.get(l);
131                                        sqlTable.addColumn((String) jsonColumn.get("name"));
132                                }
133                        }
134                }
135        }
136
137        private void appendPackages(Map jsonSchema, TSQLSchema sqlSchema) {
138                List packages = (List) jsonSchema.get("packages");
139                List dbObjs = new ArrayList();
140                if (packages != null) {
141                        dbObjs.addAll(packages);
142                }
143                for (int k = 0; k < dbObjs.size(); k++) {
144                        Map jsonOraclePackage = (Map) dbObjs.get(k);
145                        String packageName = (String) jsonOraclePackage.get("name");
146                        TSQLOraclePackage sqlPackage = sqlSchema.createOraclePackage(packageName);
147                        appendProcedures(jsonOraclePackage, sqlSchema, sqlPackage);
148                }
149        }
150
151        private void appendProcedures(Map jsonProcedureParent, TSQLSchema sqlSchema, TSQLOraclePackage sqlPackage) {
152                if (jsonProcedureParent.containsKey("procedures")) {
153                        List<Map> procedures = (List<Map>) jsonProcedureParent.get("procedures");
154                        for (Map procedure : procedures) {
155                                String procedureName = (String) procedure.get("name");
156                                if (sqlPackage != null) {
157                                        sqlPackage.createProcedure(procedureName);
158                                } else {
159                                        sqlSchema.createProcedure(procedureName);
160                                }
161                        }
162                }
163                if (jsonProcedureParent.containsKey("functions")) {
164                        List<Map> functions = (List<Map>) jsonProcedureParent.get("functions");
165                        for (Map function : functions) {
166                                String functionName = (String) function.get("name");
167                                if (sqlPackage != null) {
168                                        sqlPackage.createFunction(functionName);
169                                } else {
170                                        sqlSchema.createFunction(functionName);
171                                }
172                        }
173                }
174                if (jsonProcedureParent.containsKey("triggers")) {
175                        List<Map> triggers = (List<Map>) jsonProcedureParent.get("triggers");
176                        for (Map trigger : triggers) {
177                                String triggerName = (String) trigger.get("name");
178                                if (sqlPackage != null) {
179                                        sqlPackage.createTrigger(triggerName);
180                                } else {
181                                        sqlSchema.createTrigger(triggerName);
182                                }
183                        }
184                }
185        }
186}