1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package examples.generated.always.mybatis;
17
18 import static examples.generated.always.mybatis.GeneratedAlwaysDynamicSqlSupport.*;
19 import static org.assertj.core.api.Assertions.assertThat;
20 import static org.junit.jupiter.api.Assertions.assertAll;
21 import static org.mybatis.dynamic.sql.SqlBuilder.*;
22
23 import java.io.InputStream;
24 import java.io.InputStreamReader;
25 import java.sql.Connection;
26 import java.sql.DriverManager;
27 import java.util.ArrayList;
28 import java.util.List;
29 import java.util.Optional;
30
31 import org.apache.ibatis.datasource.unpooled.UnpooledDataSource;
32 import org.apache.ibatis.jdbc.ScriptRunner;
33 import org.apache.ibatis.mapping.Environment;
34 import org.apache.ibatis.session.Configuration;
35 import org.apache.ibatis.session.ExecutorType;
36 import org.apache.ibatis.session.SqlSession;
37 import org.apache.ibatis.session.SqlSessionFactory;
38 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
39 import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory;
40 import org.junit.jupiter.api.BeforeEach;
41 import org.junit.jupiter.api.Test;
42 import org.mybatis.dynamic.sql.insert.render.BatchInsert;
43 import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider;
44 import org.mybatis.dynamic.sql.render.RenderingStrategies;
45
46 import examples.generated.always.GeneratedAlwaysRecord;
47
48 class GeneratedAlwaysMapperTest {
49
50 private static final String JDBC_URL = "jdbc:hsqldb:mem:aname";
51 private static final String JDBC_DRIVER = "org.hsqldb.jdbcDriver";
52
53 private SqlSessionFactory sqlSessionFactory;
54
55 @BeforeEach
56 void setup() throws Exception {
57 Class.forName(JDBC_DRIVER);
58 InputStream is = getClass().getResourceAsStream("/examples/generated/always/CreateGeneratedAlwaysDB.sql");
59 assert is != null;
60 try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) {
61 ScriptRunner sr = new ScriptRunner(connection);
62 sr.setLogWriter(null);
63 sr.runScript(new InputStreamReader(is));
64 }
65
66 UnpooledDataSource ds = new UnpooledDataSource(JDBC_DRIVER, JDBC_URL, "sa", "");
67 Environment environment = new Environment("test", new JdbcTransactionFactory(), ds);
68 Configuration config = new Configuration(environment);
69 config.addMapper(GeneratedAlwaysMapper.class);
70 sqlSessionFactory = new SqlSessionFactoryBuilder().build(config);
71 }
72
73 @Test
74 void testSelectByPrimaryKey() {
75 try (SqlSession session = sqlSessionFactory.openSession()) {
76 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
77
78 Optional<GeneratedAlwaysRecord> row = mapper.selectByPrimaryKey(1);
79
80 assertThat(row).isPresent();
81 }
82 }
83
84 @Test
85 void testFirstNameIn() {
86 try (SqlSession session = sqlSessionFactory.openSession()) {
87 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
88
89 List<GeneratedAlwaysRecord> rows = mapper.select(c -> c.where(firstName, isIn("Fred", "Barney")));
90
91 assertThat(rows).hasSize(2);
92 }
93 }
94
95 @Test
96 void testInsert() {
97 try (SqlSession session = sqlSessionFactory.openSession()) {
98 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
99 GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
100 row.setId(100);
101 row.setFirstName("Joe");
102 row.setLastName("Jones");
103
104 int rows = mapper.insert(row);
105 assertThat(rows).isEqualTo(1);
106 assertThat(row.getFullName()).isEqualTo("Joe Jones");
107 }
108 }
109
110 @Test
111 void testBatchInsertWithList() {
112 try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
113 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
114 List<GeneratedAlwaysRecord> records = getTestRecords();
115
116 BatchInsert<GeneratedAlwaysRecord> batchInsert = insertBatch(records)
117 .into(generatedAlways)
118 .map(id).toProperty("id")
119 .map(firstName).toProperty("firstName")
120 .map(lastName).toProperty("lastName")
121 .build()
122 .render(RenderingStrategies.MYBATIS3);
123
124 batchInsert.insertStatements().forEach(mapper::insert);
125
126 session.commit();
127
128 assertAll(
129 () -> assertThat(records.get(0).getFullName()).isEqualTo("George Jetson"),
130 () -> assertThat(records.get(1).getFullName()).isEqualTo("Jane Jetson"),
131 () -> assertThat(records.get(2).getFullName()).isEqualTo("Judy Jetson"),
132 () -> assertThat(records.get(3).getFullName()).isEqualTo("Elroy Jetson")
133 );
134 }
135 }
136
137 @Test
138 void testBatchInsertWithArray() {
139 try (SqlSession session = sqlSessionFactory.openSession(ExecutorType.BATCH)) {
140 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
141
142 GeneratedAlwaysRecord record1 = new GeneratedAlwaysRecord();
143 record1.setId(1000);
144 record1.setFirstName("George");
145 record1.setLastName("Jetson");
146
147 GeneratedAlwaysRecord record2 = new GeneratedAlwaysRecord();
148 record2.setId(1001);
149 record2.setFirstName("Jane");
150 record2.setLastName("Jetson");
151
152 BatchInsert<GeneratedAlwaysRecord> batchInsert = insertBatch(record1, record2)
153 .into(generatedAlways)
154 .map(id).toProperty("id")
155 .map(firstName).toProperty("firstName")
156 .map(lastName).toProperty("lastName")
157 .build()
158 .render(RenderingStrategies.MYBATIS3);
159
160 batchInsert.insertStatements().forEach(mapper::insert);
161
162 session.commit();
163
164 assertThat(record1.getFullName()).isEqualTo("George Jetson");
165 assertThat(record2.getFullName()).isEqualTo("Jane Jetson");
166 }
167 }
168
169 @Test
170 void testMultiInsertWithListAndGeneratedKeys() {
171 try (SqlSession session = sqlSessionFactory.openSession()) {
172 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
173 List<GeneratedAlwaysRecord> records = getTestRecords();
174
175 int rows = mapper.insertMultiple(records);
176
177 assertThat(rows).isEqualTo(4);
178 assertThat(records.get(0).getFullName()).isEqualTo("George Jetson");
179 assertThat(records.get(1).getFullName()).isEqualTo("Jane Jetson");
180 assertThat(records.get(2).getFullName()).isEqualTo("Judy Jetson");
181 assertThat(records.get(3).getFullName()).isEqualTo("Elroy Jetson");
182 }
183 }
184
185 @Test
186 void testMultiInsertWithArray() {
187 try (SqlSession session = sqlSessionFactory.openSession()) {
188 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
189
190 GeneratedAlwaysRecord record1 = new GeneratedAlwaysRecord();
191 record1.setId(1000);
192 record1.setFirstName("George");
193 record1.setLastName("Jetson");
194
195 GeneratedAlwaysRecord record2 = new GeneratedAlwaysRecord();
196 record2.setId(1001);
197 record2.setFirstName("Jane");
198 record2.setLastName("Jetson");
199
200 int rows = mapper.insertMultiple(record1, record2);
201 assertThat(rows).isEqualTo(2);
202 assertThat(record1.getFullName()).isEqualTo("George Jetson");
203 assertThat(record2.getFullName()).isEqualTo("Jane Jetson");
204 }
205 }
206
207 @Test
208 void testMultiInsertWithArrayAndVariousMappings() {
209 try (SqlSession session = sqlSessionFactory.openSession()) {
210 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
211
212 GeneratedAlwaysRecord record1 = new GeneratedAlwaysRecord();
213 record1.setId(1000);
214 record1.setFirstName("George");
215 record1.setLastName("Jetson");
216
217 MultiRowInsertStatementProvider<GeneratedAlwaysRecord> multiRowInsert = insertMultiple(record1)
218 .into(generatedAlways)
219 .map(id).toConstant("1000")
220 .map(firstName).toStringConstant("George")
221 .map(lastName).toProperty("lastName")
222 .map(age).toNull()
223 .build()
224 .render(RenderingStrategies.MYBATIS3);
225
226 String statement = "insert into GeneratedAlways (id, first_name, last_name, age)" +
227 " values (1000, 'George', #{records[0].lastName,jdbcType=VARCHAR}, null)";
228
229 assertThat(multiRowInsert.getInsertStatement()).isEqualTo(statement);
230
231 int rows = mapper.insertMultiple(multiRowInsert.getInsertStatement(), multiRowInsert.getRecords());
232
233 assertAll(
234 () -> assertThat(rows).isEqualTo(1),
235 () -> assertThat(record1.getFullName()).isEqualTo("George Jetson")
236 );
237 }
238 }
239
240 private List<GeneratedAlwaysRecord> getTestRecords() {
241 List<GeneratedAlwaysRecord> records = new ArrayList<>();
242 GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
243 row.setId(1000);
244 row.setFirstName("George");
245 row.setLastName("Jetson");
246 records.add(row);
247
248 row = new GeneratedAlwaysRecord();
249 row.setId(1001);
250 row.setFirstName("Jane");
251 row.setLastName("Jetson");
252 records.add(row);
253
254 row = new GeneratedAlwaysRecord();
255 row.setId(1002);
256 row.setFirstName("Judy");
257 row.setLastName("Jetson");
258 records.add(row);
259
260 row = new GeneratedAlwaysRecord();
261 row.setId(1003);
262 row.setFirstName("Elroy");
263 row.setLastName("Jetson");
264 records.add(row);
265
266 return records;
267 }
268
269 @Test
270 void testInsertSelective() {
271 try (SqlSession session = sqlSessionFactory.openSession()) {
272 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
273 GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
274 row.setId(100);
275 row.setFirstName("Joe");
276 row.setLastName("Jones");
277
278 int rows = mapper.insertSelective(row);
279
280 assertAll(
281 () -> assertThat(rows).isEqualTo(1),
282 () -> assertThat(row.getFullName()).isEqualTo("Joe Jones")
283 );
284 }
285 }
286
287 @Test
288 void testUpdateByPrimaryKey() {
289 try (SqlSession session = sqlSessionFactory.openSession()) {
290 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
291 GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
292 row.setId(100);
293 row.setFirstName("Joe");
294 row.setLastName("Jones");
295
296 int rows = mapper.insert(row);
297 assertThat(rows).isEqualTo(1);
298 assertThat(row.getFullName()).isEqualTo("Joe Jones");
299
300 row.setLastName("Smith");
301 rows = mapper.updateByPrimaryKey(row);
302 assertThat(rows).isEqualTo(1);
303
304 Optional<GeneratedAlwaysRecord> newRecord = mapper.selectByPrimaryKey(100);
305 assertThat(newRecord).hasValueSatisfying(c ->
306 assertThat(c.getFullName()).isEqualTo("Joe Smith")
307 );
308 }
309 }
310
311 @Test
312 void testUpdateSelective() {
313 try (SqlSession session = sqlSessionFactory.openSession()) {
314 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
315 GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
316 row.setLastName("Jones");
317
318 int rows = mapper.update(c -> GeneratedAlwaysMapper.updateSelectiveColumns(row, c)
319 .where(lastName, isEqualTo("Flintstone")));
320 assertThat(rows).isEqualTo(3);
321
322 List<GeneratedAlwaysRecord> records = mapper.select(c ->
323 c.where(lastName, isEqualTo("Jones"))
324 .orderBy(firstName));
325
326 assertAll(
327 () -> assertThat(records).hasSize(3),
328 () -> assertThat(records).first().isNotNull().extracting(GeneratedAlwaysRecord::getFullName).isEqualTo("Fred Jones"),
329 () -> assertThat(records).element(1).isNotNull().extracting(GeneratedAlwaysRecord::getFullName).isEqualTo("Pebbles Jones"),
330 () -> assertThat(records).element(2).isNotNull().extracting(GeneratedAlwaysRecord::getFullName).isEqualTo("Wilma Jones")
331 );
332 }
333 }
334
335 @Test
336 void testUpdateByPrimaryKeySelective() {
337 try (SqlSession session = sqlSessionFactory.openSession()) {
338 GeneratedAlwaysMapper mapper = session.getMapper(GeneratedAlwaysMapper.class);
339 GeneratedAlwaysRecord row = new GeneratedAlwaysRecord();
340 row.setId(100);
341 row.setFirstName("Joe");
342 row.setLastName("Jones");
343
344 int rows = mapper.insert(row);
345 assertThat(rows).isEqualTo(1);
346
347 GeneratedAlwaysRecord updateRecord = new GeneratedAlwaysRecord();
348 updateRecord.setId(100);
349 updateRecord.setLastName("Smith");
350 rows = mapper.updateByPrimaryKeySelective(updateRecord);
351 assertThat(rows).isEqualTo(1);
352
353 Optional<GeneratedAlwaysRecord> newRecord = mapper.selectByPrimaryKey(100);
354 assertThat(newRecord).hasValueSatisfying(nr -> {
355 assertThat(nr.getFirstName()).isEqualTo("Joe");
356 assertThat(nr.getLastName()).isEqualTo("Smith");
357 assertThat(nr.getFullName()).isEqualTo("Joe Smith");
358
359 });
360 }
361 }
362 }