Add tests for a join in the new MBG style

Author: jeffgbutler

src/test/java/examples/simple/AddressDynamicSqlSupport.java

@@ -0,0 +1,40 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package examples.simple;
+
+import java.sql.JDBCType;
+
+import org.mybatis.dynamic.sql.SqlColumn;
+import org.mybatis.dynamic.sql.SqlTable;
+
+public final class AddressDynamicSqlSupport {
+    public static final Address address = new Address();
+    public static final SqlColumn<Integer> id = address.id;
+    public static final SqlColumn<String> streetAddress = address.streetAddress;
+    public static final SqlColumn<String> city = address.city;
+    public static final SqlColumn<String> state = address.state;
+    
+    public static final class Address extends SqlTable {
+        public final SqlColumn<Integer> id = column("address_id", JDBCType.INTEGER);
+        public final SqlColumn<String> streetAddress = column("street_address", JDBCType.VARCHAR);
+        public final SqlColumn<String> city = column("city", JDBCType.VARCHAR);
+        public final SqlColumn<String> state = column("state", JDBCType.VARCHAR);
+
+        public Address() {
+            super("Address");
+        }
+    }
+}

src/test/java/examples/simple/AddressRecord.java

@@ -0,0 +1,55 @@
+/**
+ *    Copyright 2016-2019 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+package examples.simple;
+
+public class AddressRecord {
+    private Integer id;
+    private String streetAddress;
+    private String city;
+    private String state;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public String getStreetAddress() {
+        return streetAddress;
+    }
+
+    public void setStreetAddress(String streetAddress) {
+        this.streetAddress = streetAddress;
+    }
+
+    public String getCity() {
+        return city;
+    }
+
+    public void setCity(String city) {
+        this.city = city;
+    }
+
+    public String getState() {
+        return state;
+    }
+
+    public void setState(String state) {
+        this.state = state;
+    }
+}

src/test/java/examples/simple/LastName.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 the original author or authors.
+ *    Copyright 2016-2019 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -31,4 +31,29 @@ public static LastName of(String name) {
         lastName.setName(name);
         return lastName;
     }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        result = prime * result + ((name == null) ? 0 : name.hashCode());
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            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;
+    }
 }

src/test/java/examples/simple/LastNameTypeHandler.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 the original author or authors.
+ *    Copyright 2016-2019 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.

src/test/java/examples/simple/SimpleTableDynamicSqlSupport.java renamed to src/test/java/examples/simple/PersonDynamicSqlSupport.java

@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 the original author or authors.
+ *    Copyright 2016-2019 the original author or authors.
  *
  *    Licensed under the Apache License, Version 2.0 (the "License");
  *    you may not use this file except in compliance with the License.
@@ -21,25 +21,27 @@
 import org.mybatis.dynamic.sql.SqlColumn;
 import org.mybatis.dynamic.sql.SqlTable;
 
-public final class SimpleTableDynamicSqlSupport {
-    public static final SimpleTable simpleTable = new SimpleTable();
-    public static final SqlColumn<Integer> id = simpleTable.id;
-    public static final SqlColumn<String> firstName = simpleTable.firstName;
-    public static final SqlColumn<LastName> lastName = simpleTable.lastName;
-    public static final SqlColumn<Date> birthDate = simpleTable.birthDate;
-    public static final SqlColumn<Boolean> employed = simpleTable.employed;
-    public static final SqlColumn<String> occupation = simpleTable.occupation;
+public final class PersonDynamicSqlSupport {
+    public static final Person person = new Person();
+    public static final SqlColumn<Integer> id = person.id;
+    public static final SqlColumn<String> firstName = person.firstName;
+    public static final SqlColumn<LastName> lastName = person.lastName;
+    public static final SqlColumn<Date> birthDate = person.birthDate;
+    public static final SqlColumn<Boolean> employed = person.employed;
+    public static final SqlColumn<String> occupation = person.occupation;
+    public static final SqlColumn<Integer> addressId = person.addressId;
 
-    public static final class SimpleTable extends SqlTable {
+    public static final class Person extends SqlTable {
         public final SqlColumn<Integer> id = column("id", JDBCType.INTEGER);
         public final SqlColumn<String> firstName = column("first_name", JDBCType.VARCHAR);
         public final SqlColumn<LastName> lastName = column("last_name", JDBCType.VARCHAR, "examples.simple.LastNameTypeHandler");
         public final SqlColumn<Date> birthDate = column("birth_date", JDBCType.DATE);
         public final SqlColumn<Boolean> employed = column("employed", JDBCType.VARCHAR, "examples.simple.YesNoTypeHandler");
         public final SqlColumn<String> occupation = column("occupation", JDBCType.VARCHAR);
+        public final SqlColumn<Integer> addressId = column("address_id", JDBCType.INTEGER);
 
-        public SimpleTable() {
-            super("SimpleTable");
+        public Person() {
+            super("Person");
         }
     }
 }

src/test/java/examples/simple/SimpleTableMapperNewStyle.java renamed to src/test/java/examples/simple/PersonMapper.java

@@ -15,7 +15,7 @@
  */
 package examples.simple;
 
