1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package examples.simple;
17
18 import static examples.simple.PersonDynamicSqlSupport.addressId;
19 import static examples.simple.PersonDynamicSqlSupport.birthDate;
20 import static examples.simple.PersonDynamicSqlSupport.employed;
21 import static examples.simple.PersonDynamicSqlSupport.firstName;
22 import static examples.simple.PersonDynamicSqlSupport.id;
23 import static examples.simple.PersonDynamicSqlSupport.lastName;
24 import static examples.simple.PersonDynamicSqlSupport.occupation;
25 import static examples.simple.PersonDynamicSqlSupport.person;
26 import static org.mybatis.dynamic.sql.SqlBuilder.isEqualTo;
27 import static org.mybatis.dynamic.sql.SqlBuilder.isEqualToWhenPresent;
28
29 import java.util.Arrays;
30 import java.util.Collection;
31 import java.util.Date;
32 import java.util.List;
33 import java.util.Optional;
34 import java.util.function.UnaryOperator;
35
36 import org.apache.ibatis.annotations.Arg;
37 import org.apache.ibatis.annotations.Mapper;
38 import org.apache.ibatis.annotations.SelectProvider;
39 import org.apache.ibatis.type.JdbcType;
40 import org.mybatis.dynamic.sql.BasicColumn;
41 import org.mybatis.dynamic.sql.dsl.CountDSLCompleter;
42 import org.mybatis.dynamic.sql.dsl.DeleteDSLCompleter;
43 import org.mybatis.dynamic.sql.dsl.SelectDSLCompleter;
44 import org.mybatis.dynamic.sql.dsl.UpdateDSL;
45 import org.mybatis.dynamic.sql.dsl.UpdateDSLCompleter;
46 import org.mybatis.dynamic.sql.insert.GeneralInsertDSL;
47 import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
48 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
49 import org.mybatis.dynamic.sql.util.mybatis3.CommonCountMapper;
50 import org.mybatis.dynamic.sql.util.mybatis3.CommonDeleteMapper;
51 import org.mybatis.dynamic.sql.util.mybatis3.CommonInsertMapper;
52 import org.mybatis.dynamic.sql.util.mybatis3.CommonUpdateMapper;
53 import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils;
54
55
56
57
58
59
60
61 @Mapper
62 public interface PersonMapperV2 extends CommonCountMapper, CommonDeleteMapper, CommonInsertMapper<PersonRecord>, CommonUpdateMapper {
63
64 @SelectProvider(type=SqlProviderAdapter.class, method="select")
65 @Arg(column="A_ID", jdbcType=JdbcType.INTEGER, id=true, javaType = Integer.class)
66 @Arg(column="first_name", jdbcType=JdbcType.VARCHAR, javaType = String.class)
67 @Arg(column="last_name", jdbcType=JdbcType.VARCHAR, typeHandler=LastNameTypeHandler.class, javaType = LastName.class)
68 @Arg(column="birth_date", jdbcType=JdbcType.DATE, javaType = Date.class)
69 @Arg(column="employed", jdbcType=JdbcType.VARCHAR, typeHandler=YesNoTypeHandler.class, javaType = Boolean.class)
70 @Arg(column="occupation", jdbcType=JdbcType.VARCHAR, javaType = String.class)
71 @Arg(column="address_id", jdbcType=JdbcType.INTEGER, javaType = Integer.class)
72 List<PersonRecord> selectMany(SelectStatementProvider selectStatement);
73
74 @SelectProvider(type=SqlProviderAdapter.class, method="select")
75 @Arg(column="A_ID", jdbcType=JdbcType.INTEGER, id=true, javaType = Integer.class)
76 @Arg(column="first_name", jdbcType=JdbcType.VARCHAR, javaType = String.class)
77 @Arg(column="last_name", jdbcType=JdbcType.VARCHAR, typeHandler=LastNameTypeHandler.class, javaType = LastName.class)
78 @Arg(column="birth_date", jdbcType=JdbcType.DATE, javaType = Date.class)
79 @Arg(column="employed", jdbcType=JdbcType.VARCHAR, typeHandler=YesNoTypeHandler.class, javaType = Boolean.class)
80 @Arg(column="occupation", jdbcType=JdbcType.VARCHAR, javaType = String.class)
81 @Arg(column="address_id", jdbcType=JdbcType.INTEGER, javaType = Integer.class)
82 Optional<PersonRecord> selectOne(SelectStatementProvider selectStatement);
83
84 BasicColumn[] selectList =
85 BasicColumn.columnList(id.as("A_ID"), firstName, lastName, birthDate, employed, occupation, addressId);
86
87 default long count(CountDSLCompleter completer) {
88 return MyBatis3Utils.countFrom(this::count, person, completer);
89 }
90
91 default long count(BasicColumn column, CountDSLCompleter completer) {
92 return MyBatis3Utils.count(this::count, column, person, completer);
93 }
94
95 default long countDistinct(BasicColumn column, CountDSLCompleter completer) {
96 return MyBatis3Utils.countDistinct(this::count, column, person, completer);
97 }
98
99 default int delete(DeleteDSLCompleter completer) {
100 return MyBatis3Utils.deleteFrom(this::delete, person, completer);
101 }
102
103 default int deleteByPrimaryKey(Integer recordId) {
104 return delete(c ->
105 c.where(id, isEqualTo(recordId))
106 );
107 }
108
109 default int generalInsert(UnaryOperator<GeneralInsertDSL> completer) {
110 return MyBatis3Utils.generalInsert(this::generalInsert, person, completer);
111 }
112
113 default int insert(PersonRecord row) {
114 return MyBatis3Utils.insert(this::insert, row, person, c ->
115 c.withMappedColumn(id)
116 .withMappedColumn(firstName)
117 .withMappedColumn(lastName)
118 .withMappedColumn(birthDate)
119 .withMappedColumn(employed)
120 .withMappedColumn(occupation)
121 .withMappedColumn(addressId)
122 );
123 }
124
125 default int insertMultiple(PersonRecord...records) {
126 return insertMultiple(Arrays.asList(records));
127 }
128
129 default int insertMultiple(Collection<PersonRecord> records) {
130 return MyBatis3Utils.insertMultiple(this::insertMultiple, records, person, c ->
131 c.withMappedColumn(id)
132 .withMappedColumn(firstName)
133 .withMappedColumn(lastName)
134 .withMappedColumn(birthDate)
135 .withMappedColumn(employed)
136 .withMappedColumn(occupation)
137 .withMappedColumn(addressId)
138 );
139 }
140
141 default int insertSelective(PersonRecord row) {
142 return MyBatis3Utils.insert(this::insert, row, person, c ->
143 c.withMappedColumnWhenPresent(id, row::id)
144 .withMappedColumnWhenPresent(firstName, row::firstName)
145 .withMappedColumnWhenPresent(lastName, row::lastName)
146 .withMappedColumnWhenPresent(birthDate, row::birthDate)
147 .withMappedColumnWhenPresent(employed, row::employed)
148 .withMappedColumnWhenPresent(occupation, row::occupation)
149 .withMappedColumnWhenPresent(addressId, row::addressId)
150 );
151 }
152
153 default Optional<PersonRecord> selectOne(SelectDSLCompleter completer) {
154 return MyBatis3Utils.selectOne(this::selectOne, selectList, person, completer);
155 }
156
157 default List<PersonRecord> select(SelectDSLCompleter completer) {
158 return MyBatis3Utils.selectList(this::selectMany, selectList, person, completer);
159 }
160
161 default List<PersonRecord> selectDistinct(SelectDSLCompleter completer) {
162 return MyBatis3Utils.selectDistinct(this::selectMany, selectList, person, completer);
163 }
164
165 default Optional<PersonRecord> selectByPrimaryKey(Integer recordId) {
166 return selectOne(c ->
167 c.where(id, isEqualTo(recordId))
168 );
169 }
170
171 default int update(UpdateDSLCompleter completer) {
172 return MyBatis3Utils.update(this::update, person, completer);
173 }
174
175 static UpdateDSL updateAllColumns(PersonRecord row, UpdateDSL dsl) {
176 return dsl.set(id).equalToOrNull(row::id)
177 .set(firstName).equalToOrNull(row::firstName)
178 .set(lastName).equalToOrNull(row::lastName)
179 .set(birthDate).equalToOrNull(row::birthDate)
180 .set(employed).equalToOrNull(row::employed)
181 .set(occupation).equalToOrNull(row::occupation)
182 .set(addressId).equalToOrNull(row::addressId);
183 }
184
185 static UpdateDSL updateSelectiveColumns(PersonRecord row, UpdateDSL dsl) {
186 return dsl.set(id).equalToWhenPresent(row::id)
187 .set(firstName).equalToWhenPresent(row::firstName)
188 .set(lastName).equalToWhenPresent(row::lastName)
189 .set(birthDate).equalToWhenPresent(row::birthDate)
190 .set(employed).equalToWhenPresent(row::employed)
191 .set(occupation).equalToWhenPresent(row::occupation)
192 .set(addressId).equalToWhenPresent(row::addressId);
193 }
194
195 default int updateByPrimaryKey(PersonRecord row) {
196 return update(c ->
197 c.set(firstName).equalToOrNull(row::firstName)
198 .set(lastName).equalToOrNull(row::lastName)
199 .set(birthDate).equalToOrNull(row::birthDate)
200 .set(employed).equalToOrNull(row::employed)
201 .set(occupation).equalToOrNull(row::occupation)
202 .set(addressId).equalToOrNull(row::addressId)
203 .where(id, isEqualToWhenPresent(row::id))
204 );
205 }
206
207 default int updateByPrimaryKeySelective(PersonRecord row) {
208 return update(c ->
209 c.set(firstName).equalToWhenPresent(row::firstName)
210 .set(lastName).equalToWhenPresent(row::lastName)
211 .set(birthDate).equalToWhenPresent(row::birthDate)
212 .set(employed).equalToWhenPresent(row::employed)
213 .set(occupation).equalToWhenPresent(row::occupation)
214 .set(addressId).equalToWhenPresent(row::addressId)
215 .where(id, isEqualToWhenPresent(row::id))
216 );
217 }
218 }