View Javadoc
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 Mar 05 12:40:05 CET 2018]
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 = 1520250005060L;
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 }