Skip to content

Commit fb47cf1

Browse files
jeffgbutlerjeffgbutler
committed
Use proper pattern in mapper
1 parent 2da7948 commit fb47cf1

File tree

4 files changed

+70
-113
lines changed

4 files changed

+70
-113
lines changed

‎src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapper.java

Lines changed: 18 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -18,6 +18,8 @@
1818
import static examples.generated.always.mybatis.GeneratedAlwaysDynamicSqlSupport.*;
1919
import static org.mybatis.dynamic.sql.SqlBuilder.*;
2020

21+
import java.util.Arrays;
22+
import java.util.Collection;
2123
import java.util.List;
2224
import java.util.Optional;
2325

@@ -69,14 +71,14 @@ public interface GeneratedAlwaysMapper extends CommonInsertMapper<GeneratedAlway
6971
// for the actual MyBatis call
7072
@Insert("${insertStatement}")
7173
@Options(useGeneratedKeys=true, keyProperty="records.fullName")
72-
int insertMultipleWithGeneratedKeys(@Param("insertStatement") String statement, @Param("records") List<GeneratedAlwaysRecord> records);
74+
int insertMultiple(@Param("insertStatement") String statement, @Param("records") List<GeneratedAlwaysRecord> records);
7375

74-
default int insertMultipleWithGeneratedKeys(MultiRowInsertStatementProvider<GeneratedAlwaysRecord> multiInsert) {
75-
return insertMultipleWithGeneratedKeys(multiInsert.getInsertStatement(), multiInsert.getRecords());
76+
default int insertMultiple(MultiRowInsertStatementProvider<GeneratedAlwaysRecord> multiInsert) {
77+
return insertMultiple(multiInsert.getInsertStatement(), multiInsert.getRecords());
7678
}
7779

7880
BasicColumn[] selectList =
79-
BasicColumn.columnList(id.as("A_ID"), firstName, lastName, fullName);
81+
BasicColumn.columnList(id, firstName, lastName, fullName);
8082

8183
default Optional<GeneratedAlwaysRecord> selectOne(SelectDSLCompleter completer) {
8284
return MyBatis3Utils.selectOne(this::selectOne, selectList, generatedAlways, completer);
@@ -131,4 +133,16 @@ static UpdateDSL<UpdateModel> updateSelectiveColumns(GeneratedAlwaysRecord recor
131133
.set(firstName).equalToWhenPresent(record::getFirstName)
132134
.set(lastName).equalToWhenPresent(record::getLastName);
133135
}
136+
137+
default int insertMultiple(GeneratedAlwaysRecord...records) {
138+
return insertMultiple(Arrays.asList(records));
139+
}
140+
141+
default int insertMultiple(Collection<GeneratedAlwaysRecord> records) {
142+
return MyBatis3Utils.insertMultiple(this::insertMultiple, records, generatedAlways, c ->
143+
c.map(id).toProperty("id")
144+
.map(firstName).toProperty("firstName")
145+
.map(lastName).toProperty("lastName")
146+
);
147+
}
134148
}

‎src/test/java/examples/generated/always/mybatis/GeneratedAlwaysMapperTest.java

Lines changed: 14 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -101,11 +101,8 @@ void testInsert() {
101101
record.setLastName("Jones");
102102

103103
int rows = mapper.insert(record);
104-
105-
assertAll(
106-
() -> assertThat(rows).isEqualTo(1),
107-
() -> assertThat(record.getFullName()).isEqualTo("Joe Jones")
108-
);
104+
assertThat(rows).isEqualTo(1);
105+
assertThat(record.getFullName()).isEqualTo("Joe Jones");
109106
}
110107
}
111108

