1 package org.apache.turbine.services.schedule;
2
3 import java.sql.Blob;
4 import java.sql.Clob;
5 import java.sql.Connection;
6 import java.sql.SQLException;
7 import java.sql.ResultSet;
8 import java.sql.PreparedStatement;
9 import java.sql.Types;
10 import java.io.IOException;
11 import java.io.InputStream;
12 import java.io.ByteArrayInputStream;
13 import java.io.ByteArrayOutputStream;
14 import java.io.Reader;
15 import java.io.StringReader;
16 import java.io.StringWriter;
17 import java.util.ArrayList;
18 import java.util.Collection;
19 import java.util.Date;
20 import java.util.Iterator;
21 import java.util.LinkedList;
22 import java.util.List;
23 import java.util.Map;
24 import java.util.HashMap;
25 import java.util.Set;
26 import java.util.HashSet;
27
28 import org.apache.commons.lang.ObjectUtils;
29 import org.apache.commons.logging.Log;
30 import org.apache.commons.logging.LogFactory;
31 import org.apache.torque.NoRowsException;
32 import org.apache.torque.OptimisticLockingFailedException;
33 import org.apache.torque.TooManyRowsException;
34 import org.apache.torque.Torque;
35 import org.apache.torque.TorqueException;
36 import org.apache.torque.TorqueRuntimeException;
37 import org.apache.torque.criteria.Criteria;
38 import org.apache.torque.criteria.Criterion;
39 import org.apache.torque.om.mapper.RecordMapper;
40 import org.apache.torque.om.mapper.CompositeMapper;
41 import org.apache.torque.om.DateKey;
42 import org.apache.torque.om.NumberKey;
43 import org.apache.torque.om.StringKey;
44 import org.apache.torque.om.ObjectKey;
45 import org.apache.torque.om.SimpleKey;
46 import org.apache.torque.om.ComboKey;
47 import org.apache.torque.map.TableMap;
48 import org.apache.torque.util.Transaction;
49 import org.apache.torque.util.ColumnValues;
50 import org.apache.torque.util.JdbcTypedValue;
51
52
53
54 /**
55 * The skeleton for this class was autogenerated by Torque on:
56 *
57 * [Mon Dec 21 20:40:21 CET 2015]
58 *
59 * You should not use this class directly. It should not even be
60 * extended; all references should be to JobEntryTorquePeer
61 */
62
63 public abstract class BaseJobEntryTorquePeerImpl
64 extends org.apache.torque.util.BasePeerImpl<JobEntryTorque>
65 {
66 /** The class log. */
67 private static Log log = LogFactory.getLog(BaseJobEntryTorquePeerImpl.class);
68
69 /** Serial version */
70 private static final long serialVersionUID = 1450726821151L;
71
72
73
74 /**
75 * Constructor.
76 * The recordMapper, tableMap and databaseName fields are correctly
77 * initialized.
78 */
79 public BaseJobEntryTorquePeerImpl()
80 {
81 this(new JobEntryTorqueRecordMapper(),
82 JobEntryTorquePeer.TABLE,
83 JobEntryTorquePeer.DATABASE_NAME);
84 }
85
86 /**
87 * Constructor providing the objects to be injected as parameters.
88 *
89 * @param recordMapper a record mapper to map JDBC result sets to objects
90 * @param tableMap the default table map
91 * @param databaseName the name of the database
92 */
93 public BaseJobEntryTorquePeerImpl(
94 RecordMapper<JobEntryTorque> recordMapper,
95 TableMap tableMap,
96 String databaseName)
97 {
98 super(recordMapper, tableMap, databaseName);
99 }
100
101
102 /**
103 * Selects JobEntryTorque objects from the database which have
104 * the same content as the passed object.
105 *
106 * @return The list of selected objects, not null.
107 *
108 * @throws TorqueException Any exceptions caught during processing will be
109 * rethrown wrapped into a TorqueException.
110 */
111 public List<JobEntryTorque> doSelect(JobEntryTorque obj)
112 throws TorqueException
113 {
114 return doSelect(buildSelectCriteria(obj));
115 }
116
117 /**
118 * Selects at most one JobEntryTorque object from the database
119 * which has the same content as the passed object.
120 *
121 * @return the selected Object, or null if no object was selected.
122 *
123 * @throws TorqueException Any exceptions caught during processing will be
124 * rethrown wrapped into a TorqueException.
125 */
126 public JobEntryTorque doSelectSingleRecord(
127 JobEntryTorque obj)
128 throws TorqueException
129 {
130 List<JobEntryTorque> jobEntryTorqueList = doSelect(obj);
131 JobEntryTorque jobEntryTorque = null;
132 if (jobEntryTorqueList.size() > 1)
133 {
134 throw new TooManyRowsException("Object " + obj
135 + " matched more than one record");
136 }
137 if (!jobEntryTorqueList.isEmpty())
138 {
139 jobEntryTorque = jobEntryTorqueList.get(0);
140 }
141 return jobEntryTorque;
142 }
143
144 /**
145 * Returns a new instance of the Data object class
146 */
147 public JobEntryTorque getDbObjectInstance()
148 {
149 return new JobEntryTorque();
150 }
151
152
153 /**
154 * Method to do inserts.
155 *
156 * @param columnValues the values to insert.
157 *
158 * @return the primary key of the inserted row.
159 *
160 * @throws TorqueException Any exceptions caught during processing will be
161 * rethrown wrapped into a TorqueException.
162 */
163 public ObjectKey doInsert(ColumnValues columnValues) throws TorqueException
164 {
165 Connection connection = null;
166 try
167 {
168 connection = Transaction.begin(
169 JobEntryTorquePeer.DATABASE_NAME);
170 ObjectKey result = doInsert(columnValues, connection);
171 Transaction.commit(connection);
172 connection = null;
173 return result;
174 }
175 finally
176 {
177 if (connection != null)
178 {
179 Transaction.safeRollback(connection);
180 }
181 }
182 }
183
184 /**
185 * Method to do inserts. This method is to be used during a transaction,
186 * otherwise use the doInsert(Criteria) method.
187 *
188 * @param columnValues the values to insert.
189 * @param con the connection to use, not null.
190 *
191 * @return the primary key of the inserted row.
192 *
193 * @throws TorqueException Any exceptions caught during processing will be
194 * rethrown wrapped into a TorqueException.
195 */
196 public ObjectKey doInsert(ColumnValues columnValues, Connection con)
197 throws TorqueException
198 {
199 correctBooleans(columnValues);
200 return super.doInsert(columnValues, con);
201 }
202
203 /**
204 * Method to do inserts
205 *
206 * @throws TorqueException Any exceptions caught during processing will be
207 * rethrown wrapped into a TorqueException.
208 */
209 public void doInsert(JobEntryTorque obj) throws TorqueException
210 {
211 obj.setPrimaryKey(doInsert(buildColumnValues(obj)));
212 obj.setNew(false);
213 obj.setModified(false);
214 }
215
216 /**
217 * Method to do inserts. This method is to be used during a transaction,
218 * otherwise use the doInsert(JobEntryTorque) method. It will take
219 * care of the connection details internally.
220 *
221 * @param obj the data object to insert into the database.
222 * @param con the connection to use
223 * @throws TorqueException Any exceptions caught during processing will be
224 * rethrown wrapped into a TorqueException.
225 */
226 public void doInsert(JobEntryTorque obj, Connection con)
227 throws TorqueException
228 {
229 ObjectKey primaryKey = doInsert(buildColumnValues(obj), con);
230 if (primaryKey != null)
231 {
232 obj.setPrimaryKey(primaryKey);
233 }
234 obj.setNew(false);
235 obj.setModified(false);
236 }
237
238 /**
239 * Method to do updates.
240 *
241 * @param columnValues the values to update plus the primary key
242 * identifying the row to update.
243 *
244 * @return the number of affected rows.
245 *
246 * @throws TorqueException Any exceptions caught during processing will be
247 * rethrown wrapped into a TorqueException.
248 */
249 public int doUpdate(ColumnValues columnValues) throws TorqueException
250 {
251 Connection connection = null;
252 try
253 {
254 connection = Transaction.begin(
255 JobEntryTorquePeer.DATABASE_NAME);
256 int result = doUpdate(columnValues, connection);
257 Transaction.commit(connection);
258 connection = null;
259 return result;
260 }
261 finally
262 {
263 if (connection != null)
264 {
265 Transaction.safeRollback(connection);
266 }
267 }
268 }
269
270 /**
271 * Method to do updates. This method is to be used during a transaction,
272 * otherwise use the doUpdate(Criteria) method.
273 *
274 * @param columnValues the values to update plus the primary key
275 * identifying the row to update.
276 * @param con the connection to use, not null.
277 *
278 * @return the number of affected rows.
279 *
280 * @throws TorqueException Any exceptions caught during processing will be
281 * rethrown wrapped into a TorqueException.
282 */
283 public int doUpdate(ColumnValues columnValues, Connection con)
284 throws TorqueException
285 {
286 Criteria selectCriteria
287 = new Criteria(JobEntryTorquePeer.DATABASE_NAME);
288 correctBooleans(columnValues);
289
290 selectCriteria.where(
291 JobEntryTorquePeer.JOB_ID,
292 columnValues.remove(JobEntryTorquePeer.JOB_ID).getValue());
293
294
295 int rowCount = doUpdate(selectCriteria, columnValues, con);
296 return rowCount;
297 }
298
299 /**
300 * Updates an JobEntryTorque in the database.
301 * The primary key is used to identify the object to update.
302 *
303 * @param obj the data object to update in the database.
304 *
305 * @return the number of affected rows.
306 *
307 * @throws TorqueException Any exceptions caught during processing will be
308 * rethrown wrapped into a TorqueException.
309 */
310 public int doUpdate(JobEntryTorque obj) throws TorqueException
311 {
312 ColumnValues columnValues = buildColumnValues(obj);
313 int result = doUpdate(columnValues);
314 obj.setModified(false);
315 return result;
316 }
317
318 /**
319 * Updates a JobEntryTorque in the database.
320 * The primary key is used to identify the object to update.
321 * This method is to be used during a transaction,
322 * otherwise the doUpdate(JobEntryTorque) method can be used.
323 *
324 * @param obj the data object to update in the database.
325 * @param con the connection to use, not null.
326
327 * @return the number of affected rows.
328 *
329 * @throws TorqueException Any exceptions caught during processing will be
330 * rethrown wrapped into a TorqueException.
331 */
332 public int doUpdate(JobEntryTorque obj, Connection con)
333 throws TorqueException
334 {
335 ColumnValues columnValues = buildColumnValues(obj);
336 int result = doUpdate(columnValues, con);
337 obj.setModified(false);
338 return result;
339 }
340
341 /**
342 * Deletes a data object, i.e. a row in a table, in the database.
343 *
344 * @param obj the data object to delete in the database, not null.
345 *
346 * @return the number of deleted rows.
347 *
348 * @throws TorqueException Any exceptions caught during processing will be
349 * rethrown wrapped into a TorqueException.
350 */
351 public int doDelete(JobEntryTorque obj) throws TorqueException
352 {
353 int result = doDelete(buildCriteria(obj.getPrimaryKey()));
354 obj.setDeleted(true);
355 return result;
356 }
357
358 /**
359 * Deletes a data object, i.e. a row in a table, in the database.
360 * This method is to be used during a transaction, otherwise use the
361 * doDelete(JobEntryTorque) method.
362 *
363 * @param obj the data object to delete in the database, not null.
364 * @param con the connection to use, not null.
365 *
366 * @return the number of deleted rows.
367 *
368 * @throws TorqueException Any exceptions caught during processing will be
369 * rethrown wrapped into a TorqueException.
370 */
371 public int doDelete(JobEntryTorque obj, Connection con)
372 throws TorqueException
373 {
374 int result = doDelete(buildCriteria(obj.getPrimaryKey()), con);
375 obj.setDeleted(true);
376 return result;
377 }
378
379 /**
380 * Deletes data objects, i.e. rows in a table, in the database.
381 *
382 * @param objects the data object to delete in the database, not null,
383 * may not contain null.
384 *
385 * @return the number of deleted rows.
386 *
387 * @throws TorqueException Any exceptions caught during processing will be
388 * rethrown wrapped into a TorqueException.
389 */
390 public int doDelete(Collection<JobEntryTorque> objects)
391 throws TorqueException
392 {
393 int result = doDelete(buildPkCriteria(objects));
394 for (JobEntryTorque object : objects)
395 {
396 object.setDeleted(true);
397 }
398 return result;
399 }
400
401 /**
402 * Deletes data objects, i.e. rows in a table, in the database.
403 * This method uses the passed connection to delete the rows;
404 * if a transaction is open in the connection, the deletion happens inside
405 * this transaction.
406 *
407 * @param objects the data objects to delete in the database, not null,
408 * may not contain null.
409 * @param con the connection to use for deleting, not null.
410 *
411 * @return the number of deleted rows.
412 *
413 * @throws TorqueException Any exceptions caught during processing will be
414 * rethrown wrapped into a TorqueException.
415 */
416 public int doDelete(
417 Collection<JobEntryTorque> objects,
418 Connection con)
419 throws TorqueException
420 {
421 int result = doDelete(buildPkCriteria(objects), con);
422 for (JobEntryTorque object : objects)
423 {
424 object.setDeleted(true);
425 }
426 return result;
427 }
428
429 /**
430 * Deletes a row in the database.
431 *
432 * @param pk the ObjectKey that identifies the row to delete.
433 *
434 * @return the number of deleted rows.
435 *
436 * @throws TorqueException Any exceptions caught during processing will be
437 * rethrown wrapped into a TorqueException.
438 */
439 public int doDelete(ObjectKey pk) throws TorqueException
440 {
441 Connection connection = null;
442 try
443 {
444 connection = Transaction.begin(
445 JobEntryTorquePeer.DATABASE_NAME);
446 int deletedRows = doDelete(pk, connection);
447 Transaction.commit(connection);
448 connection = null;
449 return deletedRows;
450 }
451 finally
452 {
453 if (connection != null)
454 {
455 Transaction.safeRollback(connection);
456 }
457 }
458 }
459
460 /**
461 * Deletes a row in the database.
462 * This method is to be used during a transaction,
463 * otherwise use the doDelete(ObjectKey) method.
464 *
465 * @param pk the ObjectKey that identifies the row to delete.
466 * @param con the connection to use for deleting, not null.
467 *
468 * @return the number of deleted rows.
469 *
470 * @throws TorqueException Any exceptions caught during processing will be
471 * rethrown wrapped into a TorqueException.
472 */
473 public int doDelete(ObjectKey pk, Connection con)
474 throws TorqueException
475 {
476 return doDelete(buildCriteria(pk), con);
477 }
478
479 /**
480 * Build a Criteria object which selects all objects which have a given
481 * primary key.
482 *
483 * @param pk the primary key value to build the criteria from, not null.
484 */
485 public Criteria buildCriteria(ObjectKey pk)
486 {
487 Criteria criteria = new Criteria();
488 criteria.and(JobEntryTorquePeer.JOB_ID, pk);
489 return criteria;
490 }
491
492 /**
493 * Build a Criteria object which selects all objects which primary keys
494 * are contained in the passed collection.
495 *
496 * @param pks the primary key values to build the criteria from, not null,
497 * may not contain null.
498 */
499 public Criteria buildCriteria(Collection<ObjectKey> pks)
500 {
501 Criteria criteria = new Criteria();
502 criteria.andIn(JobEntryTorquePeer.JOB_ID, pks);
503 return criteria;
504 }
505
506
507 /**
508 * Build a Criteria object which selects all passed objects using their
509 * primary key. Objects which do not yet have a primary key are ignored.
510 *
511 * @param objects the objects to build the criteria from, not null,
512 * may not contain null.
513 */
514 public Criteria buildPkCriteria(
515 Collection<JobEntryTorque> objects)
516 {
517 List<ObjectKey> pks = new ArrayList<ObjectKey>(objects.size());
518 for (JobEntryTorque object : objects)
519 {
520 ObjectKey pk = object.getPrimaryKey();
521 if (pk != null)
522 {
523 pks.add(pk);
524 }
525 }
526 return buildCriteria(pks);
527 }
528
529 /**
530 * Build a Criteria object from the data object for this peer.
531 * The primary key columns are only added if the object is not new.
532 *
533 * @param obj the object to build the criteria from, not null.
534 */
535 public Criteria buildCriteria(JobEntryTorque obj)
536 {
537 Criteria criteria = new Criteria(JobEntryTorquePeer.DATABASE_NAME);
538 if (!obj.isNew())
539 {
540 criteria.and(JobEntryTorquePeer.JOB_ID, obj.getJobId());
541 }
542 criteria.and(JobEntryTorquePeer.SECOND, obj.getSecond());
543 criteria.and(JobEntryTorquePeer.MINUTE, obj.getMinute());
544 criteria.and(JobEntryTorquePeer.HOUR, obj.getHour());
545 criteria.and(JobEntryTorquePeer.WEEK_DAY, obj.getWeekDay());
546 criteria.and(JobEntryTorquePeer.DAY_OF_MONTH, obj.getDayOfMonth());
547 criteria.and(JobEntryTorquePeer.TASK, obj.getTask());
548 criteria.and(JobEntryTorquePeer.EMAIL, obj.getEmail());
549 criteria.and(JobEntryTorquePeer.PROPERTY, obj.getProperty());
550 return criteria;
551 }
552
553 /**
554 * Build a Criteria object from the data object for this peer,
555 * skipping all binary columns.
556 *
557 * @param obj the object to build the criteria from, not null.
558 */
559 public Criteria buildSelectCriteria(JobEntryTorque obj)
560 {
561 Criteria criteria = new Criteria(JobEntryTorquePeer.DATABASE_NAME);
562 if (!obj.isNew())
563 {
564 criteria.and(JobEntryTorquePeer.JOB_ID, obj.getJobId());
565 }
566 criteria.and(JobEntryTorquePeer.SECOND, obj.getSecond());
567 criteria.and(JobEntryTorquePeer.MINUTE, obj.getMinute());
568 criteria.and(JobEntryTorquePeer.HOUR, obj.getHour());
569 criteria.and(JobEntryTorquePeer.WEEK_DAY, obj.getWeekDay());
570 criteria.and(JobEntryTorquePeer.DAY_OF_MONTH, obj.getDayOfMonth());
571 criteria.and(JobEntryTorquePeer.TASK, obj.getTask());
572 criteria.and(JobEntryTorquePeer.EMAIL, obj.getEmail());
573 return criteria;
574 }
575
576 /**
577 * Returns the contents of the object as ColumnValues object.
578 * Primary key columns which are generated on insertion are not
579 * added to the returned object if they still have their initial
580 * value. Also, columns which have the useDatabaseDefaultValue
581 * flag set to true are also not added to the returned object
582 * if they still have their initial value.
583 *
584 * @throws TorqueException if the table map cannot be retrieved
585 * (should not happen).
586 */
587 public ColumnValues buildColumnValues(JobEntryTorque jobEntryTorque)
588 throws TorqueException
589 {
590 ColumnValues columnValues = new ColumnValues();
591 if (!jobEntryTorque.isNew()
592 || jobEntryTorque.getJobId() != 0)
593 {
594 columnValues.put(
595 JobEntryTorquePeer.JOB_ID,
596 new JdbcTypedValue(
597 jobEntryTorque.getJobId(),
598 4));
599 }
600 columnValues.put(
601 JobEntryTorquePeer.SECOND,
602 new JdbcTypedValue(
603 jobEntryTorque.getSecond(),
604 4));
605 columnValues.put(
606 JobEntryTorquePeer.MINUTE,
607 new JdbcTypedValue(
608 jobEntryTorque.getMinute(),
609 4));
610 columnValues.put(
611 JobEntryTorquePeer.HOUR,
612 new JdbcTypedValue(
613 jobEntryTorque.getHour(),
614 4));
615 columnValues.put(
616 JobEntryTorquePeer.WEEK_DAY,
617 new JdbcTypedValue(
618 jobEntryTorque.getWeekDay(),
619 4));
620 columnValues.put(
621 JobEntryTorquePeer.DAY_OF_MONTH,
622 new JdbcTypedValue(
623 jobEntryTorque.getDayOfMonth(),
624 4));
625 columnValues.put(
626 JobEntryTorquePeer.TASK,
627 new JdbcTypedValue(
628 jobEntryTorque.getTask(),
629 12));
630 columnValues.put(
631 JobEntryTorquePeer.EMAIL,
632 new JdbcTypedValue(
633 jobEntryTorque.getEmail(),
634 12));
635 columnValues.put(
636 JobEntryTorquePeer.PROPERTY,
637 new JdbcTypedValue(
638 jobEntryTorque.getProperty(),
639 -3));
640 return columnValues;
641 }
642
643 /**
644 * Retrieve a single object by pk
645 *
646 * @param pk the primary key
647 * @throws TorqueException Any exceptions caught during processing will be
648 * rethrown wrapped into a TorqueException.
649 * @throws NoRowsException Primary key was not found in database.
650 * @throws TooManyRowsException Primary key was not found in database.
651 */
652 public JobEntryTorque retrieveByPK(int pk)
653 throws TorqueException, NoRowsException, TooManyRowsException
654 {
655 return retrieveByPK(SimpleKey.keyFor(pk));
656 }
657
658 /**
659 * Retrieve a single object by pk
660 *
661 * @param pk the primary key
662 * @param con the connection to use
663 * @throws TorqueException Any exceptions caught during processing will be
664 * rethrown wrapped into a TorqueException.
665 * @throws NoRowsException Primary key was not found in database.
666 * @throws TooManyRowsException Primary key was not found in database.
667 */
668 public JobEntryTorque retrieveByPK(int pk, Connection con)
669 throws TorqueException, NoRowsException, TooManyRowsException
670 {
671 return retrieveByPK(SimpleKey.keyFor(pk), con);
672 }
673
674
675
676
677 /**
678 * Retrieve a single object by pk
679 *
680 * @param pk the primary key
681 * @throws TorqueException Any exceptions caught during processing will be
682 * rethrown wrapped into a TorqueException.
683 * @throws NoRowsException Primary key was not found in database.
684 * @throws TooManyRowsException Primary key was not found in database.
685 */
686 public JobEntryTorque retrieveByPK(ObjectKey pk)
687 throws TorqueException, NoRowsException, TooManyRowsException
688 {
689 Connection connection = null;
690 try
691 {
692 connection = Transaction.begin(JobEntryTorquePeer.DATABASE_NAME);
693 JobEntryTorque result = retrieveByPK(pk, connection);
694 Transaction.commit(connection);
695 connection = null;
696 return result;
697 }
698 finally
699 {
700 if (connection != null)
701 {
702 Transaction.safeRollback(connection);
703 }
704 }
705 }
706
707 /**
708 * Retrieve a single object by pk
709 *
710 * @param pk the primary key
711 * @param con the connection to use
712 * @throws TorqueException Any exceptions caught during processing will be
713 * rethrown wrapped into a TorqueException.
714 * @throws NoRowsException Primary key was not found in database.
715 * @throws TooManyRowsException Primary key was not found in database.
716 */
717 public JobEntryTorque retrieveByPK(ObjectKey pk, Connection con)
718 throws TorqueException, NoRowsException, TooManyRowsException
719 {
720 Criteria criteria = buildCriteria(pk);
721 List<JobEntryTorque> v = doSelect(criteria, con);
722 if (v.size() == 0)
723 {
724 throw new NoRowsException("Failed to select a row.");
725 }
726 else if (v.size() > 1)
727 {
728 throw new TooManyRowsException("Failed to select only one row.");
729 }
730 else
731 {
732 return (JobEntryTorque)v.get(0);
733 }
734 }
735
736
737 /**
738 * Retrieve a multiple objects by pk
739 *
740 * @param pks List of primary keys
741 * @throws TorqueException Any exceptions caught during processing will be
742 * rethrown wrapped into a TorqueException.
743 */
744 public List<JobEntryTorque> retrieveByPKs(Collection<ObjectKey> pks)
745 throws TorqueException
746 {
747 Connection connection = null;
748 try
749 {
750 connection = Transaction.begin(JobEntryTorquePeer.DATABASE_NAME);
751 List<JobEntryTorque> result = retrieveByPKs(pks, connection);
752 Transaction.commit(connection);
753 connection = null;
754 return result;
755 }
756 finally
757 {
758 if (connection != null)
759 {
760 Transaction.safeRollback(connection);
761 }
762 }
763 }
764
765 /**
766 * Retrieve multiple objects by pk
767 *
768 * @param pks List of primary keys
769 * @param dbcon the connection to use
770 * @throws TorqueException Any exceptions caught during processing will be
771 * rethrown wrapped into a TorqueException.
772 */
773 public List<JobEntryTorque> retrieveByPKs(
774 Collection<ObjectKey> pks,
775 Connection dbcon)
776 throws TorqueException
777 {
778 if (pks == null || pks.size() == 0)
779 {
780 return new ArrayList<JobEntryTorque>();
781 }
782 Criteria criteria = buildCriteria(pks);
783 List<JobEntryTorque> result = doSelect(criteria, dbcon);
784 return result;
785 }
786
787
788
789
790
791
792 }