Renaming for clarity

Author: jeffgbutler

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

@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.delete;
 
+import java.util.Objects;
 import java.util.function.Function;
 
 import org.mybatis.dynamic.sql.BindableColumn;
@@ -26,12 +27,12 @@
 
 public class DeleteDSL<R> {
 
-    private Function<DeleteModel, R> decoratorFunction;
+    private Function<DeleteModel, R> adapterFunction;
     private SqlTable table;
 
-    private DeleteDSL(SqlTable table, Function<DeleteModel, R> decoratorFunction) {
-        this.table = table;
-        this.decoratorFunction = decoratorFunction;
+    private DeleteDSL(SqlTable table, Function<DeleteModel, R> adapterFunction) {
+        this.table = Objects.requireNonNull(table);
+        this.adapterFunction = Objects.requireNonNull(adapterFunction);
     }
 
     public <T> DeleteWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition) {
@@ -53,23 +54,19 @@ public R build() {
         DeleteModel deleteModel = new DeleteModel.Builder()
                 .withTable(table)
                 .build();
-        return decoratorFunction.apply(deleteModel);
+        return adapterFunction.apply(deleteModel);
     }
 
-    public static <R> DeleteDSL<R> genericDeleteFrom(SqlTable table, Function<DeleteModel, R> decoratorFunction) {
-        return new DeleteDSL<>(table, decoratorFunction);
+    public static <R> DeleteDSL<R> genericDeleteFrom(SqlTable table, Function<DeleteModel, R> adapterFunction) {
+        return new DeleteDSL<>(table, adapterFunction);
     }
 
     public static DeleteDSL<DeleteModel> deleteFrom(SqlTable table) {
         return genericDeleteFrom(table, Function.identity());
     }
 
-    public static DeleteDSL<MyBatis3DeleteModel> deleteFrom(SqlTable table, Function<DeleteStatement, Integer> mapperMethod) {
-        return genericDeleteFrom(table, decorate(mapperMethod));
-    }
-    
-    private static Function<DeleteModel, MyBatis3DeleteModel> decorate(Function<DeleteStatement, Integer> mapperMethod) {
-        return deleteModel -> MyBatis3DeleteModel.of(deleteModel, mapperMethod);
+    public static <T> DeleteDSL<MyBatis3DeleteModelAdapter<T>> deleteFrom(SqlTable table, Function<DeleteStatement, T> mapperMethod) {
+        return genericDeleteFrom(table, deleteModel -> MyBatis3DeleteModelAdapter.of(deleteModel, mapperMethod));
     }
 
     public class DeleteWhereBuilder extends AbstractWhereDSL<DeleteWhereBuilder> {
@@ -88,7 +85,7 @@ public R build() {
                     .withTable(table)
                     .withWhereModel(buildWhereModel())
                     .build();
-            return decoratorFunction.apply(deleteModel);
+            return adapterFunction.apply(deleteModel);
         }
 
         @Override

src/main/java/org/mybatis/dynamic/sql/delete/MyBatis3DeleteModel.java src/main/java/org/mybatis/dynamic/sql/delete/MyBatis3DeleteModelAdapter.java

@@ -15,32 +15,37 @@
  */
 package org.mybatis.dynamic.sql.delete;
 
+import java.util.Objects;
 import java.util.function.Function;
 
 import org.mybatis.dynamic.sql.delete.render.DeleteStatement;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 
 /**
- * This DeleteModel will render the underlying delete model for MyBatis3, and then call a MyBatis mapper method.
+ * This adapter will render the underlying delete model for MyBatis3, and then call a MyBatis mapper method.
  * 
  * @author Jeff Butler
  *
  */
-public class MyBatis3DeleteModel {
+public class MyBatis3DeleteModelAdapter<R> {
 
     private DeleteModel deleteModel;
-    private Function<DeleteStatement, Integer> mapperMethod;
+    private Function<DeleteStatement, R> mapperMethod;
 
-    private MyBatis3DeleteModel(DeleteModel deleteModel, Function<DeleteStatement, Integer> mapperMethod) {
-        this.deleteModel = deleteModel;
-        this.mapperMethod = mapperMethod;
+    private MyBatis3DeleteModelAdapter(DeleteModel deleteModel, Function<DeleteStatement, R> mapperMethod) {
+        this.deleteModel = Objects.requireNonNull(deleteModel);
+        this.mapperMethod = Objects.requireNonNull(mapperMethod);
     }
 
-    public int execute() {
-        return mapperMethod.apply(deleteModel.render(RenderingStrategy.MYBATIS3));
+    public R execute() {
+        return mapperMethod.apply(deleteStatement());
     }
 
-    public static MyBatis3DeleteModel of(DeleteModel deleteModel, Function<DeleteStatement, Integer> mapperMethod) {
-        return new MyBatis3DeleteModel(deleteModel, mapperMethod);
+    private DeleteStatement deleteStatement() {
+        return deleteModel.render(RenderingStrategy.MYBATIS3);
+    }
+    
+    public static <R> MyBatis3DeleteModelAdapter<R> of(DeleteModel deleteModel, Function<DeleteStatement, R> mapperMethod) {
+        return new MyBatis3DeleteModelAdapter<>(deleteModel, mapperMethod);
     }
 }

src/main/java/org/mybatis/dynamic/sql/select/MyBatis3SelectModel.java src/main/java/org/mybatis/dynamic/sql/select/MyBatis3SelectModelAdapter.java

@@ -15,32 +15,37 @@
  */
 package org.mybatis.dynamic.sql.select;
 
+import java.util.Objects;
 import java.util.function.Function;
 
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.select.render.SelectStatement;
 
 /**
- * This SelectModel will render the underlying select model for MyBatis3, and then call a MyBatis mapper method.
+ * This adapter will render the underlying select model for MyBatis3, and then call a MyBatis mapper method.
  * 
  * @author Jeff Butler
  *
  */
-public class MyBatis3SelectModel<R> {
+public class MyBatis3SelectModelAdapter<R> {
 
     private SelectModel selectModel;
     private Function<SelectStatement, R> mapperMethod;
 
-    private MyBatis3SelectModel(SelectModel selectModel, Function<SelectStatement, R> mapperMethod) {
-        this.selectModel = selectModel;
-        this.mapperMethod = mapperMethod;
+    private MyBatis3SelectModelAdapter(SelectModel selectModel, Function<SelectStatement, R> mapperMethod) {
+        this.selectModel = Objects.requireNonNull(selectModel);
+        this.mapperMethod = Objects.requireNonNull(mapperMethod);
     }
 
     public R execute() {
-        return mapperMethod.apply(selectModel.render(RenderingStrategy.MYBATIS3));
+        return mapperMethod.apply(selectStatement());
     }
 
-    public static <R> MyBatis3SelectModel<R> of(SelectModel selectModel, Function<SelectStatement, R> mapperMethod) {
-        return new MyBatis3SelectModel<>(selectModel, mapperMethod);
+    private SelectStatement selectStatement() {
+        return selectModel.render(RenderingStrategy.MYBATIS3);
+    }
+    
+    public static <R> MyBatis3SelectModelAdapter<R> of(SelectModel selectModel, Function<SelectStatement, R> mapperMethod) {
+        return new MyBatis3SelectModelAdapter<>(selectModel, mapperMethod);
     }
 }

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

@@ -32,12 +32,12 @@
  */
 public class SelectDSL<R> {
 
-    private Function<SelectModel, R> decoratorFunction;
+    private Function<SelectModel, R> adapterFunction;
     private List<QueryExpressionModel> queryExpressions = new ArrayList<>();    
     private OrderByModel orderByModel;
 
-    private SelectDSL(Function<SelectModel, R> decoratorFunction) {
-        this.decoratorFunction = Objects.requireNonNull(decoratorFunction);
+    private SelectDSL(Function<SelectModel, R> adapterFunction) {
+        this.adapterFunction = Objects.requireNonNull(adapterFunction);
     }
 
     private QueryExpressionDSL<R> queryExpressionBuilder(BasicColumn...selectList) {
@@ -55,34 +55,30 @@ private QueryExpressionDSL<R> distinctQueryExpressionBuilder(BasicColumn...selec
                 .build();
     }
 
-    public static <R> QueryExpressionDSL<R> genericSelect(Function<SelectModel, R> decoratorFunction, BasicColumn...selectList) {
-        SelectDSL<R> selectModelBuilder = new SelectDSL<>(decoratorFunction);
+    public static <R> QueryExpressionDSL<R> genericSelect(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> decoratorFunction, BasicColumn...selectList) {
-        SelectDSL<R> selectModelBuilder = new SelectDSL<>(decoratorFunction);
+    public static <R> QueryExpressionDSL<R> genericSelectDistinct(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);
     }
 
-    public static <T> QueryExpressionDSL<MyBatis3SelectModel<T>> select(Function<SelectStatement, T> mapperMethod, BasicColumn...selectList) {
-        return genericSelect(decorate(mapperMethod), selectList);
+    public static <T> QueryExpressionDSL<MyBatis3SelectModelAdapter<T>> select(Function<SelectStatement, T> mapperMethod, BasicColumn...selectList) {
+        return genericSelect(selectModel -> MyBatis3SelectModelAdapter.of(selectModel, mapperMethod), selectList);
     }
 
     public static QueryExpressionDSL<SelectModel> selectDistinct(BasicColumn...selectList) {
         return genericSelectDistinct(Function.identity(), selectList);
     }
 
-    public static <T> QueryExpressionDSL<MyBatis3SelectModel<T>> selectDistinct(Function<SelectStatement, T> mapperMethod, BasicColumn...selectList) {
-        return genericSelectDistinct(decorate(mapperMethod), selectList);
-    }
-    
-    private static <T> Function<SelectModel, MyBatis3SelectModel<T>> decorate(Function<SelectStatement, T> mapperMethod) {
-        return selectModel -> MyBatis3SelectModel.of(selectModel, mapperMethod);
+    public static <T> QueryExpressionDSL<MyBatis3SelectModelAdapter<T>> selectDistinct(Function<SelectStatement, T> mapperMethod, BasicColumn...selectList) {
+        return genericSelectDistinct(selectModel -> MyBatis3SelectModelAdapter.of(selectModel, mapperMethod), selectList);
     }
 
     void addQueryExpression(QueryExpressionModel queryExpression) {
@@ -98,6 +94,6 @@ public R build() {
                 .withQueryExpressions(queryExpressions)
                 .withOrderByModel(orderByModel)
                 .build();
-        return decoratorFunction.apply(selectModel);
+        return adapterFunction.apply(selectModel);
     }
 }

src/main/java/org/mybatis/dynamic/sql/update/MyBatis3UpdateModel.java src/main/java/org/mybatis/dynamic/sql/update/MyBatis3UpdateModelAdapter.java

@@ -15,32 +15,37 @@
  */
 package org.mybatis.dynamic.sql.update;
 
+import java.util.Objects;
 import java.util.function.Function;
 
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.update.render.UpdateStatement;
 
 /**
- * This UpdateModel will render the underlying update model for MyBatis3, and then call a MyBatis mapper method.
+ * This adapter will render the underlying update model for MyBatis3, and then call a MyBatis mapper method.
  * 
  * @author Jeff Butler
  *
  */
-public class MyBatis3UpdateModel {
+public class MyBatis3UpdateModelAdapter<R> {
 
     private UpdateModel updateModel;
-    private Function<UpdateStatement, Integer> mapperMethod;
+    private Function<UpdateStatement, R> mapperMethod;
 
-    private MyBatis3UpdateModel(UpdateModel updateModel, Function<UpdateStatement, Integer> mapperMethod) {
-        this.updateModel = updateModel;
-        this.mapperMethod = mapperMethod;
+    private MyBatis3UpdateModelAdapter(UpdateModel updateModel, Function<UpdateStatement, R> mapperMethod) {
+        this.updateModel = Objects.requireNonNull(updateModel);
+        this.mapperMethod = Objects.requireNonNull(mapperMethod);
     }
 
-    public int execute() {
-        return mapperMethod.apply(updateModel.render(RenderingStrategy.MYBATIS3));
+    public R execute() {
+        return mapperMethod.apply(updateStatement());
     }
 
-    public static MyBatis3UpdateModel of(UpdateModel updateModel, Function<UpdateStatement, Integer> mapperMethod) {
-        return new MyBatis3UpdateModel(updateModel, mapperMethod);
+    private UpdateStatement updateStatement() {
+        return updateModel.render(RenderingStrategy.MYBATIS3);
+    }
+    
+    public static <R> MyBatis3UpdateModelAdapter<R> of(UpdateModel updateModel, Function<UpdateStatement, R> mapperMethod) {
+        return new MyBatis3UpdateModelAdapter<>(updateModel, mapperMethod);
     }
 }

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

@@ -35,13 +35,13 @@
 
 public class UpdateDSL<R> {
 
-    private Function<UpdateModel, R> decoratorFunction;
+    private Function<UpdateModel, R> adapterFunction;
     private List<UpdateMapping> columnsAndValues = new ArrayList<>();
     private SqlTable table;
 
-    private UpdateDSL(SqlTable table, Function<UpdateModel, R> decoratorFunction) {
+    private UpdateDSL(SqlTable table, Function<UpdateModel, R> adapterFunction) {
         this.table = Objects.requireNonNull(table);
-        this.decoratorFunction = Objects.requireNonNull(decoratorFunction);
+        this.adapterFunction = Objects.requireNonNull(adapterFunction);
     }
 
     public <T> SetClauseFinisher<T> set(SqlColumn<T> column) {
@@ -68,23 +68,19 @@ public R build() {
                 .withTable(table)
                 .withColumnValues(columnsAndValues)
                 .build();
-        return decoratorFunction.apply(updateModel);
+        return adapterFunction.apply(updateModel);
     }
 
-    public static <R> UpdateDSL<R> genericUpdate(Function<UpdateModel, R> decoratorFunction, SqlTable table) {
-        return new UpdateDSL<>(table, decoratorFunction);
+    public static <R> UpdateDSL<R> genericUpdate(Function<UpdateModel, R> adapterFunction, SqlTable table) {
+        return new UpdateDSL<>(table, adapterFunction);
     }
 
     public static UpdateDSL<UpdateModel> update(SqlTable table) {
         return genericUpdate(Function.identity(), table);
     }
 
-    public static UpdateDSL<MyBatis3UpdateModel> update(Function<UpdateStatement, Integer> mapperMethod, SqlTable table) {
-        return genericUpdate(decorate(mapperMethod), table);
-    }
-    
-    private static Function<UpdateModel, MyBatis3UpdateModel> decorate(Function<UpdateStatement, Integer> mapperMethod) {
-        return updateModel -> MyBatis3UpdateModel.of(updateModel, mapperMethod);
+    public static <T> UpdateDSL<MyBatis3UpdateModelAdapter<T>> update(Function<UpdateStatement, T> mapperMethod, SqlTable table) {
+        return genericUpdate(updateModel -> MyBatis3UpdateModelAdapter.of(updateModel, mapperMethod), table);
     }
 
     public class SetClauseFinisher<T> {
@@ -140,7 +136,7 @@ public R build() {
                     .withColumnValues(columnsAndValues)
                     .withWhereModel(buildWhereModel())
                     .build();
-            return decoratorFunction.apply(updateModel);
+            return adapterFunction.apply(updateModel);
         }
 
         @Override

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

@@ -31,15 +31,15 @@
 import org.apache.ibatis.type.JdbcType;
 import org.mybatis.dynamic.sql.SqlBuilder;
 import org.mybatis.dynamic.sql.delete.DeleteDSL;
-import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModel;
+import org.mybatis.dynamic.sql.delete.MyBatis3DeleteModelAdapter;
 import org.mybatis.dynamic.sql.delete.render.DeleteStatement;
 import org.mybatis.dynamic.sql.insert.render.InsertStatement;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
-import org.mybatis.dynamic.sql.select.MyBatis3SelectModel;
+import org.mybatis.dynamic.sql.select.MyBatis3SelectModelAdapter;
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
 import org.mybatis.dynamic.sql.select.SelectDSL;
 import org.mybatis.dynamic.sql.select.render.SelectStatement;
-import org.mybatis.dynamic.sql.update.MyBatis3UpdateModel;
+import org.mybatis.dynamic.sql.update.MyBatis3UpdateModelAdapter;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
 import org.mybatis.dynamic.sql.update.render.UpdateStatement;
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
@@ -74,12 +74,12 @@ public interface SimpleTableAnnotatedMapper {
     @SelectProvider(type=SqlProviderAdapter.class, method="select")
     long count(SelectStatement selectStatement);
 
-    default QueryExpressionDSL<MyBatis3SelectModel<Long>>.QueryExpressionAfterFrom countByExample() {
+    default QueryExpressionDSL<MyBatis3SelectModelAdapter<Long>>.QueryExpressionAfterFrom countByExample() {
         return SelectDSL.select(this::count, SqlBuilder.count())
             .from(simpleTable);
     }
 
-    default DeleteDSL<MyBatis3DeleteModel> deleteByExample() {
+    default DeleteDSL<MyBatis3DeleteModelAdapter<Integer>> deleteByExample() {
         return DeleteDSL.deleteFrom(simpleTable, this::delete);
     }
 
@@ -116,7 +116,7 @@ default int insertSelective(SimpleTableRecord record) {
                 .render(RenderingStrategy.MYBATIS3));
     }
 
-    default QueryExpressionDSL<MyBatis3SelectModel<List<SimpleTableRecord>>>.QueryExpressionAfterFrom selectByExample() {
+    default QueryExpressionDSL<MyBatis3SelectModelAdapter<List<SimpleTableRecord>>>.QueryExpressionAfterFrom selectByExample() {
         return SelectDSL.select(this::selectMany, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
             .from(simpleTable);
     }
@@ -129,7 +129,7 @@ default SimpleTableRecord selectByPrimaryKey(Integer id_) {
             .render(RenderingStrategy.MYBATIS3));
     }
 
-    default UpdateDSL<MyBatis3UpdateModel> updateByExample(SimpleTableRecord record) {
+    default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExample(SimpleTableRecord record) {
         return UpdateDSL.update(this::update, simpleTable)
                 .set(id).equalTo(record.getId())
                 .set(firstName).equalTo(record.getFirstName())
@@ -139,7 +139,7 @@ default UpdateDSL<MyBatis3UpdateModel> updateByExample(SimpleTableRecord record)
                 .set(occupation).equalTo(record.getOccupation());
     }
 
-    default UpdateDSL<MyBatis3UpdateModel> updateByExampleSelective(SimpleTableRecord record) {
+    default UpdateDSL<MyBatis3UpdateModelAdapter<Integer>> updateByExampleSelective(SimpleTableRecord record) {
         return UpdateDSL.update(this::update, simpleTable)
                 .set(id).equalToWhenPresent(record.getId())
                 .set(firstName).equalToWhenPresent(record.getFirstName())