-import static examples.simple.SimpleTableDynamicSqlSupport.*;
+import static examples.simple.PersonDynamicSqlSupport.*;
 import static org.mybatis.dynamic.sql.SqlBuilder.*;
 
 import java.util.List;
@@ -55,13 +55,13 @@
  *
  */
 @Mapper
-public interface SimpleTableMapperNewStyle {
+public interface PersonMapper {
 
     @InsertProvider(type=SqlProviderAdapter.class, method="insert")
-    int insert(InsertStatementProvider<SimpleTableRecord> insertStatement);
+    int insert(InsertStatementProvider<PersonRecord> insertStatement);
 
     @InsertProvider(type=SqlProviderAdapter.class, method="insertMultiple")
-    int insertMultiple(MultiRowInsertStatementProvider<SimpleTableRecord> insertStatement);
+    int insertMultiple(MultiRowInsertStatementProvider<PersonRecord> insertStatement);
 
     @UpdateProvider(type=SqlProviderAdapter.class, method="update")
     int update(UpdateStatementProvider updateStatement);
@@ -73,13 +73,14 @@ public interface SimpleTableMapperNewStyle {
             @Result(column="last_name", property="lastName", jdbcType=JdbcType.VARCHAR, typeHandler=LastNameTypeHandler.class),
             @Result(column="birth_date", property="birthDate", jdbcType=JdbcType.DATE),
             @Result(column="employed", property="employed", jdbcType=JdbcType.VARCHAR, typeHandler=YesNoTypeHandler.class),
-            @Result(column="occupation", property="occupation", jdbcType=JdbcType.VARCHAR)
+            @Result(column="occupation", property="occupation", jdbcType=JdbcType.VARCHAR),
+            @Result(column="address_id", property="addressId", jdbcType=JdbcType.INTEGER)
     })
-    List<SimpleTableRecord> selectMany(SelectStatementProvider selectStatement);
+    List<PersonRecord> selectMany(SelectStatementProvider selectStatement);
 
     @SelectProvider(type=SqlProviderAdapter.class, method="select")
     @ResultMap("SimpleTableResult")
-    Optional<SimpleTableRecord> selectOne(SelectStatementProvider selectStatement);
+    Optional<PersonRecord> selectOne(SelectStatementProvider selectStatement);
 
     @DeleteProvider(type=SqlProviderAdapter.class, method="delete")
     int delete(DeleteStatementProvider deleteStatement);
@@ -89,13 +90,13 @@ public interface SimpleTableMapperNewStyle {
 
     default long count(MyBatis3CountHelper helper) {
         return helper.apply(SelectDSL.selectWithMapper(this::count, SqlBuilder.count())
-                .from(simpleTable))
+                .from(person))
                 .build()
                 .execute();
     }
 
     default int delete(MyBatis3DeleteHelper helper) {
-        return helper.apply(MyBatis3Utils.deleteFrom(this::delete, simpleTable))
+        return helper.apply(MyBatis3Utils.deleteFrom(this::delete, person))
                 .build()
                 .execute();
     }
@@ -106,116 +107,123 @@ default int deleteByPrimaryKey(Integer id_) {
         );
     }
 
