Add overloads with suppliers

This will make generated code a bit more consistent

Author: jeffgbutler

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

@@ -16,16 +16,17 @@
 package org.mybatis.dynamic.sql;
 
 import java.util.Objects;
+import java.util.function.Supplier;
 
 public abstract class AbstractSingleValueCondition<T> implements VisitableCondition<T> {
-    private T value;
+    private Supplier<T> valueSupplier;
 
-    protected AbstractSingleValueCondition(T value) {
-        this.value = Objects.requireNonNull(value);
+    protected AbstractSingleValueCondition(Supplier<T> valueSupplier) {
+        this.valueSupplier = Objects.requireNonNull(valueSupplier);
     }
 
     public T value() {
-        return value;
+        return valueSupplier.get();
     }
 
     @Override

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

@@ -16,22 +16,23 @@
 package org.mybatis.dynamic.sql;
 
 import java.util.Objects;
+import java.util.function.Supplier;
 
 public abstract class AbstractTwoValueCondition<T> implements VisitableCondition<T> {
-    private T value1;
-    private T value2;
+    private Supplier<T> valueSupplier1;
+    private Supplier<T> valueSupplier2;
 
-    protected AbstractTwoValueCondition(T value1, T value2) {
-        this.value1 = Objects.requireNonNull(value1);
-        this.value2 = Objects.requireNonNull(value2);
+    protected AbstractTwoValueCondition(Supplier<T> valueSupplier1, Supplier<T> valueSupplier2) {
+        this.valueSupplier1 = Objects.requireNonNull(valueSupplier1);
+        this.valueSupplier2 = Objects.requireNonNull(valueSupplier2);
     }
 
     public T value1() {
-        return value1;
+        return valueSupplier1.get();
     }
 
     public T value2() {
-        return value2;
+        return valueSupplier2.get();
     }
 
     @Override

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

@@ -17,6 +17,7 @@
 
 import java.util.Arrays;
 import java.util.List;
+import java.util.function.Supplier;
 
 import org.mybatis.dynamic.sql.delete.DeleteDSL;
 import org.mybatis.dynamic.sql.delete.DeleteModel;
@@ -213,31 +214,47 @@ static <T> IsNotNull<T> isNotNull() {
     }
 
     static <T> IsEqualTo<T> isEqualTo(T value) {
-        return IsEqualTo.of(value);
+        return isEqualTo(() -> value);
+    }
+
+    static <T> IsEqualTo<T> isEqualTo(Supplier<T> valueSupplier) {
+        return IsEqualTo.of(valueSupplier);
     }
 
     static <T> IsEqualToWithSubselect<T> isEqualTo(Buildable<SelectModel> selectModelBuilder) {
         return IsEqualToWithSubselect.of(selectModelBuilder);
     }
 
     static <T> IsNotEqualTo<T> isNotEqualTo(T value) {
-        return IsNotEqualTo.of(value);
+        return isNotEqualTo(() -> value);
+    }
+
+    static <T> IsNotEqualTo<T> isNotEqualTo(Supplier<T> valueSupplier) {
+        return IsNotEqualTo.of(valueSupplier);
     }
 
     static <T> IsNotEqualToWithSubselect<T> isNotEqualTo(Buildable<SelectModel> selectModelBuilder) {
         return IsNotEqualToWithSubselect.of(selectModelBuilder);
     }
 
     static <T> IsGreaterThan<T> isGreaterThan(T value) {
-        return IsGreaterThan.of(value);
+        return isGreaterThan(() -> value);
+    }
+    
+    static <T> IsGreaterThan<T> isGreaterThan(Supplier<T> valueSupplier) {
+        return IsGreaterThan.of(valueSupplier);
     }
 
     static <T> IsGreaterThanWithSubselect<T> isGreaterThan(Buildable<SelectModel> selectModelBuilder) {
         return IsGreaterThanWithSubselect.of(selectModelBuilder);
     }
 
     static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(T value) {
-        return IsGreaterThanOrEqualTo.of(value);
+        return isGreaterThanOrEqualTo(() -> value);
+    }
+    
+    static <T> IsGreaterThanOrEqualTo<T> isGreaterThanOrEqualTo(Supplier<T> valueSupplier) {
+        return IsGreaterThanOrEqualTo.of(valueSupplier);
     }
 
     static <T> IsGreaterThanOrEqualToWithSubselect<T> isGreaterThanOrEqualTo(
@@ -246,15 +263,23 @@ static <T> IsGreaterThanOrEqualToWithSubselect<T> isGreaterThanOrEqualTo(
     }
 
     static <T> IsLessThan<T> isLessThan(T value) {
-        return IsLessThan.of(value);
+        return isLessThan(() -> value);
+    }
+    
+    static <T> IsLessThan<T> isLessThan(Supplier<T> valueSupplier) {
+        return IsLessThan.of(valueSupplier);
     }
 
     static <T> IsLessThanWithSubselect<T> isLessThan(Buildable<SelectModel> selectModelBuilder) {
         return IsLessThanWithSubselect.of(selectModelBuilder);
     }
 
     static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(T value) {
-        return IsLessThanOrEqualTo.of(value);
+        return isLessThanOrEqualTo(() -> value);
+    }
+    
+    static <T> IsLessThanOrEqualTo<T> isLessThanOrEqualTo(Supplier<T> valueSupplier) {
+        return IsLessThanOrEqualTo.of(valueSupplier);
     }
 
     static <T> IsLessThanOrEqualToWithSubselect<T> isLessThanOrEqualTo(Buildable<SelectModel> selectModelBuilder) {
@@ -288,28 +313,52 @@ static <T> IsNotInWithSubselect<T> isNotIn(Buildable<SelectModel> selectModelBui
     }
 
     static <T> IsBetween.Builder<T> isBetween(T value1) {
-        return IsBetween.isBetween(value1);
+        return isBetween(() -> value1);
+    }
+    
+    static <T> IsBetween.Builder<T> isBetween(Supplier<T> valueSupplier1) {
+        return IsBetween.isBetween(valueSupplier1);
     }
 
     static <T> IsNotBetween.Builder<T> isNotBetween(T value1) {
-        return IsNotBetween.isNotBetween(value1);
+        return isNotBetween(() -> value1);
+    }
+    
+    static <T> IsNotBetween.Builder<T> isNotBetween(Supplier<T> valueSupplier1) {
+        return IsNotBetween.isNotBetween(valueSupplier1);
     }
 
     // conditions for strings only
     static IsLike isLike(String value) {
-        return IsLike.of(value);
+        return isLike(() -> value);
+    }
+    
+    static IsLike isLike(Supplier<String> valueSupplier) {
+        return IsLike.of(valueSupplier);
     }
 
     static IsLikeCaseInsensitive isLikeCaseInsensitive(String value) {
-        return IsLikeCaseInsensitive.of(value);
+        return isLikeCaseInsensitive(() -> value);
+    }
+    
+    static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier<String> valueSupplier) {
+        return IsLikeCaseInsensitive.of(valueSupplier);
     }
 
     static IsNotLike isNotLike(String value) {
-        return IsNotLike.of(value);
+        return isNotLike(() -> value);
+    }
+    
+    static IsNotLike isNotLike(Supplier<String> valueSupplier) {
+        return IsNotLike.of(valueSupplier);
     }
 
     static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value) {
-        return IsNotLikeCaseInsensitive.of(value);
+        return isNotLikeCaseInsensitive(() -> value);
+    }
+
+    static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier<String> valueSupplier) {
+        return IsNotLikeCaseInsensitive.of(valueSupplier);
     }
 
     static IsInCaseInsensitive isInCaseInsensitive(String...values) {

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

@@ -19,6 +19,7 @@
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Function;
+import java.util.function.Supplier;
 
 import org.mybatis.dynamic.sql.BindableColumn;
 import org.mybatis.dynamic.sql.SqlColumn;
@@ -107,13 +108,21 @@ public UpdateDSL<R> equalToStringConstant(String constant) {
         }
 
         public UpdateDSL<R> equalTo(T value) {
-            columnsAndValues.add(ValueMapping.of(column, value));
+            return equalTo(() -> value);
+        }
+
+        public UpdateDSL<R> equalTo(Supplier<T> valueSupplier) {
+            columnsAndValues.add(ValueMapping.of(column, valueSupplier));
             return UpdateDSL.this;
         }
 
         public UpdateDSL<R> equalToWhenPresent(T value) {
-            if (value != null) {
-                columnsAndValues.add(ValueMapping.of(column, value));
+            return equalToWhenPresent(() -> value);
+        }
+
+        public UpdateDSL<R> equalToWhenPresent(Supplier<T> valueSupplier) {
+            if (valueSupplier.get() != null) {
+                columnsAndValues.add(ValueMapping.of(column, valueSupplier));
             }
             return UpdateDSL.this;
         }

src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java

@@ -15,28 +15,30 @@
  */
 package org.mybatis.dynamic.sql.util;
 
+import java.util.function.Supplier;
+
 import org.mybatis.dynamic.sql.SqlColumn;
 
 public class ValueMapping<T> extends AbstractColumnMapping implements UpdateMapping {
 
-    private T value;
+    private Supplier<T> valueSupplier;
 
     private ValueMapping(SqlColumn<T> column) {
         super(column);
     }
 
     public T value() {
-        return value;
+        return valueSupplier.get();
     }
 
     @Override
     public <R> R accept(UpdateMappingVisitor<R> visitor) {
         return visitor.visit(this);
     }
 
-    public static <T> ValueMapping<T> of(SqlColumn<T> column, T value) {
+    public static <T> ValueMapping<T> of(SqlColumn<T> column, Supplier<T> valueSupplier) {
         ValueMapping<T> mapping = new ValueMapping<>(column);
-        mapping.value = value;
+        mapping.valueSupplier = valueSupplier;
         return mapping;
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/condition/IsBetween.java

@@ -15,12 +15,14 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.function.Supplier;
+
 import org.mybatis.dynamic.sql.AbstractTwoValueCondition;
 
 public class IsBetween<T> extends AbstractTwoValueCondition<T> {
 
     protected IsBetween(Builder<T> builder) {
-        super(builder.value1, builder.value2);
+        super(builder.valueSupplier1, builder.valueSupplier2);
     }
 
     @Override
@@ -29,20 +31,24 @@ public String renderCondition(String columnName, String placeholder1, String pla
     }
 
     public static class Builder<T> {
-        private T value1;
-        private T value2;
+        private Supplier<T> valueSupplier1;
+        private Supplier<T> valueSupplier2;
 
-        private Builder(T value1) {
-            this.value1 = value1;
+        private Builder(Supplier<T> valueSupplier1) {
+            this.valueSupplier1 = valueSupplier1;
         }
 
-        public IsBetween<T> and(T value2) {
-            this.value2 = value2;
+        public IsBetween<T> and(Supplier<T> valueSupplier2) {
+            this.valueSupplier2 = valueSupplier2;
             return new IsBetween<>(this);
         }
+        
+        public IsBetween<T> and(T value2) {
+            return and(() -> value2);
+        }
     }
 
-    public static <T> Builder<T> isBetween(T value) {
-        return new Builder<>(value);
+    public static <T> Builder<T> isBetween(Supplier<T> valueSupplier) {
+        return new Builder<>(valueSupplier);
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/condition/IsEqualTo.java

@@ -15,20 +15,22 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.function.Supplier;
+
 import org.mybatis.dynamic.sql.AbstractSingleValueCondition;
 
 public class IsEqualTo<T> extends AbstractSingleValueCondition<T> {
 
-    protected IsEqualTo(T value) {
-        super(value);
+    protected IsEqualTo(Supplier<T> valueSupplier) {
+        super(valueSupplier);
     }
 
     @Override
     public String renderCondition(String columnName, String placeholder) {
         return columnName + " = " + placeholder; //$NON-NLS-1$
     }
 
-    public static <T> IsEqualTo<T> of(T value) {
-        return new IsEqualTo<>(value);
+    public static <T> IsEqualTo<T> of(Supplier<T> valueSupplier) {
+        return new IsEqualTo<>(valueSupplier);
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/condition/IsGreaterThan.java

@@ -15,20 +15,22 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.function.Supplier;
+
 import org.mybatis.dynamic.sql.AbstractSingleValueCondition;
 
 public class IsGreaterThan<T> extends AbstractSingleValueCondition<T> {
 
-    protected IsGreaterThan(T value) {
-        super(value);
+    protected IsGreaterThan(Supplier<T> valueSupplier) {
+        super(valueSupplier);
     }
 
     @Override
     public String renderCondition(String columnName, String placeholder) {
         return columnName + " > " + placeholder; //$NON-NLS-1$
     }
 
-    public static <T> IsGreaterThan<T> of(T value) {
-        return new IsGreaterThan<>(value);
+    public static <T> IsGreaterThan<T> of(Supplier<T> valueSupplier) {
+        return new IsGreaterThan<>(valueSupplier);
     }
 }

src/main/java/org/mybatis/dynamic/sql/where/condition/IsGreaterThanOrEqualTo.java

@@ -15,20 +15,22 @@
  */
 package org.mybatis.dynamic.sql.where.condition;
 
+import java.util.function.Supplier;
+
 import org.mybatis.dynamic.sql.AbstractSingleValueCondition;
 
 public class IsGreaterThanOrEqualTo<T> extends AbstractSingleValueCondition<T> {
 
-    protected IsGreaterThanOrEqualTo(T value) {
-        super(value);
+    protected IsGreaterThanOrEqualTo(Supplier<T> valueSupplier) {
+        super(valueSupplier);
     }
 
     @Override
     public String renderCondition(String columnName, String placeholder) {
         return columnName + " >= " + placeholder; //$NON-NLS-1$
     }
 
-    public static <T> IsGreaterThanOrEqualTo<T> of(T value) {
-        return new IsGreaterThanOrEqualTo<>(value);
+    public static <T> IsGreaterThanOrEqualTo<T> of(Supplier<T> valueSupplier) {
+        return new IsGreaterThanOrEqualTo<>(valueSupplier);
     }
 }