Having Coverage and Tests

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java

@@ -557,6 +557,10 @@ public <T> QueryExpressionHavingBuilder having(BindableColumn<T> column, Visitab
                     .build());
         }
 
+        public QueryExpressionHavingBuilder having(SqlCriterion initialCriterion, AndOrCriteriaGroup... subCriteria) {
+            return having(initialCriterion, Arrays.asList(subCriteria));
+        }
+
         public QueryExpressionHavingBuilder having(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
             return QueryExpressionDSL.this.having(initialCriterion, subCriteria);
         }
@@ -601,6 +605,18 @@ public QueryExpressionHavingBuilder(SqlCriterion initialCriterion) {
             this.initialCriterion = initialCriterion;
         }
 
+        public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
+            return QueryExpressionDSL.this.fetchFirst(fetchFirstRows);
+        }
+
+        public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
+            return QueryExpressionDSL.this.offset(offset);
+        }
+
+        public SelectDSL<R>.LimitFinisher limit(long limit) {
+            return QueryExpressionDSL.this.limit(limit);
+        }
+
         public SelectDSL<R> orderBy(SortSpecification... columns) {
             return orderBy(Arrays.asList(columns));
         }
@@ -617,18 +633,6 @@ public UnionBuilder unionAll() {
             return QueryExpressionDSL.this.unionAll();
         }
 
-        public SelectDSL<R>.LimitFinisher limit(long limit) {
-            return QueryExpressionDSL.this.limit(limit);
-        }
-
-        public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
-            return QueryExpressionDSL.this.offset(offset);
-        }
-
-        public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
-            return QueryExpressionDSL.this.fetchFirst(fetchFirstRows);
-        }
-
         @NotNull
         @Override
         public R build() {

src/test/java/examples/groupby/GroupByTest.java

@@ -529,6 +529,30 @@ void testCountDistinct() {
 
     @Test
     void testHaving() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class);
+
+            SelectStatementProvider selectStatement = select(lastName, count())
+                    .from(person)
+                    .groupBy(lastName)
+                    .having(count(), isEqualTo(3L))
+                    .and(lastName, isEqualTo("Rubble"))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select last_name, count(*) from Person group by last_name " +
+                    "having count(*) = #{parameters.p1} and last_name = #{parameters.p2,jdbcType=VARCHAR}";
+            assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+
+            List<Map<String, Object>> rows = mapper.selectManyMappedRows(selectStatement);
+            assertThat(rows).hasSize(1);
+            Map<String, Object> row = rows.get(0);
+            assertThat(row).containsEntry("LAST_NAME", "Rubble");
+        }
+    }
+
+    @Test
+    void testHavingAndOrderBy() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class);
 
@@ -549,4 +573,93 @@ void testHaving() {
             assertThat(row).containsEntry("LAST_NAME", "Rubble");
         }
     }
+
+    @Test
+    void testHavingWithGroup() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class);
+
+            SelectStatementProvider selectStatement = select(lastName, count())
+                    .from(person)
+                    .groupBy(lastName)
+                    .having(group(count(), isEqualTo(3L), and(lastName, isEqualTo("Rubble"))))
+                    .limit(1)
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select last_name, count(*) from Person group by last_name " +
+                    "having count(*) = #{parameters.p1} and last_name = #{parameters.p2,jdbcType=VARCHAR} " +
+                    "limit #{parameters.p3}";
+            assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+
+            List<Map<String, Object>> rows = mapper.selectManyMappedRows(selectStatement);
+            assertThat(rows).hasSize(1);
+            Map<String, Object> row = rows.get(0);
+            assertThat(row).containsEntry("LAST_NAME", "Rubble");
+        }
+    }
+
+    @Test
+    void testHavingWithUnion() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class);
+
+            SelectStatementProvider selectStatement = select(lastName, count())
+                    .from(person)
+                    .groupBy(lastName)
+                    .having(group(count(), isEqualTo(3L), and(lastName, isEqualTo("Rubble"))))
+                    .union()
+                    .select(lastName, count())
+                    .from(person)
+                    .groupBy(lastName)
+                    .having(group(count(), isGreaterThan(1L), and(lastName, isEqualTo("Flintstone"))))
+                    .fetchFirst(5).rowsOnly()
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select last_name, count(*) from Person group by last_name " +
+                    "having count(*) = #{parameters.p1} and last_name = #{parameters.p2,jdbcType=VARCHAR} " +
+                    "union select last_name, count(*) from Person group by last_name " +
+                    "having count(*) > #{parameters.p3} and last_name = #{parameters.p4,jdbcType=VARCHAR} " +
+                    "fetch first #{parameters.p5} rows only";
+            assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+
+            List<Map<String, Object>> rows = mapper.selectManyMappedRows(selectStatement);
+            assertThat(rows).hasSize(2);
+            Map<String, Object> row = rows.get(0);
+            assertThat(row).containsEntry("LAST_NAME", "Flintstone");
+        }
+    }
+
+    @Test
+    void testHavingWithUnionAll() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            CommonSelectMapper mapper = session.getMapper(CommonSelectMapper.class);
+
+            SelectStatementProvider selectStatement = select(lastName, count())
+                    .from(person)
+                    .groupBy(lastName)
+                    .having(group(count(), isEqualTo(3L), and(lastName, isEqualTo("Rubble"))))
+                    .unionAll()
+                    .select(lastName, count())
+                    .from(person)
+                    .groupBy(lastName)
+                    .having(group(count(), isGreaterThan(1L), and(lastName, isEqualTo("Flintstone"))))
+                    .offset(1)
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "select last_name, count(*) from Person group by last_name " +
+                    "having count(*) = #{parameters.p1} and last_name = #{parameters.p2,jdbcType=VARCHAR} " +
+                    "union all select last_name, count(*) from Person group by last_name " +
+                    "having count(*) > #{parameters.p3} and last_name = #{parameters.p4,jdbcType=VARCHAR} " +
+                    "offset #{parameters.p5} rows";
+            assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+
+            List<Map<String, Object>> rows = mapper.selectManyMappedRows(selectStatement);
+            assertThat(rows).hasSize(1);
+            Map<String, Object> row = rows.get(0);
+            assertThat(row).containsEntry("LAST_NAME", "Flintstone");
+        }
+    }
 }