-    default int insert(SimpleTableRecord record) {
+    default int insert(PersonRecord record) {
         return insert(SqlBuilder.insert(record)
-                .into(simpleTable)
+                .into(person)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
                 .map(lastName).toProperty("lastName")
                 .map(birthDate).toProperty("birthDate")
                 .map(employed).toProperty("employed")
                 .map(occupation).toProperty("occupation")
+                .map(addressId).toProperty("addressId")
                 .build()
                 .render(RenderingStrategy.MYBATIS3));
     }
 
-    default int insertMultiple(List<SimpleTableRecord> records) {
+    default int insertMultiple(List<PersonRecord> records) {
         return insertMultiple(SqlBuilder.insertMultiple(records)
-                .into(simpleTable)
+                .into(person)
                 .map(id).toProperty("id")
                 .map(firstName).toProperty("firstName")
                 .map(lastName).toProperty("lastName")
                 .map(birthDate).toProperty("birthDate")
                 .map(employed).toProperty("employed")
                 .map(occupation).toProperty("occupation")
+                .map(addressId).toProperty("addressId")
                 .build()
                 .render(RenderingStrategy.MYBATIS3));
     }
 
-    default int insertSelective(SimpleTableRecord record) {
+    default int insertSelective(PersonRecord record) {
         return insert(SqlBuilder.insert(record)
-                .into(simpleTable)
+                .into(person)
                 .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)
                 .build()
                 .render(RenderingStrategy.MYBATIS3));
     }
 
-    default Optional<SimpleTableRecord> selectOne(MyBatis3SelectOneHelper<SimpleTableRecord> helper) {
-        return helper.apply(SelectDSL.selectWithMapper(this::selectOne, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
-                .from(simpleTable))
+    default Optional<PersonRecord> selectOne(MyBatis3SelectOneHelper<PersonRecord> helper) {
+        return helper.apply(SelectDSL.selectWithMapper(this::selectOne, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+                .from(person))
                 .build()
                 .execute();
     }
 
-    default List<SimpleTableRecord> select(MyBatis3SelectListHelper<SimpleTableRecord> helper) {
-        return helper.apply(SelectDSL.selectWithMapper(this::selectMany, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
-                .from(simpleTable))
+    default List<PersonRecord> select(MyBatis3SelectListHelper<PersonRecord> helper) {
+        return helper.apply(SelectDSL.selectWithMapper(this::selectMany, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+                .from(person))
                 .build()
                 .execute();
     }
 
-    default List<SimpleTableRecord> selectDistinct(MyBatis3SelectListHelper<SimpleTableRecord> helper) {
-        return helper.apply(SelectDSL.selectDistinctWithMapper(this::selectMany, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
-                .from(simpleTable))
+    default List<PersonRecord> selectDistinct(MyBatis3SelectListHelper<PersonRecord> helper) {
+        return helper.apply(SelectDSL.selectDistinctWithMapper(this::selectMany, id.as("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId)
+                .from(person))
                 .build()
                 .execute();
     }
 
-    default Optional<SimpleTableRecord> selectByPrimaryKey(Integer id_) {
+    default Optional<PersonRecord> selectByPrimaryKey(Integer id_) {
         return selectOne(h -> 
             h.where(id, isEqualTo(id_))
         );
     }
 
     default int update(MyBatis3UpdateHelper helper) {
-        return helper.apply(MyBatis3Utils.update(this::update, simpleTable))
+        return helper.apply(MyBatis3Utils.update(this::update, person))
                 .build()
                 .execute();
     }
 
-    static UpdateDSL<MyBatis3UpdateModelToIntAdapter> setAll(SimpleTableRecord record,
+    static UpdateDSL<MyBatis3UpdateModelToIntAdapter> setAll(PersonRecord record,
             UpdateDSL<MyBatis3UpdateModelToIntAdapter> 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(occupation).equalTo(record::getOccupation)
+                .set(addressId).equalTo(record::getAddressId);
     }
 
-    static UpdateDSL<MyBatis3UpdateModelToIntAdapter> setSelective(SimpleTableRecord record,
+    static UpdateDSL<MyBatis3UpdateModelToIntAdapter> setSelective(PersonRecord record,
             UpdateDSL<MyBatis3UpdateModelToIntAdapter> 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(occupation).equalToWhenPresent(record::getOccupation)
+                .set(addressId).equalToWhenPresent(record::getAddressId);
     }
 
-    default int updateByPrimaryKey(SimpleTableRecord record) {
+    default int updateByPrimaryKey(PersonRecord record) {
         return update(h ->
             h.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))
         );
     }
 
-    default int updateByPrimaryKeySelective(SimpleTableRecord record) {
+    default int updateByPrimaryKeySelective(PersonRecord record) {
         return update(h ->
             h.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))
         );
     }