Tests for new sharding support

jeffgbutler · jeffgbutler · commit abf62663f4bc · 2022-11-28T16:45:50.000-05:00
diff --git a/src/test/java/examples/sharding/ShardedMapper.java b/src/test/java/examples/sharding/ShardedMapper.java
@@ -0,0 +1,23 @@
+/*
+ *    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 examples.sharding;
+
+import org.mybatis.dynamic.sql.util.mybatis3.CommonCountMapper;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonGeneralInsertMapper;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper;
+
+public interface ShardedMapper extends CommonCountMapper, CommonGeneralInsertMapper, CommonSelectMapper {
+}
diff --git a/src/test/java/examples/sharding/ShardingTest.java b/src/test/java/examples/sharding/ShardingTest.java
@@ -0,0 +1,166 @@
+/*
+ *    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 examples.sharding;
+
+import static examples.sharding.TableCodesDynamicSqlSupport.tableCodes;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mybatis.dynamic.sql.SqlBuilder.countFrom;
+import static org.mybatis.dynamic.sql.SqlBuilder.insertInto;
+import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
+import static org.mybatis.dynamic.sql.SqlBuilder.select;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.sql.Connection;
+import java.sql.DriverManager;
+
+import examples.sharding.TableCodesDynamicSqlSupport.TableCodes;
+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.insert.render.GeneralInsertStatementProvider;
+import org.mybatis.dynamic.sql.render.RenderingStrategies;
+import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
+
+class ShardingTest {
+    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/sharding/ShardingDB.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(ShardedMapper.class);
+        sqlSessionFactory = new SqlSessionFactoryBuilder().build(config);
+    }
+
+    @Test
+    void testShardedSelect() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            ShardedMapper mapper = sqlSession.getMapper(ShardedMapper.class);
+            TableCodes table = calculateTable(1);
+
+            SelectStatementProvider selectStatement = select(table.description)
+                    .from(table)
+                    .where(table.id, isEqualTo(1))
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+
+            assertThat(selectStatement.getSelectStatement())
+                    .isEqualTo("select description from tableCodes_odd where id = #{parameters.p1,jdbcType=INTEGER}");
+
+            String description = mapper.selectOneString(selectStatement);
+            assertThat(description).isNull();
+        }
+    }
+
+    @Test
+    void testShardedInserts() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            ShardedMapper mapper = sqlSession.getMapper(ShardedMapper.class);
+
+            mapper.generalInsert(buildInsert(1, "Description 1"));
+            mapper.generalInsert(buildInsert(2, "Description 2"));
+            mapper.generalInsert(buildInsert(3, "Description 3"));
+            mapper.generalInsert(buildInsert(4, "Description 4"));
+            mapper.generalInsert(buildInsert(5, "Description 5"));
+            mapper.generalInsert(buildInsert(6, "Description 6"));
+            mapper.generalInsert(buildInsert(7, "Description 7"));
+
+            TableCodes oddTable = calculateTable(1);
+            SelectStatementProvider oddCountStatement = countFrom(oddTable)
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            assertThat(oddCountStatement.getSelectStatement()).isEqualTo("select count(*) from tableCodes_odd");
+            long oddRows = mapper.count(oddCountStatement);
+            assertThat(oddRows).isEqualTo(4L);
+
+            TableCodes evenTable = calculateTable(2);
+            SelectStatementProvider evenCountStatement = countFrom(evenTable)
+                    .build()
+                    .render(RenderingStrategies.MYBATIS3);
+            assertThat(evenCountStatement.getSelectStatement()).isEqualTo("select count(*) from tableCodes_even");
+            long evenRows = mapper.count(evenCountStatement);
+            assertThat(evenRows).isEqualTo(3L);
+        }
+    }
+
+    @Test
+    void testShardedSelects() {
+        try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
+            ShardedMapper mapper = sqlSession.getMapper(ShardedMapper.class);
+
+            mapper.generalInsert(buildInsert(1, "Description 1"));
+            mapper.generalInsert(buildInsert(2, "Description 2"));
+
+            assertThat(mapper.selectOneString(buildSelect(1))).isEqualTo("Description 1");
+            assertThat(mapper.selectOneString(buildSelect(2))).isEqualTo("Description 2");
+            assertThat(mapper.selectOneString(buildSelect(3))).isNull();
+            assertThat(mapper.selectOneString(buildSelect(4))).isNull();
+        }
+    }
+
+    private GeneralInsertStatementProvider buildInsert(int id, String description) {
+        TableCodesDynamicSqlSupport.TableCodes table = calculateTable(id);
+        return insertInto(table)
+                .set(table.id).toValue(id)
+                .set(table.description).toValue(description)
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
+    }
+
+    private SelectStatementProvider buildSelect(int id) {
+        TableCodesDynamicSqlSupport.TableCodes table = calculateTable(id);
+        return select(table.description)
+                .from(table)
+                .where(table.id, isEqualTo(id))
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
+    }
+
+    private TableCodes calculateTable(int id) {
+        // it might be better to lookup instances in a Map rather than creating a new instance
+        // every time
+        return tableCodes.withName(calculateTableName(id));
+    }
+
+    private String calculateTableName(int id) {
+        if (id % 2 == 0) {
+            return "tableCodes_even";
+        } else {
+            return "tableCodes_odd";
+        }
+    }
+}
diff --git a/src/test/java/examples/sharding/TableCodesDynamicSqlSupport.java b/src/test/java/examples/sharding/TableCodesDynamicSqlSupport.java
@@ -0,0 +1,35 @@
+/*
+ *    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 examples.sharding;
+
+import org.mybatis.dynamic.sql.AliasableSqlTable;
+import org.mybatis.dynamic.sql.SqlColumn;
+
+import java.sql.JDBCType;
+
+public final class TableCodesDynamicSqlSupport {
+    public static final TableCodes tableCodes = new TableCodes();
+    public static final SqlColumn<Integer> id = tableCodes.id;
+    public static final SqlColumn<String> description = tableCodes.description;
+
+    public static final class TableCodes extends AliasableSqlTable<TableCodes> {
+        public final SqlColumn<Integer> id = column("id", JDBCType.INTEGER);
+        public final SqlColumn<String> description = column("description", JDBCType.VARCHAR);
+        public TableCodes() {
+            super("tableCodes_even", TableCodes::new);
+        }
+    }
+}
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/sharding/KShardedMapper.kt b/src/test/kotlin/examples/kotlin/mybatis3/sharding/KShardedMapper.kt
@@ -0,0 +1,22 @@
+/*
+ *    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 examples.kotlin.mybatis3.sharding
+
+import org.mybatis.dynamic.sql.util.mybatis3.CommonCountMapper
+import org.mybatis.dynamic.sql.util.mybatis3.CommonGeneralInsertMapper
+import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper
+
+interface KShardedMapper: CommonCountMapper, CommonGeneralInsertMapper, CommonSelectMapper
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/sharding/KShardingTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/sharding/KShardingTest.kt
@@ -0,0 +1,143 @@
+/*
+ *    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 examples.kotlin.mybatis3.sharding
+
+import examples.kotlin.mybatis3.TestUtils
+import examples.kotlin.mybatis3.sharding.KTableCodesTableDynamicSQLSupport.tableCodes
+import org.apache.ibatis.session.SqlSessionFactory
+import org.assertj.core.api.Assertions.assertThat
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.TestInstance
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.countFrom
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insertInto
+import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class KShardingTest {
+    private lateinit var sqlSessionFactory: SqlSessionFactory
+
+    @BeforeAll
+    fun setup() {
+        sqlSessionFactory = TestUtils.buildSqlSessionFactory {
+            withInitializationScript("/examples/sharding/ShardingDB.sql")
+            withMapper(KShardedMapper::class)
+        }
+    }
+
+    @Test
+    fun testShardedSelect() {
+        sqlSessionFactory.openSession().use { session ->
+            val mapper = session.getMapper(KShardedMapper::class.java)
+            val table = calculateTable(1)
+
+            val selectStatement = select(table.description) {
+                from(table)
+                where {
+                    table.id isEqualTo 1
+                }
+            }
+
+            assertThat(selectStatement.selectStatement).isEqualTo(
+                "select description from tableCodes_odd where id = #{parameters.p1,jdbcType=INTEGER}"
+            )
+
+            val description = mapper.selectOneString(selectStatement)
+
+            assertThat(description).isNull()
+        }
+    }
+
+    @Test
+    fun testShardedInserts() {
+        sqlSessionFactory.openSession().use { session ->
+            val mapper = session.getMapper(KShardedMapper::class.java)
+
+            mapper.insert(1, "Description 1")
+            mapper.insert(2, "Description 2")
+            mapper.insert(3, "Description 3")
+            mapper.insert(4, "Description 4")
+            mapper.insert(5, "Description 5")
+            mapper.insert(6, "Description 6")
+            mapper.insert(7, "Description 7")
+
+            val oddTable = calculateTable(1)
+            val oddCountStatement = countFrom(oddTable) {
+                allRows()
+            }
+
+            assertThat(oddCountStatement.selectStatement).isEqualTo("select count(*) from tableCodes_odd")
+            val oddRows = mapper.count(oddCountStatement)
+            assertThat(oddRows).isEqualTo(4L)
+
+            val evenTable = calculateTable(2)
+            val evenCountStatement = countFrom(evenTable) {
+                allRows()
+            }
+
+            assertThat(evenCountStatement.selectStatement).isEqualTo("select count(*) from tableCodes_even")
+            val evenRows = mapper.count(evenCountStatement)
+            assertThat(evenRows).isEqualTo(3L)
+        }
+    }
+
+    @Test
+    fun testShardedSelects() {
+        sqlSessionFactory.openSession().use { session ->
+            val mapper = session.getMapper(KShardedMapper::class.java)
+
+            mapper.insert(1, "Description 1")
+            mapper.insert(2, "Description 2")
+
+            assertThat(mapper.select(1)).isEqualTo("Description 1")
+            assertThat(mapper.select(2)).isEqualTo("Description 2")
+            assertThat(mapper.select(3)).isNull()
+            assertThat(mapper.select(4)).isNull()
+        }
+    }
+
+    fun KShardedMapper.insert(id: Int, description: String): Int {
+        val table = calculateTable(id)
+        val insertStatement = insertInto(table) {
+            set(table.id) toValue id
+            set(table.description) toValue description
+        }
+
+        return generalInsert(insertStatement)
+    }
+
+    fun KShardedMapper.select(id: Int): String? {
+        val table = calculateTable(id)
+        val selectStatement = select(table.description) {
+            from(table)
+            where {
+                table.id isEqualTo id
+            }
+        }
+
+        return selectOneString(selectStatement)
+    }
+
+    private fun calculateTable(id: Int) = tableCodes.withName(calculateTableName(id))
+
+    private fun calculateTableName(id: Int): String {
+        return if (id.mod(2) == 0) {
+            "tableCodes_even"
+        } else {
+            "tableCodes_odd"
+        }
+    }
+}
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/sharding/KTableCodesTableDynamicSQLSupport.kt b/src/test/kotlin/examples/kotlin/mybatis3/sharding/KTableCodesTableDynamicSQLSupport.kt
diff --git a/src/test/resources/examples/sharding/ShardingDB.sql b/src/test/resources/examples/sharding/ShardingDB.sql
