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