Update insert bindings for record based inserts

Record based inserts (insert, batch insert, and
multirow insert) have a different form of
binding - rather than binding to a value
in a Map, these bindings bind to a
property in a row class. This commit makes
the bindings consistent for those statements.

Spring support is also updated to support
the new binding form.

Author: jeffgbutler

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

@@ -62,5 +62,8 @@ public FieldAndValueAndParameters visit(PropertyMapping mapping) {
                 .build();
     }
 
-    abstract String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName);
+    private String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {
+        return column.renderingStrategy().orElse(renderingStrategy)
+                .getRecordBasedInsertBinding(column, prefix, parameterName);
+    }
 }

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

@@ -15,18 +15,11 @@
  */
 package org.mybatis.dynamic.sql.insert.render;
 
-import org.mybatis.dynamic.sql.SqlColumn;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 
 public class BatchValuePhraseVisitor extends AbstractMultiRowValuePhraseVisitor {
 
     public BatchValuePhraseVisitor(RenderingStrategy renderingStrategy, String prefix) {
         super(renderingStrategy, prefix);
     }
-
-    @Override
-    String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {
-        return column.renderingStrategy().orElse(renderingStrategy)
-                .getFormattedJdbcPlaceholder(column, prefix, parameterName);
-    }
 }

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

@@ -15,18 +15,11 @@
  */
 package org.mybatis.dynamic.sql.insert.render;
 
-import org.mybatis.dynamic.sql.SqlColumn;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 
 public class MultiRowValuePhraseVisitor extends AbstractMultiRowValuePhraseVisitor {
 
     public MultiRowValuePhraseVisitor(RenderingStrategy renderingStrategy, String prefix) {
         super(renderingStrategy, prefix);
     }
-
-    @Override
-    String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {
-        return column.renderingStrategy().orElse(renderingStrategy)
-                .getMultiRowFormattedJdbcPlaceholder(column, prefix, parameterName);
-    }
 }

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

@@ -73,6 +73,6 @@ public Optional<FieldAndValueAndParameters> visit(PropertyWhenPresentMapping map
 
     private String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {
         return column.renderingStrategy().orElse(renderingStrategy)
-                .getFormattedJdbcPlaceholder(column, "row", parameterName); //$NON-NLS-1$
+                .getRecordBasedInsertBinding(column, "row", parameterName); //$NON-NLS-1$
     }
 }

src/main/java/org/mybatis/dynamic/sql/render/RenderingStrategy.java

@@ -21,15 +21,15 @@
 
 /**
  * A rendering strategy is used to generate a platform specific binding.
- * <p>
- * Rendering strategies are used during the rendering phase of statement generation.
+ *
+ * <p>Rendering strategies are used during the rendering phase of statement generation.
  * All generated SQL statements include the generated statement itself, and a map of parameters that
  * should be bound to the statement at execution time. For example, a generated select statement may
  * look like this when rendered for MyBatis:
- * <p>
- * <code>select foo from bar where id = #{parameters.p1,jdbcType=INTEGER}</code>
- * <p>
- * In this case, the binding is <code>#{parameters.p1,jdbcType=INTEGER}</code>. MyBatis knows how to interpret this
+ *
+ * <p><code>select foo from bar where id = #{parameters.p1,jdbcType=INTEGER}</code>
+ *
+ * <p>In this case, the binding is <code>#{parameters.p1,jdbcType=INTEGER}</code>. MyBatis knows how to interpret this
  * binding - it will look for a value in the <code>parameters.p1</code> property of the parameter object
  * passed to the statement and bind it as a prepared statement parameter when executing the statement.
  */
