Better method names

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java

@@ -57,17 +57,17 @@ public R build() {
         return adapterFunction.apply(deleteModel);
     }
 
-    public static <R> DeleteDSL<R> genericDeleteFrom(SqlTable table, Function<DeleteModel, R> adapterFunction) {
+    public static <R> DeleteDSL<R> deleteFrom(Function<DeleteModel, R> adapterFunction, SqlTable table) {
         return new DeleteDSL<>(table, adapterFunction);
     }
 
     public static DeleteDSL<DeleteModel> deleteFrom(SqlTable table) {
-        return genericDeleteFrom(table, Function.identity());
+        return deleteFrom(Function.identity(), table);
     }
 
-    public static <T> DeleteDSL<MyBatis3DeleteModelAdapter<T>> deleteFrom(SqlTable table,
-            Function<DeleteStatement, T> mapperMethod) {
-        return genericDeleteFrom(table, deleteModel -> MyBatis3DeleteModelAdapter.of(deleteModel, mapperMethod));
+    public static <T> DeleteDSL<MyBatis3DeleteModelAdapter<T>> deleteFromWithMapper(
+            Function<DeleteStatement, T> mapperMethod, SqlTable table) {
+        return deleteFrom(deleteModel -> MyBatis3DeleteModelAdapter.of(deleteModel, mapperMethod), table);
     }
 
     public class DeleteWhereBuilder extends AbstractWhereDSL<DeleteWhereBuilder> {

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

@@ -55,34 +55,34 @@ private QueryExpressionDSL<R> distinctQueryExpressionBuilder(BasicColumn...selec
                 .build();
     }
 
-    public static <R> QueryExpressionDSL<R> genericSelect(Function<SelectModel, R> adapterFunction,
+    public static <R> QueryExpressionDSL<R> select(Function<SelectModel, R> adapterFunction,
             BasicColumn...selectList) {
         SelectDSL<R> selectModelBuilder = new SelectDSL<>(adapterFunction);
         return selectModelBuilder.queryExpressionBuilder(selectList);
     }
 
-    public static <R> QueryExpressionDSL<R> genericSelectDistinct(Function<SelectModel, R> adapterFunction,
+    public static <R> QueryExpressionDSL<R> selectDistinct(Function<SelectModel, R> adapterFunction,
             BasicColumn...selectList) {
         SelectDSL<R> selectModelBuilder = new SelectDSL<>(adapterFunction);
         return selectModelBuilder.distinctQueryExpressionBuilder(selectList);
     }
 
     public static QueryExpressionDSL<SelectModel> select(BasicColumn...selectList) {
-        return genericSelect(Function.identity(), selectList);
+        return select(Function.identity(), selectList);
     }
 
-    public static <T> QueryExpressionDSL<MyBatis3SelectModelAdapter<T>> select(
+    public static <T> QueryExpressionDSL<MyBatis3SelectModelAdapter<T>> selectWithMapper(
             Function<SelectStatement, T> mapperMethod, BasicColumn...selectList) {
-        return genericSelect(selectModel -> MyBatis3SelectModelAdapter.of(selectModel, mapperMethod), selectList);
+        return select(selectModel -> MyBatis3SelectModelAdapter.of(selectModel, mapperMethod), selectList);
     }
 
     public static QueryExpressionDSL<SelectModel> selectDistinct(BasicColumn...selectList) {
-        return genericSelectDistinct(Function.identity(), selectList);
+        return selectDistinct(Function.identity(), selectList);
     }
 
-    public static <T> QueryExpressionDSL<MyBatis3SelectModelAdapter<T>> selectDistinct(
+    public static <T> QueryExpressionDSL<MyBatis3SelectModelAdapter<T>> selectDistinctWithMapper(
             Function<SelectStatement, T> mapperMethod, BasicColumn...selectList) {
-        return genericSelectDistinct(selectModel -> MyBatis3SelectModelAdapter.of(selectModel, mapperMethod),
+        return selectDistinct(selectModel -> MyBatis3SelectModelAdapter.of(selectModel, mapperMethod),
                 selectList);
     }
 

src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java

@@ -71,17 +71,17 @@ public R build() {
         return adapterFunction.apply(updateModel);
     }
 
-    public static <R> UpdateDSL<R> genericUpdate(Function<UpdateModel, R> adapterFunction, SqlTable table) {
+    public static <R> UpdateDSL<R> update(Function<UpdateModel, R> adapterFunction, SqlTable table) {
         return new UpdateDSL<>(table, adapterFunction);
     }
 
     public static UpdateDSL<UpdateModel> update(SqlTable table) {
-        return genericUpdate(Function.identity(), table);
+        return update(Function.identity(), table);
     }
 
-    public static <T> UpdateDSL<MyBatis3UpdateModelAdapter<T>> update(Function<UpdateStatement, T> mapperMethod,
+    public static <T> UpdateDSL<MyBatis3UpdateModelAdapter<T>> updateWithMapper(Function<UpdateStatement, T> mapperMethod,
             SqlTable table) {
-        return genericUpdate(updateModel -> MyBatis3UpdateModelAdapter.of(updateModel, mapperMethod), table);
+        return update(updateModel -> MyBatis3UpdateModelAdapter.of(updateModel, mapperMethod), table);
     }
 
     public class SetClauseFinisher<T> {

src/test/java/examples/simple/SimpleTableAnnotatedMapper.java

@@ -75,12 +75,12 @@ public interface SimpleTableAnnotatedMapper {
     long count(SelectStatement selectStatement);
 
     default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>>.QueryExpressionAfterFrom countByExample() {
-        return SelectDSL.select(this::count, SqlBuilder.count())
+        return SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
             .from(simpleTable);
     }
 
     default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
-        return DeleteDSL.deleteFrom(simpleTable, this::delete);
+        return DeleteDSL.deleteFromWithMapper(this::delete, simpleTable);
     }
 
     default int deleteByPrimaryKey(Integer id_) {
@@ -117,7 +117,7 @@ default int insertSelective(SimpleTableRecord record) {
     }
 
     default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<SimpleTableRecord>>>.QueryExpressionAfterFrom selectByExample() {
-        return SelectDSL.select(this::selectMany, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
+        return SelectDSL.selectWithMapper(this::selectMany, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
             .from(simpleTable);
     }
 
@@ -130,7 +130,7 @@ default SimpleTableRecord selectByPrimaryKey(Integer id_) {
     }
 
     default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(SimpleTableRecord record) {
-        return UpdateDSL.update(this::update, simpleTable)
+        return UpdateDSL.updateWithMapper(this::update, simpleTable)
                 .set(id).equalTo(record.getId())
                 .set(firstName).equalTo(record.getFirstName())
                 .set(lastName).equalTo(record.getLastName())
@@ -140,7 +140,7 @@ default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(SimpleTab
     }
 
     default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(SimpleTableRecord record) {
-        return UpdateDSL.update(this::update, simpleTable)
+        return UpdateDSL.updateWithMapper(this::update, simpleTable)
                 .set(id).equalToWhenPresent(record.getId())
                 .set(firstName).equalToWhenPresent(record.getFirstName())
                 .set(lastName).equalToWhenPresent(record.getLastName())