Initial work on map to row functions

jeffgbutler · jeffgbutler · commit e1f4903572bd · 2023-03-28T16:31:13.000-04:00
diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/BatchInsertDSL.java b/src/main/java/org/mybatis/dynamic/sql/insert/BatchInsertDSL.java
@@ -29,6 +29,7 @@
 import org.mybatis.dynamic.sql.util.ConstantMapping;
 import org.mybatis.dynamic.sql.util.NullMapping;
 import org.mybatis.dynamic.sql.util.PropertyMapping;
+import org.mybatis.dynamic.sql.util.RowMapping;
 import org.mybatis.dynamic.sql.util.StringConstantMapping;
 
 public class BatchInsertDSL<T> implements Buildable<BatchInsertModel<T>> {
@@ -103,6 +104,11 @@ public BatchInsertDSL<T> toStringConstant(String constant) {
             columnMappings.add(StringConstantMapping.of(column, constant));
             return BatchInsertDSL.this;
         }
+
+        public BatchInsertDSL<T> toRow() {
+            columnMappings.add(RowMapping.of(column));
+            return BatchInsertDSL.this;
+        }
     }
 
     public abstract static class AbstractBuilder<T, B extends AbstractBuilder<T, B>> {
diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/AbstractMultiRowValuePhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/AbstractMultiRowValuePhraseVisitor.java
@@ -66,9 +66,12 @@ public FieldAndValueAndParameters visit(PropertyMapping mapping) {
 
     @Override
     public FieldAndValueAndParameters visit(RowMapping mapping) {
-        // TODO - fix error number
-        throw new UnsupportedOperationException(Messages.getInternalErrorString(99));
+        return FieldAndValueAndParameters.withFieldName(mapping.columnName())
+                .withValuePhrase(mapping.mapColumn(this::calculateJdbcPlaceholder))
+                .build();
     }
 
     abstract String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName);
+
+    abstract String calculateJdbcPlaceholder(SqlColumn<?> column);
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchValuePhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchValuePhraseVisitor.java
@@ -29,4 +29,9 @@ String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {
         return column.renderingStrategy().orElse(renderingStrategy)
                 .getFormattedJdbcPlaceholder(column, prefix, parameterName);
     }
+
+    @Override
+    String calculateJdbcPlaceholder(SqlColumn<?> column) {
+        return column.renderingStrategy().orElse(renderingStrategy).getFormattedJdbcPlaceholder(column, prefix);
+    }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/MultiRowValuePhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/MultiRowValuePhraseVisitor.java
@@ -17,10 +17,6 @@
 
 import org.mybatis.dynamic.sql.SqlColumn;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
-import org.mybatis.dynamic.sql.util.Messages;
-import org.mybatis.dynamic.sql.util.RowMapping;
-
-import java.util.Optional;
 
 public class MultiRowValuePhraseVisitor extends AbstractMultiRowValuePhraseVisitor {
 
@@ -35,8 +31,7 @@ String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {
     }
 
     @Override
-    public FieldAndValueAndParameters visit(RowMapping mapping) {
-        // TODO - fix error number, and move this somewhere up in the hierarchy
-        throw new UnsupportedOperationException(Messages.getInternalErrorString(99));
+    String calculateJdbcPlaceholder(SqlColumn<?> column) {
+        return column.renderingStrategy().orElse(renderingStrategy).getMultiRowFormattedJdbcPlaceholder(column, prefix);
     }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/render/MyBatis3RenderingStrategy.java b/src/main/java/org/mybatis/dynamic/sql/render/MyBatis3RenderingStrategy.java
@@ -39,6 +39,16 @@ public String getFormattedJdbcPlaceholder(BindableColumn<?> column, String prefi
                 + "}"; //$NON-NLS-1$
     }
 
+    @Override
+    public String getFormattedJdbcPlaceholder(BindableColumn<?> column, String parameterName) {
+        return "#{" //$NON-NLS-1$
+                + parameterName
+                + renderJdbcType(column)
+                + renderJavaType(column)
+                + renderTypeHandler(column)
+                + "}"; //$NON-NLS-1$
+    }
+
     private String renderTypeHandler(BindableColumn<?> column) {
         return column.typeHandler()
                 .map(th -> ",typeHandler=" + th) //$NON-NLS-1$
diff --git a/src/main/java/org/mybatis/dynamic/sql/render/RenderingStrategy.java b/src/main/java/org/mybatis/dynamic/sql/render/RenderingStrategy.java
@@ -28,9 +28,15 @@ public static String formatParameterMapKey(AtomicInteger sequence) {
 
     public abstract String getFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName);
 
+    public abstract String getFormattedJdbcPlaceholder(BindableColumn<?> column, String parameterName);
+
     public abstract String getFormattedJdbcPlaceholder(String prefix, String parameterName);
 
     public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName) {
         return getFormattedJdbcPlaceholder(column, prefix, parameterName);
     }
+
+    public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String parameterName) {
+        return getFormattedJdbcPlaceholder(column, parameterName);
+    }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/render/SpringNamedParameterRenderingStrategy.java b/src/main/java/org/mybatis/dynamic/sql/render/SpringNamedParameterRenderingStrategy.java
@@ -24,6 +24,11 @@ public String getFormattedJdbcPlaceholder(BindableColumn<?> column, String prefi
         return getFormattedJdbcPlaceholder(prefix, parameterName);
     }
 
+    @Override
+    public String getFormattedJdbcPlaceholder(BindableColumn<?> column, String parameterName) {
+        return ":" + parameterName; //$NON-NLS-1$
+    }
+
     @Override
     public String getFormattedJdbcPlaceholder(String prefix, String parameterName) {
         return ":" + parameterName; //$NON-NLS-1$
@@ -33,4 +38,9 @@ public String getFormattedJdbcPlaceholder(String prefix, String parameterName) {
     public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName) {
         return ":" + prefix + "." + parameterName; //$NON-NLS-1$ //$NON-NLS-2$
     }
+
+    @Override
+    public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String parameterName) {
+        return ":" + parameterName; //$NON-NLS-1$
+    }
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/util/spring/NamedParameterJdbcTemplateExtensions.java b/src/main/java/org/mybatis/dynamic/sql/util/spring/NamedParameterJdbcTemplateExtensions.java
@@ -36,6 +36,7 @@
 import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
 import org.mybatis.dynamic.sql.util.Buildable;
 import org.springframework.dao.EmptyResultDataAccessException;
+import org.springframework.jdbc.core.JdbcOperations;
 import org.springframework.jdbc.core.RowMapper;
 import org.springframework.jdbc.core.namedparam.BeanPropertySqlParameterSource;
 import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
@@ -160,4 +161,17 @@ public int update(Buildable<UpdateModel> updateStatement) {
     public int update(UpdateStatementProvider updateStatement) {
         return template.update(updateStatement.getUpdateStatement(), updateStatement.getParameters());
     }
+
+    /**
+     * Allow access to the underlying template for unusual circumstances.
+     *
+     * @return The underlying Spring JdbcOperations implementation
+     */
+    public JdbcOperations getJdbcOperations() {
+        return template.getJdbcOperations();
+    }
+
+    public NamedParameterJdbcTemplate getTemplate() {
+        return template;
+    }
 }
diff --git a/src/test/java/examples/simple/CompoundKeyDynamicSqlSupport.java b/src/test/java/examples/simple/CompoundKeyDynamicSqlSupport.java
@@ -0,0 +1,21 @@
+package examples.simple;
+
+import org.mybatis.dynamic.sql.SqlColumn;
+import org.mybatis.dynamic.sql.SqlTable;
+
+import java.sql.JDBCType;
+
+public class CompoundKeyDynamicSqlSupport {
+    public static final CompoundKey compoundKey = new CompoundKey();
+    public static final SqlColumn<Integer> id1 = compoundKey.id1;
+    public static final SqlColumn<Integer> id2 = compoundKey.id2;
+
+    public static final class CompoundKey extends SqlTable {
+        public final SqlColumn<Integer> id1 = column("id1", JDBCType.INTEGER);
+        public final SqlColumn<Integer> id2 = column("id2", JDBCType.INTEGER);
+
+        public CompoundKey() {
+            super("CompoundKey");
+        }
+    }
+}
diff --git a/src/test/java/examples/simple/CompoundKeyMapper.java b/src/test/java/examples/simple/CompoundKeyMapper.java
@@ -0,0 +1,7 @@
+package examples.simple;
+
+import org.mybatis.dynamic.sql.util.mybatis3.CommonInsertMapper;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper;
+
+public interface CompoundKeyMapper extends CommonInsertMapper<Integer>, CommonSelectMapper {
+}
diff --git a/src/test/java/examples/simple/CompoundKeyRow.java b/src/test/java/examples/simple/CompoundKeyRow.java
@@ -0,0 +1,22 @@
+package examples.simple;
+
+public class CompoundKeyRow {
+    private Integer id1;
+    private Integer id2;
+
+    public Integer getId1() {
+        return id1;
+    }
+
+    public void setId1(Integer id1) {
+        this.id1 = id1;
+    }
+
+    public Integer getId2() {
+        return id2;
+    }
+
+    public void setId2(Integer id2) {
+        this.id2 = id2;
+    }
+}
diff --git a/src/test/java/examples/simple/MyBatisMapToRowTest.java b/src/test/java/examples/simple/MyBatisMapToRowTest.java
@@ -0,0 +1,139 @@
+package examples.simple;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.IntStream;
+
+import org.apache.ibatis.datasource.unpooled.UnpooledDataSource;
+import org.apache.ibatis.executor.BatchResult;
+import org.apache.ibatis.jdbc.ScriptRunner;
+import org.apache.ibatis.mapping.Environment;
+import org.apache.ibatis.session.Configuration;
+import org.apache.ibatis.session.ExecutorType;
+import org.apache.ibatis.session.SqlSession;
+import org.apache.ibatis.session.SqlSessionFactory;
+import org.apache.ibatis.session.SqlSessionFactoryBuilder;
+import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mybatis.dynamic.sql.insert.render.BatchInsert;
+import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
+import org.mybatis.dynamic.sql.render.RenderingStrategies;
+import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
+
+import static examples.simple.CompoundKeyDynamicSqlSupport.compoundKey;
+import static examples.simple.CompoundKeyDynamicSqlSupport.id1;
+import static examples.simple.CompoundKeyDynamicSqlSupport.id2;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mybatis.dynamic.sql.SqlBuilder.insertBatch;
+import static org.mybatis.dynamic.sql.SqlBuilder.insertMultiple;
+import static org.mybatis.dynamic.sql.SqlBuilder.select;
+
+public class MyBatisMapToRowTest {
+    private static final String JDBC_URL = "jdbc:hsqldb:mem:aname";
+    private static final String JDBC_DRIVER = "org.hsqldb.jdbcDriver";
+    private SqlSessionFactory sqlSessionFactory;
+
+    @BeforeEach
+    void setup() throws Exception {
+        Class.forName(JDBC_DRIVER);
+        InputStream is = getClass().getResourceAsStream("/examples/simple/CreateSimpleDB.sql");
+        assert is != null;
+        try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
+            ScriptRunner sr = new ScriptRunner(connection);
+            sr.setLogWriter(null);
+            sr.runScript(new InputStreamReader(is));
+        }
+
+        UnpooledDataSource ds = new UnpooledDataSource(JDBC_DRIVER, JDBC_URL, "sa", "");
+        Environment environment = new Environment("test", new JdbcTransactionFactory(), ds);
+        Configuration config = new Configuration(environment);
+        config.addMapper(CompoundKeyMapper.class);
+        sqlSessionFactory = new SqlSessionFactoryBuilder().build(config);
+    }
+
+    @Test
+    void testInsertMultiple() {
+        try (SqlSession session = sqlSessionFactory.openSession()) {
+            CompoundKeyMapper mapper = session.getMapper(CompoundKeyMapper.class);
+
+            List<Integer> integers = new ArrayList<>();
+            integers.add(1);
+            integers.add(2);
+            integers.add(3);
+
+            MultiRowInsertStatementProvider<Integer> insertStatement = insertMultiple(integers)
+                    .into(compoundKey)
+                    .map(id1).toConstant("22")
+                    .map(id2).toRow()
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "insert into CompoundKey (id1, id2) values (22, #{records[0],jdbcType=INTEGER}), (22, #{records[1],jdbcType=INTEGER}), (22, #{records[2],jdbcType=INTEGER})";
+            assertThat(insertStatement.getInsertStatement()).isEqualTo(expected);
+
+            int rows = mapper.insertMultiple(insertStatement);
+            assertThat(rows).isEqualTo(3);
+
+            SelectStatementProvider selectStatement = select(id1, id2)
+                    .from(compoundKey)
+                    .orderBy(id1, id2)
+                    .build().render(RenderingStrategies.MYBATIS3);
+
+            List<CompoundKeyRow> records = mapper.selectMany(selectStatement, this::mapRow);
+            assertThat(records).hasSize(3);
+        }
+    }
+
+    @Test
+    void testInsertBatch() {
+        try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
+            CompoundKeyMapper mapper = session.getMapper(CompoundKeyMapper.class);
+
+            List<Integer> integers = new ArrayList<>();
+            integers.add(1);
+            integers.add(2);
+            integers.add(3);
+
+            BatchInsert<Integer> insertStatement = insertBatch(integers)
+                    .into(compoundKey)
+                    .map(id1).toConstant("22")
+                    .map(id2).toRow()
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            String expected = "insert into CompoundKey (id1, id2) values (22, #{row,jdbcType=INTEGER})";
+            assertThat(insertStatement.getInsertStatementSQL()).isEqualTo(expected);
+
+            insertStatement.insertStatements().forEach(mapper::insert);
+
+            List<BatchResult> batchResults = mapper.flush();
+
+            int rows = batchResults.stream()
+                    .map(BatchResult::getUpdateCounts)
+                    .flatMapToInt(IntStream::of)
+                    .sum();
+            assertThat(rows).isEqualTo(3);
+
+            SelectStatementProvider selectStatement = select(id1, id2)
+                    .from(compoundKey)
+                    .orderBy(id1, id2)
+                    .build().render(RenderingStrategies.MYBATIS3);
+
+            List<CompoundKeyRow> records = mapper.selectMany(selectStatement, this::mapRow);
+            assertThat(records).hasSize(3);
+        }
+    }
+
+    private CompoundKeyRow mapRow(Map<String, Object> map) {
+        CompoundKeyRow answer = new CompoundKeyRow();
+        answer.setId1((Integer) map.get("ID1"));
+        answer.setId2((Integer) map.get("ID2"));
+        return answer;
+    }
+}
diff --git a/src/test/java/examples/spring/CompoundKeyDynamicSqlSupport.java b/src/test/java/examples/spring/CompoundKeyDynamicSqlSupport.java
@@ -0,0 +1,19 @@
+package examples.spring;
+
+import org.mybatis.dynamic.sql.SqlColumn;
+import org.mybatis.dynamic.sql.SqlTable;
+
+public class CompoundKeyDynamicSqlSupport {
+    public static final CompoundKey compoundKey = new CompoundKey();
+    public static final SqlColumn<Integer> id1 = compoundKey.id1;
+    public static final SqlColumn<Integer> id2 = compoundKey.id2;
+
+    public static final class CompoundKey extends SqlTable {
+        public final SqlColumn<Integer> id1 = column("id1");
+        public final SqlColumn<Integer> id2 = column("id2");
+
+        public CompoundKey() {
+            super("CompoundKey");
+        }
+    }
+}
diff --git a/src/test/java/examples/spring/CompoundKeyRow.java b/src/test/java/examples/spring/CompoundKeyRow.java
@@ -0,0 +1,22 @@
+package examples.spring;
+
+public class CompoundKeyRow {
+    private Integer id1;
+    private Integer id2;
+
+    public Integer getId1() {
+        return id1;
+    }
+
+    public void setId1(Integer id1) {
+        this.id1 = id1;
+    }
+
+    public Integer getId2() {
+        return id2;
+    }
+
+    public void setId2(Integer id2) {
+        this.id2 = id2;
+    }
+}
diff --git a/src/test/java/examples/spring/SpringMapToRowTest.java b/src/test/java/examples/spring/SpringMapToRowTest.java
diff --git a/src/test/java/org/mybatis/dynamic/sql/insert/MapToRowTest.java b/src/test/java/org/mybatis/dynamic/sql/insert/MapToRowTest.java
diff --git a/src/test/resources/examples/simple/CreateSimpleDB.sql b/src/test/resources/examples/simple/CreateSimpleDB.sql

