001package org.apache.turbine.services.schedule;
002
003import java.sql.Blob;
004import java.sql.Clob;
005import java.sql.Connection;
006import java.sql.SQLException;
007import java.sql.ResultSet;
008import java.sql.PreparedStatement;
009import java.sql.Types;
010import java.io.IOException;
011import java.io.InputStream;
012import java.io.ByteArrayInputStream;
013import java.io.ByteArrayOutputStream;
014import java.io.Reader;
015import java.io.StringReader;
016import java.io.StringWriter;
017import java.util.ArrayList;
018import java.util.Collection;
019import java.util.Date;
020import java.util.Iterator;
021import java.util.LinkedList;
022import java.util.List;
023import java.util.Map;
024import java.util.HashMap;
025import java.util.Set;
026import java.util.HashSet;
027
028import org.apache.commons.lang.ObjectUtils;
029import org.apache.commons.logging.Log;
030import org.apache.commons.logging.LogFactory;
031import org.apache.torque.NoRowsException;
032import org.apache.torque.OptimisticLockingFailedException;
033import org.apache.torque.TooManyRowsException;
034import org.apache.torque.Torque;
035import org.apache.torque.TorqueException;
036import org.apache.torque.TorqueRuntimeException;
037import org.apache.torque.criteria.Criteria;
038import org.apache.torque.criteria.Criterion;
039import org.apache.torque.om.mapper.RecordMapper;
040import org.apache.torque.om.mapper.CompositeMapper;
041import org.apache.torque.om.DateKey;
042import org.apache.torque.om.NumberKey;
043import org.apache.torque.om.StringKey;
044import org.apache.torque.om.ObjectKey;
045import org.apache.torque.om.SimpleKey;
046import org.apache.torque.om.ComboKey;
047import org.apache.torque.map.TableMap;
048import org.apache.torque.util.Transaction;
049import org.apache.torque.util.ColumnValues;
050import org.apache.torque.util.JdbcTypedValue;
051
052
053
054/**
055 * The skeleton for this class was autogenerated by Torque on:
056 *
057 * [Mon Dec 21 20:40:21 CET 2015]
058 *
059 * You should not use this class directly.  It should not even be
060 * extended; all references should be to JobEntryTorquePeer
061 */
062
063public abstract class BaseJobEntryTorquePeerImpl
064    extends org.apache.torque.util.BasePeerImpl<JobEntryTorque>
065{
066    /** The class log. */
067    private static Log log = LogFactory.getLog(BaseJobEntryTorquePeerImpl.class);
068
069    /** Serial version */
070    private static final long serialVersionUID = 1450726821151L;
071
072
073
074    /**
075     * Constructor.
076     * The recordMapper, tableMap and databaseName fields are correctly
077     * initialized.
078     */
079    public BaseJobEntryTorquePeerImpl()
080    {
081        this(new JobEntryTorqueRecordMapper(),
082            JobEntryTorquePeer.TABLE,
083            JobEntryTorquePeer.DATABASE_NAME);
084    }
085
086    /**
087     * Constructor providing the objects to be injected as parameters.
088     *
089     * @param recordMapper a record mapper to map JDBC result sets to objects
090     * @param tableMap the default table map
091     * @param databaseName the name of the database
092     */
093    public BaseJobEntryTorquePeerImpl(
094            RecordMapper<JobEntryTorque> recordMapper, 
095            TableMap tableMap,
096            String databaseName)
097    {
098        super(recordMapper, tableMap, databaseName);
099    }
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}