@@ -42,61 +42,62 @@ public String formatParameterMapKey(AtomicInteger sequence) {
 
     /**
      * This method generates a binding for a parameter to a placeholder in a generated SQL statement.
-     * <p>
-     * This binding is appropriate when there can be a mapping between a parameter and a known target column,
+     *
+     * <p>This binding is appropriate when there can be a mapping between a parameter and a known target column,
      * In MyBatis, the binding can specify type information based on the column. The bindings are specific
      * to the target framework.
-     * <p>
-     * For MyBatis, a binding looks like this: "#{prefix.parameterName,jdbcType=xxx,typeHandler=xxx,javaType=xxx}"
-     * <p>
-     * For Spring, a binding looks like this: ":parameterName"
+     *
+     * <p>For MyBatis, a binding looks like this: "#{prefix.parameterName,jdbcType=xxx,typeHandler=xxx,javaType=xxx}"
+     *
+     * <p>For Spring, a binding looks like this: ":parameterName"
      *
      * @param column column definition used for generating type details in a MyBatis binding. Ignored for Spring.
      * @param prefix parameter prefix used for locating the parameters in a SQL provider object. Typically, will be
      *               {@link RenderingStrategy#DEFAULT_PARAMETER_PREFIX}. This is ignored for Spring.
      * @param parameterName name of the parameter. Typically generated by calling
-     *    {@link RenderingStrategy#formatParameterMapKey(AtomicInteger)}
+     *     {@link RenderingStrategy#formatParameterMapKey(AtomicInteger)}
      * @return the generated binding
      */
     public abstract String getFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName);
 
     /**
      * This method generates a binding for a parameter to a placeholder in a generated SQL statement.
-     * <p>
-     * This binding is appropriate when the parameter is bound to placeholder that is not a known column (such as
+     *
+     * <p>This binding is appropriate when the parameter is bound to placeholder that is not a known column (such as
      * a limit or offset parameter). The bindings are specific to the target framework.
-     * <p>
-     * For MyBatis, a binding looks like this: "#{prefix.parameterName}"
-     * <p>
-     * For Spring, a binding looks like this: ":parameterName"
+     *
+     * <p>For MyBatis, a binding looks like this: "#{prefix.parameterName}"
+     *
+     * <p>For Spring, a binding looks like this: ":parameterName"
      *
      * @param prefix parameter prefix used for locating the parameters in a SQL provider object. Typically, will be
      *               {@link RenderingStrategy#DEFAULT_PARAMETER_PREFIX}. This is ignored for Spring.
      * @param parameterName name of the parameter. Typically generated by calling
-     *    {@link RenderingStrategy#formatParameterMapKey(AtomicInteger)}
+     *     {@link RenderingStrategy#formatParameterMapKey(AtomicInteger)}
      * @return the generated binding
      */
     public abstract String getFormattedJdbcPlaceholder(String prefix, String parameterName);
 
     /**
-     * This method generates a binding for a parameter to a placeholder in a generated multirow insert statement.
-     * <p>
-     * This binding is specifically for use with a multirow insert. The Spring implementation changes the binding
-     * to match values expected for a multirow insert statement. For MyBatis, the binding is the same
+     * This method generates a binding for a parameter to a placeholder in a record based insert statement.
+     *
+     * <p>This binding is specifically for use with insert, batch insert, and multirow insert statements.
+     * These statements bind parameters to properties of a row class. The Spring implementation changes the binding
+     * to match values expected for a these insert statements. For MyBatis, the binding is the same
      * as {@link RenderingStrategy#getFormattedJdbcPlaceholder(BindableColumn, String, String)}.
-     * <p>
-     * For MyBatis, a binding looks like this: "#{prefix.parameterName,jdbcType=xxx,typeHandler=xxx,javaType=xxx}"
-     * <p>
-     * For Spring, a binding looks like this: ":prefix.parameterName"
+     *
+     * <p>For MyBatis, a binding looks like this: "#{prefix.parameterName,jdbcType=xxx,typeHandler=xxx,javaType=xxx}"
+     *
+     * <p>For Spring, a binding looks like this: ":prefix.parameterName"
      *
      * @param column column definition used for generating type details in a MyBatis binding. Ignored for Spring.
      * @param prefix parameter prefix used for locating the parameters in a SQL provider object. Typically, will be
-     *               {@link RenderingStrategy#DEFAULT_PARAMETER_PREFIX}. This is ignored for Spring.
+     *     {@link RenderingStrategy#DEFAULT_PARAMETER_PREFIX}. This is ignored for Spring.
      * @param parameterName name of the parameter. Typically generated by calling
-     *    {@link RenderingStrategy#formatParameterMapKey(AtomicInteger)}
+     *     {@link RenderingStrategy#formatParameterMapKey(AtomicInteger)}
      * @return the generated binding
      */