@@ -163,35 +160,8 @@ void testBatchInsertWithArray() {
163160

164161
session.commit();
165162

166-
assertAll(
167-
() -> assertThat(record1.getFullName()).isEqualTo("George Jetson"),
168-
() -> assertThat(record2.getFullName()).isEqualTo("Jane Jetson")
169-
);
170-
}
171-
}
172-
173-
@Test
174-
void testMultiInsertWithRawMyBatisAnnotations() {
175-
try (SqlSession session = sqlSessionFactory.openSession()) {
176-
GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
177-
List<GeneratedAlwaysRecord> records = getTestRecords();
178-
179-
String statement = "insert into GeneratedAlways (id, first_name, last_name)" +
180-
" values" +
181-
" (#{records[0].id,jdbcType=INTEGER}, #{records[0].firstName,jdbcType=VARCHAR}, #{records[0].lastName,jdbcType=VARCHAR})," +
182-
" (#{records[1].id,jdbcType=INTEGER}, #{records[1].firstName,jdbcType=VARCHAR}, #{records[1].lastName,jdbcType=VARCHAR})," +
183-
" (#{records[2].id,jdbcType=INTEGER}, #{records[2].firstName,jdbcType=VARCHAR}, #{records[2].lastName,jdbcType=VARCHAR})," +
184-
" (#{records[3].id,jdbcType=INTEGER}, #{records[3].firstName,jdbcType=VARCHAR}, #{records[3].lastName,jdbcType=VARCHAR})";
185-
186-
int rows = mapper.insertMultipleWithGeneratedKeys(statement, records);
187-
188-
assertAll(
189-
() -> assertThat(rows).isEqualTo(4),
190-
() -> assertThat(records.get(0).getFullName()).isEqualTo("George Jetson"),
191-
() -> assertThat(records.get(1).getFullName()).isEqualTo("Jane Jetson"),
192-
() -> assertThat(records.get(2).getFullName()).isEqualTo("Judy Jetson"),
193-
() -> assertThat(records.get(3).getFullName()).isEqualTo("Elroy Jetson")
194-
);
163+
assertThat(record1.getFullName()).isEqualTo("George Jetson");
164+
assertThat(record2.getFullName()).isEqualTo("Jane Jetson");
195165
}
196166
}
197167

@@ -201,32 +171,13 @@ void testMultiInsertWithListAndGeneratedKeys() {
201171
GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
202172
List<GeneratedAlwaysRecord> records = getTestRecords();
203173

204-
MultiRowInsertStatementProvider<GeneratedAlwaysRecord> multiRowInsert = insertMultiple(records)
205-
.into(generatedAlways)
206-
.map(id).toProperty("id")
207-
.map(firstName).toProperty("firstName")
208-
.map(lastName).toProperty("lastName")
209-
.build()
210-
.render(RenderingStrategies.MYBATIS3);
211-
212-
String statement = "insert into GeneratedAlways (id, first_name, last_name)" +
213-
" values" +
214-
" (#{records[0].id,jdbcType=INTEGER}, #{records[0].firstName,jdbcType=VARCHAR}, #{records[0].lastName,jdbcType=VARCHAR})," +
215-
" (#{records[1].id,jdbcType=INTEGER}, #{records[1].firstName,jdbcType=VARCHAR}, #{records[1].lastName,jdbcType=VARCHAR})," +
216-
" (#{records[2].id,jdbcType=INTEGER}, #{records[2].firstName,jdbcType=VARCHAR}, #{records[2].lastName,jdbcType=VARCHAR})," +
217-
" (#{records[3].id,jdbcType=INTEGER}, #{records[3].firstName,jdbcType=VARCHAR}, #{records[3].lastName,jdbcType=VARCHAR})";
218-
219-
assertThat(multiRowInsert.getInsertStatement()).isEqualTo(statement);
174+
int rows = mapper.insertMultiple(records);
220175

221-
int rows = mapper.insertMultipleWithGeneratedKeys(multiRowInsert);
222-
223-
assertAll(
224-
() -> assertThat(rows).isEqualTo(4),
225-
() -> assertThat(records.get(0).getFullName()).isEqualTo("George Jetson"),
226-
() -> assertThat(records.get(1).getFullName()).isEqualTo("Jane Jetson"),
227-
() -> assertThat(records.get(2).getFullName()).isEqualTo("Judy Jetson"),
228-
() -> assertThat(records.get(3).getFullName()).isEqualTo("Elroy Jetson")
229-
);
176+
assertThat(rows).isEqualTo(4);
177+
assertThat(records.get(0).getFullName()).isEqualTo("George Jetson");
178+
assertThat(records.get(1).getFullName()).isEqualTo("Jane Jetson");
179+
assertThat(records.get(2).getFullName()).isEqualTo("Judy Jetson");
180+
assertThat(records.get(3).getFullName()).isEqualTo("Elroy Jetson");
230181
}
231182
}
232183

