Add convenience methods for different type of count queries

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java

@@ -107,6 +107,33 @@
 public interface SqlBuilder {
 
     // statements
+
+    /**
+     * Renders as select count(distinct column) from table...
+     * 
+     * @param table
+     * @return CountDSL for adding an optional where clause
+     */
+    static CountDSL<SelectModel> countDistinctFrom(BasicColumn column, SqlTable table) {
+        return CountDSL.countDistinct(column).from(table);
+    }
+    
+    /**
+     * Renders as select count(column) from table...
+     * 
+     * @param table
+     * @return CountDSL for adding an optional where clause
+     */
+    static CountDSL<SelectModel> countFrom(BasicColumn column, SqlTable table) {
+        return CountDSL.count(column).from(table);
+    }
+    
+    /**
+     * Renders as select count(*) from table...
+     * 
+     * @param table
+     * @return CountDSL for adding an optional where clause
+     */
     static CountDSL<SelectModel> countFrom(SqlTable table) {
         return CountDSL.countFrom(table);
     }

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

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2019 the original author or authors.
+ *    Copyright 2016-2020 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -18,6 +18,7 @@
 import java.util.Objects;
 import java.util.function.Function;
 
+import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.BindableColumn;
 import org.mybatis.dynamic.sql.SqlBuilder;
 import org.mybatis.dynamic.sql.SqlCriterion;
@@ -41,9 +42,11 @@ public class CountDSL<R> extends AbstractQueryExpressionDSL<CountDSL<R>, R> impl
 
     private Function<SelectModel, R> adapterFunction;
     private CountWhereBuilder whereBuilder = new CountWhereBuilder();
+    private BasicColumn countColumn;
 
-    private CountDSL(SqlTable table, Function<SelectModel, R> adapterFunction) {
+    private CountDSL(BasicColumn countColumn, SqlTable table, Function<SelectModel, R> adapterFunction) {
         super(table);
+        this.countColumn = Objects.requireNonNull(countColumn);
         this.adapterFunction = Objects.requireNonNull(adapterFunction);
     }
 
@@ -68,7 +71,7 @@ public R build() {
 
     private SelectModel buildModel() {
         QueryExpressionModel.Builder b = new QueryExpressionModel.Builder()
-                .withSelectColumn(SqlBuilder.count())
+                .withSelectColumn(countColumn)
                 .withTable(table())
                 .withTableAliases(tableAliases)
                 .withWhereModel(whereBuilder.buildWhereModel());
@@ -85,14 +88,44 @@ public static CountDSL<SelectModel> countFrom(SqlTable table) {
     }
 
     public static <R> CountDSL<R> countFrom(Function<SelectModel, R> adapterFunction, SqlTable table) {
-        return new CountDSL<>(table, adapterFunction);
+        return new CountDSL<>(SqlBuilder.count(), table, adapterFunction);
+    }
+    
+    public static FromGatherer<SelectModel> count(BasicColumn column) {
+        return count(Function.identity(), column);
+    }
+    
+    public static <R> FromGatherer<R> count(Function<SelectModel, R> adapterFunction, BasicColumn column) {
+        return new FromGatherer<>(adapterFunction, SqlBuilder.count(column));
+    }
+    
+    public static FromGatherer<SelectModel> countDistinct(BasicColumn column) {
+        return countDistinct(Function.identity(), column);
+    }
+    
+    public static <R> FromGatherer<R> countDistinct(Function<SelectModel, R> adapterFunction, BasicColumn column) {
+        return new FromGatherer<>(adapterFunction, SqlBuilder.countDistinct(column));
     }
 
     @Override
     protected CountDSL<R> getThis() {
         return this;
     }
 
+    public static class FromGatherer<R> {
+        private BasicColumn column;
+        private Function<SelectModel, R> adapterFunction;
+        
+        public FromGatherer(Function<SelectModel, R> adapterFunction, BasicColumn column) {
+            this.adapterFunction = adapterFunction;
+            this.column = column;
+        }
+        
+        public CountDSL<R> from(SqlTable table) {
+            return new CountDSL<> (column, table, adapterFunction);
+        }
+    }
+    
     public class CountWhereBuilder extends AbstractWhereDSL<CountWhereBuilder>
             implements Buildable<R> {
         private <T> CountWhereBuilder() {}

src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3Utils.java

@@ -52,6 +52,24 @@
 public class MyBatis3Utils {
     private MyBatis3Utils() {}
 
+    public static long count(ToLongFunction<SelectStatementProvider> mapper, BasicColumn column, SqlTable table,
+            CountDSLCompleter completer) {
+        return mapper.applyAsLong(count(column, table, completer));
+    }
+
+    public static SelectStatementProvider count(BasicColumn column, SqlTable table, CountDSLCompleter completer) {
+        return countFrom(SqlBuilder.countFrom(column, table), completer);
+    }
+
+    public static long countDistinct(ToLongFunction<SelectStatementProvider> mapper, BasicColumn column, SqlTable table,
+            CountDSLCompleter completer) {
+        return mapper.applyAsLong(countDistinct(column, table, completer));
+    }
+
+    public static SelectStatementProvider countDistinct(BasicColumn column, SqlTable table, CountDSLCompleter completer) {
+        return countFrom(SqlBuilder.countDistinctFrom(column, table), completer);
+    }
+
     public static SelectStatementProvider countFrom(SqlTable table, CountDSLCompleter completer) {
         return countFrom(SqlBuilder.countFrom(table), completer);
     }

src/test/java/examples/simple/PersonMapper.java

@@ -100,6 +100,14 @@ default long count(CountDSLCompleter completer) {
         return MyBatis3Utils.countFrom(this::count, person, completer);
     }
 
+    default long count(BasicColumn column, CountDSLCompleter completer) {
+        return MyBatis3Utils.count(this::count, column, person, completer);
+    }
+
+    default long countDistinct(BasicColumn column, CountDSLCompleter completer) {
+        return MyBatis3Utils.countDistinct(this::count, column, person, completer);
+    }
+
     default int delete(DeleteDSLCompleter completer) {
         return MyBatis3Utils.deleteFrom(this::delete, person, completer);
     }

src/test/java/examples/simple/PersonMapperTest.java

@@ -473,6 +473,26 @@ void testCountAll() {
         }
     }
 
+    @Test
+    void testCountLastName() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            PersonMapper mapper = session.getMapper(PersonMapper.class);
+            long rows = mapper.count(lastName, CountDSLCompleter.allRows());
+            
+            assertThat(rows).isEqualTo(6L);
+        }
+    }
+    
+    @Test
+    void testCountDistinctLastName() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            PersonMapper mapper = session.getMapper(PersonMapper.class);
+            long rows = mapper.countDistinct(lastName, CountDSLCompleter.allRows());
+            
+            assertThat(rows).isEqualTo(2L);
+        }
+    }
+    
     @Test
     void testTypeHandledLike() {
         try (SqlSession session = sqlSessionFactory.openSession()) {