Original file line number	Diff line number	Diff line change
`@@ -66,9 +66,12 @@ public FieldAndValueAndParameters visit(PropertyMapping mapping) {`
`66`	`66`
`67`	`67`	`@Override`
`68`	`68`	`public FieldAndValueAndParameters visit(RowMapping mapping) {`
`69`		`- // TODO - fix error number`
`70`		`- throw new UnsupportedOperationException(Messages.getInternalErrorString(99));`
	`69`	`+ return FieldAndValueAndParameters.withFieldName(mapping.columnName())`
	`70`	`+ .withValuePhrase(mapping.mapColumn(this::calculateJdbcPlaceholder))`
	`71`	`+ .build();`
`71`	`72`	`}`
`72`	`73`
`73`	`74`	`abstract String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName);`
	`75`	`+`
	`76`	`+ abstract String calculateJdbcPlaceholder(SqlColumn<?> column);`
`74`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,4 +29,9 @@ String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {`
`29`	`29`	`return column.renderingStrategy().orElse(renderingStrategy)`
`30`	`30`	`.getFormattedJdbcPlaceholder(column, prefix, parameterName);`
`31`	`31`	`}`
	`32`	`+`
	`33`	`+ @Override`
	`34`	`+ String calculateJdbcPlaceholder(SqlColumn<?> column) {`
	`35`	`+ return column.renderingStrategy().orElse(renderingStrategy).getFormattedJdbcPlaceholder(column, prefix);`
	`36`	`+ }`
`32`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,10 +17,6 @@`
`17`	`17`
`18`	`18`	`import org.mybatis.dynamic.sql.SqlColumn;`
`19`	`19`	`import org.mybatis.dynamic.sql.render.RenderingStrategy;`
`20`		`-import org.mybatis.dynamic.sql.util.Messages;`
`21`		`-import org.mybatis.dynamic.sql.util.RowMapping;`
`22`		`-`
`23`		`-import java.util.Optional;`
`24`	`20`
`25`	`21`	`public class MultiRowValuePhraseVisitor extends AbstractMultiRowValuePhraseVisitor {`
`26`	`22`
`@@ -35,8 +31,7 @@ String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {`
`35`	`31`	`}`
`36`	`32`
`37`	`33`	`@Override`
`38`		`- public FieldAndValueAndParameters visit(RowMapping mapping) {`
`39`		`- // TODO - fix error number, and move this somewhere up in the hierarchy`
`40`		`- throw new UnsupportedOperationException(Messages.getInternalErrorString(99));`
	`34`	`+ String calculateJdbcPlaceholder(SqlColumn<?> column) {`
	`35`	`+ return column.renderingStrategy().orElse(renderingStrategy).getMultiRowFormattedJdbcPlaceholder(column, prefix);`
`41`	`36`	`}`
`42`	`37`	`}`
Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,15 @@ public static String formatParameterMapKey(AtomicInteger sequence) {`
`28`	`28`
`29`	`29`	`public abstract String getFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName);`
`30`	`30`
	`31`	`+ public abstract String getFormattedJdbcPlaceholder(BindableColumn<?> column, String parameterName);`
	`32`	`+`
`31`	`33`	`public abstract String getFormattedJdbcPlaceholder(String prefix, String parameterName);`
`32`	`34`
`33`	`35`	`public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String prefix, String parameterName) {`
`34`	`36`	`return getFormattedJdbcPlaceholder(column, prefix, parameterName);`
`35`	`37`	`}`
	`38`	`+`
	`39`	`+ public String getMultiRowFormattedJdbcPlaceholder(BindableColumn<?> column, String parameterName) {`
	`40`	`+ return getFormattedJdbcPlaceholder(column, parameterName);`
	`41`	`+ }`
`36`	`42`	`}`