-    public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName) {
+    public String getRecordBasedInsertBinding(BindableColumn<?> column, String prefix, String parameterName) {
         return getFormattedJdbcPlaceholder(column, prefix, parameterName);
     }
 }

src/main/java/org/mybatis/dynamic/sql/render/SpringNamedParameterRenderingStrategy.java

@@ -30,7 +30,7 @@ public String getFormattedJdbcPlaceholder(String prefix, String parameterName) {
     }
 
     @Override
-    public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName) {
+    public String getRecordBasedInsertBinding(BindableColumn<?> column, String prefix, String parameterName) {
         return ":" + prefix + "." + parameterName; //$NON-NLS-1$ //$NON-NLS-2$
     }
 }

src/main/java/org/mybatis/dynamic/sql/util/spring/BatchInsertUtility.java

@@ -0,0 +1,54 @@
+/*
+ *    Copyright 2016-2023 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.util.spring;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import org.springframework.jdbc.core.namedparam.SqlParameterSource;
+import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
+
+/**
+ * Utility class for converting a list of rows to an array or SqlParameterSources.
+ *
+ * <p>This class is necessary due to the way that the library generates bindings for batch insert
+ * statements. The bindings will be of the form <code>:row.propertyName</code>. The <code>createBatch</code> method
+ * in this class will wrap all input rows in a class - RowHolder - with a single property named "row".
+ * This will allow the generated bindings to function properly with a Spring batch insert.
+ */
+public class BatchInsertUtility {
+    private BatchInsertUtility() {}
+
+    public static <T> SqlParameterSource[] createBatch(List<T> rows) {
+        List<RowHolder<T>> tt = rows.stream()
+                .map(RowHolder::new)
+                .collect(Collectors.toList());
+
+        return SqlParameterSourceUtils.createBatch(tt);
+    }
+
+    public static class RowHolder<T> {
+        private final T row;
+
+        public RowHolder(T row) {
+            this.row = row;
+        }
+
+        public T getRow() {
+            return row;
+        }
+    }
+}

src/main/java/org/mybatis/dynamic/sql/util/spring/NamedParameterJdbcTemplateExtensions.java

@@ -40,8 +40,6 @@
 import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
