Merge pull request #545 from jeffgbutler/general-refactoring

General refactoring

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/common/CommonBuilder.java

@@ -0,0 +1,79 @@
+/*
+ *    Copyright 2016-2022 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.common;
+
+import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.where.WhereModel;
+
+/**
+ * Builder class shared between the delete and update model builders.
+ *
+ * @param <T> type of the implementing builder
+ */
+public abstract class CommonBuilder<T extends CommonBuilder<T>> {
+    private SqlTable table;
+    private String tableAlias;
+    private WhereModel whereModel;
+    private Long limit;
+    private OrderByModel orderByModel;
+
+    public SqlTable table() {
+        return table;
+    }
+
+    public String tableAlias() {
+        return tableAlias;
+    }
+
+    public WhereModel whereModel() {
+        return whereModel;
+    }
+
+    public Long limit() {
+        return limit;
+    }
+
+    public OrderByModel orderByModel() {
+        return orderByModel;
+    }
+
+    public T withTable(SqlTable table) {
+        this.table = table;
+        return getThis();
+    }
+
+    public T withTableAlias(String tableAlias) {
+        this.tableAlias = tableAlias;
+        return getThis();
+    }
+
+    public T withWhereModel(WhereModel whereModel) {
+        this.whereModel = whereModel;
+        return getThis();
+    }
+
+    public T withLimit(Long limit) {
+        this.limit = limit;
+        return getThis();
+    }
+
+    public T withOrderByModel(OrderByModel orderByModel) {
+        this.orderByModel = orderByModel;
+        return getThis();
+    }
+
+    protected abstract T getThis();
+}

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

@@ -20,6 +20,7 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.common.CommonBuilder;
 import org.mybatis.dynamic.sql.common.OrderByModel;
 import org.mybatis.dynamic.sql.delete.render.DeleteRenderer;
 import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
