diff --git a/README.md b/README.md index bdbadeb28..e48edee17 100644 --- a/README.md +++ b/README.md @@ -59,11 +59,13 @@ The library test cases provide several complete examples of using the library in | Language | Runtime | Comments | Code Directory | |---|---|---|---| -| Java | MyBatis3 | Example using Java utility classes for MyBatis in the style of MyBatis Generator | [src/test/java/examples/simple](src/test/java/examples/simple) | -| Java | MyBatis3 | Example using Java utility classes for the MyBatis integration with Spring Batch | [src/test/java/examples/springbatch](src/test/java/examples/springbatch) | -| Java | Spring JDBC | Example using Java utility classes for Spring JDBC Template | [src/test/java/examples/spring](src/test/java/examples/spring) | -| Kotlin | MyBatis3 | Example using Kotlin utility classes for MyBatis in the style of MyBatis Generator | [src/test/kotlin/examples/kotlin/mybatis3/canonical](src/test/kotlin/examples/kotlin/mybatis3/canonical) | -| Kotlin | Spring JDBC | Example using Kotlin utility classes for Spring JDBC Template | [src/test/kotlin/examples/kotlin/spring/canonical](src/test/kotlin/examples/kotlin/spring/canonical) | +| Java | MyBatis3 | Example using Java utility classes for MyBatis in the style of MyBatis Generator | [../examples/simple](src/test/java/examples/simple) | +| Java | MyBatis3 + MyBatis-Spring | Example using MyBatis-Spring integration | [../examples/column/comparison](src/test/java/examples/column/comparison) | +| Java | MyBatis3 + MyBatis-Spring (Spring Batch)| Example using Java utility classes for the MyBatis integration with Spring Batch | [../examples/springbatch](src/test/java/examples/springbatch) | +| Java | Spring JDBC | Example using Java utility classes for Spring JDBC Template | [../examples/spring](src/test/java/examples/spring) | +| Kotlin | MyBatis3 | Example using Kotlin utility classes for MyBatis in the style of MyBatis Generator | [../examples/kotlin/mybatis3/canonical](src/test/kotlin/examples/kotlin/mybatis3/canonical) | +| Kotlin | MyBatis3 + MyBatis-Spring | Example using MyBatis-Spring integration in Kotlin | [../examples/kotlin/mybatis3/column/comparison](src/test/kotlin/examples/kotlin/mybatis3/column/comparison) | +| Kotlin | Spring JDBC | Example using Kotlin utility classes for Spring JDBC Template | [../examples/kotlin/spring/canonical](src/test/kotlin/examples/kotlin/spring/canonical) | ## Requirements diff --git a/src/test/java/examples/column/comparison/ColumnComparisonConfiguration.java b/src/test/java/examples/column/comparison/ColumnComparisonConfiguration.java new file mode 100644 index 000000000..c4cffc84a --- /dev/null +++ b/src/test/java/examples/column/comparison/ColumnComparisonConfiguration.java @@ -0,0 +1,46 @@ +/* + * Copyright 2016-2021 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 + * + * http://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 examples.column.comparison; + +import javax.sql.DataSource; + +import org.apache.ibatis.session.SqlSessionFactory; +import org.mybatis.spring.SqlSessionFactoryBean; +import org.mybatis.spring.annotation.MapperScan; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType; + +@Configuration +@MapperScan("examples.column.comparison") +public class ColumnComparisonConfiguration { + @Bean + public DataSource datasource() { + return new EmbeddedDatabaseBuilder() + .setType(EmbeddedDatabaseType.HSQL) + .generateUniqueName(true) + .addScript("classpath:/examples/column/comparison/CreateDB.sql") + .build(); + } + + @Bean + public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception { + SqlSessionFactoryBean factoryBean = new SqlSessionFactoryBean(); + factoryBean.setDataSource(dataSource); + return factoryBean.getObject(); + } +} diff --git a/src/test/java/examples/column/comparison/ColumnComparisonDynamicSqlSupport.java b/src/test/java/examples/column/comparison/ColumnComparisonDynamicSqlSupport.java index 6d2493a42..b67319c5c 100644 --- a/src/test/java/examples/column/comparison/ColumnComparisonDynamicSqlSupport.java +++ b/src/test/java/examples/column/comparison/ColumnComparisonDynamicSqlSupport.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2020 the original author or authors. + * Copyright 2016-2021 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. @@ -17,6 +17,7 @@ import java.sql.JDBCType; +import org.mybatis.dynamic.sql.BasicColumn; import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.SqlTable; @@ -25,6 +26,8 @@ public final class ColumnComparisonDynamicSqlSupport { public static final SqlColumn number1 = columnComparison.number1; public static final SqlColumn number2 = columnComparison.number2; + public static final BasicColumn[] columnList = { number1, number2 }; + public static final class ColumnComparison extends SqlTable { public final SqlColumn number1 = column("number1", JDBCType.INTEGER); public final SqlColumn number2 = column("number2", JDBCType.INTEGER); diff --git a/src/test/java/examples/column/comparison/ColumnComparisonMapper.java b/src/test/java/examples/column/comparison/ColumnComparisonMapper.java index 7a0cca75e..2fbe95294 100644 --- a/src/test/java/examples/column/comparison/ColumnComparisonMapper.java +++ b/src/test/java/examples/column/comparison/ColumnComparisonMapper.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2020 the original author or authors. + * Copyright 2016-2021 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. @@ -20,8 +20,10 @@ import org.apache.ibatis.annotations.Result; import org.apache.ibatis.annotations.Results; import org.apache.ibatis.annotations.SelectProvider; +import org.mybatis.dynamic.sql.select.SelectDSLCompleter; import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; import org.mybatis.dynamic.sql.util.SqlProviderAdapter; +import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils; public interface ColumnComparisonMapper { @@ -31,4 +33,9 @@ public interface ColumnComparisonMapper { @Result(column="number2", property="number2", id=true) }) List selectMany(SelectStatementProvider selectStatement); + + default List select(SelectDSLCompleter completer) { + return MyBatis3Utils.selectList(this::selectMany, ColumnComparisonDynamicSqlSupport.columnList, + ColumnComparisonDynamicSqlSupport.columnComparison, completer); + } } diff --git a/src/test/java/examples/column/comparison/ColumnComparisonTest.java b/src/test/java/examples/column/comparison/ColumnComparisonTest.java index 41f08b7e1..472d24e22 100644 --- a/src/test/java/examples/column/comparison/ColumnComparisonTest.java +++ b/src/test/java/examples/column/comparison/ColumnComparisonTest.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2020 the original author or authors. + * Copyright 2016-2021 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. @@ -17,216 +17,162 @@ import static examples.column.comparison.ColumnComparisonDynamicSqlSupport.*; import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.jupiter.api.Assertions.assertAll; import static org.mybatis.dynamic.sql.SqlBuilder.*; -import java.io.InputStream; -import java.io.InputStreamReader; -import java.sql.Connection; -import java.sql.DriverManager; import java.util.List; -import org.apache.ibatis.datasource.unpooled.UnpooledDataSource; -import org.apache.ibatis.jdbc.ScriptRunner; -import org.apache.ibatis.mapping.Environment; -import org.apache.ibatis.session.Configuration; -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.render.RenderingStrategies; import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig; +@SpringJUnitConfig(classes = ColumnComparisonConfiguration.class) class ColumnComparisonTest { - 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/column/comparison/CreateDB.sql"); - 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(ColumnComparisonMapper.class); - sqlSessionFactory = new SqlSessionFactoryBuilder().build(config); - } + @Autowired + private ColumnComparisonMapper mapper; @Test void testColumnComparisonLessThan() { - try (SqlSession sqlSession = sqlSessionFactory.openSession()) { - ColumnComparisonMapper mapper = sqlSession.getMapper(ColumnComparisonMapper.class); - - SelectStatementProvider selectStatement = select(number1, number2) - .from(columnComparison) - .where(number1, isLessThan(number2)) - .orderBy(number1, number2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expected = "select number1, number2 " - + "from ColumnComparison " - + "where number1 < number2 " - + "order by number1, number2"; - - List records = mapper.selectMany(selectStatement); - - assertAll( - () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected), - () -> assertThat(records).hasSize(5), - () -> assertThat(records.get(0).getNumber1()).isEqualTo(1), - () -> assertThat(records.get(4).getNumber1()).isEqualTo(5) - ); - } + SelectStatementProvider selectStatement = select(number1, number2) + .from(columnComparison) + .where(number1, isLessThan(number2)) + .orderBy(number1, number2) + .build() + .render(RenderingStrategies.MYBATIS3); + + String expected = "select number1, number2 " + + "from ColumnComparison " + + "where number1 < number2 " + + "order by number1, number2"; + + List records = mapper.selectMany(selectStatement); + + assertThat(selectStatement.getSelectStatement()).isEqualTo(expected); + assertThat(records).hasSize(5); + assertThat(records.get(0).getNumber1()).isEqualTo(1); + assertThat(records.get(4).getNumber1()).isEqualTo(5); } @Test void testColumnComparisonLessThanOrEqual() { - try (SqlSession sqlSession = sqlSessionFactory.openSession()) { - ColumnComparisonMapper mapper = sqlSession.getMapper(ColumnComparisonMapper.class); - - SelectStatementProvider selectStatement = select(number1, number2) - .from(columnComparison) - .where(number1, isLessThanOrEqualTo(number2)) - .orderBy(number1, number2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expected = "select number1, number2 " - + "from ColumnComparison " - + "where number1 <= number2 " - + "order by number1, number2"; - - List records = mapper.selectMany(selectStatement); - - assertAll( - () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected), - () -> assertThat(records).hasSize(6), - () -> assertThat(records.get(0).getNumber1()).isEqualTo(1), - () -> assertThat(records.get(5).getNumber1()).isEqualTo(6) - ); - } + SelectStatementProvider selectStatement = select(number1, number2) + .from(columnComparison) + .where(number1, isLessThanOrEqualTo(number2)) + .orderBy(number1, number2) + .build() + .render(RenderingStrategies.MYBATIS3); + + String expected = "select number1, number2 " + + "from ColumnComparison " + + "where number1 <= number2 " + + "order by number1, number2"; + + List records = mapper.selectMany(selectStatement); + + assertThat(selectStatement.getSelectStatement()).isEqualTo(expected); + assertThat(records).hasSize(6); + assertThat(records.get(0).getNumber1()).isEqualTo(1); + assertThat(records.get(5).getNumber1()).isEqualTo(6); } @Test void testColumnComparisonGreaterThan() { - try (SqlSession sqlSession = sqlSessionFactory.openSession()) { - ColumnComparisonMapper mapper = sqlSession.getMapper(ColumnComparisonMapper.class); - - SelectStatementProvider selectStatement = select(number1, number2) - .from(columnComparison) - .where(number1, isGreaterThan(number2)) - .orderBy(number1, number2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expected = "select number1, number2 " - + "from ColumnComparison " - + "where number1 > number2 " - + "order by number1, number2"; - - List records = mapper.selectMany(selectStatement); - - assertAll( - () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected), - () -> assertThat(records).hasSize(5), - () -> assertThat(records.get(0).getNumber1()).isEqualTo(7), - () -> assertThat(records.get(4).getNumber1()).isEqualTo(11) - ); - } + SelectStatementProvider selectStatement = select(number1, number2) + .from(columnComparison) + .where(number1, isGreaterThan(number2)) + .orderBy(number1, number2) + .build() + .render(RenderingStrategies.MYBATIS3); + + String expected = "select number1, number2 " + + "from ColumnComparison " + + "where number1 > number2 " + + "order by number1, number2"; + + List records = mapper.selectMany(selectStatement); + + assertThat(selectStatement.getSelectStatement()).isEqualTo(expected); + assertThat(records).hasSize(5); + assertThat(records.get(0).getNumber1()).isEqualTo(7); + assertThat(records.get(4).getNumber1()).isEqualTo(11); } @Test void testColumnComparisonGreaterThanOrEqual() { - try (SqlSession sqlSession = sqlSessionFactory.openSession()) { - ColumnComparisonMapper mapper = sqlSession.getMapper(ColumnComparisonMapper.class); - - SelectStatementProvider selectStatement = select(number1, number2) - .from(columnComparison) - .where(number1, isGreaterThanOrEqualTo(number2)) - .orderBy(number1, number2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expected = "select number1, number2 " - + "from ColumnComparison " - + "where number1 >= number2 " - + "order by number1, number2"; - - List records = mapper.selectMany(selectStatement); - - assertAll( - () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected), - () -> assertThat(records).hasSize(6), - () -> assertThat(records.get(0).getNumber1()).isEqualTo(6), - () -> assertThat(records.get(5).getNumber1()).isEqualTo(11) - ); - } + SelectStatementProvider selectStatement = select(number1, number2) + .from(columnComparison) + .where(number1, isGreaterThanOrEqualTo(number2)) + .orderBy(number1, number2) + .build() + .render(RenderingStrategies.MYBATIS3); + + String expected = "select number1, number2 " + + "from ColumnComparison " + + "where number1 >= number2 " + + "order by number1, number2"; + + List records = mapper.selectMany(selectStatement); + + assertThat(selectStatement.getSelectStatement()).isEqualTo(expected); + assertThat(records).hasSize(6); + assertThat(records.get(0).getNumber1()).isEqualTo(6); + assertThat(records.get(5).getNumber1()).isEqualTo(11); } @Test void testColumnComparisonEqual() { - try (SqlSession sqlSession = sqlSessionFactory.openSession()) { - ColumnComparisonMapper mapper = sqlSession.getMapper(ColumnComparisonMapper.class); - - SelectStatementProvider selectStatement = select(number1, number2) - .from(columnComparison) - .where(number1, isEqualTo(number2)) - .orderBy(number1, number2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expected = "select number1, number2 " - + "from ColumnComparison " - + "where number1 = number2 " - + "order by number1, number2"; - - List records = mapper.selectMany(selectStatement); - - assertAll( - () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected), - () -> assertThat(records).hasSize(1), - () -> assertThat(records.get(0).getNumber1()).isEqualTo(6) - ); - } + SelectStatementProvider selectStatement = select(number1, number2) + .from(columnComparison) + .where(number1, isEqualTo(number2)) + .orderBy(number1, number2) + .build() + .render(RenderingStrategies.MYBATIS3); + + String expected = "select number1, number2 " + + "from ColumnComparison " + + "where number1 = number2 " + + "order by number1, number2"; + + List records = mapper.selectMany(selectStatement); + + assertThat(selectStatement.getSelectStatement()).isEqualTo(expected); + assertThat(records).hasSize(1); + assertThat(records.get(0).getNumber1()).isEqualTo(6); } @Test void testColumnComparisonNotEqual() { - try (SqlSession sqlSession = sqlSessionFactory.openSession()) { - ColumnComparisonMapper mapper = sqlSession.getMapper(ColumnComparisonMapper.class); - - SelectStatementProvider selectStatement = select(number1, number2) - .from(columnComparison) - .where(number1, isNotEqualTo(number2)) - .orderBy(number1, number2) - .build() - .render(RenderingStrategies.MYBATIS3); - - String expected = "select number1, number2 " - + "from ColumnComparison " - + "where number1 <> number2 " - + "order by number1, number2"; - - List records = mapper.selectMany(selectStatement); - - assertAll( - () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected), - () -> assertThat(records).hasSize(10), - () -> assertThat(records.get(0).getNumber1()).isEqualTo(1), - () -> assertThat(records.get(9).getNumber1()).isEqualTo(11) - ); - } + SelectStatementProvider selectStatement = select(number1, number2) + .from(columnComparison) + .where(number1, isNotEqualTo(number2)) + .orderBy(number1, number2) + .build() + .render(RenderingStrategies.MYBATIS3); + + String expected = "select number1, number2 " + + "from ColumnComparison " + + "where number1 <> number2 " + + "order by number1, number2"; + + List records = mapper.selectMany(selectStatement); + + assertThat(selectStatement.getSelectStatement()).isEqualTo(expected); + assertThat(records).hasSize(10); + assertThat(records.get(0).getNumber1()).isEqualTo(1); + assertThat(records.get(9).getNumber1()).isEqualTo(11); + } + + @Test + void testHelperMethod() { + List records = mapper.select(d -> + d.where(number1, isNotEqualTo(number2)) + .orderBy(number1, number2) + ); + + assertThat(records).hasSize(10); + assertThat(records.get(0).getNumber1()).isEqualTo(1); + assertThat(records.get(9).getNumber1()).isEqualTo(11); } } diff --git a/src/test/java/examples/spring/PersonTemplateTest.java b/src/test/java/examples/spring/PersonTemplateTest.java index 542fa4ab9..654a41486 100644 --- a/src/test/java/examples/spring/PersonTemplateTest.java +++ b/src/test/java/examples/spring/PersonTemplateTest.java @@ -1,5 +1,5 @@ /* - * Copyright 2016-2020 the original author or authors. + * Copyright 2016-2021 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. @@ -25,7 +25,6 @@ import java.util.List; import java.util.Optional; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mybatis.dynamic.sql.delete.DeleteModel; import org.mybatis.dynamic.sql.insert.BatchInsertModel; @@ -36,26 +35,18 @@ import org.mybatis.dynamic.sql.update.UpdateModel; import org.mybatis.dynamic.sql.util.Buildable; import org.mybatis.dynamic.sql.util.spring.NamedParameterJdbcTemplateExtensions; +import org.springframework.beans.factory.annotation.Autowired; import org.springframework.jdbc.core.RowMapper; -import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase; -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder; -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType; +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig; +import org.springframework.transaction.annotation.Transactional; +@SpringJUnitConfig(classes = SpringConfiguration.class) +@Transactional class PersonTemplateTest { + @Autowired private NamedParameterJdbcTemplateExtensions template; - @BeforeEach - void setup() throws Exception { - EmbeddedDatabase db = new EmbeddedDatabaseBuilder() - .setType(EmbeddedDatabaseType.HSQL) - .generateUniqueName(true) - .addScript("classpath:/examples/simple/CreateSimpleDB.sql") - .build(); - template = new NamedParameterJdbcTemplateExtensions(new NamedParameterJdbcTemplate(db)); - } - @Test void testSelect() { Buildable selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, addressId) @@ -740,7 +731,7 @@ void testJoinCount() { } @Test - void testJoinCountWithSubcriteria() { + void testJoinCountWithSubCriteria() { Buildable countStatement = countFrom(person) .join(address, on(person.addressId, equalTo(address.id))) .where(person.id, isEqualTo(55), or(person.id, isEqualTo(1))); @@ -749,14 +740,14 @@ void testJoinCountWithSubcriteria() { assertThat(count).isEqualTo(1); } - private RowMapper personWithAddressRowMapper = + private final RowMapper personWithAddressRowMapper = (rs, i) -> { PersonWithAddress record = new PersonWithAddress(); record.setId(rs.getInt(1)); record.setFirstName(rs.getString(2)); record.setLastName(LastName.of(rs.getString(3))); record.setBirthDate(rs.getTimestamp(4)); - record.setEmployed("Yes".equals(rs.getString(5)) ? true : false); + record.setEmployed("Yes".equals(rs.getString(5))); record.setOccupation(rs.getString(6)); AddressRecord address = new AddressRecord(); @@ -777,7 +768,7 @@ void testJoinCountWithSubcriteria() { record.setFirstName(rs.getString(2)); record.setLastName(LastName.of(rs.getString(3))); record.setBirthDate(rs.getTimestamp(4)); - record.setEmployed("Yes".equals(rs.getString(5)) ? true : false); + record.setEmployed("Yes".equals(rs.getString(5))); record.setOccupation(rs.getString(6)); record.setAddressId(rs.getInt(7)); return record; diff --git a/src/test/java/examples/spring/ReusableWhereTest.java b/src/test/java/examples/spring/ReusableWhereTest.java index 4c1216235..8f8c2aa0f 100644 --- a/src/test/java/examples/spring/ReusableWhereTest.java +++ b/src/test/java/examples/spring/ReusableWhereTest.java @@ -21,7 +21,6 @@ import java.util.List; -import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.mybatis.dynamic.sql.delete.DeleteModel; import org.mybatis.dynamic.sql.render.RenderingStrategies; @@ -31,25 +30,17 @@ import org.mybatis.dynamic.sql.util.Buildable; import org.mybatis.dynamic.sql.util.spring.NamedParameterJdbcTemplateExtensions; import org.mybatis.dynamic.sql.where.WhereApplier; -import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabase; -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder; -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig; +import org.springframework.transaction.annotation.Transactional; +@SpringJUnitConfig(classes = SpringConfiguration.class) +@Transactional class ReusableWhereTest { + @Autowired private NamedParameterJdbcTemplateExtensions template; - @BeforeEach - void setup() { - EmbeddedDatabase db = new EmbeddedDatabaseBuilder() - .setType(EmbeddedDatabaseType.HSQL) - .generateUniqueName(true) - .addScript("classpath:/examples/simple/CreateSimpleDB.sql") - .build(); - template = new NamedParameterJdbcTemplateExtensions(new NamedParameterJdbcTemplate(db)); - } - @Test void testCount() { Buildable countStatement = countFrom(person) diff --git a/src/test/java/examples/spring/SpringConfiguration.java b/src/test/java/examples/spring/SpringConfiguration.java new file mode 100644 index 000000000..291297f29 --- /dev/null +++ b/src/test/java/examples/spring/SpringConfiguration.java @@ -0,0 +1,54 @@ +/* + * Copyright 2016-2021 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 + * + * http://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 examples.spring; + +import javax.sql.DataSource; + +import org.mybatis.dynamic.sql.util.spring.NamedParameterJdbcTemplateExtensions; +import org.springframework.context.annotation.Bean; +import org.springframework.context.annotation.Configuration; +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate; +import org.springframework.jdbc.datasource.DataSourceTransactionManager; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder; +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType; +import org.springframework.transaction.PlatformTransactionManager; + +@Configuration +public class SpringConfiguration { + @Bean + public DataSource datasource() { + return new EmbeddedDatabaseBuilder() + .setType(EmbeddedDatabaseType.HSQL) + .generateUniqueName(true) + .addScript("classpath:/examples/simple/CreateSimpleDB.sql") + .build(); + } + + @Bean + public NamedParameterJdbcTemplate template(DataSource dataSource) { + return new NamedParameterJdbcTemplate(dataSource); + } + + @Bean + public PlatformTransactionManager transactionManager(DataSource dataSource) { + return new DataSourceTransactionManager(dataSource); + } + + @Bean + public NamedParameterJdbcTemplateExtensions templateExtensions(NamedParameterJdbcTemplate template) { + return new NamedParameterJdbcTemplateExtensions(template); + } +} diff --git a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonConfiguration.kt b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonConfiguration.kt index 8e6b360e9..a430d1c93 100644 --- a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonConfiguration.kt +++ b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonConfiguration.kt @@ -28,18 +28,18 @@ import javax.sql.DataSource @MapperScan("examples.kotlin.mybatis3.column.comparison") open class ColumnComparisonConfiguration { @Bean - open fun dataSource(): DataSource { - return EmbeddedDatabaseBuilder() - .setType(EmbeddedDatabaseType.HSQL) - .generateUniqueName(true) - .addScript("classpath:/examples/column/comparison/CreateDB.sql") - .build() - } + open fun dataSource(): DataSource = + EmbeddedDatabaseBuilder().run { + setType(EmbeddedDatabaseType.HSQL) + generateUniqueName(true) + addScript("classpath:/examples/column/comparison/CreateDB.sql") + build() + } @Bean - open fun sqlSessionFactory(): SqlSessionFactory? { - val factoryBean = SqlSessionFactoryBean() - factoryBean.setDataSource(dataSource()) - return factoryBean.getObject() - } + open fun sqlSessionFactory(dataSource: DataSource): SqlSessionFactory = + SqlSessionFactoryBean().run { + setDataSource(dataSource) + `object`!! + } } diff --git a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonDynamicSqlSupport.kt b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonDynamicSqlSupport.kt index 5261dd67b..d36a5e0c1 100644 --- a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonDynamicSqlSupport.kt +++ b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonDynamicSqlSupport.kt @@ -24,6 +24,8 @@ object ColumnComparisonDynamicSqlSupport { val number1 = columnComparison.number1 val number2 = columnComparison.number2 + val columnList = listOf(number1, number2) + class ColumnComparison : SqlTable("ColumnComparison") { val number1 = column(name = "number1", jdbcType = JDBCType.INTEGER) val number2 = column(name = "number2", jdbcType = JDBCType.INTEGER) diff --git a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonMapper.kt b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonMapper.kt index bb19f5417..42c8721dc 100644 --- a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonMapper.kt +++ b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonMapper.kt @@ -22,6 +22,8 @@ import org.apache.ibatis.annotations.SelectProvider import org.apache.ibatis.type.JdbcType import org.mybatis.dynamic.sql.select.render.SelectStatementProvider import org.mybatis.dynamic.sql.util.SqlProviderAdapter +import org.mybatis.dynamic.sql.util.kotlin.SelectCompleter +import org.mybatis.dynamic.sql.util.kotlin.mybatis3.selectList @Mapper interface ColumnComparisonMapper { @@ -32,3 +34,12 @@ interface ColumnComparisonMapper { ) fun selectMany(selectStatement: SelectStatementProvider): List } + +// helper methods must be declared as extension methods in Kotlin +fun ColumnComparisonMapper.select(completer: SelectCompleter) = + selectList( + this::selectMany, + ColumnComparisonDynamicSqlSupport.columnList, + ColumnComparisonDynamicSqlSupport.columnComparison, + completer + ) diff --git a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonTest.kt index 3a04bb3a0..418ff1231 100644 --- a/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonTest.kt +++ b/src/test/kotlin/examples/kotlin/mybatis3/column/comparison/ColumnComparisonTest.kt @@ -32,7 +32,7 @@ import org.springframework.beans.factory.annotation.Autowired import org.springframework.test.context.junit.jupiter.SpringJUnitConfig @SpringJUnitConfig(classes = [ColumnComparisonConfiguration::class]) -internal class ColumnComparisonTest { +class ColumnComparisonTest { @Autowired private lateinit var mapper: ColumnComparisonMapper @@ -155,4 +155,16 @@ internal class ColumnComparisonTest { assertThat(records[0].number1).isEqualTo(1) assertThat(records[9].number1).isEqualTo(11) } + + @Test + fun testHelperMethod() { + val records = mapper.select { + where(number1, isNotEqualTo(number2)) + orderBy(number1, number2) + } + + assertThat(records).hasSize(10) + assertThat(records[0].number1).isEqualTo(1) + assertThat(records[9].number1).isEqualTo(11) + } } diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt index 4a53fa78a..8ab5902b8 100644 --- a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt +++ b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt @@ -26,7 +26,6 @@ import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.id import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.lastName import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.occupation import org.assertj.core.api.Assertions.assertThat -import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.mybatis.dynamic.sql.util.kotlin.elements.add import org.mybatis.dynamic.sql.util.kotlin.elements.constant @@ -50,27 +49,20 @@ import org.mybatis.dynamic.sql.util.kotlin.spring.selectDistinct import org.mybatis.dynamic.sql.util.kotlin.spring.selectOne import org.mybatis.dynamic.sql.util.kotlin.spring.update import org.mybatis.dynamic.sql.util.kotlin.spring.withKeyHolder +import org.springframework.beans.factory.annotation.Autowired import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType import org.springframework.jdbc.support.GeneratedKeyHolder +import org.springframework.test.annotation.DirtiesContext +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig +import org.springframework.transaction.annotation.Transactional import java.util.Date +@SpringJUnitConfig(classes = [SpringConfiguration::class]) +@Transactional class CanonicalSpringKotlinTemplateDirectTest { + @Autowired private lateinit var template: NamedParameterJdbcTemplate - @BeforeEach - fun setup() { - val db = with(EmbeddedDatabaseBuilder()) { - setType(EmbeddedDatabaseType.HSQL) - generateUniqueName(true) - addScript("classpath:/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql") - addScript("classpath:/examples/kotlin/spring/CreateSimpleDB.sql") - build() - } - template = NamedParameterJdbcTemplate(db) - } - @Test fun testCount() { val rows = template.countFrom(person) { @@ -284,6 +276,7 @@ class CanonicalSpringKotlinTemplateDirectTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testGeneralInsertWithGeneratedKey() { val keyHolder = GeneratedKeyHolder() @@ -300,6 +293,7 @@ class CanonicalSpringKotlinTemplateDirectTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testInsertWithGeneratedKey() { val command = GeneratedAlwaysCommand(firstName = "Fred", lastName = "Flintstone") @@ -318,6 +312,7 @@ class CanonicalSpringKotlinTemplateDirectTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testMultiRowInsertWithGeneratedKey() { val command1 = GeneratedAlwaysCommand(firstName = "Fred", lastName = "Flintstone") val command2 = GeneratedAlwaysCommand(firstName = "Barney", lastName = "Rubble") @@ -339,6 +334,7 @@ class CanonicalSpringKotlinTemplateDirectTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testInsertSelectWithGeneratedKey() { val keyHolder = GeneratedKeyHolder() diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt index 954dd32f8..391494c06 100644 --- a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt +++ b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt @@ -27,7 +27,6 @@ import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.lastName import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.occupation import org.assertj.core.api.Assertions.assertThat import org.assertj.core.api.Assertions.assertThatExceptionOfType -import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.mybatis.dynamic.sql.util.kotlin.elements.add import org.mybatis.dynamic.sql.util.kotlin.elements.constant @@ -63,28 +62,21 @@ import org.mybatis.dynamic.sql.util.kotlin.spring.selectDistinct import org.mybatis.dynamic.sql.util.kotlin.spring.selectList import org.mybatis.dynamic.sql.util.kotlin.spring.selectOne import org.mybatis.dynamic.sql.util.kotlin.spring.update +import org.springframework.beans.factory.annotation.Autowired import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType import org.springframework.jdbc.support.GeneratedKeyHolder +import org.springframework.test.annotation.DirtiesContext +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig +import org.springframework.transaction.annotation.Transactional import java.util.Date @Suppress("LargeClass") +@SpringJUnitConfig(classes = [SpringConfiguration::class]) +@Transactional class CanonicalSpringKotlinTest { + @Autowired private lateinit var template: NamedParameterJdbcTemplate - @BeforeEach - fun setup() { - val db = with(EmbeddedDatabaseBuilder()) { - setType(EmbeddedDatabaseType.HSQL) - generateUniqueName(true) - addScript("classpath:/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql") - addScript("classpath:/examples/kotlin/spring/CreateSimpleDB.sql") - build() - } - template = NamedParameterJdbcTemplate(db) - } - @Test fun testRawCount() { val countStatement = countFrom(person) { @@ -463,6 +455,7 @@ class CanonicalSpringKotlinTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testGeneralInsertWithGeneratedKey() { val insertStatement = insertInto(generatedAlways) { set(generatedAlways.firstName).toValue("Fred") @@ -478,6 +471,7 @@ class CanonicalSpringKotlinTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testInsertWithGeneratedKey() { val command = GeneratedAlwaysCommand(firstName = "Fred", lastName = "Flintstone") @@ -495,6 +489,7 @@ class CanonicalSpringKotlinTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testMultiRowInsertWithGeneratedKey() { val command1 = GeneratedAlwaysCommand(firstName = "Fred", lastName = "Flintstone") val command2 = GeneratedAlwaysCommand(firstName = "Barney", lastName = "Rubble") @@ -515,6 +510,7 @@ class CanonicalSpringKotlinTest { } @Test + @DirtiesContext(methodMode = DirtiesContext.MethodMode.AFTER_METHOD) fun testInsertSelectWithGeneratedKey() { val insertStatement = insertSelect(generatedAlways) { columns(generatedAlways.firstName, generatedAlways.lastName) @@ -1328,14 +1324,14 @@ class CanonicalSpringKotlinTest { upper(firstName), isLikeWhenPresent(search1.firstName) .map(String::trim) .filter(String::isNotEmpty) - .map(String::toUpperCase) + .map(String::uppercase) .map { "%$it%" } ) and( upper(lastName), isLikeWhenPresent(search1.lastName) .map(String::trim) .filter(String::isNotEmpty) - .map(String::toUpperCase) + .map(String::uppercase) .map { LastName("%$it%") } ) orderBy(id) diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/KotlinConditionsTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/KotlinConditionsTest.kt index 66b145f90..ce39692e6 100644 --- a/src/test/kotlin/examples/kotlin/spring/canonical/KotlinConditionsTest.kt +++ b/src/test/kotlin/examples/kotlin/spring/canonical/KotlinConditionsTest.kt @@ -24,7 +24,6 @@ import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.id import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.lastName import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.occupation import org.assertj.core.api.Assertions.assertThat -import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThan @@ -39,26 +38,18 @@ import org.mybatis.dynamic.sql.util.kotlin.elements.min import org.mybatis.dynamic.sql.util.kotlin.spring.select import org.mybatis.dynamic.sql.util.kotlin.spring.selectList import org.mybatis.dynamic.sql.util.kotlin.spring.selectOne +import org.springframework.beans.factory.annotation.Autowired import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig +import org.springframework.transaction.annotation.Transactional @Suppress("LargeClass", "MaxLineLength") +@SpringJUnitConfig(classes = [SpringConfiguration::class]) +@Transactional class KotlinConditionsTest { + @Autowired private lateinit var template: NamedParameterJdbcTemplate - @BeforeEach - fun setup() { - val db = with(EmbeddedDatabaseBuilder()) { - setType(EmbeddedDatabaseType.HSQL) - generateUniqueName(true) - addScript("classpath:/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql") - addScript("classpath:/examples/kotlin/spring/CreateSimpleDB.sql") - build() - } - template = NamedParameterJdbcTemplate(db) - } - @Test fun testSelectEqualToValue() { val selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, addressId) { diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/KotlinElementsTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/KotlinElementsTest.kt index 873a90281..d37a5e5e8 100644 --- a/src/test/kotlin/examples/kotlin/spring/canonical/KotlinElementsTest.kt +++ b/src/test/kotlin/examples/kotlin/spring/canonical/KotlinElementsTest.kt @@ -20,7 +20,6 @@ import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.firstName import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.id import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.lastName import org.assertj.core.api.Assertions.assertThat -import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.mybatis.dynamic.sql.util.kotlin.elements.applyOperator import org.mybatis.dynamic.sql.util.kotlin.elements.avg @@ -65,26 +64,18 @@ import org.mybatis.dynamic.sql.util.kotlin.elements.upper import org.mybatis.dynamic.sql.util.kotlin.spring.select import org.mybatis.dynamic.sql.util.kotlin.spring.selectList import org.mybatis.dynamic.sql.util.kotlin.spring.selectOne +import org.springframework.beans.factory.annotation.Autowired import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig +import org.springframework.transaction.annotation.Transactional @Suppress("LargeClass", "MaxLineLength") +@SpringJUnitConfig(classes = [SpringConfiguration::class]) +@Transactional class KotlinElementsTest { + @Autowired private lateinit var template: NamedParameterJdbcTemplate - @BeforeEach - fun setup() { - val db = with(EmbeddedDatabaseBuilder()) { - setType(EmbeddedDatabaseType.HSQL) - generateUniqueName(true) - addScript("classpath:/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql") - addScript("classpath:/examples/kotlin/spring/CreateSimpleDB.sql") - build() - } - template = NamedParameterJdbcTemplate(db) - } - @Test fun testCount() { val selectStatement = select(count(id)) { @@ -1145,7 +1136,7 @@ class KotlinElementsTest { where( upper(firstName), isLike(fn).filter(String::isNotBlank) - .map(String::toUpperCase) + .map(String::uppercase) .map { "%$it%" } ) orderBy(id) @@ -1170,7 +1161,7 @@ class KotlinElementsTest { where( upper(firstName), isLike(fn).filter(String::isNotBlank) - .map(String::toUpperCase) + .map(String::uppercase) .map { "%$it%" } ) orderBy(id) diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/SpringConfiguration.kt b/src/test/kotlin/examples/kotlin/spring/canonical/SpringConfiguration.kt new file mode 100644 index 000000000..bc1d215ab --- /dev/null +++ b/src/test/kotlin/examples/kotlin/spring/canonical/SpringConfiguration.kt @@ -0,0 +1,44 @@ +/* + * Copyright 2016-2021 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 + * + * http://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 examples.kotlin.spring.canonical + +import javax.sql.DataSource + +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder +import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType +import org.springframework.context.annotation.Bean +import org.springframework.context.annotation.Configuration +import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate +import org.springframework.jdbc.datasource.DataSourceTransactionManager + +@Configuration +open class SpringConfiguration { + @Bean + open fun datasource(): DataSource = + EmbeddedDatabaseBuilder().run { + setType(EmbeddedDatabaseType.HSQL) + generateUniqueName(true) + addScript("classpath:/examples/kotlin/spring/CreateGeneratedAlwaysDB.sql") + addScript("classpath:/examples/kotlin/spring/CreateSimpleDB.sql") + build() + } + + @Bean + open fun template(dataSource: DataSource) = NamedParameterJdbcTemplate(dataSource) + + @Bean + open fun transactionManager(dataSource: DataSource) = DataSourceTransactionManager(dataSource) +} diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/SpringKotlinSubQueryTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/SpringKotlinSubQueryTest.kt index bcec2b999..f2d87b6f7 100644 --- a/src/test/kotlin/examples/kotlin/spring/canonical/SpringKotlinSubQueryTest.kt +++ b/src/test/kotlin/examples/kotlin/spring/canonical/SpringKotlinSubQueryTest.kt @@ -19,31 +19,23 @@ import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.person import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.firstName import examples.kotlin.spring.canonical.PersonDynamicSqlSupport.id import org.assertj.core.api.Assertions.assertThat -import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test import org.mybatis.dynamic.sql.DerivedColumn import org.mybatis.dynamic.sql.util.kotlin.elements.isLessThan import org.mybatis.dynamic.sql.util.kotlin.elements.isLike import org.mybatis.dynamic.sql.util.kotlin.spring.select import org.mybatis.dynamic.sql.util.kotlin.spring.selectList +import org.springframework.beans.factory.annotation.Autowired import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder -import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType +import org.springframework.test.context.junit.jupiter.SpringJUnitConfig +import org.springframework.transaction.annotation.Transactional +@SpringJUnitConfig(classes = [SpringConfiguration::class]) +@Transactional class SpringKotlinSubQueryTest { + @Autowired private lateinit var template: NamedParameterJdbcTemplate - @BeforeEach - fun setup() { - val db = with(EmbeddedDatabaseBuilder()) { - setType(EmbeddedDatabaseType.HSQL) - generateUniqueName(true) - addScript("classpath:/examples/kotlin/spring/CreateSimpleDB.sql") - build() - } - template = NamedParameterJdbcTemplate(db) - } - @Test fun testBasicSubQuery() { val rowNum = DerivedColumn.of("rownum()")