@@ -245,23 +196,10 @@ void testMultiInsertWithArray() {
245196
record2.setFirstName("Jane");
246197
record2.setLastName("Jetson");
247198

248-
MultiRowInsertStatementProvider<GeneratedAlwaysRecord> multiRowInsert = insertMultiple(record1, record2)
249-
.into(generatedAlways)
250-
.map(id).toProperty("id")
251-
.map(firstName).toProperty("firstName")
252-
.map(lastName).toProperty("lastName")
253-
.build()
254-
.render(RenderingStrategies.MYBATIS3);
255-
256-
String statement = "insert into GeneratedAlways (id, first_name, last_name)" +
257-
" values" +
258-
" (#{records[0].id,jdbcType=INTEGER}, #{records[0].firstName,jdbcType=VARCHAR}, #{records[0].lastName,jdbcType=VARCHAR})," +
259-
" (#{records[1].id,jdbcType=INTEGER}, #{records[1].firstName,jdbcType=VARCHAR}, #{records[1].lastName,jdbcType=VARCHAR})";
260-
261-
assertThat(multiRowInsert.getInsertStatement()).isEqualTo(statement);
262-
263-
int rows = mapper.insertMultiple(multiRowInsert);
199+
int rows = mapper.insertMultiple(record1, record2);
264200
assertThat(rows).isEqualTo(2);
201+
assertThat(record1.getFullName()).isEqualTo("George Jetson");
202+
assertThat(record2.getFullName()).isEqualTo("Jane Jetson");
265203
}
266204
}
267205

