Simplify MyBatis3Utils

Author: jeffgbutler

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

@@ -27,7 +27,7 @@
  * client code look a bit cleaner.
  *
  * <p>This function is intended to by used in conjunction with a utility method like
- * {@link MyBatis3Utils#count(ToLongFunction, CountDSL, CountDSLCompleter)}
+ * {@link MyBatis3Utils#countFrom(ToLongFunction, CountDSL, CountDSLCompleter)}
  *
  * <p>For example, you can create mapper interface methods like this:
  *

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

@@ -17,14 +17,11 @@
 
 import java.util.Collection;
 import java.util.List;
-import java.util.Optional;
 import java.util.function.Function;
 import java.util.function.ToIntFunction;
 import java.util.function.ToLongFunction;
 import java.util.function.UnaryOperator;
 
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.SqlBuilder;
 import org.mybatis.dynamic.sql.SqlTable;
@@ -53,86 +50,110 @@
 public class MyBatis3Utils {
     private MyBatis3Utils() {}
 
+    public static SelectStatementProvider countFrom(SqlTable table, CountDSLCompleter completer) {
+        return countFrom(SqlBuilder.countFrom(table), completer);
+    }
+
     public static long countFrom(ToLongFunction<SelectStatementProvider> mapper,
             SqlTable table, CountDSLCompleter completer) {
-        return countFrom(mapper, SqlBuilder.countFrom(table), completer);
+        return mapper.applyAsLong(countFrom(table, completer));
+    }
+
+    public static SelectStatementProvider countFrom(CountDSL<SelectModel> start, CountDSLCompleter completer) {
+        return completer.apply(start)
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
     }
 
     public static long countFrom(ToLongFunction<SelectStatementProvider> mapper,
             CountDSL<SelectModel> start, CountDSLCompleter completer) {
-        return mapper.applyAsLong(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
+        return mapper.applyAsLong(countFrom(start, completer));
+    }
+
+    public static DeleteStatementProvider deleteFrom(SqlTable table, DeleteDSLCompleter completer) {
+        return completer.apply(SqlBuilder.deleteFrom(table))
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
     }
 
     public static int deleteFrom(ToIntFunction<DeleteStatementProvider> mapper,
             SqlTable table, DeleteDSLCompleter completer) {
-        return mapper.applyAsInt(
-                completer.apply(SqlBuilder.deleteFrom(table))
-                .build()
-                .render(RenderingStrategies.MYBATIS3));
+        return mapper.applyAsInt(deleteFrom(table, completer));
     }
 
+    public static <R> InsertStatementProvider<R> insert(R record, SqlTable table, UnaryOperator<InsertDSL<R>> completer) {
+        return completer.apply(SqlBuilder.insert(record).into(table))
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
+    }
+
     public static <R> int insert(ToIntFunction<InsertStatementProvider<R>> mapper, R record, 
             SqlTable table, UnaryOperator<InsertDSL<R>> completer) {
-        return mapper.applyAsInt(completer.apply(
-                SqlBuilder.insert(record).into(table)).build().render(RenderingStrategies.MYBATIS3));
+        return mapper.applyAsInt(insert(record, table, completer));
     }
 
+    public static <R> MultiRowInsertStatementProvider<R> insertMultiple(Collection<R> records, SqlTable table,
+            UnaryOperator<MultiRowInsertDSL<R>> completer) {
+        return completer.apply(SqlBuilder.insertMultiple(records).into(table))
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
+    }
+
     public static <R> int insertMultiple(ToIntFunction<MultiRowInsertStatementProvider<R>> mapper,
             Collection<R> records, SqlTable table, UnaryOperator<MultiRowInsertDSL<R>> completer) {
-        return mapper.applyAsInt(completer.apply(
-                SqlBuilder.insertMultiple(records).into(table)).build().render(RenderingStrategies.MYBATIS3));
+        return mapper.applyAsInt(insertMultiple(records, table, completer));
     }
 
-    public static <R> List<R> selectDistinct(Function<SelectStatementProvider, List<R>> mapper,
-            BasicColumn[] selectList, SqlTable table, SelectDSLCompleter completer) {
-        return selectDistinct(mapper, SqlBuilder.selectDistinct(selectList).from(table), completer);
+    public static SelectStatementProvider select(BasicColumn[] selectList, SqlTable table,
+            SelectDSLCompleter completer) {
+        return select(SqlBuilder.select(selectList).from(table), completer);
+    }
+
+    public static SelectStatementProvider select(QueryExpressionDSL<SelectModel> start,
+            SelectDSLCompleter completer) {
+        return completer.apply(start)
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
+    }
+
+    public static SelectStatementProvider selectDistinct(BasicColumn[] selectList, SqlTable table,
+            SelectDSLCompleter completer) {
+        return select(SqlBuilder.selectDistinct(selectList).from(table), completer);
     }
 
     public static <R> List<R> selectDistinct(Function<SelectStatementProvider, List<R>> mapper,
-            QueryExpressionDSL<SelectModel> start, SelectDSLCompleter completer) {
-        return mapper.apply(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
+            BasicColumn[] selectList, SqlTable table, SelectDSLCompleter completer) {
+        return mapper.apply(selectDistinct(selectList, table, completer));
     }
 
     public static <R> List<R> selectList(Function<SelectStatementProvider, List<R>> mapper,
             BasicColumn[] selectList, SqlTable table, SelectDSLCompleter completer) {
-        return selectList(mapper, SqlBuilder.select(selectList).from(table), completer);
+        return mapper.apply(select(selectList, table, completer));
     }
 
     public static <R> List<R> selectList(Function<SelectStatementProvider, List<R>> mapper,
             QueryExpressionDSL<SelectModel> start, SelectDSLCompleter completer) {
-        return mapper.apply(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
+        return mapper.apply(select(start, completer));
     }
 
-    @Nullable
     public static <R> R selectOne(Function<SelectStatementProvider, R> mapper,
             BasicColumn[] selectList, SqlTable table, SelectDSLCompleter completer) {
-        return selectOne(mapper, SqlBuilder.select(selectList).from(table), completer);
+        return mapper.apply(select(selectList, table, completer));
     }
 
-    @Nullable
     public static <R> R selectOne(Function<SelectStatementProvider, R> mapper,
-            QueryExpressionDSL<SelectModel> start,
-            SelectDSLCompleter completer) {
-        return mapper.apply(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
-    }
-
-    @NotNull
-    public static <R> Optional<R> selectOptional(Function<SelectStatementProvider, Optional<R>> mapper, 
-            BasicColumn[] selectList, SqlTable table, SelectDSLCompleter completer) {
-        return selectOptional(mapper, SqlBuilder.select(selectList).from(table), completer);
+            QueryExpressionDSL<SelectModel> start,SelectDSLCompleter completer) {
+        return mapper.apply(select(start, completer));
     }
 
-    @NotNull
-    public static <R> Optional<R> selectOptional(Function<SelectStatementProvider, Optional<R>> mapper, 
-            QueryExpressionDSL<SelectModel> start, SelectDSLCompleter completer) {
-        return mapper.apply(completer.apply(start).build().render(RenderingStrategies.MYBATIS3));
+    public static UpdateStatementProvider update(SqlTable table, UpdateDSLCompleter completer) {
+        return completer.apply(SqlBuilder.update(table))
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
     }
 
     public static int update(ToIntFunction<UpdateStatementProvider> mapper,
             SqlTable table, UpdateDSLCompleter completer) {
-        return mapper.applyAsInt(
-                completer.apply(SqlBuilder.update(table))
-                .build()
-                .render(RenderingStrategies.MYBATIS3));
+        return mapper.applyAsInt(update(table, completer));
     }
 }

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

@@ -145,7 +145,7 @@ default int insertSelective(PersonRecord record) {
     }
 
     default Optional<PersonRecord> selectOne(SelectDSLCompleter completer) {
-        return MyBatis3Utils.selectOptional(this::selectOne, selectList, person, completer);
+        return MyBatis3Utils.selectOne(this::selectOne, selectList, person, completer);
     }
 
     default List<PersonRecord> select(SelectDSLCompleter completer) {