Merge "Remove raw references to Map in XSQL"
[controller.git] / opendaylight / md-sal / sal-dom-xsql / src / main / java / org / opendaylight / controller / md / sal / dom / xsql / jdbc / JDBCServer.java
1 package org.opendaylight.controller.md.sal.dom.xsql.jdbc;
2
3 import java.net.ServerSocket;
4 import java.net.Socket;
5 import java.sql.SQLException;
6 import java.util.ArrayList;
7 import java.util.HashMap;
8 import java.util.List;
9 import java.util.Map;
10 import java.util.StringTokenizer;
11 import java.util.concurrent.ConcurrentHashMap;
12 import org.opendaylight.controller.md.sal.dom.xsql.XSQLAdapter;
13 import org.opendaylight.controller.md.sal.dom.xsql.XSQLBluePrint;
14 import org.opendaylight.controller.md.sal.dom.xsql.XSQLBluePrintNode;
15 import org.opendaylight.controller.md.sal.dom.xsql.XSQLColumn;
16 import org.opendaylight.controller.md.sal.dom.xsql.XSQLCriteria;
17
18 public class JDBCServer extends Thread {
19     private ServerSocket socket = null;
20     private XSQLAdapter adapter = null;
21
22     public JDBCServer(XSQLAdapter a) {
23         super("JDBC Server");
24         this.adapter = a;
25         start();
26     }
27
28     public void run() {
29         try {
30             socket = new ServerSocket(40004);
31             while (!adapter.stopped) {
32                 Socket s = socket.accept();
33                 new JDBCConnection(s, adapter);
34             }
35         } catch (Exception err) {
36             err.printStackTrace();
37         }
38     }
39
40     public void connectToClient(String addr) {
41         try {
42             Socket s = new Socket(addr, 50003);
43             new JDBCConnection(s, adapter);
44         } catch (Exception err) {
45             err.printStackTrace();
46         }
47     }
48
49     public static void execute(JDBCResultSet rs, XSQLAdapter adapter)
50             throws SQLException {
51         if(rs.getSQL().toLowerCase().trim().equals("select 1")){
52             rs.setFinished(true);
53             return;
54         }
55         checkAndBreakSubQueries(rs, adapter);
56         if (rs.getSubQueries().size() == 0) {
57             parseTables(rs, adapter.getBluePrint());
58             parseFields(rs, adapter.getBluePrint());
59             parseCriteria(rs, adapter.getBluePrint());
60             try {
61                 adapter.execute(rs);
62             } catch (Exception err) {
63                 throw new SQLException("Error", err);
64             }
65         } else {
66             parseExternalQuery(rs);
67         }
68     }
69
70     public static void parseExternalQuery(JDBCResultSet rs) throws SQLException {
71         String sql = rs.getSQL();
72         for (Map.Entry<String, JDBCResultSet> entry : rs.getSubQueries()
73                 .entrySet()) {
74             int index = sql.toLowerCase().indexOf(entry.getValue().getSQL());
75             String extSql = sql.substring(0, index);
76             index = extSql.lastIndexOf("(");
77             extSql = extSql.substring(0, index);
78             System.out.println("External SQL=" + extSql);
79             parseLogicalFields(extSql, rs);
80         }
81     }
82
83     public static void parseLogicalFields(String sql, JDBCResultSet rs)
84             throws SQLException {
85         if(sql.trim().toLowerCase().equals("select * from")){
86             for (Map.Entry<String, JDBCResultSet> entry : rs.getSubQueries().entrySet()) {
87                 for(XSQLBluePrintNode node:entry.getValue().getTables()){
88                     rs.addTableToQuery(node);
89                 }
90                 rs.getFields().addAll(entry.getValue().getFields());
91                 while (entry.getValue().next()) {
92                     Map<String, Object> rec = entry.getValue().getCurrent();
93                     Map<String, Object> newRec = new HashMap<>();
94                     newRec.putAll(rec);
95                     rs.addRecord(newRec);
96                 }
97             }
98             rs.setFinished(true);
99             return;
100         }
101
102         Map<String, XSQLBluePrintNode> logicalNameToNode = new HashMap<String, XSQLBluePrintNode>();
103         Map<String, String> origNameToName = new HashMap<String, String>();
104         List<XSQLColumn> columnOrder = new ArrayList<>();
105         int nextLogField = addNextLogicalField(sql, 0,
106                 logicalNameToNode, origNameToName,columnOrder);
107         int next = sql.toLowerCase().indexOf(" as ", nextLogField);
108         while (next != -1) {
109             nextLogField = addNextLogicalField(sql, nextLogField + 1,
110                     logicalNameToNode, origNameToName,columnOrder);
111             next = sql.toLowerCase().indexOf(" as ", nextLogField + 1);
112         }
113
114         for (XSQLBluePrintNode node : logicalNameToNode.values()) {
115             rs.addTableToQuery(node);
116         }
117         rs.getFields().addAll(columnOrder);
118         for (Map.Entry<String, JDBCResultSet> entry : rs.getSubQueries().entrySet()) {
119             while (entry.getValue().next()) {
120                 Map<String, Object> rec = entry.getValue().getCurrent();
121                 Map<String, Object> newRec = new HashMap<>();
122                 for (Map.Entry<String, Object> e : rec.entrySet()) {
123                     Object value = e.getValue();
124                     String logicalKey = origNameToName.get(e.getKey());
125                     if (value != null && logicalKey != null) {
126                         newRec.put(logicalKey, value);
127                     }
128                 }
129                 rs.addRecord(newRec);
130             }
131         }
132         rs.setFinished(true);
133     }
134
135     public static void main(String args[]) {
136         String sql = "SELECT DISTINCT"
137                 + "\"LOGICAL_TABLE_1\".\"nodes/node.id\" AS \"COL0\"\n"
138                 + ",\"LOGICAL_TABLE_1\".\"nodes/node.id\" AS \"COL1\"\n"
139                 + ",\"LOGICAL_TABLE_1\".\"nodes/node.id\" AS \"COL2\"\n"
140                 + "FROM\n"
141                 + "(select * from nodes/node;) \"LOGICAL_TABLE_1\"\n";
142         JDBCResultSet rs = new JDBCResultSet(sql);
143         try {
144             parseLogicalFields(sql, rs);
145         } catch (Exception err) {
146             err.printStackTrace();
147         }
148     }
149
150     public static int addNextLogicalField(String sql, int startIndex,
151             Map<String, XSQLBluePrintNode> logicalNameToNode,
152             Map<String, String> origNameToName, List<XSQLColumn> columnOrder) {
153         int index1 = sql.indexOf("\"", startIndex);
154         int index2 = sql.indexOf("\".\"", index1);
155         int index3 = sql.indexOf("\"", index2 + 3);
156         int index4 = sql.toLowerCase().indexOf(" as ", startIndex);
157         int index5 = sql.indexOf("\"", index4);
158         int index6 = sql.indexOf("\"", index5 + 1);
159
160         String tblName = sql.substring(index1 + 1, index2);
161         String origFieldNameFull = sql.substring(index2 + 3, index3);
162         String origTableName = "";
163         String origFieldName = "";
164         if (origFieldNameFull.indexOf(".") != -1) {
165             origTableName = origFieldNameFull.substring(0,origFieldNameFull.indexOf("."));
166             origFieldName = origFieldNameFull.substring(origFieldNameFull.indexOf(".") + 1);
167         }
168         String logicalFieldName = sql.substring(index5 + 1, index6);
169         XSQLBluePrintNode node = logicalNameToNode.get(tblName);
170         if (node == null) {
171             node = new XSQLBluePrintNode(tblName, origTableName, 0);
172             logicalNameToNode.put(tblName, node);
173         }
174         columnOrder.add(node.addColumn(logicalFieldName, tblName, origFieldName, origTableName));
175         origNameToName.put(origFieldNameFull, tblName + "." + logicalFieldName);
176         return index6;
177     }
178
179     public static void checkAndBreakSubQueries(JDBCResultSet rs,XSQLAdapter adapter) throws SQLException {
180         String sql = rs.getSQL().toLowerCase();
181         int index = sql.indexOf("select");
182         if (index == -1)
183             throw new SQLException("Select statement is missing...");
184         int index2 = sql.indexOf("select", index + 6);
185         if (index2 != -1) {
186             int startSubQuery = index2;
187             for (int i = startSubQuery; i >= 0; i--) {
188                 if (sql.charAt(i) == '(') {
189                     startSubQuery = i;
190                     break;
191                 }
192             }
193             int braketCount = 0;
194             int endSubQuery = startSubQuery;
195             do {
196                 if (sql.charAt(endSubQuery) == '(')
197                     braketCount++;
198                 else if (sql.charAt(endSubQuery) == ')')
199                     braketCount--;
200                 endSubQuery++;
201             } while (braketCount > 0 || endSubQuery == sql.length());
202             String subQuerySQL = sql.substring(startSubQuery + 1,endSubQuery - 1);
203             if(rs.getSQL().toLowerCase().substring(0,startSubQuery).trim().equals("select * from")){
204                 rs.setSQL(subQuerySQL);
205                 return;
206             }
207             index = sql.indexOf("\"", endSubQuery);
208             index2 = sql.indexOf("\"", index + 1);
209             if(index==-1){
210                 index = endSubQuery;
211                 index2 = sql.length();
212             }
213             String logicalName = rs.getSQL().substring(index + 1, index2).trim();
214             JDBCResultSet subRS = rs.addSubQuery(subQuerySQL, logicalName);
215             JDBCServer.execute(subRS, adapter);
216         }
217     }
218
219     public static void parseTables(JDBCResultSet rs, XSQLBluePrint bp)
220             throws SQLException {
221         String lowSQL = rs.getSQL().toLowerCase();
222         int from = lowSQL.indexOf("from");
223         int where = lowSQL.indexOf("where");
224         int subQuery = lowSQL.indexOf("select", 2);
225         int fromTo = lowSQL.indexOf(";");
226
227         if (where != -1 && subQuery != -1 && where < subQuery) {
228             fromTo = where;
229         } else if (where != -1 && subQuery != -1 && where > subQuery) {
230             fromTo = subQuery;
231         } else if (where != -1) {
232             fromTo = where;
233         } else if (subQuery != -1) {
234             fromTo = subQuery;
235         }
236
237         if (from == -1) {
238             throw new SQLException("Missing \"from\" statement.");
239         }
240
241         if (fromTo == -1) {
242             throw new SQLException("Missing terminating \";\".");
243         }
244
245         String tableNames = rs.getSQL().substring(from + 4, fromTo).trim();
246         StringTokenizer tokens = new StringTokenizer(tableNames, ",");
247         while (tokens.hasMoreTokens()) {
248             String tableName = tokens.nextToken().trim();
249             XSQLBluePrintNode table = bp.getBluePrintNodeByTableName(tableName);
250             if (table == null) {
251                 throw new SQLException("Unknown table name \"" + tableName
252                         + "\"");
253             }
254             rs.addTableToQuery(table);
255         }
256     }
257
258     public static void addCriteria(XSQLColumn col, XSQLCriteria c,
259             JDBCResultSet rs) {
260         Map<XSQLColumn, List<XSQLCriteria>> tblCriteria = rs.getCriteria().get(
261                 col.getTableName());
262         if (tblCriteria == null) {
263             tblCriteria = new ConcurrentHashMap<XSQLColumn, List<XSQLCriteria>>();
264             rs.getCriteria().put(col.getTableName(), tblCriteria);
265         }
266         List<XSQLCriteria> lstCriteria = tblCriteria.get(col);
267         if (lstCriteria == null) {
268             lstCriteria = new ArrayList<XSQLCriteria>();
269             tblCriteria.put(col, lstCriteria);
270         }
271         lstCriteria.add(c);
272     }
273
274     public static void parseFields(JDBCResultSet rs, XSQLBluePrint bp)
275             throws SQLException {
276         String lowSQL = rs.getSQL().toLowerCase();
277         if (!lowSQL.startsWith("select")) {
278             throw new SQLException("Missing 'select' statement.");
279         }
280         int from = lowSQL.indexOf("from");
281         if (from == -1) {
282             throw new SQLException("Missing 'from' statement.");
283         }
284         String fields = rs.getSQL().substring(6, from).trim();
285         StringTokenizer tokens = new StringTokenizer(fields, ",");
286         while (tokens.hasMoreTokens()) {
287             String token = tokens.nextToken().trim();
288             if (token.equals("*")) {
289                 for (XSQLBluePrintNode table : rs.getTables()) {
290                     rs.getFields().addAll(table.getColumns());
291                 }
292                 return;
293             }
294             if (token.indexOf(".") != -1) {
295                 XSQLBluePrintNode tbl = bp.getBluePrintNodeByTableName(token
296                         .substring(0, token.indexOf(".")).trim());
297                 String p = token.substring(token.indexOf(".") + 1);
298                 if (p.equals("*")) {
299                     for (XSQLColumn c : tbl.getColumns()) {
300                         rs.getFields().add(c);
301                     }
302                 } else {
303                     XSQLColumn col = tbl.findColumnByName(p);
304                     rs.getFields().add(col);
305                 }
306             } else {
307                 XSQLColumn col = null;
308                 for (XSQLBluePrintNode table : rs.getTables()) {
309                     try {
310                         col = table.findColumnByName(token);
311                     } catch (Exception err) {
312                     }
313                     if (col != null) {
314                         break;
315                     }
316                 }
317                 if (col == null) {
318                     throw new SQLException("Unknown field name '" + token
319                             + "'.");
320                 }
321
322                 rs.getFields().add(col);
323             }
324         }
325     }
326
327     public static void parseCriteria(JDBCResultSet rs, XSQLBluePrint bp) {
328         String lowSQL = rs.getSQL().toLowerCase();
329         int where = lowSQL.indexOf("where");
330         int order = lowSQL.indexOf("order");
331         int whereTo = lowSQL.indexOf(";");
332
333         if (where == -1) {
334             return;
335         }
336
337         if (order != -1) {
338             whereTo = order;
339         }
340
341         if(whereTo==-1)
342             whereTo=lowSQL.length();
343
344         String whereStatement = rs.getSQL().substring(where + 5, whereTo)
345                 .trim();
346         XSQLCriteria cr = new XSQLCriteria(whereStatement, -1);
347         for (XSQLBluePrintNode tbl : rs.getTables()) {
348             for (XSQLColumn col : tbl.getColumns()) {
349                 String colCriteria = cr.getCriteriaForProperty(col);
350                 if (colCriteria != null && !colCriteria.trim().equals("")) {
351                     addCriteria(col, new XSQLCriteria(colCriteria, -1), rs);
352                 }
353             }
354         }
355     }
356 }

©2013 OpenDaylight, A Linux Foundation Collaborative Project. All Rights Reserved.
OpenDaylight is a registered trademark of The OpenDaylight Project, Inc.
Linux Foundation and OpenDaylight are registered trademarks of the Linux Foundation.
Linux is a registered trademark of Linus Torvalds.