@@ -289,7 +227,7 @@ void testMultiInsertWithArrayAndVariousMappings() {
289227

290228
assertThat(multiRowInsert.getInsertStatement()).isEqualTo(statement);
291229

292-
int rows = mapper.insertMultipleWithGeneratedKeys(multiRowInsert);
230+
int rows = mapper.insertMultiple(multiRowInsert);
293231

294232
assertAll(
295233
() -> assertThat(rows).isEqualTo(1),

‎src/test/java/examples/generated/always/mybatis/PersonMapper.java

Lines changed: 34 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,14 @@
1515
*/
1616
package examples.generated.always.mybatis;
1717

18+
import static examples.generated.always.mybatis.GeneratedAlwaysDynamicSqlSupport.firstName;
19+
import static examples.generated.always.mybatis.GeneratedAlwaysDynamicSqlSupport.fullName;
20+
import static examples.generated.always.mybatis.GeneratedAlwaysDynamicSqlSupport.id;
21+
import static examples.generated.always.mybatis.GeneratedAlwaysDynamicSqlSupport.lastName;
22+
import static examples.generated.always.mybatis.PersonDynamicSqlSupport.*;
23+
24+
import java.util.Arrays;
25+
import java.util.Collection;
1826
import java.util.List;
1927
import java.util.Map;
2028

@@ -23,13 +31,16 @@
2331
import org.apache.ibatis.annotations.Options;
2432
import org.apache.ibatis.annotations.Param;
2533
import org.apache.ibatis.annotations.SelectProvider;
34+
import org.mybatis.dynamic.sql.BasicColumn;
2635
import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider;
2736
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
2837
import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
38+
import org.mybatis.dynamic.sql.select.SelectDSLCompleter;
2939
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
3040
import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
3141

3242
import examples.generated.always.PersonRecord;
43+
import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;
3344

3445
public interface PersonMapper {
3546

@@ -65,4 +76,27 @@ int insertSelectMultiple(@Param("insertStatement") String insertStatement, @Para
6576
default int insertSelect(InsertSelectStatementProvider insertSelectStatement, GeneratedKeyList keys) {
6677
return insertSelectMultiple(insertSelectStatement.getInsertStatement(), insertSelectStatement.getParameters(), keys);
6778
}
79+
80+
default int insert(PersonRecord record) {
81+
return MyBatis3Utils.insert(this::insert, record, person, c ->
82+
c.map(firstName).toProperty("firstName")
83+
.map(lastName).toProperty("lastName"));
84+
}
85+
86+
default int insertMultiple(PersonRecord...records) {
87+
return insertMultiple(Arrays.asList(records));
88+
}
89+
90+
default int insertMultiple(Collection<PersonRecord> records) {
91+
return MyBatis3Utils.insertMultiple(this::insertMultiple, records, person, c ->
92+
c.map(firstName).toProperty("firstName")
93+
.map(lastName).toProperty("lastName"));
94+
}
95+
96+
BasicColumn[] selectList =
97+
BasicColumn.columnList(id, firstName, lastName);
98+
99+
default List<PersonRecord> select(SelectDSLCompleter completer) {
100+
return MyBatis3Utils.selectList(this::selectMany, selectList, person, completer);
101+
}
68102
}

‎src/test/java/examples/generated/always/mybatis/PersonMapperTest.java

Lines changed: 4 additions & 33 deletions
Original file line numberDiff line numberDiff line change
@@ -37,10 +37,7 @@
3737
import org.junit.jupiter.api.Test;
3838
import org.mybatis.dynamic.sql.SqlBuilder;
3939
import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider;
40-
import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
41-
import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
4240
import org.mybatis.dynamic.sql.render.RenderingStrategies;
43-
import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
4441

4542
import examples.generated.always.PersonRecord;
4643

@@ -77,14 +74,7 @@ void testInsertSelectWithOneRecord() {
7774
record.setFirstName("Fred");
7875
record.setLastName("Flintstone");
7976

80-
InsertStatementProvider<PersonRecord> insertStatement = SqlBuilder.insert(record)
81-
.into(person)
82-
.map(firstName).toProperty("firstName")
83-
.map(lastName).toProperty("lastName")
84-
.build()
85-
.render(RenderingStrategies.MYBATIS3);
86-
87-
int rows = mapper.insert(insertStatement);
77+
int rows = mapper.insert(record);
8878

8979
assertThat(rows).isEqualTo(1);
9080
assertThat(record.getId()).isEqualTo(22);
@@ -99,13 +89,7 @@ void testInsertSelectWithOneRecord() {
9989
assertThat(rows).isEqualTo(1);
10090
assertThat(insertSelectStatement.getParameters()).containsEntry("id", 23);
10191

102-
SelectStatementProvider selectStatement = SqlBuilder.select(id, firstName, lastName)
103-
.from(person)
104-
.orderBy(id)
105-
.build()
106-
.render(RenderingStrategies.MYBATIS3);
107-
108-
List<PersonRecord> records = mapper.selectMany(selectStatement);
92+
List<PersonRecord> records = mapper.select(c -> c.orderBy(id));
10993
assertThat(records).hasSize(2);
11094
assertThat(records.get(0).getId()).isEqualTo(22);
11195
assertThat(records.get(1).getId()).isEqualTo(23);
@@ -125,14 +109,7 @@ void testInsertSelectWithMultipleRecords() {
125109
record2.setFirstName("Barney");
126110
record2.setLastName("Rubble");
127111

128-
MultiRowInsertStatementProvider<PersonRecord> insertStatement = SqlBuilder.insertMultiple(record1, record2)
129-
.into(person)
130-
.map(firstName).toProperty("firstName")
131-
.map(lastName).toProperty("lastName")
132-
.build()
133-
.render(RenderingStrategies.MYBATIS3);
134-
135-
int rows = mapper.insertMultiple(insertStatement);
112+
int rows = mapper.insertMultiple(record1, record2);
136113

137114
assertThat(rows).isEqualTo(2);
138115
assertThat(record1.getId()).isEqualTo(22);
@@ -153,13 +130,7 @@ void testInsertSelectWithMultipleRecords() {
153130
assertThat(keys.get(0).getKey()).isEqualTo(24);
154131
assertThat(keys.get(1).getKey()).isEqualTo(25);
155132

156-
SelectStatementProvider selectStatement = SqlBuilder.select(id, firstName, lastName)
157-
.from(person)
158-
.orderBy(id)
159-
.build()
160-
.render(RenderingStrategies.MYBATIS3);
161-
162-
List<PersonRecord> records = mapper.selectMany(selectStatement);
133+
List<PersonRecord> records = mapper.select(c -> c.orderBy(id));
163134
assertThat(records).hasSize(4);
164135
assertThat(records.get(0).getId()).isEqualTo(22);
165136
assertThat(records.get(1).getId()).isEqualTo(23);

0 commit comments

Comments
 (0)