From bd75feef719652f2a78d3d6e08e11afc496dbf80 Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Mon, 20 May 2024 10:50:12 -0400
Subject: [PATCH 01/11] Type

---
 src/site/markdown/docs/conditions.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/site/markdown/docs/conditions.md b/src/site/markdown/docs/conditions.md
index b7fde71bf..d5683f206 100644
--- a/src/site/markdown/docs/conditions.md
+++ b/src/site/markdown/docs/conditions.md
@@ -203,7 +203,7 @@ case String values to enable case-insensitive queries. There are extension point
 mapping if you so desire.
 
 Starting with version 1.5.2, we made a change to the rendering rules for the "in" conditions. This was done to limit the
-danger of conditions failing to render and thus affecting more rows than expected. For the base conditions ("isIn", 
+danger of conditions failing to render and thus affecting more rows than expected. For the base conditions ("isIn",
 "isNotIn", etc.), if the list of values is empty, then the condition will still render, but the resulting SQL will
 be invalid and will cause a runtime exception. We believe this is the safest outcome. For example, suppose
 a DELETE statement was coded as follows:
@@ -220,7 +220,7 @@ This statement will be rendered as follows:
    delete from foo where status = ? and id in ()
 ```
 
-This will cause a runtime error due to invalid SQL, but it eliminates the possibility of deleting ALLs rows with
+This will cause a runtime error due to invalid SQL, but it eliminates the possibility of deleting ALL rows with
 active status. If you want to allow the "in" condition to drop from the SQL if the list is empty, then use the
 "inWhenPresent" condition.
 

From 785ea41b898637e3dbbd583bbbe0eb23af6bd04e Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Mon, 20 May 2024 10:56:47 -0400
Subject: [PATCH 02/11] Replace "record" with "row"

---
 .../dynamic/sql/ParameterTypeConverter.java   |   2 +-
 .../dynamic/sql/render/RenderingStrategy.java |   4 +-
 .../sql/update/UpdateDSLCompleter.java        |   2 +-
 .../sql/util/mybatis3/CommonInsertMapper.java |   2 +-
 .../examples/animal/data/AnimalDataTest.java  |  86 +++----
 src/test/java/examples/array/ArrayTest.java   |   8 +-
 .../custom_render/CustomRenderingTest.java    |  24 +-
 .../mybatis/GeneratedAlwaysMapperTest.java    | 102 ++++-----
 .../always/mybatis/PersonMapperTest.java      |  10 +-
 .../generated/always/spring/SpringTest.java   |  98 ++++----
 .../examples/simple/PersonMapperTest.java     | 200 ++++++++---------
 .../examples/spring/PersonTemplateTest.java   | 212 +++++++++---------
 src/test/java/issues/gh324/NameService.java   |  32 +--
 .../gh324/spring/SpringNameService.java       |  24 +-
 .../sql/insert/InsertStatementTest.java       |  48 ++--
 .../sql/mybatis3/InsertStatementTest.java     |  24 +-
 .../mybatis3/canonical/GeneratedAlwaysTest.kt |   8 +-
 .../mybatis3/canonical/PersonMapperTest.kt    |  50 ++---
 .../custom/render/KCustomRenderingTest.kt     |  14 +-
 ...CanonicalSpringKotlinTemplateDirectTest.kt |  10 +-
 .../canonical/CanonicalSpringKotlinTest.kt    |  24 +-
 21 files changed, 492 insertions(+), 492 deletions(-)

diff --git a/src/main/java/org/mybatis/dynamic/sql/ParameterTypeConverter.java b/src/main/java/org/mybatis/dynamic/sql/ParameterTypeConverter.java
index 3868f4d4b..7df7572b1 100644
--- a/src/main/java/org/mybatis/dynamic/sql/ParameterTypeConverter.java
+++ b/src/main/java/org/mybatis/dynamic/sql/ParameterTypeConverter.java
@@ -32,7 +32,7 @@
  * Existing converters may be reused if they are marked with this additional interface.
  *
  * <p>The converter is only used for parameters in a parameter map. It is not used for result set processing.
- * It is also not used for insert statements that are based on an external record class. The converter will be called
+ * It is also not used for insert statements that are based on an external row class. The converter will be called
  * in the following circumstances:
  *
  * <ul>
diff --git a/src/main/java/org/mybatis/dynamic/sql/render/RenderingStrategy.java b/src/main/java/org/mybatis/dynamic/sql/render/RenderingStrategy.java
index 7472654f2..70b369c73 100644
--- a/src/main/java/org/mybatis/dynamic/sql/render/RenderingStrategy.java
+++ b/src/main/java/org/mybatis/dynamic/sql/render/RenderingStrategy.java
@@ -79,7 +79,7 @@ public String formatParameterMapKey(AtomicInteger sequence) {
     public abstract String getFormattedJdbcPlaceholder(String prefix, String parameterName);
 
     /**
-     * This method generates a binding for a parameter to a placeholder in a record based insert statement.
+     * This method generates a binding for a parameter to a placeholder in a row 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
@@ -102,7 +102,7 @@ public String getRecordBasedInsertBinding(BindableColumn<?> column, String prefi
     }
 
     /**
-     * This method generates a binding for a parameter to a placeholder in a record based insert statement.
+     * This method generates a binding for a parameter to a placeholder in a row based insert statement.
      *
      * <p>This binding is specifically for use with insert, batch insert, and multirow insert statements and the
      * MapToRow mapping. These statements bind parameters to the row class directly.
diff --git a/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSLCompleter.java b/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSLCompleter.java
index 48ea503a7..70abc3a5e 100644
--- a/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSLCompleter.java
+++ b/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSLCompleter.java
@@ -59,7 +59,7 @@
  * </pre>
  *
  * <p>You could also implement a helper method that would set fields based on values of a record. For example,
- * the following method would set all fields of a record based on whether or not the values are null:
+ * the following method would set all fields of a row based on whether the values are null:
  *
  * <pre>
  * static UpdateDSL&lt;UpdateModel&gt; updateSelectiveColumns(PersonRecord record,
diff --git a/src/main/java/org/mybatis/dynamic/sql/util/mybatis3/CommonInsertMapper.java b/src/main/java/org/mybatis/dynamic/sql/util/mybatis3/CommonInsertMapper.java
index 63a9b8234..0a834f604 100644
--- a/src/main/java/org/mybatis/dynamic/sql/util/mybatis3/CommonInsertMapper.java
+++ b/src/main/java/org/mybatis/dynamic/sql/util/mybatis3/CommonInsertMapper.java
@@ -29,7 +29,7 @@
  * insert statements that do NOT expect generated keys.
  *
  * @param <T>
- *            the type of record associated with this mapper
+ *            the type of row associated with this mapper
  */
 public interface CommonInsertMapper<T> extends CommonGeneralInsertMapper {
     /**
diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/src/test/java/examples/animal/data/AnimalDataTest.java
index a051434dc..ee12b3204 100644
--- a/src/test/java/examples/animal/data/AnimalDataTest.java
+++ b/src/test/java/examples/animal/data/AnimalDataTest.java
@@ -1498,11 +1498,11 @@ void testComplexCondition() {
     void testUpdate() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
             AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
-            AnimalData record = new AnimalData();
-            record.setBodyWeight(2.6);
+            AnimalData row = new AnimalData();
+            row.setBodyWeight(2.6);
 
             UpdateStatementProvider updateStatement = update(animalData)
-                    .set(bodyWeight).equalTo(record.getBodyWeight())
+                    .set(bodyWeight).equalTo(row.getBodyWeight())
                     .set(animalName).equalToNull()
                     .where(id, isIn(1, 5, 7))
                     .or(id, isIn(2, 6, 8), and(animalName, isLike("%bat")))
@@ -1556,13 +1556,13 @@ void testUpdateValueOrNullWithNull() {
     void testInsert() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
             AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
-            AnimalData record = new AnimalData();
-            record.setId(100);
-            record.setAnimalName("Old Shep");
-            record.setBodyWeight(22.5);
-            record.setBrainWeight(1.2);
+            AnimalData row = new AnimalData();
+            row.setId(100);
+            row.setAnimalName("Old Shep");
+            row.setBodyWeight(22.5);
+            row.setBrainWeight(1.2);
 
-            InsertStatementProvider<AnimalData> insertStatement = insert(record)
+            InsertStatementProvider<AnimalData> insertStatement = insert(row)
                     .into(animalData)
                     .map(id).toProperty("id")
                     .map(animalName).toProperty("animalName")
@@ -1580,13 +1580,13 @@ void testInsert() {
     void testInsertNull() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
             AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
-            AnimalData record = new AnimalData();
-            record.setId(100);
-            record.setAnimalName("Old Shep");
-            record.setBodyWeight(22.5);
-            record.setBrainWeight(1.2);
+            AnimalData row = new AnimalData();
+            row.setId(100);
+            row.setAnimalName("Old Shep");
+            row.setBodyWeight(22.5);
+            row.setBrainWeight(1.2);
 
-            InsertStatementProvider<AnimalData> insertStatement = insert(record)
+            InsertStatementProvider<AnimalData> insertStatement = insert(row)
                     .into(animalData)
                     .map(id).toProperty("id")
                     .map(animalName).toNull()
@@ -1605,17 +1605,17 @@ void testBulkInsert() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
             AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
             List<AnimalData> records = new ArrayList<>();
-            AnimalData record = new AnimalData();
-            record.setId(100);
-            record.setAnimalName("Old Shep");
-            record.setBodyWeight(22.5);
-            records.add(record);
-
-            record = new AnimalData();
-            record.setId(101);
-            record.setAnimalName("Old Dan");
-            record.setBodyWeight(22.5);
-            records.add(record);
+            AnimalData row = new AnimalData();
+            row.setId(100);
+            row.setAnimalName("Old Shep");
+            row.setBodyWeight(22.5);
+            records.add(row);
+
+            row = new AnimalData();
+            row.setId(101);
+            row.setAnimalName("Old Dan");
+            row.setBodyWeight(22.5);
+            records.add(row);
 
             BatchInsert<AnimalData> batchInsert = insertBatch(records)
                     .into(animalData)
@@ -1655,17 +1655,17 @@ void testBulkInsert2() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
             AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
             List<AnimalData> records = new ArrayList<>();
-            AnimalData record = new AnimalData();
-            record.setId(100);
-            record.setAnimalName("Old Shep");
-            record.setBodyWeight(22.5);
-            records.add(record);
-
-            record = new AnimalData();
-            record.setId(101);
-            record.setAnimalName("Old Dan");
-            record.setBodyWeight(22.5);
-            records.add(record);
+            AnimalData row = new AnimalData();
+            row.setId(100);
+            row.setAnimalName("Old Shep");
+            row.setBodyWeight(22.5);
+            records.add(row);
+
+            row = new AnimalData();
+            row.setId(101);
+            row.setAnimalName("Old Dan");
+            row.setBodyWeight(22.5);
+            records.add(row);
 
             BatchInsert<AnimalData> batchInsert = insertBatch(records)
                     .into(animalData)
@@ -2245,14 +2245,14 @@ void testUpdateWithAddAndSubtract() {
             int rows = mapper.update(updateStatement);
             assertThat(rows).isEqualTo(1);
 
-            AnimalData record = MyBatis3Utils.selectOne(mapper::selectOne,
+            AnimalData row = MyBatis3Utils.selectOne(mapper::selectOne,
                     BasicColumn.columnList(id, bodyWeight, brainWeight),
                     animalData,
                     c -> c.where(id, isEqualTo(1))
             );
 
-            assertThat(record.getBodyWeight()).isEqualTo(-2.86);
-            assertThat(record.getBrainWeight()).isEqualTo(2.005);
+            assertThat(row.getBodyWeight()).isEqualTo(-2.86);
+            assertThat(row.getBrainWeight()).isEqualTo(2.005);
         }
     }
 
@@ -2278,14 +2278,14 @@ void testUpdateWithMultiplyAndDivide() {
             int rows = mapper.update(updateStatement);
             assertThat(rows).isEqualTo(1);
 
-            AnimalData record = MyBatis3Utils.selectOne(mapper::selectOne,
+            AnimalData row = MyBatis3Utils.selectOne(mapper::selectOne,
                     BasicColumn.columnList(id, bodyWeight, brainWeight),
                     animalData,
                     c -> c.where(id, isEqualTo(1))
             );
 
-            assertThat(record.getBodyWeight()).isEqualTo(0.42, within(.001));
-            assertThat(record.getBrainWeight()).isEqualTo(.0025);
+            assertThat(row.getBodyWeight()).isEqualTo(0.42, within(.001));
+            assertThat(row.getBrainWeight()).isEqualTo(.0025);
         }
     }
 }
diff --git a/src/test/java/examples/array/ArrayTest.java b/src/test/java/examples/array/ArrayTest.java
index 540cfefea..b8feb5f5d 100644
--- a/src/test/java/examples/array/ArrayTest.java
+++ b/src/test/java/examples/array/ArrayTest.java
@@ -83,8 +83,8 @@ void testInsertSelectById() {
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
 
-            Optional<NamesRecord> record = mapper.selectOne(selectStatement);
-            assertThat(record).hasValueSatisfying( r -> {
+            Optional<NamesRecord> row = mapper.selectOne(selectStatement);
+            assertThat(row).hasValueSatisfying( r -> {
                 assertThat(r.getId()).isEqualTo(1);
                 assertThat(r.getNames()).isEqualTo(someNames);
             });
@@ -112,8 +112,8 @@ void testInsertSelectByArray() {
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
 
-            Optional<NamesRecord> record = mapper.selectOne(selectStatement);
-            assertThat(record).hasValueSatisfying( r -> {
+            Optional<NamesRecord> row = mapper.selectOne(selectStatement);
+            assertThat(row).hasValueSatisfying( r -> {
                 assertThat(r.getId()).isEqualTo(1);
                 assertThat(r.getNames()).isEqualTo(someNames);
             });
diff --git a/src/test/java/examples/custom_render/CustomRenderingTest.java b/src/test/java/examples/custom_render/CustomRenderingTest.java
index 819804f60..8ca34bbc2 100644
--- a/src/test/java/examples/custom_render/CustomRenderingTest.java
+++ b/src/test/java/examples/custom_render/CustomRenderingTest.java
@@ -81,12 +81,12 @@ void testInsertRecord() {
         try (SqlSession sqlSession = sqlSessionFactory.openSession()) {
             JsonTestMapper mapper = sqlSession.getMapper(JsonTestMapper.class);
 
-            JsonTestRecord record = new JsonTestRecord();
-            record.setId(1);
-            record.setDescription("Fred");
-            record.setInfo("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}");
+            JsonTestRecord row = new JsonTestRecord();
+            row.setId(1);
+            row.setDescription("Fred");
+            row.setInfo("{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}");
 
-            InsertStatementProvider<JsonTestRecord> insertStatement = insert(record).into(jsonTest)
+            InsertStatementProvider<JsonTestRecord> insertStatement = insert(row).into(jsonTest)
                     .map(id).toProperty("id")
                     .map(description).toProperty("description")
                     .map(info).toProperty("info")
@@ -102,12 +102,12 @@ void testInsertRecord() {
             int rows = mapper.insert(insertStatement);
             assertThat(rows).isEqualTo(1);
 
-            record = new JsonTestRecord();
-            record.setId(2);
-            record.setDescription("Wilma");
-            record.setInfo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
+            row = new JsonTestRecord();
+            row.setId(2);
+            row.setDescription("Wilma");
+            row.setInfo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}");
 
-            insertStatement = insert(record).into(jsonTest)
+            insertStatement = insert(row).into(jsonTest)
                     .map(id).toProperty("id")
                     .map(description).toProperty("description")
                     .map(info).toProperty("info")
@@ -313,9 +313,9 @@ void testDeReference() {
 
             assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
 
-            Optional<JsonTestRecord> record = mapper.selectOne(selectStatement);
+            Optional<JsonTestRecord> row = mapper.selectOne(selectStatement);
 
-            assertThat(record).hasValueSatisfying( r ->
+            assertThat(row).hasValueSatisfying( r ->
                 assertThat(r.getInfo())
                         .isEqualTo("{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}")
             );
diff --git a/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java b/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java
index d8b37d103..2edf63933 100644
--- a/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java
+++ b/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java
@@ -95,14 +95,14 @@ void testFirstNameIn() {
     void testInsert() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
-            GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName("Jones");
+            GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName("Jones");
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
-            assertThat(record.getFullName()).isEqualTo("Joe Jones");
+            assertThat(row.getFullName()).isEqualTo("Joe Jones");
         }
     }
 
@@ -238,29 +238,29 @@ void testMultiInsertWithArrayAndVariousMappings() {
 
     private List<GeneratedAlwaysRecord> getTestRecords() {
         List<GeneratedAlwaysRecord> records = new ArrayList<>();
-        GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-        record.setId(1000);
-        record.setFirstName("George");
-        record.setLastName("Jetson");
-        records.add(record);
-
-        record = new GeneratedAlwaysRecord();
-        record.setId(1001);
-        record.setFirstName("Jane");
-        record.setLastName("Jetson");
-        records.add(record);
-
-        record = new GeneratedAlwaysRecord();
-        record.setId(1002);
-        record.setFirstName("Judy");
-        record.setLastName("Jetson");
-        records.add(record);
-
-        record = new GeneratedAlwaysRecord();
-        record.setId(1003);
-        record.setFirstName("Elroy");
-        record.setLastName("Jetson");
-        records.add(record);
+        GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+        row.setId(1000);
+        row.setFirstName("George");
+        row.setLastName("Jetson");
+        records.add(row);
+
+        row = new GeneratedAlwaysRecord();
+        row.setId(1001);
+        row.setFirstName("Jane");
+        row.setLastName("Jetson");
+        records.add(row);
+
+        row = new GeneratedAlwaysRecord();
+        row.setId(1002);
+        row.setFirstName("Judy");
+        row.setLastName("Jetson");
+        records.add(row);
+
+        row = new GeneratedAlwaysRecord();
+        row.setId(1003);
+        row.setFirstName("Elroy");
+        row.setLastName("Jetson");
+        records.add(row);
 
         return records;
     }
@@ -269,16 +269,16 @@ record = new GeneratedAlwaysRecord();
     void testInsertSelective() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
-            GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName("Jones");
+            GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName("Jones");
 
-            int rows = mapper.insertSelective(record);
+            int rows = mapper.insertSelective(row);
 
             assertAll(
                     () -> assertThat(rows).isEqualTo(1),
-                    () -> assertThat(record.getFullName()).isEqualTo("Joe Jones")
+                    () -> assertThat(row.getFullName()).isEqualTo("Joe Jones")
             );
         }
     }
@@ -287,17 +287,17 @@ void testInsertSelective() {
     void testUpdateByPrimaryKey() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
-            GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName("Jones");
+            GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName("Jones");
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
-            assertThat(record.getFullName()).isEqualTo("Joe Jones");
+            assertThat(row.getFullName()).isEqualTo("Joe Jones");
 
-            record.setLastName("Smith");
-            rows = mapper.updateByPrimaryKey(record);
+            row.setLastName("Smith");
+            rows = mapper.updateByPrimaryKey(row);
             assertThat(rows).isEqualTo(1);
 
             Optional<GeneratedAlwaysRecord> newRecord = mapper.selectByPrimaryKey(100);
@@ -311,10 +311,10 @@ void testUpdateByPrimaryKey() {
     void testUpdateSelective() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
-            GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-            record.setLastName("Jones");
+            GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+            row.setLastName("Jones");
 
-            int rows = mapper.update(c -> GeneratedAlwaysMapper.updateSelectiveColumns(record, c)
+            int rows = mapper.update(c -> GeneratedAlwaysMapper.updateSelectiveColumns(row, c)
                     .where(lastName, isEqualTo("Flintstone")));
             assertThat(rows).isEqualTo(3);
 
@@ -335,12 +335,12 @@ void testUpdateSelective() {
     void testUpdateByPrimaryKeySelective() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
-            GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName("Jones");
+            GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName("Jones");
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
 
             GeneratedAlwaysRecord updateRecord = new GeneratedAlwaysRecord();
diff --git a/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java b/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java
index 4ef8b419c..e421c19ae 100644
--- a/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java
+++ b/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java
@@ -70,14 +70,14 @@ void testInsertSelectWithOneRecord() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
 
-            PersonRecord record = new PersonRecord();
-            record.setFirstName("Fred");
-            record.setLastName("Flintstone");
+            PersonRecord row = new PersonRecord();
+            row.setFirstName("Fred");
+            row.setLastName("Flintstone");
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
 
             assertThat(rows).isEqualTo(1);
-            assertThat(record.getId()).isEqualTo(22);
+            assertThat(row.getId()).isEqualTo(22);
 
             InsertSelectStatementProvider insertSelectStatement = SqlBuilder.insertInto(person)
                     .withColumnList(firstName, lastName)
diff --git a/src/test/java/examples/generated/always/spring/SpringTest.java b/src/test/java/examples/generated/always/spring/SpringTest.java
index eb75df450..57eb4ce65 100644
--- a/src/test/java/examples/generated/always/spring/SpringTest.java
+++ b/src/test/java/examples/generated/always/spring/SpringTest.java
@@ -94,12 +94,12 @@ void testSelect() {
 
         List<GeneratedAlwaysRecord> records = template.query(selectStatement.getSelectStatement(), namedParameters,
                 (rs, rowNum) -> {
-                    GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-                    record.setId(rs.getInt(1));
-                    record.setFirstName(rs.getString(2));
-                    record.setLastName(rs.getString(3));
-                    record.setFullName(rs.getString(4));
-                    return record;
+                    GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+                    row.setId(rs.getInt(1));
+                    row.setFirstName(rs.getString(2));
+                    row.setLastName(rs.getString(3));
+                    row.setFullName(rs.getString(4));
+                    return row;
                 });
 
         assertThat(records).hasSize(3);
@@ -129,12 +129,12 @@ void testDelete() {
 
     @Test
     void testInsert() {
-        GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-        record.setId(100);
-        record.setFirstName("Bob");
-        record.setLastName("Jones");
+        GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+        row.setId(100);
+        row.setFirstName("Bob");
+        row.setLastName("Jones");
 
-        InsertStatementProvider<GeneratedAlwaysRecord> insertStatement = insert(record)
+        InsertStatementProvider<GeneratedAlwaysRecord> insertStatement = insert(row)
                 .into(generatedAlways)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
@@ -154,12 +154,12 @@ void testInsert() {
 
     @Test
     void testInsertWithExtensions() {
-        GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-        record.setId(100);
-        record.setFirstName("Bob");
-        record.setLastName("Jones");
+        GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+        row.setId(100);
+        row.setFirstName("Bob");
+        row.setLastName("Jones");
 
-        Buildable<InsertModel<GeneratedAlwaysRecord>> insertStatement = insert(record)
+        Buildable<InsertModel<GeneratedAlwaysRecord>> insertStatement = insert(row)
                 .into(generatedAlways)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
@@ -229,17 +229,17 @@ void testGeneralInsertWithGeneratedKeyAndExtensions() {
     @Test
     void testInsertBatch() {
         List<GeneratedAlwaysRecord> records = new ArrayList<>();
-        GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-        record.setId(100);
-        record.setFirstName("Bob");
-        record.setLastName("Jones");
-        records.add(record);
-
-        record = new GeneratedAlwaysRecord();
-        record.setId(101);
-        record.setFirstName("Jim");
-        record.setLastName("Smith");
-        records.add(record);
+        GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+        row.setId(100);
+        row.setFirstName("Bob");
+        row.setLastName("Jones");
+        records.add(row);
+
+        row = new GeneratedAlwaysRecord();
+        row.setId(101);
+        row.setFirstName("Jim");
+        row.setLastName("Smith");
+        records.add(row);
 
         SqlParameterSource[] batch = BatchInsertUtility.createBatch(records);
 
@@ -263,17 +263,17 @@ void testInsertBatchWithExtensions() {
         NamedParameterJdbcTemplateExtensions extensions = new NamedParameterJdbcTemplateExtensions(template);
 
         List<GeneratedAlwaysRecord> records = new ArrayList<>();
-        GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-        record.setId(100);
-        record.setFirstName("Bob");
-        record.setLastName("Jones");
-        records.add(record);
-
-        record = new GeneratedAlwaysRecord();
-        record.setId(101);
-        record.setFirstName("Jim");
-        record.setLastName("Smith");
-        records.add(record);
+        GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+        row.setId(100);
+        row.setFirstName("Bob");
+        row.setLastName("Jones");
+        records.add(row);
+
+        row = new GeneratedAlwaysRecord();
+        row.setId(101);
+        row.setFirstName("Jim");
+        row.setLastName("Smith");
+        records.add(row);
 
         Buildable<BatchInsertModel<GeneratedAlwaysRecord>> insertStatement = insertBatch(records)
                 .into(generatedAlways)
@@ -294,17 +294,17 @@ void testMultiRowInsert() {
         KeyHolder keyHolder = new GeneratedKeyHolder();
 
         List<GeneratedAlwaysRecord> records = new ArrayList<>();
-        GeneratedAlwaysRecord record = new GeneratedAlwaysRecord();
-        record.setId(100);
-        record.setFirstName("Bob");
-        record.setLastName("Jones");
-        records.add(record);
-
-        record = new GeneratedAlwaysRecord();
-        record.setId(101);
-        record.setFirstName("Jim");
-        record.setLastName("Smith");
-        records.add(record);
+        GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
+        row.setId(100);
+        row.setFirstName("Bob");
+        row.setLastName("Jones");
+        records.add(row);
+
+        row = new GeneratedAlwaysRecord();
+        row.setId(101);
+        row.setFirstName("Jim");
+        row.setLastName("Smith");
+        records.add(row);
 
         Buildable<MultiRowInsertModel<GeneratedAlwaysRecord>> insertStatement = insertMultiple(records).into(generatedAlways)
                 .map(id).toProperty("id")
diff --git a/src/test/java/examples/simple/PersonMapperTest.java b/src/test/java/examples/simple/PersonMapperTest.java
index 3a8ee5b85..05c47cd29 100644
--- a/src/test/java/examples/simple/PersonMapperTest.java
+++ b/src/test/java/examples/simple/PersonMapperTest.java
@@ -232,8 +232,8 @@ void testSelectByPrimaryKeyWithMissingRecord() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
 
-            Optional<PersonRecord> record = mapper.selectByPrimaryKey(300);
-            assertThat(record).isNotPresent();
+            Optional<PersonRecord> row = mapper.selectByPrimaryKey(300);
+            assertThat(row).isNotPresent();
         }
     }
 
@@ -320,16 +320,16 @@ void testDeleteByPrimaryKey() {
     void testInsert() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
         }
     }
@@ -359,25 +359,25 @@ void testInsertMultiple() {
 
             List<PersonRecord> records = new ArrayList<>();
 
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
-            records.add(record);
-
-            record = new PersonRecord();
-            record.setId(101);
-            record.setFirstName("Sarah");
-            record.setLastName(LastName.of("Smith"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Architect");
-            record.setAddressId(2);
-            records.add(record);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
+            records.add(row);
+
+            row = new PersonRecord();
+            row.setId(101);
+            row.setFirstName("Sarah");
+            row.setLastName(LastName.of("Smith"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Architect");
+            row.setAddressId(2);
+            records.add(row);
 
             int rows = mapper.insertMultiple(records);
             assertThat(rows).isEqualTo(2);
@@ -388,15 +388,15 @@ record = new PersonRecord();
     void testInsertSelective() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(false);
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(false);
+            row.setAddressId(1);
 
-            int rows = mapper.insertSelective(record);
+            int rows = mapper.insertSelective(row);
             assertThat(rows).isEqualTo(1);
         }
     }
@@ -405,20 +405,20 @@ void testInsertSelective() {
     void testUpdateByPrimaryKey() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
 
-            record.setOccupation("Programmer");
-            rows = mapper.updateByPrimaryKey(record);
+            row.setOccupation("Programmer");
+            rows = mapper.updateByPrimaryKey(row);
             assertThat(rows).isEqualTo(1);
 
             Optional<PersonRecord> newRecord = mapper.selectByPrimaryKey(100);
@@ -431,16 +431,16 @@ void testUpdateByPrimaryKey() {
     void testUpdateByPrimaryKeySelective() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
 
             PersonRecord updateRecord = new PersonRecord();
@@ -461,22 +461,22 @@ void testUpdateByPrimaryKeySelective() {
     void testUpdate() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
 
-            record.setOccupation("Programmer");
+            row.setOccupation("Programmer");
 
             rows = mapper.update(c ->
-                PersonMapper.updateAllColumns(record, c)
+                PersonMapper.updateAllColumns(row, c)
                 .where(id, isEqualTo(100))
                 .and(firstName, isEqualTo("Joe")));
 
@@ -492,16 +492,16 @@ void testUpdate() {
     void testUpdateOneField() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
 
             rows = mapper.update(c ->
@@ -520,16 +520,16 @@ void testUpdateOneField() {
     void testUpdateAll() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
 
             PersonRecord updateRecord = new PersonRecord();
@@ -549,16 +549,16 @@ void testUpdateAll() {
     void testUpdateSelective() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonMapper mapper = session.getMapper(PersonMapper.class);
-            PersonRecord record = new PersonRecord();
-            record.setId(100);
-            record.setFirstName("Joe");
-            record.setLastName(LastName.of("Jones"));
-            record.setBirthDate(new Date());
-            record.setEmployed(true);
-            record.setOccupation("Developer");
-            record.setAddressId(1);
+            PersonRecord row = new PersonRecord();
+            row.setId(100);
+            row.setFirstName("Joe");
+            row.setLastName(LastName.of("Jones"));
+            row.setBirthDate(new Date());
+            row.setEmployed(true);
+            row.setOccupation("Developer");
+            row.setAddressId(1);
 
-            int rows = mapper.insert(record);
+            int rows = mapper.insert(row);
             assertThat(rows).isEqualTo(1);
 
             PersonRecord updateRecord = new PersonRecord();
@@ -693,9 +693,9 @@ void testJoinOneRow() {
     void testJoinPrimaryKey() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonWithAddressMapper mapper = session.getMapper(PersonWithAddressMapper.class);
-            Optional<PersonWithAddress> record = mapper.selectByPrimaryKey(1);
+            Optional<PersonWithAddress> row = mapper.selectByPrimaryKey(1);
 
-            assertThat(record).hasValueSatisfying(r -> {
+            assertThat(row).hasValueSatisfying(r -> {
                 assertThat(r.getId()).isEqualTo(1);
                 assertThat(r.getEmployed()).isTrue();
                 assertThat(r.getFirstName()).isEqualTo("Fred");
@@ -714,9 +714,9 @@ void testJoinPrimaryKey() {
     void testJoinPrimaryKeyInvalidRecord() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             PersonWithAddressMapper mapper = session.getMapper(PersonWithAddressMapper.class);
-            Optional<PersonWithAddress> record = mapper.selectByPrimaryKey(55);
+            Optional<PersonWithAddress> row = mapper.selectByPrimaryKey(55);
 
-            assertThat(record).isEmpty();
+            assertThat(row).isEmpty();
         }
     }
 
diff --git a/src/test/java/examples/spring/PersonTemplateTest.java b/src/test/java/examples/spring/PersonTemplateTest.java
index 6142e7450..ec8f12544 100644
--- a/src/test/java/examples/spring/PersonTemplateTest.java
+++ b/src/test/java/examples/spring/PersonTemplateTest.java
@@ -187,9 +187,9 @@ void testSelectByPrimaryKeyWithMissingRecord() {
                 .from(person)
                 .where(id, isEqualTo(300));
 
-        Optional<PersonRecord> record = template.selectOne(selectStatement, personRowMapper);
+        Optional<PersonRecord> row = template.selectOne(selectStatement, personRowMapper);
 
-        assertThat(record).isNotPresent();
+        assertThat(row).isNotPresent();
     }
 
     @Test
@@ -236,16 +236,16 @@ void testDeleteByPrimaryKey() {
 
     @Test
     void testInsert() {
-        PersonRecord record = new PersonRecord();
-        record.setId(100);
-        record.setFirstName("Joe");
-        record.setLastName(LastName.of("Jones"));
-        record.setBirthDate(new Date());
-        record.setEmployed(true);
-        record.setOccupation("Developer");
-        record.setAddressId(1);
-
-        Buildable<InsertModel<PersonRecord>> insertStatement = insert(record).into(person)
+        PersonRecord row = new PersonRecord();
+        row.setId(100);
+        row.setFirstName("Joe");
+        row.setLastName(LastName.of("Jones"));
+        row.setBirthDate(new Date());
+        row.setEmployed(true);
+        row.setOccupation("Developer");
+        row.setAddressId(1);
+
+        Buildable<InsertModel<PersonRecord>> insertStatement = insert(row).into(person)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
                 .map(lastName).toProperty("lastNameAsString")
@@ -280,25 +280,25 @@ void testInsertMultiple() {
 
         List<PersonRecord> records = new ArrayList<>();
 
-        PersonRecord record = new PersonRecord();
-        record.setId(100);
-        record.setFirstName("Joe");
-        record.setLastName(LastName.of("Jones"));
-        record.setBirthDate(new Date());
-        record.setEmployed(true);
-        record.setOccupation("Developer");
-        record.setAddressId(1);
-        records.add(record);
-
-        record = new PersonRecord();
-        record.setId(101);
-        record.setFirstName("Sarah");
-        record.setLastName(LastName.of("Smith"));
-        record.setBirthDate(new Date());
-        record.setEmployed(true);
-        record.setOccupation("Architect");
-        record.setAddressId(2);
-        records.add(record);
+        PersonRecord row = new PersonRecord();
+        row.setId(100);
+        row.setFirstName("Joe");
+        row.setLastName(LastName.of("Jones"));
+        row.setBirthDate(new Date());
+        row.setEmployed(true);
+        row.setOccupation("Developer");
+        row.setAddressId(1);
+        records.add(row);
+
+        row = new PersonRecord();
+        row.setId(101);
+        row.setFirstName("Sarah");
+        row.setLastName(LastName.of("Smith"));
+        row.setBirthDate(new Date());
+        row.setEmployed(true);
+        row.setOccupation("Architect");
+        row.setAddressId(2);
+        records.add(row);
 
         Buildable<MultiRowInsertModel<PersonRecord>> insertStatement = insertMultiple(records).into(person)
                 .map(id).toProperty("id")
@@ -319,25 +319,25 @@ void testInsertBatch() {
 
         List<PersonRecord> records = new ArrayList<>();
 
-        PersonRecord record = new PersonRecord();
-        record.setId(100);
-        record.setFirstName("Joe");
-        record.setLastName(LastName.of("Jones"));
-        record.setBirthDate(new Date());
-        record.setEmployed(true);
-        record.setOccupation("Developer");
-        record.setAddressId(1);
-        records.add(record);
-
-        record = new PersonRecord();
-        record.setId(101);
-        record.setFirstName("Sarah");
-        record.setLastName(LastName.of("Smith"));
-        record.setBirthDate(new Date());
-        record.setEmployed(true);
-        record.setOccupation("Architect");
-        record.setAddressId(2);
-        records.add(record);
+        PersonRecord row = new PersonRecord();
+        row.setId(100);
+        row.setFirstName("Joe");
+        row.setLastName(LastName.of("Jones"));
+        row.setBirthDate(new Date());
+        row.setEmployed(true);
+        row.setOccupation("Developer");
+        row.setAddressId(1);
+        records.add(row);
+
+        row = new PersonRecord();
+        row.setId(101);
+        row.setFirstName("Sarah");
+        row.setLastName(LastName.of("Smith"));
+        row.setBirthDate(new Date());
+        row.setEmployed(true);
+        row.setOccupation("Architect");
+        row.setAddressId(2);
+        records.add(row);
 
         Buildable<BatchInsertModel<PersonRecord>> insertStatement = insertBatch(records).into(person)
                 .map(id).toProperty("id")
@@ -357,22 +357,22 @@ record = new PersonRecord();
 
     @Test
     void testInsertSelective() {
-        PersonRecord record = new PersonRecord();
-        record.setId(100);
-        record.setFirstName("Joe");
-        record.setLastName(LastName.of("Jones"));
-        record.setBirthDate(new Date());
-        record.setEmployed(false);
-        record.setAddressId(1);
-
-        Buildable<InsertModel<PersonRecord>> insertStatement = insert(record).into(person)
-                .map(id).toPropertyWhenPresent("id", record::getId)
-                .map(firstName).toPropertyWhenPresent("firstName", record::getFirstName)
-                .map(lastName).toPropertyWhenPresent("lastNameAsString", record::getLastNameAsString)
-                .map(birthDate).toPropertyWhenPresent("birthDate", record::getBirthDate)
-                .map(employed).toPropertyWhenPresent("employedAsString", record::getEmployedAsString)
-                .map(occupation).toPropertyWhenPresent("occupation", record::getOccupation)
-                .map(addressId).toPropertyWhenPresent("addressId", record::getAddressId);
+        PersonRecord row = new PersonRecord();
+        row.setId(100);
+        row.setFirstName("Joe");
+        row.setLastName(LastName.of("Jones"));
+        row.setBirthDate(new Date());
+        row.setEmployed(false);
+        row.setAddressId(1);
+
+        Buildable<InsertModel<PersonRecord>> insertStatement = insert(row).into(person)
+                .map(id).toPropertyWhenPresent("id", row::getId)
+                .map(firstName).toPropertyWhenPresent("firstName", row::getFirstName)
+                .map(lastName).toPropertyWhenPresent("lastNameAsString", row::getLastNameAsString)
+                .map(birthDate).toPropertyWhenPresent("birthDate", row::getBirthDate)
+                .map(employed).toPropertyWhenPresent("employedAsString", row::getEmployedAsString)
+                .map(occupation).toPropertyWhenPresent("occupation", row::getOccupation)
+                .map(addressId).toPropertyWhenPresent("addressId", row::getAddressId);
 
         int rows = template.insert(insertStatement);
 
@@ -480,16 +480,16 @@ void testUpdateByPrimaryKeySelective() {
 
     @Test
     void testUpdate() {
-        PersonRecord record = new PersonRecord();
-        record.setId(100);
-        record.setFirstName("Joe");
-        record.setLastName(LastName.of("Jones"));
-        record.setBirthDate(new Date());
-        record.setEmployed(true);
-        record.setOccupation("Developer");
-        record.setAddressId(1);
-
-        Buildable<InsertModel<PersonRecord>> insertStatement = insert(record).into(person)
+        PersonRecord row = new PersonRecord();
+        row.setId(100);
+        row.setFirstName("Joe");
+        row.setLastName(LastName.of("Jones"));
+        row.setBirthDate(new Date());
+        row.setEmployed(true);
+        row.setOccupation("Developer");
+        row.setAddressId(1);
+
+        Buildable<InsertModel<PersonRecord>> insertStatement = insert(row).into(person)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
                 .map(lastName).toProperty("lastNameAsString")
@@ -501,16 +501,16 @@ void testUpdate() {
         int rows = template.insert(insertStatement);
         assertThat(rows).isEqualTo(1);
 
-        record.setOccupation("Programmer");
+        row.setOccupation("Programmer");
 
         Buildable<UpdateModel> updateStatement = update(person)
-                .set(firstName).equalTo(record::getFirstName)
-                .set(lastName).equalTo(record::getLastName)
-                .set(birthDate).equalTo(record::getBirthDate)
-                .set(employed).equalTo(record::getEmployed)
-                .set(occupation).equalTo(record::getOccupation)
-                .set(addressId).equalTo(record::getAddressId)
-                .where(id, isEqualTo(record::getId));
+                .set(firstName).equalTo(row::getFirstName)
+                .set(lastName).equalTo(row::getLastName)
+                .set(birthDate).equalTo(row::getBirthDate)
+                .set(employed).equalTo(row::getEmployed)
+                .set(occupation).equalTo(row::getOccupation)
+                .set(addressId).equalTo(row::getAddressId)
+                .where(id, isEqualTo(row::getId));
 
         rows = template.update(updateStatement);
         assertThat(rows).isEqualTo(1);
@@ -709,9 +709,9 @@ void testJoinPrimaryKey() {
                 .join(address, on(person.addressId, equalTo(address.id)))
                 .where(id, isEqualTo(1));
 
-        Optional<PersonWithAddress> record = template.selectOne(selectStatement, personWithAddressRowMapper);
+        Optional<PersonWithAddress> row = template.selectOne(selectStatement, personWithAddressRowMapper);
 
-        assertThat(record).hasValueSatisfying(r -> {
+        assertThat(row).hasValueSatisfying(r -> {
             assertThat(r.getId()).isEqualTo(1);
             assertThat(r.getEmployed()).isTrue();
             assertThat(r.getFirstName()).isEqualTo("Fred");
@@ -733,8 +733,8 @@ void testJoinPrimaryKeyInvalidRecord() {
                 .join(address, on(person.addressId, equalTo(address.id)))
                 .where(id, isEqualTo(55));
 
-        Optional<PersonWithAddress> record = template.selectOne(selectStatement, personWithAddressRowMapper);
-        assertThat(record).isEmpty();
+        Optional<PersonWithAddress> row = template.selectOne(selectStatement, personWithAddressRowMapper);
+        assertThat(row).isEmpty();
     }
 
     @Test
@@ -759,35 +759,35 @@ void testJoinCountWithSubCriteria() {
 
     private final RowMapper<PersonWithAddress> 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)));
-                record.setOccupation(rs.getString(6));
+                PersonWithAddress row = new PersonWithAddress();
+                row.setId(rs.getInt(1));
+                row.setFirstName(rs.getString(2));
+                row.setLastName(LastName.of(rs.getString(3)));
+                row.setBirthDate(rs.getTimestamp(4));
+                row.setEmployed("Yes".equals(rs.getString(5)));
+                row.setOccupation(rs.getString(6));
 
                 AddressRecord address = new AddressRecord();
-                record.setAddress(address);
+                row.setAddress(address);
                 address.setId(rs.getInt(7));
                 address.setStreetAddress(rs.getString(8));
                 address.setCity(rs.getString(9));
                 address.setState(rs.getString(10));
 
-                return record;
+                return row;
             };
 
 
     static RowMapper<PersonRecord> personRowMapper =
             (rs, i) -> {
-                PersonRecord record = new PersonRecord();
-                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)));
-                record.setOccupation(rs.getString(6));
-                record.setAddressId(rs.getInt(7));
-                return record;
+                PersonRecord row = new PersonRecord();
+                row.setId(rs.getInt(1));
+                row.setFirstName(rs.getString(2));
+                row.setLastName(LastName.of(rs.getString(3)));
+                row.setBirthDate(rs.getTimestamp(4));
+                row.setEmployed("Yes".equals(rs.getString(5)));
+                row.setOccupation(rs.getString(6));
+                row.setAddressId(rs.getInt(7));
+                return row;
             };
 }
diff --git a/src/test/java/issues/gh324/NameService.java b/src/test/java/issues/gh324/NameService.java
index a5a911a76..9e4941f1a 100644
--- a/src/test/java/issues/gh324/NameService.java
+++ b/src/test/java/issues/gh324/NameService.java
@@ -59,20 +59,20 @@ public NameService() {
     public void insertRecord() {
         try (SqlSession session = sqlSessionFactory.openSession(true)) {
             NameTableMapper mapper = session.getMapper(NameTableMapper.class);
-            NameRecord record = new NameRecord();
-            record.setId(1);
-            record.setName("Fred");
-            mapper.insert(record);
+            NameRecord row = new NameRecord();
+            row.setId(1);
+            row.setName("Fred");
+            mapper.insert(row);
         }
     }
 
     public void updateRecordWithAutoCommit() {
         try (SqlSession session = sqlSessionFactory.openSession(true)) {
             NameTableMapper mapper = session.getMapper(NameTableMapper.class);
-            NameRecord record = new NameRecord();
-            record.setId(1);
-            record.setName("Barney");
-            mapper.updateByPrimaryKey(record);
+            NameRecord row = new NameRecord();
+            row.setId(1);
+            row.setName("Barney");
+            mapper.updateByPrimaryKey(row);
         }
     }
 
@@ -80,20 +80,20 @@ public void updateRecordWithoutAutoCommitAndNoExplicitCommit() {
         // this should rollback
         try (SqlSession session = sqlSessionFactory.openSession()) {
             NameTableMapper mapper = session.getMapper(NameTableMapper.class);
-            NameRecord record = new NameRecord();
-            record.setId(1);
-            record.setName("Barney");
-            mapper.updateByPrimaryKey(record);
+            NameRecord row = new NameRecord();
+            row.setId(1);
+            row.setName("Barney");
+            mapper.updateByPrimaryKey(row);
         }
     }
 
     public void updateRecordWithoutAutoCommitAndExplicitCommit() {
         try (SqlSession session = sqlSessionFactory.openSession()) {
             NameTableMapper mapper = session.getMapper(NameTableMapper.class);
-            NameRecord record = new NameRecord();
-            record.setId(1);
-            record.setName("Barney");
-            mapper.updateByPrimaryKey(record);
+            NameRecord row = new NameRecord();
+            row.setId(1);
+            row.setName("Barney");
+            mapper.updateByPrimaryKey(row);
             session.commit();
         }
     }
diff --git a/src/test/java/issues/gh324/spring/SpringNameService.java b/src/test/java/issues/gh324/spring/SpringNameService.java
index 4dfe95ac2..a35af4e58 100644
--- a/src/test/java/issues/gh324/spring/SpringNameService.java
+++ b/src/test/java/issues/gh324/spring/SpringNameService.java
@@ -37,26 +37,26 @@ public class SpringNameService {
 
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void insertRecord() {
-        NameRecord record = new NameRecord();
-        record.setId(1);
-        record.setName("Fred");
-        mapper.insert(record);
+        NameRecord row = new NameRecord();
+        row.setId(1);
+        row.setName("Fred");
+        mapper.insert(row);
     }
 
     @Transactional(propagation = Propagation.REQUIRES_NEW)
     public void updateRecordAndCommit() {
-        NameRecord record = new NameRecord();
-        record.setId(1);
-        record.setName("Barney");
-        mapper.updateByPrimaryKey(record);
+        NameRecord row = new NameRecord();
+        row.setId(1);
+        row.setName("Barney");
+        mapper.updateByPrimaryKey(row);
     }
 
     public void updateRecordAndRollback() {
         TransactionStatus txStatus = transactionManager.getTransaction(new DefaultTransactionDefinition());
-        NameRecord record = new NameRecord();
-        record.setId(1);
-        record.setName("Barney");
-        mapper.updateByPrimaryKey(record);
+        NameRecord row = new NameRecord();
+        row.setId(1);
+        row.setName("Barney");
+        mapper.updateByPrimaryKey(row);
         transactionManager.rollback(txStatus);
     }
 
diff --git a/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java b/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java
index bcf9c81c8..350532cb2 100644
--- a/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java
+++ b/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java
@@ -37,11 +37,11 @@ class InsertStatementTest {
     @Test
     void testFullInsertStatementBuilder() {
 
-        TestRecord record = new TestRecord();
-        record.setLastName("jones");
-        record.setOccupation("dino driver");
+        TestRecord row = new TestRecord();
+        row.setLastName("jones");
+        row.setOccupation("dino driver");
 
-        InsertStatementProvider<TestRecord> insertStatement = insert(record)
+        InsertStatementProvider<TestRecord> insertStatement = insert(row)
                 .into(foo)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
@@ -60,9 +60,9 @@ void testFullInsertStatementBuilder() {
     @Test
     void testInsertStatementBuilderWithNulls() {
 
-        TestRecord record = new TestRecord();
+        TestRecord row = new TestRecord();
 
-        InsertStatementProvider<TestRecord> insertStatement = insert(record)
+        InsertStatementProvider<TestRecord> insertStatement = insert(row)
                 .into(foo)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
@@ -79,9 +79,9 @@ void testInsertStatementBuilderWithNulls() {
     @Test
     void testInsertStatementBuilderWithConstants() {
 
-        TestRecord record = new TestRecord();
+        TestRecord row = new TestRecord();
 
-        InsertStatementProvider<TestRecord> insertStatement = insert(record)
+        InsertStatementProvider<TestRecord> insertStatement = insert(row)
                 .into(foo)
                 .map(id).toConstant("3")
                 .map(firstName).toProperty("firstName")
@@ -97,16 +97,16 @@ void testInsertStatementBuilderWithConstants() {
 
     @Test
     void testSelectiveInsertStatementBuilder() {
-        TestRecord record = new TestRecord();
-        record.setLastName("jones");
-        record.setOccupation("dino driver");
+        TestRecord row = new TestRecord();
+        row.setLastName("jones");
+        row.setOccupation("dino driver");
 
-        InsertStatementProvider<TestRecord> insertStatement = insert(record)
+        InsertStatementProvider<TestRecord> insertStatement = insert(row)
                 .into(foo)
-                .map(id).toPropertyWhenPresent("id", record::getId)
-                .map(firstName).toPropertyWhenPresent("firstName", record::getFirstName)
-                .map(lastName).toPropertyWhenPresent("lastName", record::getLastName)
-                .map(occupation).toPropertyWhenPresent("occupation", record::getOccupation)
+                .map(id).toPropertyWhenPresent("id", row::getId)
+                .map(firstName).toPropertyWhenPresent("firstName", row::getFirstName)
+                .map(lastName).toPropertyWhenPresent("lastName", row::getLastName)
+                .map(occupation).toPropertyWhenPresent("occupation", row::getOccupation)
                 .build()
                 .render(RenderingStrategies.MYBATIS3);
 
@@ -117,16 +117,16 @@ void testSelectiveInsertStatementBuilder() {
 
     @Test
     void testDeprecatedMethod() {
-        TestRecord record = new TestRecord();
-        record.setLastName("jones");
-        record.setOccupation("dino driver");
+        TestRecord row = new TestRecord();
+        row.setLastName("jones");
+        row.setOccupation("dino driver");
 
-        InsertStatementProvider<TestRecord> insertStatement = insert(record)
+        InsertStatementProvider<TestRecord> insertStatement = insert(row)
                 .into(foo)
-                .map(id).toPropertyWhenPresent("id", record::getId)
-                .map(firstName).toPropertyWhenPresent("firstName", record::getFirstName)
-                .map(lastName).toPropertyWhenPresent("lastName", record::getLastName)
-                .map(occupation).toPropertyWhenPresent("occupation", record::getOccupation)
+                .map(id).toPropertyWhenPresent("id", row::getId)
+                .map(firstName).toPropertyWhenPresent("firstName", row::getFirstName)
+                .map(lastName).toPropertyWhenPresent("lastName", row::getLastName)
+                .map(occupation).toPropertyWhenPresent("occupation", row::getOccupation)
                 .build()
                 .render(RenderingStrategies.MYBATIS3);
 
diff --git a/src/test/java/org/mybatis/dynamic/sql/mybatis3/InsertStatementTest.java b/src/test/java/org/mybatis/dynamic/sql/mybatis3/InsertStatementTest.java
index 740275296..471c9ef3e 100644
--- a/src/test/java/org/mybatis/dynamic/sql/mybatis3/InsertStatementTest.java
+++ b/src/test/java/org/mybatis/dynamic/sql/mybatis3/InsertStatementTest.java
@@ -35,11 +35,11 @@ class InsertStatementTest {
 
     @Test
     void testFullInsertStatementBuilder() {
-        TestRecord record = new TestRecord();
-        record.setLastName("jones");
-        record.setOccupation("dino driver");
+        TestRecord row = new TestRecord();
+        row.setLastName("jones");
+        row.setOccupation("dino driver");
 
-        InsertStatementProvider<?> insertStatement = insert(record)
+        InsertStatementProvider<?> insertStatement = insert(row)
                 .into(foo)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
@@ -57,16 +57,16 @@ void testFullInsertStatementBuilder() {
 
     @Test
     void testSelectiveInsertStatementBuilder() {
-        TestRecord record = new TestRecord();
-        record.setLastName("jones");
-        record.setOccupation("dino driver");
+        TestRecord row = new TestRecord();
+        row.setLastName("jones");
+        row.setOccupation("dino driver");
 
-        InsertStatementProvider<?> insertStatement = insert(record)
+        InsertStatementProvider<?> insertStatement = insert(row)
                 .into(foo)
-                .map(id).toPropertyWhenPresent("id", record::getId)
-                .map(firstName).toPropertyWhenPresent("firstName", record::getFirstName)
-                .map(lastName).toPropertyWhenPresent("lastName", record::getLastName)
-                .map(occupation).toPropertyWhenPresent("occupation", record::getOccupation)
+                .map(id).toPropertyWhenPresent("id", row::getId)
+                .map(firstName).toPropertyWhenPresent("firstName", row::getFirstName)
+                .map(lastName).toPropertyWhenPresent("lastName", row::getLastName)
+                .map(occupation).toPropertyWhenPresent("occupation", row::getOccupation)
                 .build()
                 .render(RenderingStrategies.MYBATIS3);
 
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysTest.kt
index c7aae83ee..39bcd2e1c 100644
--- a/src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysTest.kt
+++ b/src/test/kotlin/examples/kotlin/mybatis3/canonical/GeneratedAlwaysTest.kt
@@ -39,16 +39,16 @@ class GeneratedAlwaysTest {
         newSession().use { session ->
             val mapper = session.getMapper(GeneratedAlwaysMapper::class.java)
 
-            val record = GeneratedAlwaysRecord(
+            val row = GeneratedAlwaysRecord(
                 firstName = "Fred",
                 lastName = "Flintstone"
             )
 
-            val rows = mapper.insert(record)
+            val rows = mapper.insert(row)
 
             assertThat(rows).isEqualTo(1)
-            assertThat(record.id).isEqualTo(22)
-            assertThat(record.fullName).isEqualTo("Fred Flintstone")
+            assertThat(row.id).isEqualTo(22)
+            assertThat(row.fullName).isEqualTo("Fred Flintstone")
         }
     }
 
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt
index e36174be6..8276ebe9c 100644
--- a/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt
+++ b/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt
@@ -141,8 +141,8 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = mapper.selectByPrimaryKey(300)
-            assertThat(record).isNull()
+            val row = mapper.selectByPrimaryKey(300)
+            assertThat(row).isNull()
         }
     }
 
@@ -215,9 +215,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            val rows = mapper.insert(record)
+            val rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
         }
     }
@@ -319,9 +319,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), false, null, 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), false, null, 1)
 
-            val rows = mapper.insertSelective(record)
+            val rows = mapper.insertSelective(row)
             assertThat(rows).isEqualTo(1)
         }
     }
@@ -331,9 +331,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            var rows = mapper.insert(record)
+            var rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
 
             rows = mapper.update {
@@ -352,9 +352,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            var rows = mapper.insert(record)
+            var rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
 
             rows = mapper.update {
@@ -374,9 +374,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            var rows = mapper.insert(record)
+            var rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
 
             rows = mapper.update {
@@ -399,9 +399,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            var rows = mapper.insert(record)
+            var rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
 
             rows = mapper.update {
@@ -421,9 +421,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            var rows = mapper.insert(record)
+            var rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
 
             rows = mapper.update {
@@ -442,9 +442,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            var rows = mapper.insert(record)
+            var rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
 
             rows = mapper.update {
@@ -463,9 +463,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonMapper::class.java)
 
-            val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+            val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-            var rows = mapper.insert(record)
+            var rows = mapper.insert(row)
             assertThat(rows).isEqualTo(1)
 
             rows = mapper.update {
@@ -717,10 +717,10 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonWithAddressMapper::class.java)
 
-            val record = mapper.selectByPrimaryKey(1)
+            val row = mapper.selectByPrimaryKey(1)
 
-            assertThat(record).isNotNull
-            with(record!!) {
+            assertThat(row).isNotNull
+            with(row!!) {
                 assertThat(id).isEqualTo(1)
                 assertThat(employed).isTrue
                 assertThat(firstName).isEqualTo("Fred")
@@ -741,9 +741,9 @@ class PersonMapperTest {
         sqlSessionFactory.openSession().use { session ->
             val mapper = session.getMapper(PersonWithAddressMapper::class.java)
 
-            val record = mapper.selectByPrimaryKey(55)
+            val row = mapper.selectByPrimaryKey(55)
 
-            assertThat(record).isNull()
+            assertThat(row).isNull()
         }
     }
 
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/custom/render/KCustomRenderingTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/custom/render/KCustomRenderingTest.kt
index 1fd118711..04c359fac 100644
--- a/src/test/kotlin/examples/kotlin/mybatis3/custom/render/KCustomRenderingTest.kt
+++ b/src/test/kotlin/examples/kotlin/mybatis3/custom/render/KCustomRenderingTest.kt
@@ -64,13 +64,13 @@ class KCustomRenderingTest {
     fun testInsertRecord() {
         sqlSessionFactory.openSession().use {
             val mapper = it.getMapper(KJsonTestMapper::class.java)
-            var record = KJsonTestRecord(
+            var row = KJsonTestRecord(
                 id = 1,
                 description = "Fred",
                 info = "{\"firstName\": \"Fred\", \"lastName\": \"Flintstone\", \"age\": 30}"
             )
 
-            var insertStatement = insert(record) {
+            var insertStatement = insert(row) {
                 into(jsonTest)
                 map(id) toProperty "id"
                 map(description) toProperty "description"
@@ -82,13 +82,13 @@ class KCustomRenderingTest {
             assertThat(insertStatement.insertStatement).isEqualTo(expected)
             var rows = mapper.insert(insertStatement)
             assertThat(rows).isEqualTo(1)
-            record = KJsonTestRecord(
+            row = KJsonTestRecord(
                 id = 2,
                 description = "Wilma",
                 info = "{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}"
             )
 
-            insertStatement = insert(record) {
+            insertStatement = insert(row) {
                 into(jsonTest)
                 map(id) toProperty "id"
                 map(description) toProperty "description"
@@ -260,9 +260,9 @@ class KCustomRenderingTest {
                 "from JsonTest " +
                 "where info->>'age' = #{parameters.p1,jdbcType=VARCHAR}"
             assertThat(selectStatement.selectStatement).isEqualTo(expected)
-            val record = mapper.selectOne(selectStatement)
-            assertThat(record).isNotNull
-            assertThat(record!!.info).isEqualTo(
+            val row = mapper.selectOne(selectStatement)
+            assertThat(row).isNotNull
+            assertThat(row!!.info).isEqualTo(
                 "{\"firstName\": \"Wilma\", \"lastName\": \"Flintstone\", \"age\": 25}"
             )
         }
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt
index b3f384ebc..7157e709a 100644
--- a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt
+++ b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTemplateDirectTest.kt
@@ -185,16 +185,16 @@ open class CanonicalSpringKotlinTemplateDirectTest {
 
     @Test
     fun testInsert() {
-        val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+        val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-        val rows = template.insert(record) {
+        val rows = template.insert(row) {
             into(person)
             map(id) toProperty "id"
             map(firstName) toProperty "firstName"
             map(lastName) toProperty "lastNameAsString"
             map(birthDate) toProperty "birthDate"
             map(employed) toProperty "employedAsString"
-            map(occupation).toPropertyWhenPresent("occupation", record::occupation)
+            map(occupation).toPropertyWhenPresent("occupation", row::occupation)
             map(addressId) toProperty "addressId"
         }
 
@@ -483,14 +483,14 @@ open class CanonicalSpringKotlinTemplateDirectTest {
 
     @Test
     fun testSelectByPrimaryKey() {
-        val record = template.selectOne(
+        val row = template.selectOne(
             id `as` "A_ID", firstName, lastName, birthDate, employed, occupation, addressId
         ) {
             from(person)
             where { id isEqualTo 1 }
         }.withRowMapper(personRowMapper)
 
-        with(record!!) {
+        with(row!!) {
             assertThat(id).isEqualTo(1)
             assertThat(firstName).isEqualTo("Fred")
             assertThat(lastName!!.name).isEqualTo("Flintstone")
diff --git a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt
index 17e19bc7f..7b9093892 100644
--- a/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt
+++ b/src/test/kotlin/examples/kotlin/spring/canonical/CanonicalSpringKotlinTest.kt
@@ -252,9 +252,9 @@ open class CanonicalSpringKotlinTest {
     @Test
     fun testInsert() {
 
-        val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+        val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
-        val insertStatement = insert(record) {
+        val insertStatement = insert(row) {
             into(person)
             map(id).toProperty("id")
             map(firstName).toProperty("firstName")
@@ -300,13 +300,13 @@ open class CanonicalSpringKotlinTest {
         assertThat(insertStatement.insertStatement).isEqualTo(expected)
 
         val rows = template.generalInsert(insertStatement)
-        val record = template.selectOne(id, firstName, lastName, birthDate, employed, occupation, addressId) {
+        val row = template.selectOne(id, firstName, lastName, birthDate, employed, occupation, addressId) {
             from(person)
             where { id isEqualTo 100 }
         }.withRowMapper(personRowMapper)
 
         assertThat(rows).isEqualTo(1)
-        with(record!!) {
+        with(row!!) {
             assertThat(id).isEqualTo(100)
             assertThat(firstName).isEqualTo("Joe")
             assertThat(lastName!!.name).isEqualTo("Jones")
@@ -337,13 +337,13 @@ open class CanonicalSpringKotlinTest {
         assertThat(insertStatement.insertStatement).isEqualTo(expected)
 
         val rows = template.generalInsert(insertStatement)
-        val record = template.selectOne(id, firstName, lastName, birthDate, employed, occupation, addressId) {
+        val row = template.selectOne(id, firstName, lastName, birthDate, employed, occupation, addressId) {
             from(person)
             where { id isEqualTo 100 }
         }.withRowMapper(personRowMapper)
 
         assertThat(rows).isEqualTo(1)
-        with(record!!) {
+        with(row!!) {
             assertThat(id).isEqualTo(100)
             assertThat(firstName).isEqualTo("Joe")
             assertThat(lastName!!.name).isEqualTo("Jones")
@@ -530,10 +530,10 @@ open class CanonicalSpringKotlinTest {
 
     @Test
     fun testInsertNoTable() {
-        val record = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
+        val row = PersonRecord(100, "Joe", LastName("Jones"), Date(), true, "Developer", 1)
 
         assertThatExceptionOfType(KInvalidSQLException::class.java).isThrownBy {
-            insert(record) {
+            insert(row) {
                 map(person.firstName) toProperty "firstName"
             }
         }.withMessage(Messages.getString("ERROR.25")) //$NON-NLS-1$
@@ -685,9 +685,9 @@ open class CanonicalSpringKotlinTest {
             where { id isEqualTo 300 }
         }
 
-        val record = template.selectOne(selectStatement, personRowMapper)
+        val row = template.selectOne(selectStatement, personRowMapper)
 
-        assertThat(record).isNull()
+        assertThat(row).isNull()
     }
 
     @Test
@@ -699,9 +699,9 @@ open class CanonicalSpringKotlinTest {
             where { id isEqualTo 1 }
         }
 
-        val record = template.selectOne(selectStatement, personRowMapper)
+        val row = template.selectOne(selectStatement, personRowMapper)
 
-        with(record!!) {
+        with(row!!) {
             assertThat(id).isEqualTo(1)
             assertThat(firstName).isEqualTo("Fred")
             assertThat(lastName!!.name).isEqualTo("Flintstone")

From d6ed7813f166fc61cce5b81fa7dd7c2324af8f7a Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Mon, 20 May 2024 11:04:57 -0400
Subject: [PATCH 03/11] Remove some duplicate tests

---
 .../examples/spring/PersonTemplateTest.java   | 27 -------------------
 .../sql/select/SelectStatementTest.java       | 22 +++++++--------
 2 files changed, 10 insertions(+), 39 deletions(-)

diff --git a/src/test/java/examples/spring/PersonTemplateTest.java b/src/test/java/examples/spring/PersonTemplateTest.java
index ec8f12544..2cd2b6b42 100644
--- a/src/test/java/examples/spring/PersonTemplateTest.java
+++ b/src/test/java/examples/spring/PersonTemplateTest.java
@@ -525,33 +525,6 @@ void testUpdate() {
         });
     }
 
-    @Test
-    void testUpdateOneField() {
-        Buildable<GeneralInsertModel> insertStatement = insertInto(person)
-                .set(id).toValue(100)
-                .set(firstName).toValue("Joe")
-                .set(lastName).toValue(LastName.of("Jones"))
-                .set(birthDate).toValue(new Date())
-                .set(employed).toValue(true)
-                .set(occupation).toValue("Developer")
-                .set(addressId).toValue(1);
-
-        int rows = template.generalInsert(insertStatement);
-        assertThat(rows).isEqualTo(1);
-
-        Buildable<UpdateModel> updateStatement = update(person)
-                .set(occupation).equalTo("Programmer")
-                .where(id, isEqualTo(100));
-        rows = template.update(updateStatement);
-        assertThat(rows).isEqualTo(1);
-
-        Buildable<SelectModel> selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, addressId)
-                .from(person)
-                .where(id, isEqualTo(100));
-        Optional<PersonRecord> newRecord = template.selectOne(selectStatement, personRowMapper);
-        assertThat(newRecord).hasValueSatisfying(r -> assertThat(r.getOccupation()).isEqualTo("Programmer"));
-    }
-
     @Test
     void testUpdateAll() {
         Buildable<GeneralInsertModel> insertStatement = insertInto(person)
diff --git a/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java b/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java
index 91ca56390..19832a415 100644
--- a/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java
+++ b/src/test/java/org/mybatis/dynamic/sql/select/SelectStatementTest.java
@@ -288,14 +288,13 @@ void testGroupBySingleColumn() {
     @Test
     void testInEmptyList() {
         List<String> emptyList = Collections.emptyList();
-        SelectModel selectModel = select(column1, column3)
+        SelectStatementProvider selectStatement = select(column1, column3)
                 .from(table, "a")
-                .where(column3, isInWhenPresent(emptyList))
-                .build();
+                .where(column3, isIn(emptyList))
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
 
-        assertThatExceptionOfType(RuntimeException.class).isThrownBy(() ->
-                selectModel.render(RenderingStrategies.MYBATIS3)
-        );
+        assertThat(selectStatement.getSelectStatement()).isEqualTo("select a.column1, a.column3 from foo a where a.column3 in ()");
     }
 
     @Test
@@ -363,14 +362,13 @@ void testNotInWhenPresentEmptyList() {
 
     @Test
     void testNotInCaseInsensitiveEmptyList() {
-        SelectModel selectModel = select(column1, column3)
+        SelectStatementProvider selectStatement = select(column1, column3)
                 .from(table, "a")
-                .where(column3, isNotInCaseInsensitiveWhenPresent(Collections.emptyList()))
-                .build();
+                .where(column3, isNotInCaseInsensitive(Collections.emptyList()))
+                .build()
+                .render(RenderingStrategies.MYBATIS3);
 
-        assertThatExceptionOfType(NonRenderingWhereClauseException.class).isThrownBy(() ->
-                selectModel.render(RenderingStrategies.MYBATIS3)
-        );
+        assertThat(selectStatement.getSelectStatement()).isEqualTo("select a.column1, a.column3 from foo a where upper(a.column3) not in ()");
     }
 
     @Test

From 98a5b3ea9635d64ee279a2b5f51ddc4ba32b5a01 Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Mon, 20 May 2024 17:34:55 -0400
Subject: [PATCH 04/11] Modernize Tests

---
 .../examples/animal/data/AnimalDataTest.java  | 311 +++++++++++-------
 1 file changed, 191 insertions(+), 120 deletions(-)

diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/src/test/java/examples/animal/data/AnimalDataTest.java
index ee12b3204..78261208d 100644
--- a/src/test/java/examples/animal/data/AnimalDataTest.java
+++ b/src/test/java/examples/animal/data/AnimalDataTest.java
@@ -16,9 +16,12 @@
 package examples.animal.data;
 
 import static examples.animal.data.AnimalDataDynamicSqlSupport.*;
+import static org.assertj.core.api.Assertions.as;
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.assertj.core.api.Assertions.within;
+import static org.assertj.core.api.InstanceOfAssertFactories.DOUBLE;
+import static org.assertj.core.api.InstanceOfAssertFactories.MAP;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.mybatis.dynamic.sql.SqlBuilder.*;
 
@@ -97,9 +100,10 @@ void testSelectAllRows() {
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
             List<AnimalData> animals = mapper.selectMany(selectStatement);
+
             assertAll(
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -118,7 +122,7 @@ void testSelectAllRowsWithRowBounds() {
             List<AnimalData> animals = mapper.selectManyWithRowBounds(selectStatement, rowBounds);
             assertAll(
                     () -> assertThat(animals).hasSize(6),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(5)
+                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(5)
             );
         }
     }
@@ -135,7 +139,7 @@ void testSelectAllRowsWithOrder() {
             List<AnimalData> animals = mapper.selectMany(selectStatement);
             assertAll(
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(65)
+                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -153,8 +157,9 @@ void testSelectAllRowsAllColumns() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id DESC"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals.get(0)).containsEntry("ID", 65),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "Brachiosaurus")
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ID", "ANIMAL_NAME")
+                            .containsExactly(65, "Brachiosaurus")
             );
         }
     }
@@ -172,7 +177,8 @@ void testSelectAllRowsAllColumnsWithOrder() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id DESC"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(65)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -190,7 +196,7 @@ void testSelectAllRowsAllColumnsWithOrderAndAlias() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select ad.* from AnimalData ad order by id DESC"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(65)
+                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -840,8 +846,8 @@ void testLikeCaseInsensitive() {
 
             assertAll(
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getAnimalName()).isEqualTo("Ground squirrel"),
-                    () -> assertThat(animals.get(1).getAnimalName()).isEqualTo("Artic ground squirrel")
+                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getAnimalName).isEqualTo("Ground squirrel"),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getAnimalName).isEqualTo("Artic ground squirrel")
             );
         }
     }
@@ -861,8 +867,10 @@ void testLikeLowerCase() {
 
             assertAll(
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMALNAME", "ground squirrel"),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMALNAME", "artic ground squirrel")
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMALNAME").isEqualTo("ground squirrel"),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMALNAME").isEqualTo("artic ground squirrel")
             );
         }
     }
@@ -882,8 +890,10 @@ void testLikeUpperCase() {
 
             assertAll(
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMALNAME", "GROUND SQUIRREL"),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMALNAME", "ARTIC GROUND SQUIRREL")
+                    () -> assertThat(animals).element(0).isNotNull().extracting("ANIMALNAME")
+                            .isEqualTo("GROUND SQUIRREL"),
+                    () -> assertThat(animals).element(1).isNotNull().extracting("ANIMALNAME")
+                            .isEqualTo("ARTIC GROUND SQUIRREL")
             );
         }
     }
@@ -902,9 +912,13 @@ void testLength() {
 
             List<Map<String, Object>> animals = mapper.selectManyMappedRows(selectStatement);
 
-            assertThat(animals).hasSize(2);
-            assertThat(animals.get(0)).containsEntry("ANIMALNAME", "LESSER SHORT-TAILED SHREW");
-            assertThat(animals.get(1)).containsEntry("ANIMALNAME", "AFRICAN GIANT POUCHED RAT");
+            assertAll(
+                    () -> assertThat(animals).hasSize(2),
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMALNAME").isEqualTo("LESSER SHORT-TAILED SHREW"),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMALNAME").isEqualTo("AFRICAN GIANT POUCHED RAT")
+            );
         }
     }
 
@@ -928,12 +942,15 @@ void testNumericConstant() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("SOME_NUMBER", 3),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("SOME_NUMBER", 3),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("SOME_NUMBER", 3)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "SOME_NUMBER")
+                            .containsExactly("African elephant", 3),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "SOME_NUMBER")
+                            .containsExactly("Dipliodocus", 3),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "SOME_NUMBER")
+                            .containsExactly("Brachiosaurus", 3)
             );
         }
     }
@@ -958,12 +975,15 @@ void testStringConstant() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("SOME_STRING", "fred"),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("SOME_STRING", "fred"),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("SOME_STRING", "fred")
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "SOME_STRING")
+                            .containsExactly("African elephant", "fred"),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "SOME_STRING")
+                            .containsExactly("Dipliodocus", "fred"),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "SOME_STRING")
+                            .containsExactly("Brachiosaurus", "fred")
             );
         }
     }
@@ -988,12 +1008,15 @@ void testAdd() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 12366.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 11750.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 87154.5)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 12366.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 11750.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 87154.5)
             );
         }
     }
@@ -1018,12 +1041,15 @@ void testAddConstant() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 5767.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 105.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 209.5)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 5767.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 105.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 209.5)
             );
         }
     }
@@ -1048,12 +1074,15 @@ void testAddConstantWithConstantFirst() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 5767.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 105.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 209.5)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 5767.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 105.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 209.5)
             );
         }
     }
@@ -1078,9 +1107,15 @@ void testConcat() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("DISPLAY_NAME", "African elephant - The Legend"),
-                    () -> assertThat(animals.get(1)).containsEntry("DISPLAY_NAME", "Dipliodocus - The Legend"),
-                    () -> assertThat(animals.get(2)).containsEntry("DISPLAY_NAME", "Brachiosaurus - The Legend")
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("African elephant - The Legend"),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("Dipliodocus - The Legend"),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("Brachiosaurus - The Legend")
             );
         }
     }
@@ -1105,9 +1140,15 @@ void testConcatenate() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("DISPLAY_NAME", "African elephant - The Legend"),
-                    () -> assertThat(animals.get(1)).containsEntry("DISPLAY_NAME", "Dipliodocus - The Legend"),
-                    () -> assertThat(animals.get(2)).containsEntry("DISPLAY_NAME", "Brachiosaurus - The Legend")
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("African elephant - The Legend"),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("Dipliodocus - The Legend"),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("Brachiosaurus - The Legend")
             );
         }
     }
@@ -1132,9 +1173,15 @@ void testConcatenateConstantFirst() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("DISPLAY_NAME", "Name: African elephant"),
-                    () -> assertThat(animals.get(1)).containsEntry("DISPLAY_NAME", "Name: Dipliodocus"),
-                    () -> assertThat(animals.get(2)).containsEntry("DISPLAY_NAME", "Name: Brachiosaurus")
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("Name: African elephant"),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("Name: Dipliodocus"),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("DISPLAY_NAME")
+                            .isEqualTo("Name: Brachiosaurus")
             );
         }
     }
@@ -1159,12 +1206,15 @@ void testDivide() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat((Double) animals.get(0).get("CALCULATED_WEIGHT")).isEqualTo(0.858, within(0.001)),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat((Double) animals.get(1).get("CALCULATED_WEIGHT")).isEqualTo(0.004, within(0.001)),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat((Double) animals.get(2).get("CALCULATED_WEIGHT")).isEqualTo(0.001, within(0.001))
+                    () -> assertThat(animals).element(0, as(MAP)).isNotNull()
+                            .containsEntry("ANIMAL_NAME", "African elephant")
+                            .extracting("CALCULATED_WEIGHT", as(DOUBLE)).isEqualTo(0.858, within(0.001)),
+                    () -> assertThat(animals).element(1, as(MAP)).isNotNull()
+                            .containsEntry("ANIMAL_NAME", "Dipliodocus")
+                            .extracting("CALCULATED_WEIGHT", as(DOUBLE)).isEqualTo(0.004, within(0.001)),
+                    () -> assertThat(animals).element(2, as(MAP)).isNotNull()
+                            .containsEntry("ANIMAL_NAME", "Brachiosaurus")
+                            .extracting("CALCULATED_WEIGHT", as(DOUBLE)).isEqualTo(0.001, within(0.001))
             );
         }
     }
@@ -1189,12 +1239,15 @@ void testDivideConstant() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 571.2),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 5.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 15.45)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 571.2),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 5.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 15.45)
             );
         }
     }
@@ -1219,12 +1272,15 @@ void testMultiply() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 38007648.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 585000.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 13441500.0)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 38007648.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 585000.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 13441500.0)
             );
         }
     }
@@ -1249,12 +1305,15 @@ void testMultiplyConstant() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 11424.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 100.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 309.0)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 11424.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 100.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 309.0)
             );
         }
     }
@@ -1279,12 +1338,15 @@ void testSubtract() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", -942.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", -11650.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", -86845.5)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", -942.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", -11650.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", -86845.5)
             );
         }
     }
@@ -1309,12 +1371,15 @@ void testSubtractConstant() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 5706.5),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 44.5),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 149.0)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 5706.5),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 44.5),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 149.0)
             );
         }
     }
@@ -1339,12 +1404,15 @@ void testGeneralOperator() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", -942.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", -11650.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", -86845.5)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", -942.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", -11650.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", -86845.5)
             );
         }
     }
@@ -1369,12 +1437,15 @@ void testComplexExpression() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo(expected),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0)).containsEntry("ANIMAL_NAME", "African elephant"),
-                    () -> assertThat(animals.get(0)).containsEntry("CALCULATED_WEIGHT", 38068.0),
-                    () -> assertThat(animals.get(1)).containsEntry("ANIMAL_NAME", "Dipliodocus"),
-                    () -> assertThat(animals.get(1)).containsEntry("CALCULATED_WEIGHT", 11973.0),
-                    () -> assertThat(animals.get(2)).containsEntry("ANIMAL_NAME", "Brachiosaurus"),
-                    () -> assertThat(animals.get(2)).containsEntry("CALCULATED_WEIGHT", 87847.75)
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("African elephant", 38068.0),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Dipliodocus", 11973.0),
+                    () -> assertThat(animals).element(2).isNotNull()
+                            .extracting("ANIMAL_NAME", "CALCULATED_WEIGHT")
+                            .containsExactly("Brachiosaurus", 87847.75)
             );
         }
     }
@@ -1640,12 +1711,12 @@ void testBulkInsert() {
 
             assertAll(
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(100),
-                    () -> assertThat(animals.get(0).getBrainWeight()).isEqualTo(1.2),
-                    () -> assertThat(animals.get(0).getAnimalName()).isNull(),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(101),
-                    () -> assertThat(animals.get(1).getBrainWeight()).isEqualTo(1.2),
-                    () -> assertThat(animals.get(1).getAnimalName()).isNull()
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting(AnimalData::getId, AnimalData::getBrainWeight, AnimalData::getAnimalName)
+                            .containsExactly(100, 1.2, null),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting(AnimalData::getId, AnimalData::getBrainWeight, AnimalData::getAnimalName)
+                            .containsExactly(101, 1.2, null)
             );
         }
     }
@@ -1690,12 +1761,12 @@ void testBulkInsert2() {
 
             assertAll(
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(100),
-                    () -> assertThat(animals.get(0).getBrainWeight()).isEqualTo(1.2),
-                    () -> assertThat(animals.get(0).getAnimalName()).isEqualTo("Old Fred"),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(101),
-                    () -> assertThat(animals.get(1).getBrainWeight()).isEqualTo(1.2),
-                    () -> assertThat(animals.get(1).getAnimalName()).isEqualTo("Old Fred")
+                    () -> assertThat(animals).element(0).isNotNull()
+                            .extracting(AnimalData::getId, AnimalData::getBrainWeight, AnimalData::getAnimalName)
+                            .containsExactly(100, 1.2, "Old Fred"),
+                    () -> assertThat(animals).element(1).isNotNull()
+                            .extracting(AnimalData::getId, AnimalData::getBrainWeight, AnimalData::getAnimalName)
+                            .containsExactly(101, 1.2, "Old Fred")
             );
         }
     }
@@ -1717,7 +1788,7 @@ void testOrderByAndDistinct() {
 
             assertAll(
                     () -> assertThat(rows).hasSize(14),
-                    () -> assertThat(rows.get(0).getId()).isEqualTo(65)
+                    () -> assertThat(rows).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -1739,7 +1810,7 @@ void testOrderByWithFullClause() {
 
             assertAll(
                     () -> assertThat(rows).hasSize(14),
-                    () -> assertThat(rows.get(0).getId()).isEqualTo(65)
+                    () -> assertThat(rows).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -1855,7 +1926,7 @@ void testMaxSubselect() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select a.id, a.animal_name, a.body_weight, a.brain_weight from AnimalData a where a.brain_weight = (select max(b.brain_weight) from AnimalData b)"),
                     () -> assertThat(records).hasSize(1),
-                    () -> assertThat(records.get(0).getAnimalName()).isEqualTo("Brachiosaurus")
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getAnimalName).isEqualTo("Brachiosaurus")
             );
         }
     }
@@ -1915,7 +1986,7 @@ void testMinSubselect() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select a.id, a.animal_name, a.body_weight, a.brain_weight from AnimalData a where a.brain_weight <> (select min(b.brain_weight) from AnimalData b) order by animal_name"),
                     () -> assertThat(records).hasSize(64),
-                    () -> assertThat(records.get(0).getAnimalName()).isEqualTo("African elephant")
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getAnimalName).isEqualTo("African elephant")
             );
         }
     }
@@ -1937,7 +2008,7 @@ void testMinSubselectNoAlias() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where brain_weight <> (select min(brain_weight) from AnimalData) order by animal_name"),
                     () -> assertThat(records).hasSize(64),
-                    () -> assertThat(records.get(0).getAnimalName()).isEqualTo("African elephant")
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getAnimalName).isEqualTo("African elephant")
             );
         }
     }

From eddbcd0e0bcb851eb65e9679a0bd6411d19ff83b Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Mon, 20 May 2024 17:37:17 -0400
Subject: [PATCH 05/11] Modernize Tests

---
 .../examples/animal/data/AnimalDataTest.java     | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/src/test/java/examples/animal/data/AnimalDataTest.java
index 78261208d..d751decab 100644
--- a/src/test/java/examples/animal/data/AnimalDataTest.java
+++ b/src/test/java/examples/animal/data/AnimalDataTest.java
@@ -103,7 +103,7 @@ void testSelectAllRows() {
 
             assertAll(
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -122,7 +122,7 @@ void testSelectAllRowsWithRowBounds() {
             List<AnimalData> animals = mapper.selectManyWithRowBounds(selectStatement, rowBounds);
             assertAll(
                     () -> assertThat(animals).hasSize(6),
-                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(5)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(5)
             );
         }
     }
@@ -139,7 +139,7 @@ void testSelectAllRowsWithOrder() {
             List<AnimalData> animals = mapper.selectMany(selectStatement);
             assertAll(
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -157,7 +157,7 @@ void testSelectAllRowsAllColumns() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id DESC"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals).element(0).isNotNull()
+                    () -> assertThat(animals).first().isNotNull()
                             .extracting("ID", "ANIMAL_NAME")
                             .containsExactly(65, "Brachiosaurus")
             );
@@ -177,7 +177,7 @@ void testSelectAllRowsAllColumnsWithOrder() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id DESC"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals).element(0).isNotNull()
+                    () -> assertThat(animals).first().isNotNull()
                             .extracting(AnimalData::getId).isEqualTo(65)
             );
         }
@@ -196,7 +196,7 @@ void testSelectAllRowsAllColumnsWithOrderAndAlias() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select ad.* from AnimalData ad order by id DESC"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -1788,7 +1788,7 @@ void testOrderByAndDistinct() {
 
             assertAll(
                     () -> assertThat(rows).hasSize(14),
-                    () -> assertThat(rows).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
+                    () -> assertThat(rows).first().isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }
@@ -1810,7 +1810,7 @@ void testOrderByWithFullClause() {
 
             assertAll(
                     () -> assertThat(rows).hasSize(14),
-                    () -> assertThat(rows).element(0).isNotNull().extracting(AnimalData::getId).isEqualTo(65)
+                    () -> assertThat(rows).first().isNotNull().extracting(AnimalData::getId).isEqualTo(65)
             );
         }
     }

From b85265b6365451dc2634800dce408c19e76fff27 Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Tue, 21 May 2024 18:27:08 -0500
Subject: [PATCH 06/11] Modernize Tests

---
 .../animal/data/CommonSelectMapperTest.java   |  1 +
 .../examples/animal/data/FetchFirstTest.java  | 23 +++++++++++--------
 2 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/src/test/java/examples/animal/data/CommonSelectMapperTest.java b/src/test/java/examples/animal/data/CommonSelectMapperTest.java
index 06f6a3e3d..cd20d88fa 100644
--- a/src/test/java/examples/animal/data/CommonSelectMapperTest.java
+++ b/src/test/java/examples/animal/data/CommonSelectMapperTest.java
@@ -55,6 +55,7 @@ class CommonSelectMapperTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/animal/data/CreateAnimalData.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
diff --git a/src/test/java/examples/animal/data/FetchFirstTest.java b/src/test/java/examples/animal/data/FetchFirstTest.java
index 86860a11b..4466f152f 100644
--- a/src/test/java/examples/animal/data/FetchFirstTest.java
+++ b/src/test/java/examples/animal/data/FetchFirstTest.java
@@ -17,6 +17,7 @@
 
 import static examples.animal.data.AnimalDataDynamicSqlSupport.*;
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.entry;
 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.mybatis.dynamic.sql.SqlBuilder.*;
 
@@ -50,6 +51,7 @@ class FetchFirstTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/animal/data/CreateAnimalData.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
@@ -78,7 +80,7 @@ void testOffsetAndFetchFirstAfterFrom() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(23),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(23),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData offset #{parameters.p1} rows fetch first #{parameters.p2} rows only"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p2", 3L),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 22L)
@@ -100,7 +102,7 @@ void testFetchFirstOnlyAfterFrom() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(1),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData fetch first #{parameters.p1} rows only"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 3L)
             );
@@ -124,10 +126,9 @@ void testOffsetAndFetchFirstAfterWhere() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(45),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(45),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} and id > #{parameters.p2,jdbcType=INTEGER} offset #{parameters.p3} rows fetch first #{parameters.p4} rows only"),
-                    () -> assertThat(selectStatement.getParameters()).containsEntry("p4", 3L),
-                    () -> assertThat(selectStatement.getParameters()).containsEntry("p3", 22L)
+                    () -> assertThat(selectStatement.getParameters()).contains(entry("p4", 3L), entry("p3", 22L))
             );
         }
     }
@@ -147,7 +148,7 @@ void testFetchFirstOnlyAfterWhere() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(1),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} fetch first #{parameters.p2} rows only"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p2", 3L)
             );
@@ -170,10 +171,12 @@ void testOffsetAndFetchFirstAfterOrderBy() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(23),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(23),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id offset #{parameters.p1} rows fetch first #{parameters.p2} rows only"),
-                    () -> assertThat(selectStatement.getParameters()).containsEntry("p2", 3L),
-                    () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 22L)
+                    () -> assertThat(selectStatement)
+                            .extracting(SelectStatementProvider::getParameters)
+                            .extracting("p2", "p1")
+                            .containsExactly(3L, 22L)
             );
         }
     }
@@ -193,7 +196,7 @@ void testLimitOnlyAfterOrderBy() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(1),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id fetch first #{parameters.p1} rows only"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 3L)
             );

From ed842fcea2aa4b57ce0aaf51e5e6785f12b5dd42 Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Wed, 22 May 2024 11:54:33 -0500
Subject: [PATCH 07/11] Test Improvements

---
 .../animal/data/LimitAndOffsetTest.java       |  19 ++--
 .../OptionalConditionsAnimalDataTest.java     | 100 +++++++++---------
 ...onditionsWithPredicatesAnimalDataTest.java |  98 ++++++++---------
 .../examples/animal/data/SubQueryTest.java    |   1 +
 src/test/java/examples/array/ArrayTest.java   |   1 +
 .../mybatis/GeneratedAlwaysMapperTest.java    |   7 +-
 .../always/mybatis/PersonMapperTest.java      |   1 +
 .../generated/always/spring/SpringTest.java   |  12 +--
 .../examples/paging/LimitAndOffsetTest.java   |   1 +
 .../schema_supplier/SchemaSupplierTest.java   |   1 +
 .../type_conversion/TypeConversionTest.java   |   1 +
 src/test/java/issues/gh324/Issue324Test.java  |   2 +-
 12 files changed, 124 insertions(+), 120 deletions(-)

diff --git a/src/test/java/examples/animal/data/LimitAndOffsetTest.java b/src/test/java/examples/animal/data/LimitAndOffsetTest.java
index 0d5057756..5267adde3 100644
--- a/src/test/java/examples/animal/data/LimitAndOffsetTest.java
+++ b/src/test/java/examples/animal/data/LimitAndOffsetTest.java
@@ -50,6 +50,7 @@ class LimitAndOffsetTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/animal/data/CreateAnimalData.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
@@ -78,7 +79,7 @@ void testLimitAndOffsetAfterFrom() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(23),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(23),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData limit #{parameters.p1} offset #{parameters.p2}"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 3L),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p2", 22L)
@@ -100,7 +101,7 @@ void testLimitOnlyAfterFrom() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(1),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData limit #{parameters.p1}"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 3L)
             );
@@ -121,7 +122,7 @@ void testOffsetOnlyAfterFrom() {
 
             assertAll(
                     () -> assertThat(records).hasSize(43),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(23),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(23),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData offset #{parameters.p1} rows"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 22L)
             );
@@ -145,7 +146,7 @@ void testLimitAndOffsetAfterWhere() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(45),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(45),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} and id > #{parameters.p2,jdbcType=INTEGER} limit #{parameters.p3} offset #{parameters.p4}"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p3", 3L),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p4", 22L)
@@ -168,7 +169,7 @@ void testLimitOnlyAfterWhere() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(1),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} limit #{parameters.p2}"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p2", 3L)
             );
@@ -190,7 +191,7 @@ void testOffsetOnlyAfterWhere() {
 
             assertAll(
                     () -> assertThat(records).hasSize(27),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(23),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(23),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} offset #{parameters.p2} rows"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p2", 22L)
             );
@@ -213,7 +214,7 @@ void testLimitAndOffsetAfterOrderBy() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(23),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(23),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id limit #{parameters.p1} offset #{parameters.p2}"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 3L),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p2", 22L)
@@ -236,7 +237,7 @@ void testLimitOnlyAfterOrderBy() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(1),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id limit #{parameters.p1}"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 3L)
             );
@@ -258,7 +259,7 @@ void testOffsetOnlyAfterOrderBy() {
 
             assertAll(
                     () -> assertThat(records).hasSize(43),
-                    () -> assertThat(records.get(0).getId()).isEqualTo(23),
+                    () -> assertThat(records).first().isNotNull().extracting(AnimalData::getId).isEqualTo(23),
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id offset #{parameters.p1} rows"),
                     () -> assertThat(selectStatement.getParameters()).containsEntry("p1", 22L)
             );
diff --git a/src/test/java/examples/animal/data/OptionalConditionsAnimalDataTest.java b/src/test/java/examples/animal/data/OptionalConditionsAnimalDataTest.java
index 481254e3b..acf2cd2a3 100644
--- a/src/test/java/examples/animal/data/OptionalConditionsAnimalDataTest.java
+++ b/src/test/java/examples/animal/data/OptionalConditionsAnimalDataTest.java
@@ -80,8 +80,8 @@ void testAllIgnored() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData order by id"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(2)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(2)
             );
         }
     }
@@ -102,8 +102,8 @@ void testIgnoredBetweenRendered() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -124,8 +124,8 @@ void testIgnoredInWhere() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -147,8 +147,8 @@ void testManyIgnored() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -168,8 +168,8 @@ void testIgnoredInitialWhere() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -188,7 +188,7 @@ void testEqualWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(1),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -208,7 +208,7 @@ void testEqualWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -228,7 +228,7 @@ void testNotEqualWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <> #{parameters.p1,jdbcType=INTEGER} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(9),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -248,7 +248,7 @@ void testNotEqualWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -268,7 +268,7 @@ void testGreaterThanWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id > #{parameters.p1,jdbcType=INTEGER} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(6),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(5)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(5)
             );
         }
     }
@@ -288,7 +288,7 @@ void testGreaterThanWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -308,7 +308,7 @@ void testGreaterThanOrEqualToWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id >= #{parameters.p1,jdbcType=INTEGER} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(7),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -328,7 +328,7 @@ void testGreaterThanOrEqualToWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -347,7 +347,7 @@ void testLessThanWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -367,7 +367,7 @@ void testLessThanWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -386,7 +386,7 @@ void testLessThanOrEqualToWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(4),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -406,7 +406,7 @@ void testLessThanOrEqualToWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -425,7 +425,7 @@ void testIsInWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER},#{parameters.p3,jdbcType=INTEGER}) order by id"),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -444,7 +444,7 @@ void testIsInWhenPresentWithSomeValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER}) order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3)
             );
         }
     }
@@ -464,7 +464,7 @@ void testIsInWhenPresentWithNoValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -483,7 +483,7 @@ void testIsInCaseInsensitiveWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -502,7 +502,7 @@ void testIsInCaseInsensitiveWhenPresentWithSomeValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -522,7 +522,7 @@ void testIsInCaseInsensitiveWhenPresentWithNoValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -542,7 +542,7 @@ void testIsNotInWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id not in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER},#{parameters.p3,jdbcType=INTEGER}) and id <= #{parameters.p4,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(7),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -562,7 +562,7 @@ void testIsNotInWhenPresentWithSomeValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id not in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER}) and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -582,7 +582,7 @@ void testIsNotInWhenPresentWithNoValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -602,7 +602,7 @@ void testIsNotInCaseInsensitiveWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) not in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -622,7 +622,7 @@ void testIsNotInCaseInsensitiveWhenPresentWithSomeValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) not in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -642,7 +642,7 @@ void testIsNotInCaseInsensitiveWhenPresentWithNoValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -661,7 +661,7 @@ void testIsBetweenWhenPresentWithValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id between #{parameters.p1,jdbcType=INTEGER} and #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(4),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3)
             );
         }
     }
@@ -681,7 +681,7 @@ void testIsBetweenWhenPresentWithFirstMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -701,7 +701,7 @@ void testIsBetweenWhenPresentWithSecondMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -721,7 +721,7 @@ void testIsBetweenWhenPresentWithBothMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -741,7 +741,7 @@ void testIsNotBetweenWhenPresentWithValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id not between #{parameters.p1,jdbcType=INTEGER} and #{parameters.p2,jdbcType=INTEGER} and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(6),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -761,7 +761,7 @@ void testIsNotBetweenWhenPresentWithFirstMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -781,7 +781,7 @@ void testIsNotBetweenWhenPresentWithSecondMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -801,7 +801,7 @@ void testIsNotBetweenWhenPresentWithBothMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -821,7 +821,7 @@ void testIsLikeWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where animal_name like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(6)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(6)
             );
         }
     }
@@ -841,7 +841,7 @@ void testIsLikeWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -861,7 +861,7 @@ void testIsLikeCaseInsensitiveWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(6)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(6)
             );
         }
     }
@@ -881,7 +881,7 @@ void testIsLikeCaseInsensitiveWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -901,7 +901,7 @@ void testIsNotLikeWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where animal_name not like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -921,7 +921,7 @@ void testIsNotLikeWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -941,7 +941,7 @@ void testIsNotLikeCaseInsensitiveWhenPresentWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) not like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -961,7 +961,7 @@ void testIsNotLikeCaseInsensitiveWhenPresentWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
diff --git a/src/test/java/examples/animal/data/OptionalConditionsWithPredicatesAnimalDataTest.java b/src/test/java/examples/animal/data/OptionalConditionsWithPredicatesAnimalDataTest.java
index 2cfaab8bb..7dd1e131e 100644
--- a/src/test/java/examples/animal/data/OptionalConditionsWithPredicatesAnimalDataTest.java
+++ b/src/test/java/examples/animal/data/OptionalConditionsWithPredicatesAnimalDataTest.java
@@ -86,8 +86,8 @@ void testAllIgnored() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData order by id"),
                     () -> assertThat(animals).hasSize(65),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(2)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(2)
             );
         }
     }
@@ -108,8 +108,8 @@ void testIgnoredBetweenRendered() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -130,8 +130,8 @@ void testIgnoredInWhere() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -153,8 +153,8 @@ void testManyIgnored() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -174,8 +174,8 @@ void testIgnoredInitialWhere() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} or id = #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -194,7 +194,7 @@ void testEqualWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id = #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(1),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -214,7 +214,7 @@ void testEqualWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -234,7 +234,7 @@ void testNotEqualWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <> #{parameters.p1,jdbcType=INTEGER} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(9),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -254,7 +254,7 @@ void testNotEqualWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -274,7 +274,7 @@ void testGreaterThanWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id > #{parameters.p1,jdbcType=INTEGER} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(6),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(5)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(5)
             );
         }
     }
@@ -294,7 +294,7 @@ void testGreaterThanWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -314,7 +314,7 @@ void testGreaterThanOrEqualToWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id >= #{parameters.p1,jdbcType=INTEGER} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(7),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -334,7 +334,7 @@ void testGreaterThanOrEqualToWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -353,7 +353,7 @@ void testLessThanWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -373,7 +373,7 @@ void testLessThanWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -392,7 +392,7 @@ void testLessThanOrEqualToWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(4),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -412,7 +412,7 @@ void testLessThanOrEqualToWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -431,7 +431,7 @@ void testIsInWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER},#{parameters.p3,jdbcType=INTEGER}) order by id"),
                     () -> assertThat(animals).hasSize(3),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -450,8 +450,8 @@ void testIsInWhenWithSomeValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER}) order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(6),
-                    () -> assertThat(animals.get(1).getId()).isEqualTo(8)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(6),
+                    () -> assertThat(animals).element(1).isNotNull().extracting(AnimalData::getId).isEqualTo(8)
             );
         }
     }
@@ -470,7 +470,7 @@ void testIsInCaseInsensitiveWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -492,7 +492,7 @@ void testValueStreamTransformer() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where animal_name in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -511,7 +511,7 @@ void testValueStreamTransformerWithCustomCondition() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where animal_name in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(4)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(4)
             );
         }
     }
@@ -531,7 +531,7 @@ void testIsInCaseInsensitiveWhenWithNoValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -551,7 +551,7 @@ void testIsNotInWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id not in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER},#{parameters.p3,jdbcType=INTEGER}) and id <= #{parameters.p4,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(7),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -571,7 +571,7 @@ void testIsNotInWhenWithSomeValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id not in (#{parameters.p1,jdbcType=INTEGER},#{parameters.p2,jdbcType=INTEGER}) and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -591,7 +591,7 @@ void testIsNotInCaseInsensitiveWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) not in (#{parameters.p1,jdbcType=VARCHAR},#{parameters.p2,jdbcType=VARCHAR}) and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -611,7 +611,7 @@ void testIsNotInCaseInsensitiveWhenWithNoValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -630,7 +630,7 @@ void testIsBetweenWhenWithValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id between #{parameters.p1,jdbcType=INTEGER} and #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(4),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(3)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(3)
             );
         }
     }
@@ -650,7 +650,7 @@ void testIsBetweenWhenWithFirstMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -670,7 +670,7 @@ void testIsBetweenWhenWithSecondMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -690,7 +690,7 @@ void testIsBetweenWhenWithBothMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -710,7 +710,7 @@ void testIsNotBetweenWhenWithValues() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id not between #{parameters.p1,jdbcType=INTEGER} and #{parameters.p2,jdbcType=INTEGER} and id <= #{parameters.p3,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(6),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -730,7 +730,7 @@ void testIsNotBetweenWhenWithFirstMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -750,7 +750,7 @@ void testIsNotBetweenWhenWithSecondMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -770,7 +770,7 @@ void testIsNotBetweenWhenWithBothMissing() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -790,7 +790,7 @@ void testIsLikeWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where animal_name like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(6)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(6)
             );
         }
     }
@@ -810,7 +810,7 @@ void testIsLikeWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -830,7 +830,7 @@ void testIsLikeCaseInsensitiveWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(2),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(6)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(6)
             );
         }
     }
@@ -850,7 +850,7 @@ void testIsLikeCaseInsensitiveWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -870,7 +870,7 @@ void testIsNotLikeWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where animal_name not like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -890,7 +890,7 @@ void testIsNotLikeWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -910,7 +910,7 @@ void testIsNotLikeCaseInsensitiveWhenWithValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where upper(animal_name) not like #{parameters.p1,jdbcType=VARCHAR} and id <= #{parameters.p2,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(8),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
@@ -930,7 +930,7 @@ void testIsNotLikeCaseInsensitiveWhenWithoutValue() {
             assertAll(
                     () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select id, animal_name, body_weight, brain_weight from AnimalData where id <= #{parameters.p1,jdbcType=INTEGER} order by id"),
                     () -> assertThat(animals).hasSize(10),
-                    () -> assertThat(animals.get(0).getId()).isEqualTo(1)
+                    () -> assertThat(animals).first().isNotNull().extracting(AnimalData::getId).isEqualTo(1)
             );
         }
     }
diff --git a/src/test/java/examples/animal/data/SubQueryTest.java b/src/test/java/examples/animal/data/SubQueryTest.java
index 41b6a2adb..5a683c6af 100644
--- a/src/test/java/examples/animal/data/SubQueryTest.java
+++ b/src/test/java/examples/animal/data/SubQueryTest.java
@@ -52,6 +52,7 @@ class SubQueryTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/animal/data/CreateAnimalData.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
diff --git a/src/test/java/examples/array/ArrayTest.java b/src/test/java/examples/array/ArrayTest.java
index b8feb5f5d..1890c1821 100644
--- a/src/test/java/examples/array/ArrayTest.java
+++ b/src/test/java/examples/array/ArrayTest.java
@@ -49,6 +49,7 @@ class ArrayTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/array/CreateDB.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
diff --git a/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java b/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java
index 2edf63933..7313e6871 100644
--- a/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java
+++ b/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java
@@ -56,6 +56,7 @@ class GeneratedAlwaysMapperTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/generated/always/CreateGeneratedAlwaysDB.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
@@ -324,9 +325,9 @@ void testUpdateSelective() {
 
             assertAll(
                     () -> assertThat(records).hasSize(3),
-                    () -> assertThat(records.get(0).getFullName()).isEqualTo("Fred Jones"),
-                    () -> assertThat(records.get(1).getFullName()).isEqualTo("Pebbles Jones"),
-                    () -> assertThat(records.get(2).getFullName()).isEqualTo("Wilma Jones")
+                    () -> assertThat(records).first().isNotNull().extracting(GeneratedAlwaysRecord::getFullName).isEqualTo("Fred Jones"),
+                    () -> assertThat(records).element(1).isNotNull().extracting(GeneratedAlwaysRecord::getFullName).isEqualTo("Pebbles Jones"),
+                    () -> assertThat(records).element(2).isNotNull().extracting(GeneratedAlwaysRecord::getFullName).isEqualTo("Wilma Jones")
             );
         }
     }
diff --git a/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java b/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java
index e421c19ae..5687b12ea 100644
--- a/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java
+++ b/src/test/java/examples/generated/always/mybatis/PersonMapperTest.java
@@ -52,6 +52,7 @@ class PersonMapperTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/generated/always/CreateGeneratedAlwaysDB.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
diff --git a/src/test/java/examples/generated/always/spring/SpringTest.java b/src/test/java/examples/generated/always/spring/SpringTest.java
index 57eb4ce65..a84a31bbf 100644
--- a/src/test/java/examples/generated/always/spring/SpringTest.java
+++ b/src/test/java/examples/generated/always/spring/SpringTest.java
@@ -146,10 +146,9 @@ void testInsert() {
         KeyHolder keyHolder = new GeneratedKeyHolder();
 
         int rows = template.update(insertStatement.getInsertStatement(), parameterSource, keyHolder);
-        String generatedKey = (String) keyHolder.getKeys().get("FULL_NAME");
 
         assertThat(rows).isEqualTo(1);
-        assertThat(generatedKey).isEqualTo("Bob Jones");
+        assertThat(keyHolder).extracting(KeyHolder::getKeys).extracting("FULL_NAME").isEqualTo("Bob Jones");
     }
 
     @Test
@@ -170,10 +169,9 @@ void testInsertWithExtensions() {
         KeyHolder keyHolder = new GeneratedKeyHolder();
 
         int rows = extensions.insert(insertStatement, keyHolder);
-        String generatedKey = (String) keyHolder.getKeys().get("FULL_NAME");
 
         assertThat(rows).isEqualTo(1);
-        assertThat(generatedKey).isEqualTo("Bob Jones");
+        assertThat(keyHolder).extracting(KeyHolder::getKeys).extracting("FULL_NAME").isEqualTo("Bob Jones");
     }
 
     @Test
@@ -203,10 +201,9 @@ void testGeneralInsertWithGeneratedKey() {
         KeyHolder keyHolder = new GeneratedKeyHolder();
 
         int rows = template.update(insertStatement.getInsertStatement(), parameterSource, keyHolder);
-        String generatedKey = (String) keyHolder.getKeys().get("FULL_NAME");
 
         assertThat(rows).isEqualTo(1);
-        assertThat(generatedKey).isEqualTo("Bob Jones");
+        assertThat(keyHolder).extracting(KeyHolder::getKeys).extracting("FULL_NAME").isEqualTo("Bob Jones");
     }
 
     @Test
@@ -220,10 +217,9 @@ void testGeneralInsertWithGeneratedKeyAndExtensions() {
         KeyHolder keyHolder = new GeneratedKeyHolder();
 
         int rows = extensions.generalInsert(insertStatement, keyHolder);
-        String generatedKey = (String) keyHolder.getKeys().get("FULL_NAME");
 
         assertThat(rows).isEqualTo(1);
-        assertThat(generatedKey).isEqualTo("Bob Jones");
+        assertThat(keyHolder).extracting(KeyHolder::getKeys).extracting("FULL_NAME").isEqualTo("Bob Jones");
     }
 
     @Test
diff --git a/src/test/java/examples/paging/LimitAndOffsetTest.java b/src/test/java/examples/paging/LimitAndOffsetTest.java
index b160a0b88..f5a3ab96a 100644
--- a/src/test/java/examples/paging/LimitAndOffsetTest.java
+++ b/src/test/java/examples/paging/LimitAndOffsetTest.java
@@ -48,6 +48,7 @@ class LimitAndOffsetTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/animal/data/CreateAnimalData.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
diff --git a/src/test/java/examples/schema_supplier/SchemaSupplierTest.java b/src/test/java/examples/schema_supplier/SchemaSupplierTest.java
index 0325228be..7cc70fc7c 100644
--- a/src/test/java/examples/schema_supplier/SchemaSupplierTest.java
+++ b/src/test/java/examples/schema_supplier/SchemaSupplierTest.java
@@ -48,6 +48,7 @@ class SchemaSupplierTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/schema_supplier/CreateDB.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
diff --git a/src/test/java/examples/type_conversion/TypeConversionTest.java b/src/test/java/examples/type_conversion/TypeConversionTest.java
index e86fadbd5..3e43bc147 100644
--- a/src/test/java/examples/type_conversion/TypeConversionTest.java
+++ b/src/test/java/examples/type_conversion/TypeConversionTest.java
@@ -54,6 +54,7 @@ class TypeConversionTest {
     void setup() throws Exception {
         Class.forName(JDBC_DRIVER);
         InputStream is = getClass().getResourceAsStream("/examples/type_conversion/CreateDB.sql");
+        assert is != null;
         try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
             ScriptRunner sr = new ScriptRunner(connection);
             sr.setLogWriter(null);
diff --git a/src/test/java/issues/gh324/Issue324Test.java b/src/test/java/issues/gh324/Issue324Test.java
index 07827cef0..28ec52d35 100644
--- a/src/test/java/issues/gh324/Issue324Test.java
+++ b/src/test/java/issues/gh324/Issue324Test.java
@@ -20,7 +20,7 @@
 import org.junit.jupiter.api.Test;
 
 class Issue324Test {
-    private NameService nameService = new NameService();
+    private final NameService nameService = new NameService();
 
     @Test
     void testCacheWithAutoCommitOnUpdate() {

From 03e0ea2527f3c319f5fdd3c2201d8faa898c3791 Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Fri, 24 May 2024 10:30:06 -0400
Subject: [PATCH 08/11] Test Improvements

---
 src/test/java/org/mybatis/dynamic/sql/SqlTableTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/test/java/org/mybatis/dynamic/sql/SqlTableTest.java b/src/test/java/org/mybatis/dynamic/sql/SqlTableTest.java
index 69ae342a0..32d336572 100644
--- a/src/test/java/org/mybatis/dynamic/sql/SqlTableTest.java
+++ b/src/test/java/org/mybatis/dynamic/sql/SqlTableTest.java
@@ -123,7 +123,7 @@ private static String namePropertyReader() {
     }
 
     static class MySchemaSupplier implements Supplier<Optional<String>> {
-        private static MySchemaSupplier instance = new MySchemaSupplier();
+        private static final MySchemaSupplier instance = new MySchemaSupplier();
 
         static MySchemaSupplier instance() {
             return instance;

From 5f498fa80735018ba365a7fe8a1c1d95c60f95ff Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Sat, 1 Jun 2024 12:59:42 -0400
Subject: [PATCH 09/11] Polishing

---
 src/test/java/examples/paging/LimitAndOffsetAdapter.java  | 6 +++---
 src/test/java/examples/simple/LastName.java               | 7 ++-----
 src/test/java/examples/spring/LastName.java               | 7 ++-----
 .../springbatch/bulkinsert/TestRecordGenerator.java       | 2 +-
 src/test/java/issues/gh100/README.md                      | 8 ++++++--
 src/test/java/issues/gh324/NameService.java               | 1 +
 6 files changed, 15 insertions(+), 16 deletions(-)

diff --git a/src/test/java/examples/paging/LimitAndOffsetAdapter.java b/src/test/java/examples/paging/LimitAndOffsetAdapter.java
index a8b2a0739..02a7cf7d8 100644
--- a/src/test/java/examples/paging/LimitAndOffsetAdapter.java
+++ b/src/test/java/examples/paging/LimitAndOffsetAdapter.java
@@ -28,13 +28,13 @@
  * This adapter modifies the generated SQL by adding a LIMIT and OFFSET clause at the end
  * of the generated SQL.  This can be used to create a paginated query.
  *
- * LIMIT and OFFSET has limited support in relational databases, so this cannot be considered
+ * <p>LIMIT and OFFSET has limited support in relational databases, so this cannot be considered
  * a general solution for all paginated queries (and that is why this adapter lives only in the
  * test source tree and is not packaged with the core library code).
  *
- * I believe it works in MySQL, HSQLDB, and Postgres.
+ * <p>I believe it works in MySQL, HSQLDB, and Postgres.
  *
- * <b>Important Note: </b> this adapter is no longer required for limit and offset support as the
+ * <p><b>Important Note: </b> this adapter is no longer required for limit and offset support as the
  * library now supports limit and offset natively. However, this remains a good example of altering the generated
  * SQL before it is executed.
  *
diff --git a/src/test/java/examples/simple/LastName.java b/src/test/java/examples/simple/LastName.java
index 3f5895cab..f909d90df 100644
--- a/src/test/java/examples/simple/LastName.java
+++ b/src/test/java/examples/simple/LastName.java
@@ -50,10 +50,7 @@ public boolean equals(Object obj) {
             return false;
         LastName other = (LastName) obj;
         if (name == null) {
-            if (other.name != null)
-                return false;
-        } else if (!name.equals(other.name))
-            return false;
-        return true;
+            return other.name == null;
+        } else return name.equals(other.name);
     }
 }
diff --git a/src/test/java/examples/spring/LastName.java b/src/test/java/examples/spring/LastName.java
index 31d9dfe62..389ad04c3 100644
--- a/src/test/java/examples/spring/LastName.java
+++ b/src/test/java/examples/spring/LastName.java
@@ -50,10 +50,7 @@ public boolean equals(Object obj) {
             return false;
         LastName other = (LastName) obj;
         if (name == null) {
-            if (other.name != null)
-                return false;
-        } else if (!name.equals(other.name))
-            return false;
-        return true;
+            return other.name == null;
+        } else return name.equals(other.name);
     }
 }
diff --git a/src/test/java/examples/springbatch/bulkinsert/TestRecordGenerator.java b/src/test/java/examples/springbatch/bulkinsert/TestRecordGenerator.java
index a2910685d..0f1fd9ff2 100644
--- a/src/test/java/examples/springbatch/bulkinsert/TestRecordGenerator.java
+++ b/src/test/java/examples/springbatch/bulkinsert/TestRecordGenerator.java
@@ -23,7 +23,7 @@ public class TestRecordGenerator implements ItemReader<PersonRecord> {
 
     private int index = 0;
 
-    private static PersonRecord[] testRecords = {
+    private static final PersonRecord[] testRecords = {
             new PersonRecord("Fred", "Flintstone"),
             new PersonRecord("Wilma", "Flintstone"),
             new PersonRecord("Pebbles", "Flintstone"),
diff --git a/src/test/java/issues/gh100/README.md b/src/test/java/issues/gh100/README.md
index 80732bbcf..923d07323 100644
--- a/src/test/java/issues/gh100/README.md
+++ b/src/test/java/issues/gh100/README.md
@@ -1,5 +1,9 @@
 # About these Tests
 
-GitHub issues 100 and 102 exposed issues where calling the `build()` method at an unexpected location caused the rendered SQL to be incorrect. Changes for this issue now allow for the `build()` method to be called on any intermediate object in the select statement chain * regardless if further operations have been performed * and consistent renderings will occur.
+GitHub issues 100 and 102 exposed issues where calling the `build()` method at an unexpected location caused the
+rendered SQL to be incorrect. Changes for this issue now allow for the `build()` method to be called on any
+intermediate object in the select statement chain regardless if further operations have been performed and
+consistent renderings will occur.
 
-Tests in this directory cover many of the possible places where a `build()` method could be called and many of the possible paths through a select statement.
+Tests in this directory cover many of the possible places where a `build()` method could be called and many of the
+possible paths through a select statement.
diff --git a/src/test/java/issues/gh324/NameService.java b/src/test/java/issues/gh324/NameService.java
index 9e4941f1a..564cd221b 100644
--- a/src/test/java/issues/gh324/NameService.java
+++ b/src/test/java/issues/gh324/NameService.java
@@ -40,6 +40,7 @@ public NameService() {
         try {
             Class.forName(JDBC_DRIVER);
             InputStream is = getClass().getResourceAsStream("/issues/gh324/CreateDB.sql");
+            assert is != null;
             try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
                 ScriptRunner sr = new ScriptRunner(connection);
                 sr.setLogWriter(null);

From d2081da312b8cbebca080352d13e848465d0a35c Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Mon, 3 Jun 2024 10:08:56 -0400
Subject: [PATCH 10/11] Use the common mappers where possible

---
 .../java/examples/array/NamesTableMapper.java |  8 ++------
 .../examples/schema_supplier/UserMapper.java  |  8 ++------
 .../simple/PersonWithAddressMapper.java       |  6 ++----
 .../springbatch/mapper/PersonMapper.java      | 20 ++++---------------
 .../type_conversion/MyFilesMapper.java        | 18 +++--------------
 .../type_conversion/TypeConversionTest.java   | 12 +++++------
 6 files changed, 19 insertions(+), 53 deletions(-)

diff --git a/src/test/java/examples/array/NamesTableMapper.java b/src/test/java/examples/array/NamesTableMapper.java
index 6327c246d..b8fcc0e80 100644
--- a/src/test/java/examples/array/NamesTableMapper.java
+++ b/src/test/java/examples/array/NamesTableMapper.java
@@ -18,16 +18,15 @@
 import java.util.List;
 import java.util.Optional;
 
-import org.apache.ibatis.annotations.InsertProvider;
 import org.apache.ibatis.annotations.Result;
 import org.apache.ibatis.annotations.ResultMap;
 import org.apache.ibatis.annotations.Results;
 import org.apache.ibatis.annotations.SelectProvider;
-import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider;
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonGeneralInsertMapper;
 
-public interface NamesTableMapper {
+public interface NamesTableMapper extends CommonGeneralInsertMapper {
     @SelectProvider(type=SqlProviderAdapter.class, method="select")
     @Results(id="NamesTableResult", value={
             @Result(column="id", property="id", id=true),
@@ -38,7 +37,4 @@ public interface NamesTableMapper {
     @SelectProvider(type = SqlProviderAdapter.class, method = "select")
     @ResultMap("NamesTableResult")
     Optional<NamesRecord> selectOne(SelectStatementProvider selectStatement);
-
-    @InsertProvider(type = SqlProviderAdapter.class, method = "generalInsert")
-    int generalInsert(GeneralInsertStatementProvider insertStatement);
 }
diff --git a/src/test/java/examples/schema_supplier/UserMapper.java b/src/test/java/examples/schema_supplier/UserMapper.java
index 42bf21dc6..540ab6fad 100644
--- a/src/test/java/examples/schema_supplier/UserMapper.java
+++ b/src/test/java/examples/schema_supplier/UserMapper.java
@@ -19,24 +19,20 @@
 
 import java.util.List;
 
-import org.apache.ibatis.annotations.InsertProvider;
 import org.apache.ibatis.annotations.Result;
 import org.apache.ibatis.annotations.Results;
 import org.apache.ibatis.annotations.SelectProvider;
 import org.apache.ibatis.type.JdbcType;
 import org.mybatis.dynamic.sql.BasicColumn;
 import org.mybatis.dynamic.sql.SqlBuilder;
-import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
 import org.mybatis.dynamic.sql.render.RenderingStrategies;
 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.CommonInsertMapper;
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;
 
-public interface UserMapper {
-
-    @InsertProvider(type=SqlProviderAdapter.class, method="insert")
-    int insert(InsertStatementProvider<User> insertStatement);
+public interface UserMapper extends CommonInsertMapper<User> {
 
     @SelectProvider(type=SqlProviderAdapter.class, method="select")
     @Results(id="UserResult", value= {
diff --git a/src/test/java/examples/simple/PersonWithAddressMapper.java b/src/test/java/examples/simple/PersonWithAddressMapper.java
index 04ad8115a..a36946bad 100644
--- a/src/test/java/examples/simple/PersonWithAddressMapper.java
+++ b/src/test/java/examples/simple/PersonWithAddressMapper.java
@@ -44,13 +44,14 @@
 import org.mybatis.dynamic.sql.select.SelectModel;
 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonCountMapper;
 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;
 
 /**
  * This is a mapper that shows coding a join
  */
 @Mapper
-public interface PersonWithAddressMapper {
+public interface PersonWithAddressMapper extends CommonCountMapper {
 
     @SelectProvider(type=SqlProviderAdapter.class, method="select")
     @Results(id="PersonWithAddressResult", value= {
@@ -73,9 +74,6 @@ public interface PersonWithAddressMapper {
     @ResultMap("PersonWithAddressResult")
     Optional<PersonWithAddress> selectOne(SelectStatementProvider selectStatement);
 
-    @SelectProvider(type=SqlProviderAdapter.class, method="select")
-    long count(SelectStatementProvider selectStatement);
-
     BasicColumn[] selectList =
             BasicColumn.columnList(id.as("A_ID"), firstName, lastName, birthDate, employed, occupation, address.id,
                     address.streetAddress, address.city, address.state, address.addressType);
diff --git a/src/test/java/examples/springbatch/mapper/PersonMapper.java b/src/test/java/examples/springbatch/mapper/PersonMapper.java
index 677e0f15f..6fc3bea8f 100644
--- a/src/test/java/examples/springbatch/mapper/PersonMapper.java
+++ b/src/test/java/examples/springbatch/mapper/PersonMapper.java
@@ -18,22 +18,19 @@
 import java.util.List;
 import java.util.Map;
 
-import org.apache.ibatis.annotations.InsertProvider;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Result;
 import org.apache.ibatis.annotations.Results;
 import org.apache.ibatis.annotations.SelectProvider;
-import org.apache.ibatis.annotations.UpdateProvider;
-import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
-import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
-import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
-import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonCountMapper;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonInsertMapper;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonUpdateMapper;
 import org.mybatis.dynamic.sql.util.springbatch.SpringBatchProviderAdapter;
 
 import examples.springbatch.common.PersonRecord;
 
 @Mapper
-public interface PersonMapper {
+public interface PersonMapper extends CommonCountMapper, CommonInsertMapper<PersonRecord>, CommonUpdateMapper {
 
     @SelectProvider(type=SpringBatchProviderAdapter.class, method="select")
     @Results({
@@ -42,13 +39,4 @@ public interface PersonMapper {
         @Result(column="last_name", property="lastName")
     })
     List<PersonRecord> selectMany(Map<String, Object> parameterValues);
-
-    @UpdateProvider(type=SqlProviderAdapter.class, method="update")
-    int update(UpdateStatementProvider updateStatement);
-
-    @SelectProvider(type=SqlProviderAdapter.class, method="select")
-    long count(SelectStatementProvider selectStatement);
-
-    @InsertProvider(type=SqlProviderAdapter.class, method="insert")
-    int insert(InsertStatementProvider<PersonRecord> insertStatement);
 }
diff --git a/src/test/java/examples/type_conversion/MyFilesMapper.java b/src/test/java/examples/type_conversion/MyFilesMapper.java
index 554b46acb..87b5718b6 100644
--- a/src/test/java/examples/type_conversion/MyFilesMapper.java
+++ b/src/test/java/examples/type_conversion/MyFilesMapper.java
@@ -15,19 +15,7 @@
  */
 package examples.type_conversion;
 
-import java.util.Map;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonGeneralInsertMapper;
+import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper;
 
-import org.apache.ibatis.annotations.InsertProvider;
-import org.apache.ibatis.annotations.SelectProvider;
-import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider;
-import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
-import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
-
-public interface MyFilesMapper {
-
-    @InsertProvider(type = SqlProviderAdapter.class, method = "generalInsert")
-    int insert(GeneralInsertStatementProvider insertStatement);
-
-    @SelectProvider(type = SqlProviderAdapter.class, method = "select")
-    Map<String, Object> generalSelect(SelectStatementProvider selectStatement);
-}
+public interface MyFilesMapper extends CommonGeneralInsertMapper, CommonSelectMapper { }
diff --git a/src/test/java/examples/type_conversion/TypeConversionTest.java b/src/test/java/examples/type_conversion/TypeConversionTest.java
index 3e43bc147..7aa0e0f9f 100644
--- a/src/test/java/examples/type_conversion/TypeConversionTest.java
+++ b/src/test/java/examples/type_conversion/TypeConversionTest.java
@@ -83,7 +83,7 @@ void testFunctionInSelect() {
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
 
-            int rows = mapper.insert(insertStatement);
+            int rows = mapper.generalInsert(insertStatement);
             assertThat(rows).isEqualTo(1);
 
             SelectStatementProvider selectStatement = select(fileId, fileContents)
@@ -92,7 +92,7 @@ void testFunctionInSelect() {
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
 
-            Map<String, Object> row = mapper.generalSelect(selectStatement);
+            Map<String, Object> row = mapper.selectOneMappedRow(selectStatement);
             assertThat(row).containsExactly(entry("FILE_ID", 1), entry("FILE_CONTENTS", randomBlob));
 
             selectStatement = select(fileId, toBase64(fileContents).as("checksum"))
@@ -105,7 +105,7 @@ void testFunctionInSelect() {
                     + "where file_id = #{parameters.p1,jdbcType=INTEGER}";
             assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
 
-            row = mapper.generalSelect(selectStatement);
+            row = mapper.selectOneMappedRow(selectStatement);
 
             String base64 = Base64.getEncoder().encodeToString(randomBlob);
             assertThat(row).contains(entry("FILE_ID", 1), entry("CHECKSUM", base64));
@@ -127,7 +127,7 @@ void testFunctionInWhere() {
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
 
-            int rows = mapper.insert(insertStatement);
+            int rows = mapper.generalInsert(insertStatement);
             assertThat(rows).isEqualTo(1);
 
             SelectStatementProvider selectStatement = select(fileId, fileContents)
@@ -136,7 +136,7 @@ void testFunctionInWhere() {
                     .build()
                     .render(RenderingStrategies.MYBATIS3);
 
-            Map<String, Object> row = mapper.generalSelect(selectStatement);
+            Map<String, Object> row = mapper.selectOneMappedRow(selectStatement);
             assertThat(row).contains(entry("FILE_ID", 1), entry("FILE_CONTENTS", randomBlob));
 
             String base64 = Base64.getEncoder().encodeToString(randomBlob);
@@ -150,7 +150,7 @@ void testFunctionInWhere() {
                     + "where TO_BASE64(file_contents) = #{parameters.p1,jdbcType=VARCHAR}";
             assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
 
-            row = mapper.generalSelect(selectStatement);
+            row = mapper.selectOneMappedRow(selectStatement);
 
             assertThat(row).contains(entry("FILE_ID", 1), entry("FILE_CONTENTS", randomBlob));
         }

From ef5dd4cb6a0620f475298ba6430219906c3ffaf4 Mon Sep 17 00:00:00 2001
From: Jeff Butler <jeffgbutler@gmail.com>
Date: Mon, 3 Jun 2024 10:11:39 -0400
Subject: [PATCH 11/11] Upgrade test container versions

---
 src/test/java/config/TestContainersConfiguration.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/test/java/config/TestContainersConfiguration.java b/src/test/java/config/TestContainersConfiguration.java
index 28c553328..ed2c95c96 100644
--- a/src/test/java/config/TestContainersConfiguration.java
+++ b/src/test/java/config/TestContainersConfiguration.java
@@ -21,6 +21,6 @@
  * Utility interface to hold Docker image tags for the test containers we use
  */
 public interface TestContainersConfiguration {
-    DockerImageName POSTGRES_LATEST = DockerImageName.parse("postgres:15.4");
-    DockerImageName MARIADB_LATEST = DockerImageName.parse("mariadb:11.0.3");
+    DockerImageName POSTGRES_LATEST = DockerImageName.parse("postgres:16.3");
+    DockerImageName MARIADB_LATEST = DockerImageName.parse("mariadb:11.4.2");
 }