@@ -34,11 +35,11 @@ public class DeleteModel {
     private final OrderByModel orderByModel;
 
     private DeleteModel(Builder builder) {
-        table = Objects.requireNonNull(builder.table);
-        whereModel = builder.whereModel;
-        tableAlias = builder.tableAlias;
-        limit = builder.limit;
-        orderByModel = builder.orderByModel;
+        table = Objects.requireNonNull(builder.table());
+        whereModel = builder.whereModel();
+        tableAlias = builder.tableAlias();
+        limit = builder.limit();
+        orderByModel = builder.orderByModel();
     }
 
     public SqlTable table() {
@@ -73,35 +74,9 @@ public static Builder withTable(SqlTable table) {
         return new Builder().withTable(table);
     }
 
-    public static class Builder {
-        private SqlTable table;
-        private String tableAlias;
-        private WhereModel whereModel;
-        private Long limit;
-        private OrderByModel orderByModel;
-
-        public Builder withTable(SqlTable table) {
-            this.table = table;
-            return this;
-        }
-
-        public Builder withTableAlias(String tableAlias) {
-            this.tableAlias = tableAlias;
-            return this;
-        }
-
-        public Builder withWhereModel(WhereModel whereModel) {
-            this.whereModel = whereModel;
-            return this;
-        }
-
-        public Builder withLimit(Long limit) {
-            this.limit = limit;
-            return this;
-        }
-
-        public Builder withOrderByModel(OrderByModel orderByModel) {
-            this.orderByModel = orderByModel;
+    public static class Builder extends CommonBuilder<Builder> {
+        @Override
+        protected Builder getThis() {
             return this;
         }
 

src/main/java/org/mybatis/dynamic/sql/insert/render/AbstractMultiRowValuePhraseVisitor.java

@@ -23,7 +23,8 @@
 import org.mybatis.dynamic.sql.util.PropertyMapping;
 import org.mybatis.dynamic.sql.util.StringConstantMapping;
 
-public abstract class AbstractMultiRowValuePhraseVisitor extends MultiRowInsertMappingVisitor<FieldAndValue> {
+public abstract class AbstractMultiRowValuePhraseVisitor
+        extends MultiRowInsertMappingVisitor<FieldAndValueAndParameters> {
 
     protected final RenderingStrategy renderingStrategy;
     protected final String prefix;
@@ -34,29 +35,29 @@ protected AbstractMultiRowValuePhraseVisitor(RenderingStrategy renderingStrategy
     }
 
     @Override
-    public FieldAndValue visit(NullMapping mapping) {
-        return FieldAndValue.withFieldName(mapping.columnName())
+    public FieldAndValueAndParameters visit(NullMapping mapping) {
+        return FieldAndValueAndParameters.withFieldName(mapping.columnName())
                 .withValuePhrase("null") //$NON-NLS-1$
                 .build();
     }
 
     @Override
-    public FieldAndValue visit(ConstantMapping mapping) {
-        return FieldAndValue.withFieldName(mapping.columnName())
+    public FieldAndValueAndParameters visit(ConstantMapping mapping) {
+        return FieldAndValueAndParameters.withFieldName(mapping.columnName())
                 .withValuePhrase(mapping.constant())
                 .build();
     }
 
     @Override
-    public FieldAndValue visit(StringConstantMapping mapping) {
-        return FieldAndValue.withFieldName(mapping.columnName())
+    public FieldAndValueAndParameters visit(StringConstantMapping mapping) {
+        return FieldAndValueAndParameters.withFieldName(mapping.columnName())
                 .withValuePhrase("'" + mapping.constant() + "'") //$NON-NLS-1$ //$NON-NLS-2$
                 .build();
     }
 
     @Override
-    public FieldAndValue visit(PropertyMapping mapping) {
-        return FieldAndValue.withFieldName(mapping.columnName())
+    public FieldAndValueAndParameters visit(PropertyMapping mapping) {
+        return FieldAndValueAndParameters.withFieldName(mapping.columnName())
                 .withValuePhrase(mapping.mapColumn(c -> calculateJdbcPlaceholder(c, mapping.property())))
                 .build();
     }

src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsertRenderer.java

@@ -15,11 +15,7 @@
  */
 package org.mybatis.dynamic.sql.insert.render;
 
-import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore;
-
-import java.util.List;
 import java.util.Objects;
-import java.util.stream.Collectors;
 
 import org.mybatis.dynamic.sql.insert.BatchInsertModel;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
@@ -36,34 +32,16 @@ private BatchInsertRenderer(Builder<T> builder) {
 
     public BatchInsert<T> render() {
         BatchValuePhraseVisitor visitor = new BatchValuePhraseVisitor(renderingStrategy, "row"); //$NON-NLS-1$)
-        List<FieldAndValue> fieldsAndValues = model
-                .mapColumnMappings(m -> m.accept(visitor))
-                .collect(Collectors.toList());
+        FieldAndValueCollector collector = model.mapColumnMappings(m -> m.accept(visitor))
+                .collect(FieldAndValueCollector.collect());
+
+        String insertStatement = InsertRenderingUtilities.calculateInsertStatement(model.table(), collector);
 
         return BatchInsert.withRecords(model.records())
-                .withInsertStatement(calculateInsertStatement(fieldsAndValues))
+                .withInsertStatement(insertStatement)
                 .build();
     }
 
-    private String calculateInsertStatement(List<FieldAndValue> fieldsAndValues) {
-        return "insert into" //$NON-NLS-1$
-                + spaceBefore(model.table().tableNameAtRuntime())
-                + spaceBefore(calculateColumnsPhrase(fieldsAndValues))
-                + spaceBefore(calculateValuesPhrase(fieldsAndValues));
-    }
-
-    private String calculateColumnsPhrase(List<FieldAndValue> fieldsAndValues) {
-        return fieldsAndValues.stream()
-                .map(FieldAndValue::fieldName)
-                .collect(Collectors.joining(", ", "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-    }
-
-    private String calculateValuesPhrase(List<FieldAndValue> fieldsAndValues) {
-        return fieldsAndValues.stream()
-                .map(FieldAndValue::valuePhrase)
-                .collect(Collectors.joining(", ", "values (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-    }
-
     public static <T> Builder<T> withBatchInsertModel(BatchInsertModel<T> model) {
         return new Builder<T>().withBatchInsertModel(model);
     }

src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValue.java

@@ -0,0 +1,82 @@
+/*
+ *    Copyright 2016-2022 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package org.mybatis.dynamic.sql.insert.render;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class FieldAndValueCollector {
+    final List<FieldAndValueAndParameters> fieldsAndValues = new ArrayList<>();
+
+    public FieldAndValueCollector() {
+        super();
+    }
+
+    public void add(FieldAndValueAndParameters fieldAndValueAndParameters) {
+        fieldsAndValues.add(fieldAndValueAndParameters);
+    }
+
+    public FieldAndValueCollector merge(FieldAndValueCollector other) {
+        fieldsAndValues.addAll(other.fieldsAndValues);
+        return this;
+    }
+
+    public boolean isEmpty() {
+        return fieldsAndValues.isEmpty();
+    }
+
+    public String columnsPhrase() {
+        return fieldsAndValues.stream()
+                .map(FieldAndValueAndParameters::fieldName)
+                .collect(Collectors.joining(", ", "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    }
+
+    public String valuesPhrase() {
+        return fieldsAndValues.stream()
+                .map(FieldAndValueAndParameters::valuePhrase)
+                .collect(Collectors.joining(", ", "values (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    }
+
+    public String multiRowInsertValuesPhrase(int rowCount) {
+        return IntStream.range(0, rowCount)
+                .mapToObj(this::toSingleRowOfValues)
+                .collect(Collectors.joining(", ", "values ", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    }
+
+    private String toSingleRowOfValues(int row) {
+        return fieldsAndValues.stream()
+                .map(FieldAndValueAndParameters::valuePhrase)
+                .map(s -> String.format(s, row))
+                .collect(Collectors.joining(", ", "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+    }
+
+    public Map<String, Object> parameters() {
+        return fieldsAndValues.stream()
+                .map(FieldAndValueAndParameters::parameters)
+                .collect(HashMap::new, HashMap::putAll, HashMap::putAll);
+    }
+
+    public static Collector<FieldAndValueAndParameters, FieldAndValueCollector, FieldAndValueCollector> collect() {
+        return Collector.of(FieldAndValueCollector::new,
+                FieldAndValueCollector::add,
+                FieldAndValueCollector::merge);
+    }
+}