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