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 }