Better Names

Author: jeffgbutler

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

@@ -21,11 +21,11 @@
 import org.mybatis.dynamic.sql.SqlCriterion;
 import org.mybatis.dynamic.sql.VisitableCondition;
 import org.mybatis.dynamic.sql.util.Buildable;
-import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3SelectHelper;
+import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3SelectCompleter;
 
 /**
  * This interface describes operations allowed for a select statement after the from and join clauses. This is
- * primarily to support the {@link MyBatis3SelectHelper} class.
+ * primarily to support {@link MyBatis3SelectCompleter}.
  * 
  * @author Jeff Butler
  *

src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3DeleteHelper.java renamed to src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3DeleteCompleter.java

@@ -16,34 +16,37 @@
 package org.mybatis.dynamic.sql.util.mybatis3;
 
 import java.util.function.Function;
+import java.util.function.ToIntFunction;
 
+import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.delete.DeleteDSL;
 import org.mybatis.dynamic.sql.delete.DeleteModel;
 import org.mybatis.dynamic.sql.util.Buildable;
 
 /**
  * Represents a function that can be used to create a general delete method in the style
  * of MyBatis Generator. When using this function, you can create a method that does not require a user to
- * call the build().execute() methods - making client code look a bit cleaner.
+ * call the build() and render() methods - making client code look a bit cleaner.
+ * 
+ * <p>This function is intended to be used in conjunction with the utility function
+ *  {@link MyBatis3Utils#deleteFrom(ToIntFunction, SqlTable, MyBatis3DeleteCompleter)}
  * 
  * <p>For example, you can create mapper interface methods like this:
  * 
  * <pre>
  * &#64;DeleteProvider(type=SqlProviderAdapter.class, method="delete")
  * int delete(DeleteStatementProvider deleteStatement);
  *   
- * default int delete(MyBatis3DeleteHelper helper) {
- *     return helper.apply(DeleteDSL.deleteFromWithMapper(this::delete, simpleTable))
- *           .build()
- *           .execute();
+ * default int delete(MyBatis3DeleteCompleter completer) {
+ *     return MyBatis3Utils.deleteFrom(this::delete, person, completer);
  * }
  * </pre>
  * 
  * <p>And then call the simplified default method like this:
  * 
  * <pre>
- * int rows = mapper.delete(q -&gt;
- *           q.where(occupation, isNull()));
+ * int rows = mapper.delete(c -&gt;
+ *           c.where(occupation, isNull()));
  * </pre>
  *  
  * <p>You can implement a "delete all" with the following code:
@@ -55,21 +58,21 @@
  * <p>Or
  * 
  * <pre>
- * long rows = mapper.delete(MyBatis3DeleteHelper.allRows());
+ * long rows = mapper.delete(MyBatis3DeleteCompleter.allRows());
  * </pre>
 
  * @author Jeff Butler
  */
 @FunctionalInterface
