Remove UpdateDSL Generics

Author: jeffgbutler

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

@@ -57,7 +57,6 @@
 import org.mybatis.dynamic.sql.select.function.Subtract;
 import org.mybatis.dynamic.sql.select.function.Upper;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
-import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.util.Buildable;
 import org.mybatis.dynamic.sql.where.WhereDSL;
 import org.mybatis.dynamic.sql.where.condition.IsBetween;
@@ -237,11 +236,11 @@ static MultiSelectDSL multiSelect(Buildable<SelectModel> selectModelBuilder) {
         return new MultiSelectDSL(selectModelBuilder);
     }
 
-    static UpdateDSL<UpdateModel> update(SqlTable table) {
+    static UpdateDSL update(SqlTable table) {
         return UpdateDSL.update(table);
     }
 
-    static UpdateDSL<UpdateModel> update(SqlTable table, String tableAlias) {
+    static UpdateDSL update(SqlTable table, String tableAlias) {
         return UpdateDSL.update(table, tableAlias);
     }
 

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

@@ -21,7 +21,6 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Consumer;
-import java.util.function.Function;
 import java.util.function.Supplier;
 
 import org.jspecify.annotations.Nullable;
@@ -47,10 +46,9 @@
 import org.mybatis.dynamic.sql.where.AbstractWhereStarter;
 import org.mybatis.dynamic.sql.where.EmbeddedWhereModel;
 
-public class UpdateDSL<R> implements AbstractWhereStarter<UpdateDSL<R>.UpdateWhereBuilder, UpdateDSL<R>>,
-        Buildable<R> {
+public class UpdateDSL implements AbstractWhereStarter<UpdateDSL.UpdateWhereBuilder, UpdateDSL>,
+        Buildable<UpdateModel> {
 
-    private final Function<UpdateModel, R> adapterFunction;
     private final List<AbstractColumnMapping> columnMappings = new ArrayList<>();
     private final SqlTable table;
     private final @Nullable String tableAlias;
@@ -59,10 +57,9 @@ public class UpdateDSL<R> implements AbstractWhereStarter<UpdateDSL<R>.UpdateWhe
     private @Nullable Long limit;
     private @Nullable OrderByModel orderByModel;
 
-    private UpdateDSL(SqlTable table, @Nullable String tableAlias, Function<UpdateModel, R> adapterFunction) {
+    private UpdateDSL(SqlTable table, @Nullable String tableAlias) {
         this.table = Objects.requireNonNull(table);
         this.tableAlias = tableAlias;
-        this.adapterFunction = Objects.requireNonNull(adapterFunction);
     }
 
     public <T> SetClauseFinisher<T> set(SqlColumn<T> column) {
@@ -75,20 +72,20 @@ public UpdateWhereBuilder where() {
         return whereBuilder;
     }
 
-    public UpdateDSL<R> limit(long limit) {
+    public UpdateDSL limit(long limit) {
         return limitWhenPresent(limit);
     }
 
-    public UpdateDSL<R> limitWhenPresent(@Nullable Long limit) {
+    public UpdateDSL limitWhenPresent(@Nullable Long limit) {
         this.limit = limit;
         return this;
     }
 
-    public UpdateDSL<R> orderBy(SortSpecification... columns) {
+    public UpdateDSL orderBy(SortSpecification... columns) {
         return orderBy(Arrays.asList(columns));
     }
 
-    public UpdateDSL<R> orderBy(Collection<? extends SortSpecification> columns) {
+    public UpdateDSL orderBy(Collection<? extends SortSpecification> columns) {
         orderByModel = OrderByModel.of(columns);
         return this;
     }
@@ -100,36 +97,29 @@ public UpdateDSL<R> orderBy(Collection<? extends SortSpecification> columns) {
      * @return the update model
      */
     @Override
-    public R build() {
-        UpdateModel updateModel = UpdateModel.withTable(table)
+    public UpdateModel build() {
+        return UpdateModel.withTable(table)
                 .withTableAlias(tableAlias)
                 .withColumnMappings(columnMappings)
                 .withLimit(limit)
                 .withOrderByModel(orderByModel)
                 .withWhereModel(whereBuilder == null ? null : whereBuilder.buildWhereModel())
                 .withStatementConfiguration(statementConfiguration)
                 .build();
-
-        return adapterFunction.apply(updateModel);
     }
 
     @Override
-    public UpdateDSL<R> configureStatement(Consumer<StatementConfiguration> consumer) {
+    public UpdateDSL configureStatement(Consumer<StatementConfiguration> consumer) {
         consumer.accept(statementConfiguration);
         return this;
     }
 
-    public static <R> UpdateDSL<R> update(Function<UpdateModel, R> adapterFunction, SqlTable table,
-                                          @Nullable String tableAlias) {
-        return new UpdateDSL<>(table, tableAlias, adapterFunction);
-    }
-
-    public static UpdateDSL<UpdateModel> update(SqlTable table) {
-        return update(Function.identity(), table, null);
+    public static UpdateDSL update(SqlTable table, @Nullable String tableAlias) {
+        return new UpdateDSL(table, tableAlias);
     }
 
-    public static UpdateDSL<UpdateModel> update(SqlTable table, String tableAlias) {
-        return update(Function.identity(), table, tableAlias);
+    public static UpdateDSL update(SqlTable table) {
+        return update(table, null);
     }
 
     public class SetClauseFinisher<T> {
@@ -140,84 +130,85 @@ public SetClauseFinisher(SqlColumn<T> column) {
             this.column = column;
         }
 
-        public UpdateDSL<R> equalToNull() {
+        public UpdateDSL equalToNull() {
             columnMappings.add(NullMapping.of(column));
             return UpdateDSL.this;
         }
 
-        public UpdateDSL<R> equalToConstant(String constant) {
+        public UpdateDSL equalToConstant(String constant) {
             columnMappings.add(ConstantMapping.of(column, constant));
             return UpdateDSL.this;
         }
 
-        public UpdateDSL<R> equalToStringConstant(String constant) {
+        public UpdateDSL equalToStringConstant(String constant) {
             columnMappings.add(StringConstantMapping.of(column, constant));
             return UpdateDSL.this;
         }
 
-        public UpdateDSL<R> equalTo(T value) {
+        public UpdateDSL equalTo(T value) {
             return equalTo(() -> value);
         }
 
-        public UpdateDSL<R> equalTo(Supplier<T> valueSupplier) {
+        public UpdateDSL equalTo(Supplier<T> valueSupplier) {
             columnMappings.add(ValueMapping.of(column, valueSupplier));
             return UpdateDSL.this;
         }
 
-        public UpdateDSL<R> equalTo(Buildable<SelectModel> buildable) {
+        public UpdateDSL equalTo(Buildable<SelectModel> buildable) {
             columnMappings.add(SelectMapping.of(column, buildable));
             return UpdateDSL.this;
         }
 
-        public UpdateDSL<R> equalTo(BasicColumn rightColumn) {
+        public UpdateDSL equalTo(BasicColumn rightColumn) {
             columnMappings.add(ColumnToColumnMapping.of(column, rightColumn));
             return UpdateDSL.this;
         }
 
-        public UpdateDSL<R> equalToOrNull(@Nullable T value) {
+        public UpdateDSL equalToOrNull(@Nullable T value) {
             return equalToOrNull(() -> value);
         }
 
-        public UpdateDSL<R> equalToOrNull(Supplier<@Nullable T> valueSupplier) {
+        public UpdateDSL equalToOrNull(Supplier<@Nullable T> valueSupplier) {
             columnMappings.add(ValueOrNullMapping.of(column, valueSupplier));
             return UpdateDSL.this;
         }
 
-        public UpdateDSL<R> equalToWhenPresent(@Nullable T value) {
+        public UpdateDSL equalToWhenPresent(@Nullable T value) {
             return equalToWhenPresent(() -> value);
         }
 
-        public UpdateDSL<R> equalToWhenPresent(Supplier<@Nullable T> valueSupplier) {
+        public UpdateDSL equalToWhenPresent(Supplier<@Nullable T> valueSupplier) {
             columnMappings.add(ValueWhenPresentMapping.of(column, valueSupplier));
             return UpdateDSL.this;
         }
     }
 
-    public class UpdateWhereBuilder extends AbstractWhereFinisher<UpdateWhereBuilder> implements Buildable<R> {
+    public class UpdateWhereBuilder extends AbstractWhereFinisher<UpdateWhereBuilder>
+            implements Buildable<UpdateModel> {
 
         private UpdateWhereBuilder() {
             super(UpdateDSL.this);
         }
 
-        public UpdateDSL<R> limit(long limit) {
+        public UpdateDSL limit(long limit) {
             return limitWhenPresent(limit);
         }
 
-        public UpdateDSL<R> limitWhenPresent(Long limit) {
+        public UpdateDSL limitWhenPresent(Long limit) {
             return UpdateDSL.this.limitWhenPresent(limit);
         }
 
-        public UpdateDSL<R> orderBy(SortSpecification... columns) {
+        public UpdateDSL orderBy(SortSpecification... columns) {
             return orderBy(Arrays.asList(columns));
         }
 
-        public UpdateDSL<R> orderBy(Collection<? extends SortSpecification> columns) {
+        public UpdateDSL orderBy(Collection<? extends SortSpecification> columns) {
             orderByModel = OrderByModel.of(columns);
             return UpdateDSL.this;
         }
 
         @Override
-        public R build() {
+        public UpdateModel build() {
             return UpdateDSL.this.build();
         }
 

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

@@ -88,5 +88,5 @@
  */
 @FunctionalInterface
 public interface UpdateDSLCompleter extends
-        Function<UpdateDSL<UpdateModel>, Buildable<UpdateModel>> {
+        Function<UpdateDSL, Buildable<UpdateModel>> {
 }

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinUpdateBuilder.kt

@@ -24,8 +24,8 @@ import org.mybatis.dynamic.sql.util.Buildable
 
 typealias UpdateCompleter = KotlinUpdateBuilder.() -> Unit
 
-class KotlinUpdateBuilder(private val dsl: UpdateDSL<UpdateModel>) :
-    KotlinBaseBuilder<UpdateDSL<UpdateModel>>(), Buildable<UpdateModel> {
+class KotlinUpdateBuilder(private val dsl: UpdateDSL) :
+    KotlinBaseBuilder<UpdateDSL>(), Buildable<UpdateModel> {
 
     fun <T : Any> set(column: SqlColumn<T>): KotlinSetClauseFinisher<T> = KotlinSetClauseFinisher(column)
 
@@ -43,7 +43,7 @@ class KotlinUpdateBuilder(private val dsl: UpdateDSL<UpdateModel>) :
 
     override fun build(): UpdateModel = dsl.build()
 
-    override fun getDsl(): UpdateDSL<UpdateModel> = dsl
+    override fun getDsl(): UpdateDSL = dsl
 
     @MyBatisDslMarker
     @Suppress("TooManyFunctions")
@@ -94,7 +94,7 @@ class KotlinUpdateBuilder(private val dsl: UpdateDSL<UpdateModel>) :
 
         infix fun equalToWhenPresent(value: T?): Unit = equalToWhenPresent { value }
 
-        private fun applyToDsl(block: UpdateDSL<UpdateModel>.() -> Unit) {
+        private fun applyToDsl(block: UpdateDSL.() -> Unit) {
             this@KotlinUpdateBuilder.dsl.apply(block)
         }
     }

src/test/java/examples/emptywhere/EmptyWhereTest.java

@@ -32,7 +32,6 @@
 import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
-import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
 import org.mybatis.dynamic.sql.where.WhereDSL;
 import org.mybatis.dynamic.sql.where.render.WhereClauseProvider;
@@ -212,7 +211,7 @@ void testUpdateThreeConditions() {
         String fName = "Fred";
         String lName = "Flintstone";
 
-        UpdateDSL<UpdateModel>.UpdateWhereBuilder builder = update(person)
+        UpdateDSL.UpdateWhereBuilder builder = update(person)
                 .set(id).equalTo(3)
                 .where(id, isEqualTo(3));
 
@@ -233,7 +232,7 @@ void testUpdateThreeConditions() {
     @ParameterizedTest
     @MethodSource("updateWhereVariations")
     void testUpdateVariations(Variation variation) {
-        UpdateDSL<UpdateModel>.UpdateWhereBuilder builder = update(person)
+        UpdateDSL.UpdateWhereBuilder builder = update(person)
                 .set(id).equalTo(3)
                 .where();
 

src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java

@@ -36,7 +36,6 @@
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
 import org.mybatis.dynamic.sql.update.UpdateDSLCompleter;
-import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
 import org.mybatis.dynamic.sql.util.mybatis3.CommonUpdateMapper;
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;
@@ -128,7 +127,7 @@ default int updateByPrimaryKeySelective(GeneratedAlwaysRecord row) {
         );
     }
 
-    static UpdateDSL<UpdateModel> updateSelectiveColumns(GeneratedAlwaysRecord row, UpdateDSL<UpdateModel> dsl) {
+    static UpdateDSL updateSelectiveColumns(GeneratedAlwaysRecord row, UpdateDSL dsl) {
         return dsl.set(id).equalToWhenPresent(row::getId)
                 .set(firstName).equalToWhenPresent(row::getFirstName)
                 .set(lastName).equalToWhenPresent(row::getLastName);

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

@@ -38,7 +38,6 @@
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.update.UpdateDSL;
 import org.mybatis.dynamic.sql.update.UpdateDSLCompleter;
-import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
 import org.mybatis.dynamic.sql.util.mybatis3.CommonCountMapper;
 import org.mybatis.dynamic.sql.util.mybatis3.CommonDeleteMapper;
@@ -162,8 +161,7 @@ default int update(UpdateDSLCompleter completer) {
         return MyBatis3Utils.update(this::update, person, completer);
     }
 
-    static UpdateDSL<UpdateModel> updateAllColumns(PersonRecord row,
-            UpdateDSL<UpdateModel> dsl) {
+    static UpdateDSL updateAllColumns(PersonRecord row, UpdateDSL dsl) {
         return dsl.set(id).equalTo(row::getId)
                 .set(firstName).equalTo(row::getFirstName)
                 .set(lastName).equalTo(row::getLastName)
@@ -173,8 +171,7 @@ static UpdateDSL<UpdateModel> updateAllColumns(PersonRecord row,
                 .set(addressId).equalTo(row::getAddressId);
     }
 
-    static UpdateDSL<UpdateModel> updateSelectiveColumns(PersonRecord row,
-            UpdateDSL<UpdateModel> dsl) {
+    static UpdateDSL updateSelectiveColumns(PersonRecord row, UpdateDSL dsl) {
         return dsl.set(id).equalToWhenPresent(row::getId)
                 .set(firstName).equalToWhenPresent(row::getFirstName)
                 .set(lastName).equalToWhenPresent(row::getLastName)