Merge pull request #806 from jeffgbutler/more-sonar-fixes

More "record" to "row" fixes for Sonar warnings
mybatis · Jun 3, 2024 · ed8cf05 · ed8cf05
2 parents deb1815 + 8809a8c
commit ed8cf05
Show file tree

Hide file tree

Showing 8 changed files with 77 additions and 76 deletions.
diff --git a/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java b/src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java
@@ -100,37 +100,37 @@ default int insertMultiple(Collection<GeneratedAlwaysRecord> records) {
         );
     }
 
-    default int insertSelective(GeneratedAlwaysRecord record) {
-        return MyBatis3Utils.insert(this::insert, record, generatedAlways, c ->
-                c.map(id).toPropertyWhenPresent("id", record::getId)
-                        .map(firstName).toPropertyWhenPresent("firstName", record::getFirstName)
-                        .map(lastName).toPropertyWhenPresent("lastName", record::getLastName)
+    default int insertSelective(GeneratedAlwaysRecord row) {
+        return MyBatis3Utils.insert(this::insert, row, generatedAlways, c ->
+                c.map(id).toPropertyWhenPresent("id", row::getId)
+                        .map(firstName).toPropertyWhenPresent("firstName", row::getFirstName)
+                        .map(lastName).toPropertyWhenPresent("lastName", row::getLastName)
         );
     }
 
     default int update(UpdateDSLCompleter completer) {
         return MyBatis3Utils.update(this::update, generatedAlways, completer);
     }
 
-    default int updateByPrimaryKey(GeneratedAlwaysRecord record) {
+    default int updateByPrimaryKey(GeneratedAlwaysRecord row) {
         return update(c ->
-                c.set(firstName).equalTo(record::getFirstName)
-                .set(lastName).equalTo(record::getLastName)
-                .where(id, isEqualTo(record::getId))
+                c.set(firstName).equalTo(row::getFirstName)
+                .set(lastName).equalTo(row::getLastName)
+                .where(id, isEqualTo(row::getId))
         );
     }
 
-    default int updateByPrimaryKeySelective(GeneratedAlwaysRecord record) {
+    default int updateByPrimaryKeySelective(GeneratedAlwaysRecord row) {
         return update(c ->
-                c.set(firstName).equalToWhenPresent(record::getFirstName)
-                        .set(lastName).equalToWhenPresent(record::getLastName)
-                        .where(id, isEqualTo(record::getId))
+                c.set(firstName).equalToWhenPresent(row::getFirstName)
+                        .set(lastName).equalToWhenPresent(row::getLastName)
+                        .where(id, isEqualTo(row::getId))
         );
     }
 
-    static UpdateDSL<UpdateModel> updateSelectiveColumns(GeneratedAlwaysRecord record, UpdateDSL<UpdateModel> dsl) {
-        return dsl.set(id).equalToWhenPresent(record::getId)
-                .set(firstName).equalToWhenPresent(record::getFirstName)
-                .set(lastName).equalToWhenPresent(record::getLastName);
+    static UpdateDSL<UpdateModel> updateSelectiveColumns(GeneratedAlwaysRecord row, UpdateDSL<UpdateModel> dsl) {
+        return dsl.set(id).equalToWhenPresent(row::getId)
+                .set(firstName).equalToWhenPresent(row::getFirstName)
+                .set(lastName).equalToWhenPresent(row::getLastName);
     }
 }
diff --git a/src/test/java/examples/generated/always/mybatis/PersonMapper.java b/src/test/java/examples/generated/always/mybatis/PersonMapper.java
@@ -74,8 +74,8 @@ default int insertSelect(InsertSelectStatementProvider insertSelectStatement, Ge
         return insertSelectMultiple(insertSelectStatement.getInsertStatement(), insertSelectStatement.getParameters(), keys);
     }
 
-    default int insert(PersonRecord record) {
-        return MyBatis3Utils.insert(this::insert, record, person, c ->
+    default int insert(PersonRecord row) {
+        return MyBatis3Utils.insert(this::insert, row, person, c ->
                 c.map(firstName).toProperty("firstName")
                         .map(lastName).toProperty("lastName"));
     }

diff --git a/src/test/java/examples/schema_supplier/UserMapper.java b/src/test/java/examples/schema_supplier/UserMapper.java
@@ -45,8 +45,8 @@ default List<User> select(SelectDSLCompleter completer) {
         return MyBatis3Utils.selectList(this::selectMany, BasicColumn.columnList(id, name), user, completer);
     }
 
-    default int insert(User record) {
-        return insert(SqlBuilder.insert(record)
+    default int insert(User row) {
+        return insert(SqlBuilder.insert(row)
                 .into(user)
                 .map(id).toProperty("id")
                 .map(name).toProperty("name")

diff --git a/src/test/java/examples/simple/PersonMapper.java b/src/test/java/examples/simple/PersonMapper.java
@@ -100,8 +100,8 @@ default int generalInsert(UnaryOperator<GeneralInsertDSL> completer) {
         return MyBatis3Utils.generalInsert(this::generalInsert, person, completer);
     }
 
-    default int insert(PersonRecord record) {
-        return MyBatis3Utils.insert(this::insert, record, person, c ->
+    default int insert(PersonRecord row) {
+        return MyBatis3Utils.insert(this::insert, row, person, c ->
             c.map(id).toProperty("id")
             .map(firstName).toProperty("firstName")
             .map(lastName).toProperty("lastName")
@@ -128,15 +128,15 @@ default int insertMultiple(Collection<PersonRecord> records) {
         );
     }
 
-    default int insertSelective(PersonRecord record) {
-        return MyBatis3Utils.insert(this::insert, record, person, c ->
-            c.map(id).toPropertyWhenPresent("id", record::getId)
-            .map(firstName).toPropertyWhenPresent("firstName", record::getFirstName)
-            .map(lastName).toPropertyWhenPresent("lastName", record::getLastName)
-            .map(birthDate).toPropertyWhenPresent("birthDate", record::getBirthDate)
-            .map(employed).toPropertyWhenPresent("employed", record::getEmployed)
-            .map(occupation).toPropertyWhenPresent("occupation", record::getOccupation)
-            .map(addressId).toPropertyWhenPresent("addressId", record::getAddressId)
+    default int insertSelective(PersonRecord row) {
+        return MyBatis3Utils.insert(this::insert, row, person, c ->
+            c.map(id).toPropertyWhenPresent("id", row::getId)
+            .map(firstName).toPropertyWhenPresent("firstName", row::getFirstName)
+            .map(lastName).toPropertyWhenPresent("lastName", row::getLastName)
+            .map(birthDate).toPropertyWhenPresent("birthDate", row::getBirthDate)
+            .map(employed).toPropertyWhenPresent("employed", row::getEmployed)
+            .map(occupation).toPropertyWhenPresent("occupation", row::getOccupation)
+            .map(addressId).toPropertyWhenPresent("addressId", row::getAddressId)
         );
     }
 
@@ -162,49 +162,49 @@ default int update(UpdateDSLCompleter completer) {
         return MyBatis3Utils.update(this::update, person, completer);
     }
 
-    static UpdateDSL<UpdateModel> updateAllColumns(PersonRecord record,
+    static UpdateDSL<UpdateModel> updateAllColumns(PersonRecord row,
             UpdateDSL<UpdateModel> dsl) {
-        return dsl.set(id).equalTo(record::getId)
-                .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);
+        return dsl.set(id).equalTo(row::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);
     }
 
-    static UpdateDSL<UpdateModel> updateSelectiveColumns(PersonRecord record,
+    static UpdateDSL<UpdateModel> updateSelectiveColumns(PersonRecord row,
             UpdateDSL<UpdateModel> dsl) {
-        return dsl.set(id).equalToWhenPresent(record::getId)
-                .set(firstName).equalToWhenPresent(record::getFirstName)
-                .set(lastName).equalToWhenPresent(record::getLastName)
-                .set(birthDate).equalToWhenPresent(record::getBirthDate)
-                .set(employed).equalToWhenPresent(record::getEmployed)
-                .set(occupation).equalToWhenPresent(record::getOccupation)
-                .set(addressId).equalToWhenPresent(record::getAddressId);
+        return dsl.set(id).equalToWhenPresent(row::getId)
+                .set(firstName).equalToWhenPresent(row::getFirstName)
+                .set(lastName).equalToWhenPresent(row::getLastName)
+                .set(birthDate).equalToWhenPresent(row::getBirthDate)
+                .set(employed).equalToWhenPresent(row::getEmployed)
+                .set(occupation).equalToWhenPresent(row::getOccupation)
+                .set(addressId).equalToWhenPresent(row::getAddressId);
     }
 
-    default int updateByPrimaryKey(PersonRecord record) {
+    default int updateByPrimaryKey(PersonRecord row) {
         return update(c ->
-            c.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))
+            c.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))
         );
     }
 
-    default int updateByPrimaryKeySelective(PersonRecord record) {
+    default int updateByPrimaryKeySelective(PersonRecord row) {
         return update(c ->
-            c.set(firstName).equalToWhenPresent(record::getFirstName)
-            .set(lastName).equalToWhenPresent(record::getLastName)
-            .set(birthDate).equalToWhenPresent(record::getBirthDate)
-            .set(employed).equalToWhenPresent(record::getEmployed)
-            .set(occupation).equalToWhenPresent(record::getOccupation)
-            .set(addressId).equalToWhenPresent(record::getAddressId)
-            .where(id, isEqualTo(record::getId))
+            c.set(firstName).equalToWhenPresent(row::getFirstName)
+            .set(lastName).equalToWhenPresent(row::getLastName)
+            .set(birthDate).equalToWhenPresent(row::getBirthDate)
+            .set(employed).equalToWhenPresent(row::getEmployed)
+            .set(occupation).equalToWhenPresent(row::getOccupation)
+            .set(addressId).equalToWhenPresent(row::getAddressId)
+            .where(id, isEqualTo(row::getId))
         );
     }
 }
diff --git a/src/test/java/examples/springbatch/bulkinsert/BulkInsertConfiguration.java b/src/test/java/examples/springbatch/bulkinsert/BulkInsertConfiguration.java
@@ -89,7 +89,7 @@ public MyBatisBatchItemWriter<PersonRecord> writer(SqlSessionFactory sqlSessionF
         MyBatisBatchItemWriter<PersonRecord> writer = new MyBatisBatchItemWriter<>();
         writer.setSqlSessionFactory(sqlSessionFactory);
 
-        writer.setItemToParameterConverter(record -> InsertDSL.insert(record)
+        writer.setItemToParameterConverter(row -> InsertDSL.insert(row)
                     .into(PersonDynamicSqlSupport.person)
                     .map(firstName).toProperty("firstName")
                     .map(lastName).toProperty("lastName")

diff --git a/src/test/java/issues/gh324/NameTableMapper.java b/src/test/java/issues/gh324/NameTableMapper.java
@@ -55,8 +55,8 @@ default Optional<NameRecord> selectByPrimaryKey(Integer id_) {
         );
     }
 
-    default int insert(NameRecord record) {
-        return MyBatis3Utils.insert(this::insert, record, nameTable, c ->
+    default int insert(NameRecord row) {
+        return MyBatis3Utils.insert(this::insert, row, nameTable, c ->
                 c.map(id).toProperty("id")
                         .map(name).toProperty("name")
         );
@@ -66,10 +66,10 @@ default int update(UpdateDSLCompleter completer) {
         return MyBatis3Utils.update(this::update, nameTable, completer);
     }
 
-    default int updateByPrimaryKey(NameRecord record) {
+    default int updateByPrimaryKey(NameRecord row) {
         return update(c ->
-                c.set(name).equalTo(record::getName)
-                        .where(id, isEqualTo(record::getId))
+                c.set(name).equalTo(row::getName)
+                        .where(id, isEqualTo(row::getId))
         );
     }
 

diff --git a/src/test/java/issues/gh324/TestUtils.java b/src/test/java/issues/gh324/TestUtils.java
@@ -18,13 +18,13 @@
 import static org.assertj.core.api.Assertions.assertThat;
 
 public class TestUtils {
-    public static void recordIsFred(NameRecord record) {
-        assertThat(record.getId()).isEqualTo(1);
-        assertThat(record.getName()).isEqualTo("Fred");
+    public static void recordIsFred(NameRecord row) {
+        assertThat(row.getId()).isEqualTo(1);
+        assertThat(row.getName()).isEqualTo("Fred");
     }
 
-    public static void recordIsBarney(NameRecord record) {
-        assertThat(record.getId()).isEqualTo(1);
-        assertThat(record.getName()).isEqualTo("Barney");
+    public static void recordIsBarney(NameRecord row) {
+        assertThat(row.getId()).isEqualTo(1);
+        assertThat(row.getName()).isEqualTo("Barney");
     }
 }
diff --git a/src/test/java/org/mybatis/dynamic/sql/InvalidSQLTest.java b/src/test/java/org/mybatis/dynamic/sql/InvalidSQLTest.java
@@ -316,6 +316,7 @@ static class DeprecatedCount<T> implements BindableColumn<T> {
         private String alias;
 
         @Override
+        @Deprecated
         public String renderWithTableAlias(TableAliasCalculator tableAliasCalculator) {
             return "count(*)";
         }