-public interface MyBatis3DeleteHelper extends
+public interface MyBatis3DeleteCompleter extends
         Function<DeleteDSL<DeleteModel>, Buildable<DeleteModel>> {
 
     /**
      * Returns a helper that can be used to delete every row in a table.
      * 
      * @return the helper that will delete every row in a table
      */
-    static MyBatis3DeleteHelper allRows() {
+    static MyBatis3DeleteCompleter allRows() {
         return h -> h;
     }
 }

src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3SelectHelper.java renamed to src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3SelectCompleter.java

@@ -25,33 +25,33 @@
 /**
  * Represents a function that can be used to create a general count method in the style
  * of MyBatis Generator. When using this function, you can create a method that does not require a user to
- * call the build().execute() methods - making client code look a bit cleaner.
+ * call the build() and render() methods - making client code look a bit cleaner.
+ * 
+ * <p>This function is intended to by used in conjunction with several utility methods in
+ * {@link MyBatis3Utils} 
  * 
  * <p>For example, you can create mapper interface methods like this:
  * 
  * <pre>
  * &#64;SelectProvider(type=SqlProviderAdapter.class, method="select")
  * long count(SelectStatementProvider selectStatement);
  *   
- * default long count(MyBatis3CountHelper helper) {
- *     return helper.apply(SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
- *             .from(simpleTable))
- *             .build()
- *             .execute();
+ * default long count(MyBatis3SelectCompleter completer) {
+        return MyBatis3Utils.count(this::count, person, completer);
  * }
  * </pre>
  * 
  * <p>And then call the simplified default method like this:
  * 
  * <pre>
- * long rows = mapper.count(q -&gt;
- *         q.where(occupation, isNull()));
+ * long rows = mapper.count(c -&gt;
+ *         c.where(occupation, isNull()));
  * </pre>
  * 
  * <p>You can implement a "count all" with the following code:
  * 
  * <pre>
- * long rows = mapper.count(q -&gt; q);
+ * long rows = mapper.count(c -&gt; c);
  * </pre>
  * 
  * <p>Or
@@ -63,19 +63,19 @@
  * @author Jeff Butler
  */
 @FunctionalInterface
-public interface MyBatis3SelectHelper extends
+public interface MyBatis3SelectCompleter extends
         Function<CompletableQuery<SelectModel>, Buildable<SelectModel>> {
 
     /**
      * Returns a helper that can be used to count every row in a table.
      * 
      * @return the helper that will count every row in a table
      */
-    static MyBatis3SelectHelper allRows() {
+    static MyBatis3SelectCompleter allRows() {
         return h -> h;
     }
 
-    static MyBatis3SelectHelper allRowsOrderedBy(SortSpecification...columns) {
+    static MyBatis3SelectCompleter allRowsOrderedBy(SortSpecification...columns) {
         return h -> h.orderBy(columns);
     }
 }

src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3UpdateHelper.java renamed to src/main/java/org/mybatis/dynamic/sql/util/mybatis3/MyBatis3UpdateCompleter.java

@@ -16,52 +16,55 @@
 package org.mybatis.dynamic.sql.util.mybatis3;
 
 import java.util.function.Function;
+import java.util.function.ToIntFunction;
 
+import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
 import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.util.Buildable;
 
 /**
  * Represents a function that can be used to create a general update method in the style
  * of MyBatis Generator. When using this function, you can create a method that does not require a user to
- * call the build().execute() methods - making client code look a bit cleaner.
+ * call the build() and render() methods - making client code look a bit cleaner.
+ * 
+ * <p>This function is intended to be used in conjunction with the utility function
+ *  {@link MyBatis3Utils#update(ToIntFunction, SqlTable, MyBatis3UpdateCompleter)}
  * 
  * <p>For example, you can create mapper interface methods like this:
  * 
  * <pre>
  * &#64;UpdateProvider(type=SqlProviderAdapter.class, method="update")
  * int update(UpdateStatementProvider updateStatement);
  *   
- * default int update(MyBatis3UpdateHelper helper) {
- *     return helper.apply(UpdateDSL.updateWithMapper(this::update, simpleTable))
- *             .build()
- *             .execute();
+ * default int update(MyBatis3UpdateCompleter completer) {
+        return MyBatis3Utils.update(this::update, person, completer);
  * }
  * </pre>
  * 
  * <p>And then call the simplified default method like this:
  * 
  * <pre>
- * int rows = mapper.update(q -&gt;
- *                q.set(firstName).equalTo("Fred")
+ * int rows = mapper.update(c -&gt;
+ *                c.set(firstName).equalTo("Fred")
  *                .where(id, isEqualTo(100))
  *            );
  * </pre>
  *  
  * <p>You can implement an "update all" simply by omitting a where clause:
  * 
  * <pre>
- * int rows = mapper.update(q -&gt;
- *                q.set(firstName).equalTo("Fred")
+ * int rows = mapper.update(c -&gt;
+ *                c.set(firstName).equalTo("Fred")
  *            );
  * </pre>
  * 
  * <p>You could also implement a helper method that would set fields based on values of a record. For example,
  * the following method would set all fields of a record based on whether or not the values are null:
  * 
  * <pre>
- * static UpdateDSL&lt;MyBatis3UpdateModelAdapter&lt;Integer&gt;&gt; setSelective(SimpleTableRecord record,
- *         UpdateDSL&lt;MyBatis3UpdateModelAdapter&lt;Integer&gt;&gt; dsl) {
+ * static UpdateDSL&lt;UpdateModel&gt; setSelective(PersonRecord record,
+ *         UpdateDSL&lt;UpdateModel&gt; dsl) {
  *     return dsl.set(id).equalToWhenPresent(record::getId)
  *             .set(firstName).equalToWhenPresent(record::getFirstName)
  *             .set(lastName).equalToWhenPresent(record::getLastName)
@@ -74,8 +77,8 @@
  * <p>The helper method could be used like this:
  * 
  * <pre>
- * rows = mapper.update(dsl -&gt;
- *        SimpleTableAnnotatedMapperNewStyle.setSelective(record, dsl)
+ * rows = mapper.update(c -&gt;
+ *        PersonMapper.setSelective(record, c)
  *        .where(id, isLessThan(100)));
  * </pre>
  * 
@@ -85,6 +88,6 @@
  * @author Jeff Butler
  */
 @FunctionalInterface
-public interface MyBatis3UpdateHelper extends
+public interface MyBatis3UpdateCompleter extends
         Function<UpdateDSL<UpdateModel>, Buildable<UpdateModel>> {
 }

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

@@ -51,70 +51,70 @@ public class MyBatis3Utils {
     private MyBatis3Utils() {}
 
     public static long count(ToLongFunction<SelectStatementProvider> mapper,
-            SqlTable table, MyBatis3SelectHelper helper) {
-        return count(mapper, SelectDSL.select(SqlBuilder.count()).from(table), helper);
+            SqlTable table, MyBatis3SelectCompleter completer) {
+        return count(mapper, SelectDSL.select(SqlBuilder.count()).from(table), completer);
     }
 
     public static long count(ToLongFunction<SelectStatementProvider> mapper,
-            QueryExpressionDSL<SelectModel> start, MyBatis3SelectHelper helper) {
-        return mapper.applyAsLong(helper.apply(start).build().render(RenderingStrategy.MYBATIS3));
+            QueryExpressionDSL<SelectModel> start, MyBatis3SelectCompleter completer) {
+        return mapper.applyAsLong(completer.apply(start).build().render(RenderingStrategy.MYBATIS3));
     }
 
     public static int deleteFrom(ToIntFunction<DeleteStatementProvider> mapper,
-            SqlTable table, MyBatis3DeleteHelper helper) {
+            SqlTable table, MyBatis3DeleteCompleter completer) {
         return mapper.applyAsInt(
-                helper.apply(DeleteDSL.deleteFrom(table))
+                completer.apply(DeleteDSL.deleteFrom(table))
                 .build()
                 .render(RenderingStrategy.MYBATIS3));
     }
 
     public static <R> int insert(ToIntFunction<InsertStatementProvider<R>> mapper, R record, 
-            SqlTable table, UnaryOperator<InsertDSL<R>> helper) {
-        return mapper.applyAsInt(helper.apply(
+            SqlTable table, UnaryOperator<InsertDSL<R>> completer) {
+        return mapper.applyAsInt(completer.apply(
                 InsertDSL.insert(record).into(table)).build().render(RenderingStrategy.MYBATIS3));
     }
 
     public static <R> int insertMultiple(ToIntFunction<MultiRowInsertStatementProvider<R>> mapper,
-            Collection<R> records, SqlTable table, UnaryOperator<MultiRowInsertDSL<R>> helper) {
-        return mapper.applyAsInt(helper.apply(
+            Collection<R> records, SqlTable table, UnaryOperator<MultiRowInsertDSL<R>> completer) {
+        return mapper.applyAsInt(completer.apply(
                 MultiRowInsertDSL.insert(records).into(table)).build().render(RenderingStrategy.MYBATIS3));
     }
 
     public static <R> List<R> selectDistinct(Function<SelectStatementProvider, List<R>> mapper,
-            BasicColumn[] selectList, SqlTable table, MyBatis3SelectHelper helper) {
-        return selectDistinct(mapper, SelectDSL.selectDistinct(selectList).from(table), helper);
+            BasicColumn[] selectList, SqlTable table, MyBatis3SelectCompleter completer) {
+        return selectDistinct(mapper, SelectDSL.selectDistinct(selectList).from(table), completer);
     }
 
     public static <R> List<R> selectDistinct(Function<SelectStatementProvider, List<R>> mapper,
-            CompletableQuery<SelectModel> start, MyBatis3SelectHelper helper) {
-        return mapper.apply(helper.apply(start).build().render(RenderingStrategy.MYBATIS3));
+            CompletableQuery<SelectModel> start, MyBatis3SelectCompleter completer) {
+        return mapper.apply(completer.apply(start).build().render(RenderingStrategy.MYBATIS3));
     }
 
     public static <R> List<R> selectList(Function<SelectStatementProvider, List<R>> mapper,
-            BasicColumn[] selectList, SqlTable table, MyBatis3SelectHelper helper) {
-        return selectList(mapper, SelectDSL.select(selectList).from(table), helper);
+            BasicColumn[] selectList, SqlTable table, MyBatis3SelectCompleter completer) {
+        return selectList(mapper, SelectDSL.select(selectList).from(table), completer);
     }
 
     public static <R> List<R> selectList(Function<SelectStatementProvider, List<R>> mapper,
-            CompletableQuery<SelectModel> start, MyBatis3SelectHelper helper) {
-        return mapper.apply(helper.apply(start).build().render(RenderingStrategy.MYBATIS3));
+            CompletableQuery<SelectModel> start, MyBatis3SelectCompleter completer) {
+        return mapper.apply(completer.apply(start).build().render(RenderingStrategy.MYBATIS3));
     }
 
     public static <R> Optional<R> selectOne(Function<SelectStatementProvider, Optional<R>> mapper,
-            BasicColumn[] selectList, SqlTable table, MyBatis3SelectHelper helper) {
-        return selectOne(mapper, SelectDSL.select(selectList).from(table), helper);
+            BasicColumn[] selectList, SqlTable table, MyBatis3SelectCompleter completer) {
+        return selectOne(mapper, SelectDSL.select(selectList).from(table), completer);
     }
 
     public static <R> Optional<R> selectOne(Function<SelectStatementProvider, Optional<R>> mapper,
             CompletableQuery<SelectModel> start,
-            MyBatis3SelectHelper helper) {
-        return mapper.apply(helper.apply(start).build().render(RenderingStrategy.MYBATIS3));
+            MyBatis3SelectCompleter completer) {
+        return mapper.apply(completer.apply(start).build().render(RenderingStrategy.MYBATIS3));
     }
 
     public static int update(ToIntFunction<UpdateStatementProvider> mapper,
-            SqlTable table, MyBatis3UpdateHelper helper) {
+            SqlTable table, MyBatis3UpdateCompleter completer) {
         return mapper.applyAsInt(
-                helper.apply(UpdateDSL.update(table))
+                completer.apply(UpdateDSL.update(table))
                 .build()
                 .render(RenderingStrategy.MYBATIS3));
     }