|
1
3 package jodd.db.orm;
4
5 import jodd.db.DbQuery;
6 import jodd.db.DbQueryMode;
7 import jodd.db.DbSession;
8 import jodd.db.orm.sqlgen.DbSqlGenerator;
9 import jodd.db.orm.mapper.DefaultResultSetMapper;
10 import jodd.db.orm.mapper.ResultSetMapper;
11
12 import java.sql.Connection  ;
13 import java.util.*;
14
15
28 public class DbOrmQuery extends DbQuery {
29
30 protected DbOrm orm;
31
32
34 public DbOrmQuery(Connection conn, String sqlString) {
35 super(conn, sqlString);
36 }
37
38 public DbOrmQuery(Connection conn, String sqlString, DbQueryMode mode) {
39 super(conn, sqlString, mode);
40 }
41
42 public DbOrmQuery(DbSession session, String sqlString, DbQueryMode mode) {
43 super(session, sqlString, mode);
44 }
45
46 public DbOrmQuery(DbSession session, String sqlString) {
47 super(session, sqlString);
48 }
49
50 public DbOrmQuery(String sqlString, DbQueryMode mode) {
51 super(sqlString, mode);
52 }
53
54 public DbOrmQuery(String sqlString) {
55 super(sqlString);
56 }
57
58 protected void init(Connection conn, String sqlString, DbQueryMode mode) {
59 this.orm = DbOrm.getInstance();
60 super.init(conn, sqlString, mode);
61 }
62
63
65 protected DbSqlGenerator sqlgen;
66
67 public DbOrmQuery(Connection conn, DbSqlGenerator sqlgen) {
68 super(conn, null);
69 this.sqlgen = sqlgen;
70 init();
71 }
72
73 public DbOrmQuery(Connection conn, DbSqlGenerator sqlgen, DbQueryMode mode) {
74 super(conn, null, mode);
75 this.sqlgen = sqlgen;
76 init();
77 }
78
79 public DbOrmQuery(DbSession session, DbSqlGenerator sqlgen, DbQueryMode mode) {
80 super(session, null, mode);
81 this.sqlgen = sqlgen;
82 init();
83 }
84
85 public DbOrmQuery(DbSession session, DbSqlGenerator sqlgen) {
86 super(session, null);
87 this.sqlgen = sqlgen;
88 init();
89 }
90
91 public DbOrmQuery(DbSqlGenerator sqlgen, DbQueryMode mode) {
92 super(null, mode);
93 this.sqlgen = sqlgen;
94 init();
95 }
96
97 public DbOrmQuery(DbSqlGenerator sqlgen) {
98 super(null);
99 this.sqlgen = sqlgen;
100 init();
101 }
102
103
106 protected void init() {
107 super.init(sqlgen.generateQuery());
108 setParameters(sqlgen.getQueryParameters());
109 }
110
111
113
116 public ResultSetMapper buildResultSetMapper() {
117 if (sqlgen != null) {
118 return new DefaultResultSetMapper(execute(), sqlgen.getColumnData(), orm);
119 }
120 return new DefaultResultSetMapper(execute(), orm);
121 }
122
123
124
126 public Iterator iterateOne(Class type) {
127 return iterateOne(type, false);
128 }
129 public Iterator iterateOneAndClose(Class type) {
130 return iterateOne(type, true);
131 }
132 public Iterator iterateOne() {
133 return iterateOne(null, false);
134 }
135 public Iterator iterateOneAndClose() {
136 return iterateOne(null, true);
137 }
138 protected Iterator iterateOne(Class type, boolean close) {
139 if (type != null) {
140 return new DbListIterator(this, type, close);
141 }
142 return new DbListIterator(this, close, true);
143 }
144
145 public Iterator iterate(Class ... types) {
146 return iterate(types, false);
147 }
148 public Iterator iterateAndClose(Class ... types) {
149 return iterate(types, true);
150 }
151 public Iterator iterate() {
152 return iterate(null, false);
153 }
154 public Iterator iterateAndClose() {
155 return iterate(null, true);
156 }
157 protected Iterator iterate(Class [] types, boolean close) {
158 if (types != null) {
159 return new DbListIterator(this, types, close);
160 }
161 return new DbListIterator(this, close);
162 }
163
164
166 public <T> List<T> listOne(Class <T> type) {
167 return listOne(type, false);
168 }
169 public <T> List<T> listOneAndClose(Class <T> type) {
170 return listOne(type, true);
171 }
172 @SuppressWarnings ({"unchecked"})
173 protected <T> List<T> listOne(Class <T> type, boolean close) {
174 List<T> result = new ArrayList<T>();
175 ResultSetMapper rsm = buildResultSetMapper();
176 Class [] types = new Class []{type};
177 while (rsm.next()) {
178 result.add((T) rsm.parseOneObject(types));
179 }
180 close(rsm, close);
181 return result;
182 }
183 public List<Object > listOne() {
184 return listOne(null, false);
185 }
186 public List<Object > listOneAndClose() {
187 return listOne(null, true);
188 }
189 protected List<Object > listOne(boolean close) {
190 List<Object > result = new ArrayList<Object >();
191 ResultSetMapper rsm = buildResultSetMapper();
192 while (rsm.next()) {
193 result.add(rsm.parseOneObject());
194 }
195 close(rsm, close);
196 return result;
197 }
198
199 public List<Object []> list(Class ... types) {
200 return list(types, false);
201 }
202 public List<Object []> listAndClose(Class ... types) {
203 return list(types, true);
204 }
205 public List<Object []> list() {
206 return list(null, false);
207 }
208 public List<Object []> listAndClose() {
209 return list(null, true);
210 }
211 protected List<Object []> list(Class [] types, boolean close) {
212 List<Object []> result = new ArrayList<Object []>();
213 ResultSetMapper rsm = buildResultSetMapper();
214 if (types != null) {
215 while (rsm.next()) {
216 result.add(rsm.parseObjects(types));
217 }
218 } else {
219 while (rsm.next()) {
220 result.add(rsm.parseObjects());
221 }
222 }
223 close(rsm, close);
224 return result;
225 }
226
227
228
229
231 public <T> Set<T> listSetOne(Class <T> type) {
232 return listSetOne(type, false);
233 }
234 public <T> Set<T> listSetOneAndClose(Class <T> type) {
235 return listSetOne(type, true);
236 }
237 @SuppressWarnings ({"unchecked"})
238 protected <T> Set<T> listSetOne(Class <T> type, boolean close) {
239 Set<T> result = new LinkedHashSet<T>();
240 ResultSetMapper rsm = buildResultSetMapper();
241 Class [] types = new Class []{type};
242 while (rsm.next()) {
243 result.add((T) rsm.parseOneObject(types));
244 }
245 close(rsm, close);
246 return result;
247 }
248
249
250 public Set<Object > listSetOne() {
251 return listSetOne(false);
252 }
253 public Set<Object > listSetOneAndClose() {
254 return listSetOne(true);
255 }
256 protected Set<Object > listSetOne(boolean close) {
257 Set<Object > result = new LinkedHashSet<Object >();
258 ResultSetMapper rsm = buildResultSetMapper();
259 while (rsm.next()) {
260 result.add(rsm.parseOneObject());
261 }
262 close(rsm, close);
263 return result;
264 }
265
266
267 public Set<Object []> listSet(Class ... types) {
268 return listSet(types, false);
269 }
270 public Set<Object []> listSetAndClose(Class ... types) {
271 return listSet(types, true);
272 }
273 public Set<Object []> listSet() {
274 return listSet(null, false);
275 }
276 public Set<Object []> listSetAndClose() {
277 return listSet(null, false);
278 }
279
280 protected Set<Object []> listSet(Class [] types, boolean close) {
281 Set<Object []> result = new LinkedHashSet<Object []>();
282 ResultSetMapper rsm = buildResultSetMapper();
283 if (types != null) {
284 while (rsm.next()) {
285 result.add(rsm.parseObjects(types));
286 }
287 } else {
288 while (rsm.next()) {
289 result.add(rsm.parseObjects());
290 }
291 }
292 close(rsm, close);
293 return result;
294 }
295
296
297
299
300 @SuppressWarnings ({"unchecked"})
301 public <T> T findOne(Class <T> type) {
302 return findOne(type, false);
303 }
304 public <T> T findOneAndClose(Class <T> type) {
305 return findOne(type, true);
306 }
307 @SuppressWarnings ({"unchecked"})
308 protected <T> T findOne(Class <T> type, boolean close) {
309 setFetchSize(1);
310 ResultSetMapper rsm = buildResultSetMapper();
311 if (rsm.next() == false) {
312 return null;
313 }
314 Class [] types = new Class []{type};
315 Object result = rsm.parseOneObject(types);
316 close(rsm, close);
317 return (T) result;
318 }
319
320 public Object findOne() {
321 return findOne(false);
322 }
323 public Object findOneAndClose() {
324 return findOne(true);
325 }
326 protected Object findOne(boolean close) {
327 setFetchSize(1);
328 ResultSetMapper rsm = buildResultSetMapper();
329 if (rsm.next() == false) {
330 return null;
331 }
332 Object result = rsm.parseOneObject();
333 close(rsm, close);
334 return result;
335 }
336
337
338
339 public Object [] find(Class ... types) {
340 return find(types, false);
341 }
342 public Object [] findAndClose(Class ... types) {
343 return find(types, true);
344 }
345
346 public Object [] find() {
347 return find(null, false);
348 }
349
350 public Object [] findAndClose() {
351 return find(null, true);
352 }
353
354 protected Object [] find(Class [] types, boolean close) {
355 setFetchSize(1);
356 ResultSetMapper rsm = buildResultSetMapper();
357 if (rsm.next() == false) {
358 return null;
359 }
360 Object [] result;
361 if (types != null) {
362 result = rsm.parseObjects(types);
363 } else {
364 result = rsm.parseObjects();
365 }
366 close(rsm, close);
367 return result;
368 }
369
370
371
373
376 protected void close(ResultSetMapper rsm, boolean closeQuery) {
377 if (closeQuery == true) {
378 close();
379 } else {
380 close(rsm.getResultSet());
381 }
382 }
383
384
385 }
|
Popular Tags
|
Java API By Example, From Geeks To Geeks.