Remove use of Optional.ifPresent

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteStatement.java

@@ -17,7 +17,7 @@
 
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore;
 
-import java.util.HashMap;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -26,45 +26,38 @@
 
 public class DeleteStatement {
     private String tableName;
-    private Optional<String> whereClause;
-    private Map<String, Object> parameters;
+    private Optional<WhereClauseAndParameters> whereClauseAndParameters;
 
     private DeleteStatement(Builder builder) {
         tableName = Objects.requireNonNull(builder.tableName);
-        whereClause = Objects.requireNonNull(builder.whereClause);
-        parameters = Objects.requireNonNull(builder.parameters);
+        whereClauseAndParameters = Objects.requireNonNull(builder.whereClauseAndParameters);
     }
 
     public Map<String, Object> getParameters() {
-        return parameters;
+        return whereClauseAndParameters.map(WhereClauseAndParameters::parameters)
+                .orElse(Collections.emptyMap());
     }
 
     public String getDeleteStatement() {
         return "delete from" //$NON-NLS-1$
                 + spaceBefore(tableName)
-                + spaceBefore(whereClause);
+                + spaceBefore(whereClauseAndParameters.map(WhereClauseAndParameters::whereClause));
     }
 
     public static class Builder {
         private String tableName;
-        private Optional<String> whereClause = Optional.empty();
-        private Map<String, Object> parameters = new HashMap<>();
+        private Optional<WhereClauseAndParameters> whereClauseAndParameters = Optional.empty();
 
         public Builder withTableName(String tableName) {
             this.tableName = tableName;
             return this;
         }
 
         public Builder withWhereClause(Optional<WhereClauseAndParameters> whereClauseAndParameters) {
-            whereClauseAndParameters.ifPresent(this::handleWhereClause);
+            this.whereClauseAndParameters = whereClauseAndParameters;
             return this;
         }
 
-        private void handleWhereClause(WhereClauseAndParameters whereClauseAndParameters) {
-            this.whereClause = Optional.of(whereClauseAndParameters.whereClause());
-            parameters.putAll(whereClauseAndParameters.parameters());
-        }
-        
         public DeleteStatement build() {
             return new DeleteStatement(this);
         }

src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpression.java

@@ -18,7 +18,7 @@
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceAfter;
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore;
 
-import java.util.HashMap;
+import java.util.Collections;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -30,8 +30,7 @@ public class QueryExpression {
     private String tableName;
     private Optional<String> connector;
     private String columnList;
-    private Optional<String> whereClause;
-    private Map<String, Object> parameters;
+    private Optional<WhereClauseAndParameters> whereClauseAndParameters;
     private boolean isDistinct;
     private Optional<String> joinClause;
     private Optional<String> groupByClause;
@@ -40,15 +39,15 @@ private QueryExpression(Builder builder) {
         tableName = Objects.requireNonNull(builder.tableName);
         connector = Objects.requireNonNull(builder.connector);
         columnList = Objects.requireNonNull(builder.columnList);
-        whereClause = Objects.requireNonNull(builder.whereClause);
-        parameters = Objects.requireNonNull(builder.parameters);
+        whereClauseAndParameters = Objects.requireNonNull(builder.whereClauseAndParameters);
         isDistinct = builder.isDistinct;
         joinClause = Objects.requireNonNull(builder.joinClause);
         groupByClause = Objects.requireNonNull(builder.groupByClause);
     }
 
     public Map<String, Object> parameters() {
-        return parameters;
+        return whereClauseAndParameters.map(WhereClauseAndParameters::parameters)
+                .orElse(Collections.emptyMap());
     }
 
     public String queryExpression() {
@@ -59,18 +58,17 @@ public String queryExpression() {
                 + " from " //$NON-NLS-1$
                 + tableName
                 + spaceBefore(joinClause)
-                + spaceBefore(whereClause)
+                + spaceBefore(whereClauseAndParameters.map(WhereClauseAndParameters::whereClause))
                 + spaceBefore(groupByClause);
     }
 
     public static class Builder {
         private Optional<String> connector;
         private String tableName;
         private boolean isDistinct;
-        private Map<String, Object> parameters = new HashMap<>();
         private String columnList;
         private Optional<String> joinClause = Optional.empty();
-        private Optional<String> whereClause = Optional.empty();
+        private Optional<WhereClauseAndParameters> whereClauseAndParameters = Optional.empty();
         private Optional<String> groupByClause = Optional.empty();
 
         public Builder withConnector(Optional<String> connector) {
@@ -89,12 +87,7 @@ public Builder isDistinct(boolean isDistinct) {
         }
 
         public Builder withWhereClause(Optional<WhereClauseAndParameters> whereClauseAndParameters) {
-            whereClauseAndParameters.ifPresent(this::handleWhereClause);
-            return this;
-        }
-        
-        public Builder withParameters(Map<String, Object> parameters) {
-            this.parameters.putAll(parameters);
+            this.whereClauseAndParameters = whereClauseAndParameters;
             return this;
         }
 
@@ -113,11 +106,6 @@ public Builder withGroupByClause(Optional<String> groupByClause) {
             return this;
         }
 
-        private void handleWhereClause(WhereClauseAndParameters whereClauseAndParameters) {
-            this.whereClause = Optional.of(whereClauseAndParameters.whereClause());
-            parameters.putAll(whereClauseAndParameters.parameters());
-        }
-        
         public QueryExpression build() {
             return new QueryExpression(this);
         }

src/main/java/org/mybatis/dynamic/sql/update/render/UpdateStatement.java

@@ -17,6 +17,7 @@
 
 import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
@@ -35,13 +36,16 @@ public class UpdateStatement {
     private String tableName;
     private String setClause;
     private Optional<String> whereClause;
-    private Map<String, Object> parameters;
+    private Map<String, Object> parameters = new HashMap<>();
 
     private UpdateStatement(Builder builder) {
         tableName = Objects.requireNonNull(builder.tableName);
         setClause = Objects.requireNonNull(builder.setClause);
-        whereClause = Objects.requireNonNull(builder.whereClause);
-        parameters = Objects.requireNonNull(builder.parameters);
+        whereClause = builder.whereClauseAndParameters.map(WhereClauseAndParameters::whereClause);
+        parameters.putAll(builder.parameters);
+        parameters.putAll(builder.whereClauseAndParameters
+                .map(WhereClauseAndParameters::parameters)
+                .orElse(Collections.emptyMap()));
     }
 
     public Map<String, Object> getParameters() {
@@ -58,7 +62,7 @@ public String getUpdateStatement() {
     public static class Builder {
         private String tableName;
         private String setClause;
-        private Optional<String> whereClause = Optional.empty();
+        private Optional<WhereClauseAndParameters> whereClauseAndParameters = Optional.empty();
         private Map<String, Object> parameters = new HashMap<>();
 
         public Builder withTableName(String tableName) {
@@ -72,7 +76,7 @@ public Builder withSetClause(String setClause) {
         }
 
         public Builder withWhereClause(Optional<WhereClauseAndParameters> whereClauseAndParameters) {
-            whereClauseAndParameters.ifPresent(this::handleWhereClause);
+            this.whereClauseAndParameters = whereClauseAndParameters;
             return this;
         }
 
@@ -81,11 +85,6 @@ public Builder withParameters(Map<String, Object> parameters) {
             return this;
         }
 
-        private void handleWhereClause(WhereClauseAndParameters whereClauseAndParameters) {
-            this.whereClause = Optional.of(whereClauseAndParameters.whereClause());
-            parameters.putAll(whereClauseAndParameters.parameters());
-        }
-        
         public UpdateStatement build() {
             return new UpdateStatement(this);
         }

src/test/java/org/mybatis/dynamic/sql/select/render/QueryExpressionCollectorTest.java

@@ -26,6 +26,7 @@
 import org.junit.jupiter.api.Test;
 import org.junit.platform.runner.JUnitPlatform;
 import org.junit.runner.RunWith;
+import org.mybatis.dynamic.sql.where.render.WhereClauseAndParameters;
 
 @RunWith(JUnitPlatform.class)
 public class QueryExpressionCollectorTest {
@@ -36,29 +37,41 @@ public void testQueryExpressionCollectorMerge() {
 
         Map<String, Object> parms1 = new HashMap<>();
         parms1.put("p1", 1);
+
+        WhereClauseAndParameters wcp1 = new WhereClauseAndParameters.Builder()
+                .withWhereClause("where fred = ?")
+                .withParameters(parms1)
+                .build();
+        
         QueryExpression qe1 = new QueryExpression.Builder()
                 .withConnector(Optional.empty())
                 .withColumnList("foo")
                 .withTableName("bar")
-                .withParameters(parms1)
+                .withWhereClause(Optional.of(wcp1))
                 .build();
         queryExpressions.add(qe1);
 
         Map<String, Object> parms2 = new HashMap<>();
         parms2.put("p2", 2);
+
+        WhereClauseAndParameters wcp2 = new WhereClauseAndParameters.Builder()
+                .withWhereClause("where betty = ?")
+                .withParameters(parms2)
+                .build();
+        
         QueryExpression qe2 = new QueryExpression.Builder()
                 .withConnector(Optional.of("union"))
                 .withColumnList("bar")
                 .withTableName("foo")
-                .withParameters(parms2)
+                .withWhereClause(Optional.of(wcp2))
                 .build();
         queryExpressions.add(qe2);
 
         // parallelStream should trigger the merge
         QueryExpressionCollector collector = queryExpressions.parallelStream()
                 .collect(QueryExpressionCollector.collect());
 
-        assertThat(collector.queryExpression()).isEqualTo("select foo from bar union select bar from foo");
+        assertThat(collector.queryExpression()).isEqualTo("select foo from bar where fred = ? union select bar from foo where betty = ?");
         assertThat(collector.parameters().size()).isEqualTo(2);
         assertThat(collector.parameters().get("p1")).isEqualTo(1);
         assertThat(collector.parameters().get("p2")).isEqualTo(2);