add test cases for DQLMergeEngine

sharding-core/src/test/java/io/shardingjdbc/core/merger/dql/DQLMergeEngineTest.java

@@ -28,6 +28,8 @@ import io.shardingjdbc.core.merger.dql.groupby.GroupByStreamMergedResult;
 import io.shardingjdbc.core.merger.dql.iterator.IteratorStreamMergedResult;
 import io.shardingjdbc.core.merger.dql.orderby.OrderByStreamMergedResult;
 import io.shardingjdbc.core.merger.dql.pagination.LimitDecoratorMergedResult;
+import io.shardingjdbc.core.merger.dql.pagination.RowNumberDecoratorMergedResult;
+import io.shardingjdbc.core.merger.dql.pagination.TopAndRowNumberDecoratorMergedResult;
 import io.shardingjdbc.core.merger.fixture.TestQueryResult;
 import io.shardingjdbc.core.parsing.parser.context.OrderItem;
 import io.shardingjdbc.core.parsing.parser.context.limit.Limit;
@@ -74,7 +76,7 @@ public final class DQLMergeEngineTest {
     }
     
     @Test
-    public void assertBuildIteratorStreamMergedResultWithLimit() throws SQLException {
+    public void assertBuildIteratorStreamMergedResultWithMySQLLimit() throws SQLException {
         selectStatement.setLimit(new Limit(DatabaseType.MySQL));
         mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
         MergedResult actual = mergeEngine.merge();
@@ -82,6 +84,24 @@ public final class DQLMergeEngineTest {
         assertThat(((LimitDecoratorMergedResult) actual).getMergedResult(), instanceOf(IteratorStreamMergedResult.class));
     }
     
+    @Test
+    public void assertBuildIteratorStreamMergedResultWithOracleLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.Oracle));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(RowNumberDecoratorMergedResult.class));
+        assertThat(((RowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(IteratorStreamMergedResult.class));
+    }
+    
+    @Test
+    public void assertBuildIteratorStreamMergedResultWithSQLServerLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.SQLServer));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(TopAndRowNumberDecoratorMergedResult.class));
+        assertThat(((TopAndRowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(IteratorStreamMergedResult.class));
+    }
+    
     @Test
     public void assertBuildOrderByStreamMergedResult() throws SQLException {
         selectStatement.getOrderByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
@@ -90,7 +110,7 @@ public final class DQLMergeEngineTest {
     }
     
     @Test
-    public void assertBuildOrderByStreamMergedResultWithLimit() throws SQLException {
+    public void assertBuildOrderByStreamMergedResultWithMySQLLimit() throws SQLException {
         selectStatement.setLimit(new Limit(DatabaseType.MySQL));
         selectStatement.getOrderByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
         mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
@@ -99,6 +119,26 @@ public final class DQLMergeEngineTest {
         assertThat(((LimitDecoratorMergedResult) actual).getMergedResult(), instanceOf(OrderByStreamMergedResult.class));
     }
     
+    @Test
+    public void assertBuildOrderByStreamMergedResultWithOracleLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.Oracle));
+        selectStatement.getOrderByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(RowNumberDecoratorMergedResult.class));
+        assertThat(((RowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(OrderByStreamMergedResult.class));
+    }
+    
+    @Test
+    public void assertBuildOrderByStreamMergedResultWithSQLServerLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.SQLServer));
+        selectStatement.getOrderByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(TopAndRowNumberDecoratorMergedResult.class));
+        assertThat(((TopAndRowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(OrderByStreamMergedResult.class));
+    }
+    
     @Test
     public void assertBuildGroupByStreamMergedResult() throws SQLException {
         selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
@@ -108,7 +148,7 @@ public final class DQLMergeEngineTest {
     }
     
     @Test
-    public void assertBuildGroupByStreamMergedResultWithLimit() throws SQLException {
+    public void assertBuildGroupByStreamMergedResultWithMySQLLimit() throws SQLException {
         selectStatement.setLimit(new Limit(DatabaseType.MySQL));
         selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
         selectStatement.getOrderByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
@@ -118,6 +158,28 @@ public final class DQLMergeEngineTest {
         assertThat(((LimitDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByStreamMergedResult.class));
     }
     
+    @Test
+    public void assertBuildGroupByStreamMergedResultWithOracleLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.Oracle));
+        selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        selectStatement.getOrderByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(RowNumberDecoratorMergedResult.class));
+        assertThat(((RowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByStreamMergedResult.class));
+    }
+    
+    @Test
+    public void assertBuildGroupByStreamMergedResultWithSQLServerLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.SQLServer));
+        selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        selectStatement.getOrderByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(TopAndRowNumberDecoratorMergedResult.class));
+        assertThat(((TopAndRowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByStreamMergedResult.class));
+    }
+    
     @Test
     public void assertBuildGroupByMemoryMergedResult() throws SQLException {
         selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
@@ -126,7 +188,7 @@ public final class DQLMergeEngineTest {
     }
     
     @Test
-    public void assertBuildGroupByMemoryMergedResultWithLimit() throws SQLException {
+    public void assertBuildGroupByMemoryMergedResultWithMySQLLimit() throws SQLException {
         selectStatement.setLimit(new Limit(DatabaseType.MySQL));
         selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
         mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
@@ -135,6 +197,28 @@ public final class DQLMergeEngineTest {
         assertThat(((LimitDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByMemoryMergedResult.class));
     }
     
+    @Test
+    public void assertBuildGroupByMemoryMergedResultWithOracleLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.Oracle));
+        selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        selectStatement.getOrderByItems().add(new OrderItem(2, OrderDirection.DESC, OrderDirection.ASC));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(RowNumberDecoratorMergedResult.class));
+        assertThat(((RowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByMemoryMergedResult.class));
+    }
+    
+    @Test
+    public void assertBuildGroupByMemoryMergedResultWithSQLServerLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.SQLServer));
+        selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.DESC, OrderDirection.ASC));
+        selectStatement.getGroupByItems().add(new OrderItem(1, OrderDirection.ASC, OrderDirection.ASC));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(TopAndRowNumberDecoratorMergedResult.class));
+        assertThat(((TopAndRowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByMemoryMergedResult.class));
+    }
+    
     @Test
     public void assertBuildGroupByMemoryMergedResultWithAggregationOnly() throws SQLException {
         selectStatement.getItems().add(new AggregationSelectItem(AggregationType.COUNT, "(*)", Optional.<String>absent()));
@@ -143,7 +227,7 @@ public final class DQLMergeEngineTest {
     }
     
     @Test
-    public void assertBuildGroupByMemoryMergedResultWithAggregationOnlyWithLimit() throws SQLException {
+    public void assertBuildGroupByMemoryMergedResultWithAggregationOnlyWithMySQLLimit() throws SQLException {
         selectStatement.setLimit(new Limit(DatabaseType.MySQL));
         selectStatement.getItems().add(new AggregationSelectItem(AggregationType.COUNT, "(*)", Optional.<String>absent()));
         mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
@@ -151,4 +235,24 @@ public final class DQLMergeEngineTest {
         assertThat(actual, instanceOf(LimitDecoratorMergedResult.class));
         assertThat(((LimitDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByMemoryMergedResult.class));
     }
+    
+    @Test
+    public void assertBuildGroupByMemoryMergedResultWithAggregationOnlyWithOracleLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.Oracle));
+        selectStatement.getItems().add(new AggregationSelectItem(AggregationType.COUNT, "(*)", Optional.<String>absent()));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(RowNumberDecoratorMergedResult.class));
+        assertThat(((RowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByMemoryMergedResult.class));
+    }
+    
+    @Test
+    public void assertBuildGroupByMemoryMergedResultWithAggregationOnlyWithSQLServerLimit() throws SQLException {
+        selectStatement.setLimit(new Limit(DatabaseType.SQLServer));
+        selectStatement.getItems().add(new AggregationSelectItem(AggregationType.COUNT, "(*)", Optional.<String>absent()));
+        mergeEngine = new DQLMergeEngine(queryResults, selectStatement);
+        MergedResult actual = mergeEngine.merge();
+        assertThat(actual, instanceOf(TopAndRowNumberDecoratorMergedResult.class));
+        assertThat(((TopAndRowNumberDecoratorMergedResult) actual).getMergedResult(), instanceOf(GroupByMemoryMergedResult.class));
+    }
 }