-import org.springframework.jdbc.core.namedparam.SqlParameterSource;
-import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
 import org.springframework.jdbc.support.KeyHolder;
 
 public class NamedParameterJdbcTemplateExtensions {
@@ -90,7 +88,7 @@ public <T> int insert(Buildable<InsertModel<T>> insertStatement) {
 
     public <T> int insert(InsertStatementProvider<T> insertStatement) {
         return template.update(insertStatement.getInsertStatement(),
-                new BeanPropertySqlParameterSource(insertStatement.getRow()));
+                new BeanPropertySqlParameterSource(insertStatement));
     }
 
     public <T> int insert(Buildable<InsertModel<T>> insertStatement, KeyHolder keyHolder) {
@@ -99,16 +97,16 @@ public <T> int insert(Buildable<InsertModel<T>> insertStatement, KeyHolder keyHo
 
     public <T> int insert(InsertStatementProvider<T> insertStatement, KeyHolder keyHolder) {
         return template.update(insertStatement.getInsertStatement(),
-                new BeanPropertySqlParameterSource(insertStatement.getRow()), keyHolder);
+                new BeanPropertySqlParameterSource(insertStatement), keyHolder);
     }
 
     public <T> int[] insertBatch(Buildable<BatchInsertModel<T>> insertStatement) {
         return insertBatch(insertStatement.build().render(RenderingStrategies.SPRING_NAMED_PARAMETER));
     }
 
     public <T> int[] insertBatch(BatchInsert<T> insertStatement) {
-        SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(insertStatement.getRecords());
-        return template.batchUpdate(insertStatement.getInsertStatementSQL(), batch);
+        return template.batchUpdate(insertStatement.getInsertStatementSQL(),
+                BatchInsertUtility.createBatch(insertStatement.getRecords()));
     }
 
     public <T> int insertMultiple(Buildable<MultiRowInsertModel<T>> insertStatement) {

src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/spring/NamedParameterJdbcTemplateExtensions.kt

@@ -36,12 +36,12 @@ import org.mybatis.dynamic.sql.util.kotlin.KotlinMultiRowInsertCompleter
 import org.mybatis.dynamic.sql.util.kotlin.MyBatisDslMarker
 import org.mybatis.dynamic.sql.util.kotlin.SelectCompleter
 import org.mybatis.dynamic.sql.util.kotlin.UpdateCompleter
+import org.mybatis.dynamic.sql.util.spring.BatchInsertUtility
 import org.springframework.dao.EmptyResultDataAccessException
 import org.springframework.jdbc.core.RowMapper
 import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate
-import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils
 import org.springframework.jdbc.support.KeyHolder
 import java.sql.ResultSet
 import kotlin.reflect.KClass
@@ -66,7 +66,7 @@ fun NamedParameterJdbcTemplate.deleteFrom(table: SqlTable, completer: DeleteComp
 
 // batch insert
 fun <T> NamedParameterJdbcTemplate.insertBatch(insertStatement: BatchInsert<T>): IntArray =
-    batchUpdate(insertStatement.insertStatementSQL, SqlParameterSourceUtils.createBatch(insertStatement.records))
+    batchUpdate(insertStatement.insertStatementSQL, BatchInsertUtility.createBatch(insertStatement.records))
 
 fun <T : Any> NamedParameterJdbcTemplate.insertBatch(
     vararg records: T,
@@ -82,13 +82,13 @@ fun <T : Any> NamedParameterJdbcTemplate.insertBatch(
 
 // single row insert
 fun <T> NamedParameterJdbcTemplate.insert(insertStatement: InsertStatementProvider<T>): Int =
-    update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement.row))
+    update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement))
 
 fun <T> NamedParameterJdbcTemplate.insert(
     insertStatement: InsertStatementProvider<T>,
     keyHolder: KeyHolder
 ): Int =
-    update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement.row), keyHolder)
+    update(insertStatement.insertStatement, BeanPropertySqlParameterSource(insertStatement), keyHolder)
 
 fun <T : Any> NamedParameterJdbcTemplate.insert(row: T, completer: KotlinInsertCompleter<T>): Int =
     insert(org.mybatis.dynamic.sql.util.kotlin.spring.insert(row, completer))

src/test/java/examples/generated/always/spring/SpringTest.java

@@ -38,11 +38,11 @@
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
 import org.mybatis.dynamic.sql.util.Buildable;
 import org.mybatis.dynamic.sql.util.spring.NamedParameterJdbcTemplateExtensions;
+import org.mybatis.dynamic.sql.util.spring.BatchInsertUtility;
 import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
 import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
 import org.springframework.jdbc.core.namedparam.SqlParameterSource;
-import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
 import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
@@ -142,7 +142,7 @@ void testInsert() {
                 .build()
                 .render(RenderingStrategies.SPRING_NAMED_PARAMETER);
 
-        SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(insertStatement.getRow());
+        SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(insertStatement);
         KeyHolder keyHolder = new GeneratedKeyHolder();
 
         int rows = template.update(insertStatement.getInsertStatement(), parameterSource, keyHolder);
@@ -241,7 +241,7 @@ record = new GeneratedAlwaysRecord();
         record.setLastName("Smith");
         records.add(record);
 
-        SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(records);
+        SqlParameterSource[] batch = BatchInsertUtility.createBatch(records);
 
         BatchInsert<GeneratedAlwaysRecord> batchInsert = insertBatch(records)
                 .into(generatedAlways)