import org.onap.music.logging.format.ErrorTypes;
import org.onap.music.mdbc.mixins.MusicMixin;
import org.onap.music.mdbc.mixins.Utils;
+import org.onap.music.mdbc.query.SQLOperation;
import org.onap.music.mdbc.tables.Operation;
import org.onap.music.mdbc.tables.StagingTable;
return prop;
}
- public static List<Range> getTables(Map<String,List<String>> queryParsed){
+ public static List<Range> getTables(Map<String,List<SQLOperation>> queryParsed){
List<Range> ranges = new ArrayList<>();
for(String table: queryParsed.keySet()){
ranges.add(new Range(table));
import org.onap.music.mdbc.ownership.DagNode;
import org.onap.music.mdbc.ownership.OwnershipAndCheckpoint;
import org.onap.music.mdbc.query.QueryProcessor;
+import org.onap.music.mdbc.query.SQLOperation;
import org.onap.music.mdbc.tables.MusicTxDigestDaemon;
import org.onap.music.mdbc.tables.MusicRangeInformationRow;
import org.onap.music.mdbc.tables.StagingTable;
* can be synchronized before a SELECT, for those databases that do not support SELECT triggers.
* @param sql the SQL statement that is about to be executed
*/
- public void preStatementHook(final String sql) throws MDBCServiceException {
+ public void preStatementHook(final String sql) throws MDBCServiceException, SQLException {
//TODO: verify ownership of keys here
//Parse tables from the sql query
- Map<String, List<String>> tableToInstruction = QueryProcessor.extractTableFromQuery(sql);
+ Map<String, List<SQLOperation>> tableToInstruction = QueryProcessor.parseSqlQuery(sql);
//Check ownership of keys
List<Range> queryTables = MDBCUtils.getTables(tableToInstruction);
- if(this.partition!=null ){
+ if (this.partition!=null) {
List<Range> snapshot = this.partition.getSnapshot();
if(snapshot!=null){
queryTables.addAll(snapshot);
import org.onap.music.mdbc.MDBCUtils;
import org.onap.music.mdbc.Range;
import org.onap.music.mdbc.TableInfo;
+import org.onap.music.mdbc.query.SQLOperation;
+import org.onap.music.mdbc.query.SQLOperationType;
import org.onap.music.mdbc.tables.Operation;
-import org.onap.music.mdbc.tables.OperationType;
import org.onap.music.mdbc.tables.StagingTable;
import net.sf.jsqlparser.JSQLParserException;
}
}
- private OperationType toOpEnum(String operation) throws NoSuchFieldException {
+ private SQLOperation toOpEnum(String operation) throws NoSuchFieldException {
switch (operation.toLowerCase()) {
case "i":
- return OperationType.INSERT;
+ return SQLOperation.INSERT;
case "d":
- return OperationType.DELETE;
+ return SQLOperation.DELETE;
case "u":
- return OperationType.UPDATE;
+ return SQLOperation.UPDATE;
case "s":
- return OperationType.SELECT;
+ return SQLOperation.SELECT;
default:
logger.error(EELFLoggerDelegate.errorLogger,"Invalid operation selected: ["+operation+"]");
throw new NoSuchFieldException("Invalid operation enum");
biggestIx = Integer.max(biggestIx,ix);
smallestIx = Integer.min(smallestIx,ix);
String op = rs.getString("OP");
- OperationType opType = toOpEnum(op);
+ SQLOperation opType = toOpEnum(op);
String tbl = rs.getString("TABLENAME");
String newRowStr = rs.getString("ROWDATA");
String rowStr = rs.getString("KEYDATA");
StringBuilder sqlInverse = null;
switch (op.getOperationType()) {
case INSERT:
- sqlInverse = constructUpdate(op.getTable() , OperationType.UPDATE, op.getKey(), cols, vals);
+ sqlInverse = constructUpdate(op.getTable() , SQLOperation.UPDATE, op.getKey(), cols, vals);
break;
case UPDATE:
- sqlInverse = constructInsert(op.getTable() , OperationType.INSERT, cols, vals);
+ sqlInverse = constructInsert(op.getTable() , SQLOperation.INSERT, cols, vals);
break;
default:
break;
}
return sql;
}
- private StringBuilder constructDelete(String r, OperationType op, JSONObject key) {
+ private StringBuilder constructDelete(String r, SQLOperation op, JSONObject key) {
StringBuilder sql = new StringBuilder();
sql.append(op + " FROM ");
sql.append(r + " WHERE ");
sql.append(";");
return sql;
}
- private StringBuilder constructInsert(String r, OperationType op, ArrayList<String> cols,
+ private StringBuilder constructInsert(String r, SQLOperation op, ArrayList<String> cols,
ArrayList<Object> vals) {
StringBuilder sql = new StringBuilder();
String sep;
sql.append(");");
return sql;
}
- private StringBuilder constructUpdate(String r, OperationType op, JSONObject key, ArrayList<String> cols,
+ private StringBuilder constructUpdate(String r, SQLOperation op, JSONObject key, ArrayList<String> cols,
ArrayList<Object> vals) {
StringBuilder sql = new StringBuilder();
String sep;
+++ /dev/null
-/*
- * ============LICENSE_START====================================================
- * org.onap.music.mdbc
- * =============================================================================
- * Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
- * =============================================================================
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- * ============LICENSE_END======================================================
- */
-
-package org.onap.music.mdbc.query;
-
-public enum Operation {
-
- INSERT("W"), SELECT("R"), UPDATE("W"), DELETE("W"), TABLE("T");
-
- String operation;
-
- String getOperation() {
- return this.operation;
- }
-
- Operation(String operation) {
- this.operation = operation;
- }
-
- }
\ No newline at end of file
package org.onap.music.mdbc.query;
+import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import org.apache.calcite.avatica.util.Casing;
import org.apache.calcite.avatica.util.Quoting;
+import org.apache.calcite.sql.SqlBasicCall;
import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlIdentifier;
import org.apache.calcite.sql.SqlInsert;
+import org.apache.calcite.sql.SqlJoin;
import org.apache.calcite.sql.SqlKind;
import org.apache.calcite.sql.SqlNode;
-import org.apache.calcite.sql.SqlNodeList;
import org.apache.calcite.sql.SqlSelect;
import org.apache.calcite.sql.SqlUpdate;
import org.apache.calcite.sql.fun.SqlInOperator;
import org.apache.calcite.util.Util;
import org.onap.music.logging.EELFLoggerDelegate;
-import net.sf.jsqlparser.JSQLParserException;
-import net.sf.jsqlparser.parser.CCJSqlParserUtil;
-import net.sf.jsqlparser.statement.delete.Delete;
-import net.sf.jsqlparser.statement.insert.Insert;
-import net.sf.jsqlparser.statement.select.Select;
-import net.sf.jsqlparser.statement.update.Update;
-import net.sf.jsqlparser.statement.create.table.CreateTable;
-import net.sf.jsqlparser.util.TablesNamesFinder;
-
public class QueryProcessor {
private static EELFLoggerDelegate logger = EELFLoggerDelegate.getLogger(QueryProcessor.class);
- public List<String> tables = null;
-
public QueryProcessor() {
}
/**
*
* @param query
- * @return map of table name to {@link org.onap.music.mdbc.query.Operation}
+ * @return map of table name to {@link org.onap.music.mdbc.query.SQLOperation}
* @throws SqlParseException
*/
- public static Map<String, List<Operation>> parseSqlQuery(String query) throws SqlParseException {
+ public static Map<String, List<SQLOperation>> parseSqlQuery(String query) throws SQLException {
logger.info(EELFLoggerDelegate.applicationLogger, "Parsing query: "+query);
- Map<String, List<Operation>> tableOpsMap = new HashMap<>();
+ query = query.trim();
+ if (query.endsWith(";")) {
+ query = query.substring(0, query.length() - 1);
+ }
+ Map<String, List<SQLOperation>> tableOpsMap = new HashMap<>();
//for Create no need to check locks.
if(query.toUpperCase().startsWith("CREATE")) {
logger.error(EELFLoggerDelegate.errorLogger, "CREATE TABLE DDL not currently supported currently.");
return tableOpsMap;
}
- /*SqlParser parser = SqlParser.create(query);
- SqlNode sqlNode = parser.parseQuery();*/
- SqlNode sqlNode = getSqlParser(query).parseStmt();
+ SqlNode sqlNode;
+ try {
+ sqlNode = getSqlParser(query).parseStmt();
+ } catch (SqlParseException e) {
+ logger.error(EELFLoggerDelegate.errorLogger, "Unable to parse query: " + query +". " + e.getMessage());
+ throw new SQLException("Unable to parse query: " + query);
+ }
SqlBasicVisitor<Void> visitor = new SqlBasicVisitor<Void>() {
};
- // sqlNode.accept(new SqlAnalyzer());
sqlNode.accept(visitor);
switch (sqlNode.getKind()) {
case INSERT:
return tableOpsMap;
}
- private static void parseInsert(SqlInsert sqlNode, Map<String, List<Operation>> tableOpsMap) {
- SqlInsert sqlInsert = (SqlInsert) sqlNode;
+ private static void parseInsert(SqlInsert sqlInsert, Map<String, List<SQLOperation>> tableOpsMap) {
String tableName = sqlInsert.getTargetTable().toString();
//handle insert into select query
if (sqlInsert.getSource().getKind()==SqlKind.SELECT) {
parseSelect((SqlSelect) sqlInsert.getSource(), tableOpsMap);
}
- List<Operation> Ops = tableOpsMap.get(tableName);
+ List<SQLOperation> Ops = tableOpsMap.get(tableName);
if (Ops == null)
Ops = new ArrayList<>();
- Ops.add(Operation.INSERT);
+ Ops.add(SQLOperation.INSERT);
tableOpsMap.put(tableName, Ops);
}
- private static void parseUpdate(SqlUpdate sqlNode, Map<String, List<Operation>> tableOpsMap) {
- SqlUpdate sqlUpdate = (SqlUpdate) sqlNode;
- String tableName = sqlUpdate.getTargetTable().toString();
- List<Operation> Ops = tableOpsMap.get(tableName);
- if (Ops == null)
- Ops = new ArrayList<>();
- Ops.add(Operation.UPDATE);
- tableOpsMap.put(tableName, Ops);
+ private static void parseUpdate(SqlUpdate sqlUpdate, Map<String, List<SQLOperation>> tableOpsMap) {
+ SqlNode targetTable = sqlUpdate.getTargetTable();
+ switch (targetTable.getKind()) {
+ case IDENTIFIER:
+ addIdentifierToMap(tableOpsMap, (SqlIdentifier) targetTable, SQLOperation.UPDATE);
+ break;
+ default:
+ logger.error("Unable to process: " + targetTable.getKind() + " query");
+ }
}
- private static void parseSelect(SqlSelect sqlNode, Map<String, List<Operation>> tableOpsMap ) {
- SqlSelect sqlSelect = (SqlSelect) sqlNode;
- SqlNodeList selectList = sqlSelect.getSelectList();
- String tables = sqlSelect.getFrom().toString();
- String[] tablesArr = tables.split(",");
-
- for (String table : tablesArr) {
-
- String tableName = null;
- if(table.contains("`")) {
- String[] split = table.split("`");
- tableName = split[1];
- } else {
- tableName = table;
- }
- List<Operation> Ops = tableOpsMap.get(tableName);
- if (Ops == null) Ops = new ArrayList<>();
- Ops.add(Operation.SELECT);
- tableOpsMap.put(tableName, Ops);
+ private static void parseSelect(SqlSelect sqlSelect, Map<String, List<SQLOperation>> tableOpsMap ) {
+ SqlNode from = sqlSelect.getFrom();
+ switch (from.getKind()) {
+ case IDENTIFIER:
+ addIdentifierToMap(tableOpsMap, (SqlIdentifier) from, SQLOperation.SELECT);
+ break;
+ case AS:
+ SqlBasicCall as = (SqlBasicCall) from;
+ SqlNode node = as.getOperandList().get(0);
+ addIdentifierToMap(tableOpsMap, (SqlIdentifier) node, SQLOperation.SELECT);
+ break;
+ case JOIN:
+ parseJoin((SqlJoin) from, tableOpsMap);
+ break;
+ default:
+ logger.error("Unable to process: " + from.getKind() + " query");
}
}
- @Deprecated
- public static Map<String, List<String>> extractTableFromQuery(String sqlQuery) {
- List<String> tables = null;
- Map<String, List<String>> tableOpsMap = new HashMap<>();
- try {
- net.sf.jsqlparser.statement.Statement stmt = CCJSqlParserUtil.parse(sqlQuery);
- if (stmt instanceof Insert) {
- Insert s = (Insert) stmt;
- String tbl = s.getTable().getName();
- List<String> Ops = tableOpsMap.get(tbl);
- if (Ops == null)
- Ops = new ArrayList<>();
- Ops.add(Operation.INSERT.getOperation());
- tableOpsMap.put(tbl, Ops);
- logger.debug(EELFLoggerDelegate.applicationLogger, "Inserting into table: " + tbl);
- } else {
- String tbl;
- String where = "";
- if (stmt instanceof Update) {
- Update u = (Update) stmt;
- tbl = u.getTables().get(0).getName();
- List<String> Ops = tableOpsMap.get(tbl);
- if (Ops == null)
- Ops = new ArrayList<>();
- if (u.getWhere() != null) {
- where = u.getWhere().toString();
- logger.debug(EELFLoggerDelegate.applicationLogger, "Updating table: " + tbl);
- Ops.add(Operation.UPDATE.getOperation());
- } else {
- Ops.add(Operation.TABLE.getOperation());
- }
- tableOpsMap.put(tbl, Ops);
- } else if (stmt instanceof Delete) {
- Delete d = (Delete) stmt;
- tbl = d.getTable().getName();
- List<String> Ops = tableOpsMap.get(tbl);
- if (Ops == null)
- Ops = new ArrayList<>();
- if (d.getWhere() != null) {
- where = d.getWhere().toString();
- Ops.add(Operation.DELETE.getOperation());
- } else {
- Ops.add(Operation.TABLE.getOperation());
- }
- tableOpsMap.put(tbl, Ops);
- logger.debug(EELFLoggerDelegate.applicationLogger, "Deleting from table: " + tbl);
- } else if (stmt instanceof Select) {
- TablesNamesFinder tablesNamesFinder = new TablesNamesFinder();
- tables = tablesNamesFinder.getTableList(stmt);
- for (String table : tables) {
- List<String> Ops = tableOpsMap.get(table);
- if (Ops == null)
- Ops = new ArrayList<>();
- Ops.add(Operation.SELECT.getOperation());
- tableOpsMap.put(table, Ops);
- }
- } else if (stmt instanceof CreateTable) {
- CreateTable ct = (CreateTable) stmt;
- List<String> Ops = new ArrayList<>();
- Ops.add(Operation.TABLE.getOperation());
- tableOpsMap.put(ct.getTable().getName(), Ops);
- } else {
- logger.error(EELFLoggerDelegate.errorLogger, "Not recognized sql type:" + stmt.getClass());
- tbl = "";
- }
- }
- } catch (JSQLParserException e) {
- // TODO Auto-generated catch block
- e.printStackTrace();
+ private static void parseJoin(SqlJoin join, Map<String, List<SQLOperation>> tableOpsMap) {
+ switch (join.getLeft().getKind()) {
+ case IDENTIFIER:
+ addIdentifierToMap(tableOpsMap, (SqlIdentifier) join.getLeft(), SQLOperation.SELECT);
+ break;
+ case AS:
+ SqlBasicCall as = (SqlBasicCall) join.getLeft();
+ SqlNode node = as.getOperandList().get(0);
+ addIdentifierToMap(tableOpsMap, (SqlIdentifier) node, SQLOperation.SELECT);
+ break;
+ default:
+ logger.error("Error parsing join. Can't process left type: " + join.getLeft().getKind());
}
- return tableOpsMap;
+
+ switch (join.getRight().getKind()) {
+ case IDENTIFIER:
+ addIdentifierToMap(tableOpsMap, (SqlIdentifier) join.getRight(), SQLOperation.SELECT);
+ break;
+ case AS:
+ SqlBasicCall as = (SqlBasicCall) join.getRight();
+ SqlNode node = as.getOperandList().get(0);
+ addIdentifierToMap(tableOpsMap, (SqlIdentifier) node, SQLOperation.SELECT);
+ break;
+ default:
+ logger.error("Error parsing join. Can't process left type: " + join.getRight().getKind());
+ }
+ }
+
+ /**
+ * Add the identifier, the range in the query, to the map
+ * @param tableOpsMap
+ * @param identifier
+ * @param op
+ */
+ private static void addIdentifierToMap(Map<String, List<SQLOperation>> tableOpsMap, SqlIdentifier identifier,
+ SQLOperation op) {
+ List<SQLOperation> opList = tableOpsMap.get(identifier.toString());
+ if (opList == null) opList = new ArrayList<>();
+ opList.add(op);
+ tableOpsMap.put(identifier.toString(), opList);
}
}
--- /dev/null
+/*
+ * ============LICENSE_START==================================================== org.onap.music.mdbc
+ * ============================================================================= Copyright (C) 2018 AT&T Intellectual
+ * Property. All rights reserved. ============================================================================= Licensed
+ * under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
+ * License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ * ============LICENSE_END======================================================
+ */
+
+package org.onap.music.mdbc.query;
+
+public enum SQLOperation {
+
+ INSERT(SQLOperationType.WRITE), SELECT(SQLOperationType.READ), UPDATE(SQLOperationType.WRITE),
+ DELETE(SQLOperationType.WRITE), TABLE(SQLOperationType.TABLE);
+
+ SQLOperationType opType;
+
+ public SQLOperationType getOperationType() {
+ return this.opType;
+ }
+
+ SQLOperation(SQLOperationType operation) {
+ this.opType = operation;
+ }
+
+}
* limitations under the License.
* ============LICENSE_END======================================================
*/
-package org.onap.music.mdbc.tables;
+package org.onap.music.mdbc.query;
-public enum OperationType{
- DELETE, UPDATE, INSERT, SELECT
+public enum SQLOperationType {
+ READ, WRITE, TABLE;
}
import org.json.JSONObject;
import org.json.JSONTokener;
import org.onap.music.exceptions.MDBCServiceException;
-
+import org.onap.music.mdbc.query.SQLOperation;
+import org.onap.music.mdbc.query.SQLOperationType;
import static java.util.Objects.hash;
public final class Operation implements Serializable{
private static final long serialVersionUID = -1215301985078183104L;
- final OperationType TYPE;
+ final SQLOperation TYPE;
final String VAL;
final String KEY;
final String TABLE;
- public Operation(String table,OperationType type, String newVal, String key) {
+ public Operation(String table, SQLOperation type, String newVal, String key) {
TABLE = table;
TYPE = type;
VAL = newVal;
return keys;
}
- public OperationType getOperationType() {
+ public SQLOperation getOperationType() {
return this.TYPE;
}
import org.onap.music.mdbc.proto.ProtoDigest.Digest.CompleteDigest.Builder;
import org.onap.music.mdbc.proto.ProtoDigest.Digest.Row;
import org.onap.music.mdbc.proto.ProtoDigest.Digest.Row.OpType;
+import org.onap.music.mdbc.query.SQLOperation;
+import org.onap.music.mdbc.query.SQLOperationType;
public class StagingTable {
}
for(Row row : completeDigest.getRowsList()){
final OpType type = row.getType();
- OperationType newType = (type==OpType.INSERT)?OperationType.INSERT:(type==OpType.DELETE)?
- OperationType.DELETE:OperationType.UPDATE;
+ SQLOperation newType = (type==OpType.INSERT)?SQLOperation.INSERT:(type==OpType.DELETE)?
+ SQLOperation.DELETE:SQLOperation.UPDATE;
operations.add(new Operation(row.getTable(),newType,row.getVal(),row.getKey()));
}
}
return isBuilderInitialized();
}
- synchronized public void addOperation(Range range, OperationType type, String newVal, String keys)
+ synchronized public void addOperation(Range range, SQLOperation type, String newVal, String keys)
throws MDBCServiceException {
if(!builderInitialized){
throw new MDBCServiceException("This type of staging table is unmutable, please use the constructor"
+ "with no parameters");
}
- OpType newType = (type==OperationType.INSERT)?OpType.INSERT:(type==OperationType.DELETE)?
+ OpType newType = (type==SQLOperation.INSERT)?OpType.INSERT:(type==SQLOperation.DELETE)?
OpType.DELETE:OpType.UPDATE;
Row.Builder rowBuilder = Row.newBuilder().setTable(range.getTable()).setType(newType).setVal(newVal);
if(keys!=null){
ArrayList<Operation> newOperations = new ArrayList<>();
for(Row row : digestBuilder.getRowsList()){
final OpType type = row.getType();
- OperationType newType = (type==OpType.INSERT)?OperationType.INSERT:(type==OpType.DELETE)?
- OperationType.DELETE:OperationType.UPDATE;
+ SQLOperation newType = (type==OpType.INSERT)?SQLOperation.INSERT:(type==OpType.DELETE)?
+ SQLOperation.DELETE:SQLOperation.UPDATE;
newOperations.add(new Operation(row.getTable(),newType,row.getVal(),row.getKey()));
}
return newOperations;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.io.IOException;
import java.nio.ByteBuffer;
-import java.util.HashMap;
-import java.util.HashSet;
import org.json.JSONObject;
-import org.junit.Ignore;
import org.junit.Test;
import org.onap.music.exceptions.MDBCServiceException;
-import org.onap.music.mdbc.tables.OperationType;
+import org.onap.music.mdbc.query.SQLOperation;
import org.onap.music.mdbc.tables.StagingTable;
public class MDBCUtilsTest {
public void toStringTest1() {
StagingTable table = new StagingTable();
try {
- table.addOperation(new Range("TABLE1"),OperationType.INSERT,(new JSONObject(new String[]{"test3", "Test4"})).toString(),null);
+ table.addOperation(new Range("TABLE1"),SQLOperation.INSERT,(new JSONObject(new String[]{"test3", "Test4"})).toString(),null);
} catch (MDBCServiceException e) {
fail();
}
package org.onap.music.mdbc.query;
import static org.junit.Assert.*;
-import java.io.IOException;
+import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
-import org.apache.calcite.sql.parser.SqlParseException;
import org.junit.Test;
-import org.onap.music.mdbc.tables.MusicTxDigestDaemon;
-import org.onap.music.mdbc.tables.StagingTable;
public class QueryProcessorTest {
@Test
- public void tableQuery() throws Exception {
+ public void tableQuery() throws SQLException {
String sqlQuery = "CREATE TABLE pet (name VARCHAR(20), owner VARCHAR(20))";
- HashMap<String, List<Operation>> expectedOut = new HashMap<>();
- List<Operation> op = new ArrayList<>();
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> op = new ArrayList<>();
// no table ops for now
// op.add(Operation.TABLE);
// expectedOut.put("pet", op);
}
@Test
- public void selectQuery() throws SqlParseException {
- String sqlQuery = "SELECT name, age FROM table1 t1";
- HashMap<String, List<Operation>> expectedOut = new HashMap<>();
- List<Operation> t1op = new ArrayList<>();
- t1op.add(Operation.SELECT);
- expectedOut.put("TABLE1", t1op);
+ public void selectQuery() throws SQLException {
+ String sqlQuery = "SELECT name, age FROM DB.table1 t1;";
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> t1op = new ArrayList<>();
+ t1op.add(SQLOperation.SELECT);
+ expectedOut.put("DB.TABLE1", t1op);
+ assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
+ }
+
+ @Test
+ public void selectQuery1() throws SQLException {
+ String sqlQuery = "SELECT name, age FROM DB.table1;";
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> t1op = new ArrayList<>();
+ t1op.add(SQLOperation.SELECT);
+ expectedOut.put("DB.TABLE1", t1op);
assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
}
@Test
- public void selectQuery2Table() throws SqlParseException {
+ public void selectQuery2Table() throws SQLException {
String sqlQuery = "SELECT name, age FROM table1 t1, table2 t2 WHERE t1.id = t2.id";
- HashMap<String, List<Operation>> expectedOut = new HashMap<>();
- List<Operation> t1op = new ArrayList<>();
- List<Operation> t2op = new ArrayList<>();
- t1op.add(Operation.SELECT);
- t2op.add(Operation.SELECT);
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> t1op = new ArrayList<>();
+ List<SQLOperation> t2op = new ArrayList<>();
+ t1op.add(SQLOperation.SELECT);
+ t2op.add(SQLOperation.SELECT);
expectedOut.put("TABLE1", t1op);
expectedOut.put("TABLE2", t2op);
assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
}
@Test
- public void insertQuery() throws SqlParseException {
+ public void insertQuery() throws SQLException {
String sqlQuery = "INSERT INTO Employees (id, name) values ('1','Vikram')";
- HashMap<String, List<Operation>> expectedOut = new HashMap<>();
- List<Operation> t1op = new ArrayList<>();
- t1op.add(Operation.INSERT);
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> t1op = new ArrayList<>();
+ t1op.add(SQLOperation.INSERT);
expectedOut.put("EMPLOYEES", t1op);
assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
}
@Test
- public void updateQuery() throws SqlParseException {
- String sqlQuery = "UPDATE Employees SET id = 1 WHERE id = 2";
- HashMap<String, List<Operation>> expectedOut = new HashMap<>();
- List<Operation> t1op = new ArrayList<>();
- t1op.add(Operation.UPDATE);
- expectedOut.put("EMPLOYEES", t1op);
+ public void updateQuery() throws SQLException {
+ String sqlQuery = "UPDATE Db.Employees SET id = 1 WHERE id = 2";
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> t1op = new ArrayList<>();
+ t1op.add(SQLOperation.UPDATE);
+ expectedOut.put("DB.EMPLOYEES", t1op);
assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
- sqlQuery = "UPDATE Employees SET id = 1";
+ sqlQuery = "UPDATE db.Employees SET id = 1";
assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
}
@Test
- public void insertSelect() throws SqlParseException {
+ public void insertSelect() throws SQLException {
String sqlQuery =
"INSERT INTO table1 (CustomerName, City, Country) SELECT SupplierName, City, Country FROM table2";
- HashMap<String, List<Operation>> expectedOut = new HashMap<>();
- List<Operation> t1op = new ArrayList<>();
- List<Operation> t2op = new ArrayList<>();
- t1op.add(Operation.INSERT);
- t2op.add(Operation.SELECT);
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> t1op = new ArrayList<>();
+ List<SQLOperation> t2op = new ArrayList<>();
+ t1op.add(SQLOperation.INSERT);
+ t2op.add(SQLOperation.SELECT);
expectedOut.put("TABLE1", t1op);
expectedOut.put("TABLE2", t2op);
assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
}
-
+
+ @Test
+ public void selectJoin() throws SQLException {
+ String sqlQuery =
+ "SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate " +
+ "FROM Orders " +
+ "INNER JOIN DB.Customers ON Orders.CustomerID=Customers.CustomerID;";
+
+ HashMap<String, List<SQLOperation>> expectedOut = new HashMap<>();
+ List<SQLOperation> t1op = new ArrayList<>();
+ List<SQLOperation> t2op = new ArrayList<>();
+ t1op.add(SQLOperation.SELECT);
+ t2op.add(SQLOperation.SELECT);
+ expectedOut.put("ORDERS", t1op);
+ expectedOut.put("DB.CUSTOMERS", t2op);
+ assertEquals(expectedOut, QueryProcessor.parseSqlQuery(sqlQuery));
+ }
}
Code Review / music / mdbc.git / commitdiff