    001package org.apache.turbine.services.schedule;
    002
    003import java.sql.Connection;
    004import java.sql.SQLException;
    005import java.sql.ResultSet;
    006import java.io.IOException;
    007import java.io.InputStream;
    008import java.util.ArrayList;
    009import java.util.Collection;
    010import java.util.Date;
    011import java.util.Iterator;
    012import java.util.List;
    013
    014import org.apache.commons.logging.Log;
    015import org.apache.commons.logging.LogFactory;
    016import org.apache.torque.NoRowsException;
    017import org.apache.torque.TooManyRowsException;
    018import org.apache.torque.Column;
    019import org.apache.torque.Torque;
    020import org.apache.torque.TorqueException;
    021import org.apache.torque.TorqueRuntimeException;
    022import org.apache.torque.adapter.IDMethod;
    023import org.apache.torque.criteria.Criteria;
    024import org.apache.torque.map.DatabaseMap;
    025import org.apache.torque.map.TableMap;
    026import org.apache.torque.map.ColumnMap;
    027import org.apache.torque.map.ForeignKeyMap;
    028import org.apache.torque.map.InheritanceMap;
    029import org.apache.torque.om.mapper.RecordMapper;
    030import org.apache.torque.om.mapper.CompositeMapper;
    031import org.apache.torque.om.DateKey;
    032import org.apache.torque.om.NumberKey;
    033import org.apache.torque.om.StringKey;
    034import org.apache.torque.om.ObjectKey;
    035import org.apache.torque.om.SimpleKey;
    036import org.apache.torque.util.Transaction;
    037import org.apache.torque.util.ColumnValues;
    038import org.apache.torque.util.JdbcTypedValue;
    039
    040
    041
    042/**
    043 * The skeleton for this class was autogenerated by Torque on:
    044 *
    045 * [Mon Mar 05 12:40:05 CET 2018]
    046 *
    047 * You should not use this class directly.  It should not even be
    048 * extended; all references should be to JobEntryTorquePeer
    049 */
    050
    051public abstract class BaseJobEntryTorquePeer
    052{
    053    /** The class log. */
    054    private static Log log = LogFactory.getLog(BaseJobEntryTorquePeerImpl.class);
    055    /** The default database name for this class. */
    056    public static final String DATABASE_NAME;
    057
    058     /** The table name for this class. */
    059    public static final String TABLE_NAME;
    060
    061     /** The table map for this class. */
    062    public static final TableMap TABLE;
    063    /** The column for the JOB_ID field */
    064    public static final ColumnMap JOB_ID;
    065    /** The column for the SECOND field */
    066    public static final ColumnMap SECOND;
    067    /** The column for the MINUTE field */
    068    public static final ColumnMap MINUTE;
    069    /** The column for the HOUR field */
    070    public static final ColumnMap HOUR;
    071    /** The column for the WEEK_DAY field */
    072    public static final ColumnMap WEEK_DAY;
    073    /** The column for the DAY_OF_MONTH field */
    074    public static final ColumnMap DAY_OF_MONTH;
    075    /** The column for the TASK field */
    076    public static final ColumnMap TASK;
    077    /** The column for the EMAIL field */
    078    public static final ColumnMap EMAIL;
    079    /** The column for the PROPERTY field */
    080    public static final ColumnMap PROPERTY;
    081
    082    /** number of columns for this peer */
    083    public static final int numColumns = 9;
    084
    085
    086    /** The implementation of the peer. */
    087    private static JobEntryTorquePeerImpl jobEntryTorquePeerImpl;
    088
    089
    090    static
    091    {
    092        DatabaseMap dbMap = Torque.getOrCreateDatabase("default")
    093                .getDatabaseMap();
    094        if (dbMap.getTable("TURBINE_SCHEDULED_JOB") == null)
    095        {
    096            dbMap.addTable("TURBINE_SCHEDULED_JOB");
    097        }
    098        DATABASE_NAME = "default";
    099        TABLE_NAME = "TURBINE_SCHEDULED_JOB";
    100
    101        TABLE = dbMap.getTable("TURBINE_SCHEDULED_JOB");
    102        TABLE.setJavaName("JobEntryTorque");
    103        TABLE.setOMClass(org.apache.turbine.services.schedule.JobEntryTorque.class);
    104        TABLE.setPeerClass(org.apache.turbine.services.schedule.JobEntryTorquePeer.class);
    105        TABLE.setPrimaryKeyMethod(IDMethod.ID_BROKER);
    106        TABLE.setPrimaryKeyMethodInfo(IDMethod.ID_BROKER, TABLE.getName());
    107        TABLE.setPrimaryKeyMethodInfo(IDMethod.SEQUENCE, "$sequenceName");
    108        TABLE.setPrimaryKeyMethodInfo(IDMethod.AUTO_INCREMENT, "TURBINE_SCHEDULED_JOB");
    109        TABLE.setUseInheritance(true);
    110
    111
    112    // ------------- Column: JOB_ID --------------------
    113        JOB_ID = new ColumnMap("JOB_ID", TABLE);
    114        JOB_ID.setType(Integer.valueOf(0));
    115        JOB_ID.setTorqueType("INTEGER");
    116        JOB_ID.setUsePrimitive(true);
    117        JOB_ID.setPrimaryKey(true);
    118        JOB_ID.setNotNull(true);
    119        JOB_ID.setJavaName("JobId");
    120        JOB_ID.setAutoIncrement(true);
    121        JOB_ID.setProtected(false);
    122        JOB_ID.setJavaType( "int" );
    123        JOB_ID.setPosition(1);
    124        TABLE.addColumn(JOB_ID);
    125    // ------------- Column: SECOND --------------------
    126        SECOND = new ColumnMap("SECOND", TABLE);
    127        SECOND.setType(Integer.valueOf(0));
    128        SECOND.setTorqueType("INTEGER");
    129        SECOND.setUsePrimitive(true);
    130        SECOND.setPrimaryKey(false);
    131        SECOND.setNotNull(true);
    132        SECOND.setJavaName("Second");
    133        SECOND.setAutoIncrement(true);
    134        SECOND.setProtected(false);
    135        SECOND.setJavaType( "int" );
    136        SECOND.setDefault("-1");
    137        SECOND.setPosition(2);
    138        TABLE.addColumn(SECOND);
    139    // ------------- Column: MINUTE --------------------
    140        MINUTE = new ColumnMap("MINUTE", TABLE);
    141        MINUTE.setType(Integer.valueOf(0));
    142        MINUTE.setTorqueType("INTEGER");
    143        MINUTE.setUsePrimitive(true);
    144        MINUTE.setPrimaryKey(false);
    145        MINUTE.setNotNull(true);
    146        MINUTE.setJavaName("Minute");
    147        MINUTE.setAutoIncrement(true);
    148        MINUTE.setProtected(false);
    149        MINUTE.setJavaType( "int" );
    150        MINUTE.setDefault("-1");
    151        MINUTE.setPosition(3);
    152        TABLE.addColumn(MINUTE);
    153    // ------------- Column: HOUR --------------------
    154        HOUR = new ColumnMap("HOUR", TABLE);
    155        HOUR.setType(Integer.valueOf(0));
    156        HOUR.setTorqueType("INTEGER");
    157        HOUR.setUsePrimitive(true);
    158        HOUR.setPrimaryKey(false);
    159        HOUR.setNotNull(true);
    160        HOUR.setJavaName("Hour");
    161        HOUR.setAutoIncrement(true);
    162        HOUR.setProtected(false);
    163        HOUR.setJavaType( "int" );
    164        HOUR.setDefault("-1");
    165        HOUR.setPosition(4);
    166        TABLE.addColumn(HOUR);
    167    // ------------- Column: WEEK_DAY --------------------
    168        WEEK_DAY = new ColumnMap("WEEK_DAY", TABLE);
    169        WEEK_DAY.setType(Integer.valueOf(0));
    170        WEEK_DAY.setTorqueType("INTEGER");
    171        WEEK_DAY.setUsePrimitive(true);
    172        WEEK_DAY.setPrimaryKey(false);
    173        WEEK_DAY.setNotNull(true);
    174        WEEK_DAY.setJavaName("WeekDay");
    175        WEEK_DAY.setAutoIncrement(true);
    176        WEEK_DAY.setProtected(false);
    177        WEEK_DAY.setJavaType( "int" );
    178        WEEK_DAY.setDefault("-1");
    179        WEEK_DAY.setPosition(5);
    180        TABLE.addColumn(WEEK_DAY);
    181    // ------------- Column: DAY_OF_MONTH --------------------
    182        DAY_OF_MONTH = new ColumnMap("DAY_OF_MONTH", TABLE);
    183        DAY_OF_MONTH.setType(Integer.valueOf(0));
    184        DAY_OF_MONTH.setTorqueType("INTEGER");
    185        DAY_OF_MONTH.setUsePrimitive(true);
    186        DAY_OF_MONTH.setPrimaryKey(false);
    187        DAY_OF_MONTH.setNotNull(true);
    188        DAY_OF_MONTH.setJavaName("DayOfMonth");
    189        DAY_OF_MONTH.setAutoIncrement(true);
    190        DAY_OF_MONTH.setProtected(false);
    191        DAY_OF_MONTH.setJavaType( "int" );
    192        DAY_OF_MONTH.setDefault("-1");
    193        DAY_OF_MONTH.setPosition(6);
    194        TABLE.addColumn(DAY_OF_MONTH);
    195    // ------------- Column: TASK --------------------
    196        TASK = new ColumnMap("TASK", TABLE);
    197        TASK.setType("");
    198        TASK.setTorqueType("VARCHAR");
    199        TASK.setUsePrimitive(false);
    200        TASK.setPrimaryKey(false);
    201        TASK.setNotNull(true);
    202        TASK.setJavaName("Task");
    203        TASK.setAutoIncrement(true);
    204        TASK.setProtected(false);
    205        TASK.setJavaType( "String" );
    206        TASK.setSize(99);
    207        TASK.setPosition(7);
    208        TABLE.addColumn(TASK);
    209    // ------------- Column: EMAIL --------------------
    210        EMAIL = new ColumnMap("EMAIL", TABLE);
    211        EMAIL.setType("");
    212        EMAIL.setTorqueType("VARCHAR");
    213        EMAIL.setUsePrimitive(false);
    214        EMAIL.setPrimaryKey(false);
    215        EMAIL.setNotNull(false);
    216        EMAIL.setJavaName("Email");
    217        EMAIL.setAutoIncrement(true);
    218        EMAIL.setProtected(false);
    219        EMAIL.setJavaType( "String" );
    220        EMAIL.setSize(99);
    221        EMAIL.setPosition(8);
    222        TABLE.addColumn(EMAIL);
    223    // ------------- Column: PROPERTY --------------------
    224        PROPERTY = new ColumnMap("PROPERTY", TABLE);
    225        PROPERTY.setType(new Object());
    226        PROPERTY.setTorqueType("VARBINARY");
    227        PROPERTY.setUsePrimitive(false);
    228        PROPERTY.setPrimaryKey(false);
    229        PROPERTY.setNotNull(false);
    230        PROPERTY.setJavaName("Property");
    231        PROPERTY.setAutoIncrement(true);
    232        PROPERTY.setProtected(false);
    233        PROPERTY.setJavaType( "byte[]" );
    234        PROPERTY.setPosition(9);
    235        TABLE.addColumn(PROPERTY);
    236
    237
    238
    239        initDatabaseMap();
    240    }
    241
    242    /**
    243     * Creates a new instance of the  implementation of the peer.
    244     *
    245     * @return the new instance.
    246     */
    247    protected static JobEntryTorquePeerImpl createJobEntryTorquePeerImpl()
    248    {
    249        JobEntryTorquePeerImpl instance = new JobEntryTorquePeerImpl();
    250        return instance;
    251    }
    252
    253
    254    /**
    255     * Returns an instance of the implementation of the peer.
    256     * If no instance is currently cached, a new instance is created and cached.
    257     *
    258     * @return an instance of the implementation of the peer, not null.
    259     */
    260    public static JobEntryTorquePeerImpl getJobEntryTorquePeerImpl()
    261    {
    262        JobEntryTorquePeerImpl peerImplInstance = jobEntryTorquePeerImpl;
    263        if (peerImplInstance == null)
    264        {
    265            peerImplInstance = JobEntryTorquePeer.createJobEntryTorquePeerImpl();
    266            jobEntryTorquePeerImpl = peerImplInstance;
    267        }
    268        return peerImplInstance;
    269    }
    270
    271
    272
    273    /**
    274     * Sets the instance of the implementation of the peer.
    275     *
    276     * @param an instance of the implementation of the peer, or null
    277     *        if a new instance should be created automatically.
    278     */
    279    public static void setJobEntryTorquePeerImpl(JobEntryTorquePeerImpl peerImplInstance)
    280    {
    281        jobEntryTorquePeerImpl = peerImplInstance;
    282    }
    283
    284
    285    /**
    286     * Add all the columns needed to create a new object.
    287     *
    288     * @param criteria object containing the columns to add.
    289     * @throws TorqueException Any exceptions caught during processing will be
    290     *         rethrown wrapped into a TorqueException.
    291     */
    292    public static void addSelectColumns(Criteria criteria)
    293            throws TorqueException
    294    {
    295        getJobEntryTorquePeerImpl().addSelectColumns(criteria);
    296    }
    297
    298    /**
    299     * changes the boolean values in the criteria to the appropriate type,
    300     * whenever a booleanchar or booleanint column is involved.
    301     * This enables the user to create criteria using Boolean values
    302     * for booleanchar or booleanint columns.
    303     *
    304     * @param criteria the criteria in which the boolean values
    305     *        should be corrected.
    306     *
    307     * @throws TorqueException if the database map for the criteria cannot be
    308               obtained.
    309     */
    310    public static void correctBooleans(Criteria criteria) throws TorqueException
    311    {
    312        getJobEntryTorquePeerImpl().correctBooleans(criteria);
    313    }
    314
    315    /**
    316     * Checks all columns in the criteria to see whether
    317     * booleanchar and booleanint columns are queried with a boolean.
    318     * If yes, the query values are mapped onto values the database
    319     * does understand, i.e. 0 and 1 for booleanints and N and Y for
    320     * booleanchar columns.
    321     *
    322     * @param columnValues The value to be checked for booleanint
    323     *        and booleanchar columns.
    324     * @throws TorqueException if the database map for the criteria cannot be
    325     *         retrieved.
    326     */
    327    public static void correctBooleans(
    328            ColumnValues columnValues)
    329        throws TorqueException
    330    {
    331        getJobEntryTorquePeerImpl().correctBooleans(columnValues);
    332    }
    333
    334    /**
    335     * Selects JobEntryTorque objects from a database.
    336     *
    337     * @param criteria object used to create the SELECT statement.
    338     *
    339     * @return the list of selected objects, not null.
    340     *
    341     * @throws TorqueException Any exceptions caught during processing will be
    342     *         rethrown wrapped into a TorqueException.
    343     */
    344    public static List<JobEntryTorque> doSelect(Criteria criteria)
    345            throws TorqueException
    346    {
    347        return getJobEntryTorquePeerImpl().doSelect(criteria);
    348    }
    349
    350    /**
    351     * Selects JobEntryTorque objects from a database
    352     * within a transaction.
    353     *
    354     * @param criteria object used to create the SELECT statement.
    355     * @param connection the connection holding the transaction, not null.
    356     *
    357     * @return The list of selected objects, not null.
    358     *
    359     * @throws TorqueException Any exceptions caught during processing will be
    360     *         rethrown wrapped into a TorqueException.
    361     */
    362    public static List<JobEntryTorque> doSelect(
    363                Criteria criteria,
    364                Connection connection)
    365            throws TorqueException
    366    {
    367        return getJobEntryTorquePeerImpl().doSelect(criteria, connection);
    368    }
    369
    370    /**
    371     * Selects rows from a database an maps them to objects.
    372     *
    373     * @param criteria A Criteria specifying the records to select, not null.
    374     * @param mapper The mapper creating the objects from the resultSet,
    375     *        not null.
    376     *
    377     * @return The results of the query, not null.
    378     *
    379     * @throws TorqueException if querying the database fails.
    380     */
    381    public static <T> List<T> doSelect(
    382                Criteria criteria,
    383                RecordMapper<T> mapper)
    384            throws TorqueException
    385    {
    386        return getJobEntryTorquePeerImpl().doSelect(criteria, mapper);
    387    }
    388
    389    /**
    390     * Selects rows from a database an maps them to objects.
    391     *
    392     * @param criteria A Criteria specifying the records to select, not null.
    393     * @param mapper The mapper creating the objects from the resultSet,
    394     *        not null.
    395     * @param connection the database connection for selecting records,
    396     *        not null.
    397     *
    398     * @return The results of the query, not null.
    399     * @throws TorqueException Error performing database query.
    400     */
    401    public static <T> List<T> doSelect(
    402            Criteria criteria,
    403            RecordMapper<T> mapper,
    404            Connection connection)
    405        throws TorqueException
    406    {
    407        return getJobEntryTorquePeerImpl().doSelect(
    408                criteria,
    409                mapper,
    410                connection);
    411    }
    412
    413    /**
    414     * Selects rows from a database an maps them to objects.
    415     *
    416     * @param query the sql query to execute, not null.
    417     * @param mapper The mapper creating the objects from the resultSet,
    418     *        not null.
    419     * @param dbName The name of the database to create the connection for,
    420     *        or null for the default SDB.
    421     *
    422     * @return The results of the query, not null.
    423     *
    424     * @throws TorqueException if querying the database fails.
    425     */
    426    public static <T> List<T> doSelect(
    427                String query,
    428                RecordMapper<T> mapper,
    429                String dbName)
    430            throws TorqueException
    431    {
    432        return getJobEntryTorquePeerImpl().doSelect(
    433                query,
    434                mapper,
    435                dbName);
    436    }
    437
    438    /**
    439     * Selects rows from a database an maps them to objects.
    440     *
    441     * @param query the SQL Query to execute, not null.
    442     * @param mapper The mapper creating the objects from the resultSet,
    443     *        not null.
    444     * @param connection the database connection, not null.
    445     *
    446     * @return The results of the query, not null.
    447     *
    448     * @throws TorqueException if querying the database fails.
    449     */
    450    public static <T> List<T> doSelect(
    451                String query,
    452                RecordMapper<T> mapper,
    453                Connection connection)
    454            throws TorqueException
    455    {
    456        return getJobEntryTorquePeerImpl().doSelect(
    457                query,
    458                mapper,
    459                connection);
    460    }
    461
    462    /**
    463     * Selects JobEntryTorque objects from the database which have
    464     * the same content as the passed object.
    465     *
    466     * @return The list of selected objects, not null.
    467     *
    468     * @throws TorqueException Any exceptions caught during processing will be
    469     *         rethrown wrapped into a TorqueException.
    470     */
    471    public static List<JobEntryTorque> doSelect(JobEntryTorque obj)
    472            throws TorqueException
    473    {
    474        return getJobEntryTorquePeerImpl().doSelect(obj);
    475    }
    476
    477    /**
    478     * Selects at most one JobEntryTorque object from a database.
    479     *
    480     * @param criteria object used to create the SELECT statement.
    481     *
    482     * @return the selected Object, or null if no object was selected.
    483     *
    484     * @throws TorqueException If more than one record is selected or if
    485     *         an error occurs when processing the query.
    486     */
    487    public static JobEntryTorque doSelectSingleRecord(
    488                Criteria criteria)
    489            throws TorqueException
    490    {
    491        return getJobEntryTorquePeerImpl().doSelectSingleRecord(criteria);
    492    }
    493
    494    /**
    495     * Selects at most one JobEntryTorque object from a database
    496     * within a transaction.
    497     *
    498     * @param criteria object used to create the SELECT statement.
    499     * @param connection the connection holding the transaction, not null.
    500     *
    501     * @return the selected Object, or null if no object was selected.
    502     *
    503     * @throws TorqueException If more than one record is selected or if
    504     *         an error occurs when processing the query.
    505     */
    506    public static JobEntryTorque doSelectSingleRecord(
    507                Criteria criteria,
    508                Connection connection)
    509            throws TorqueException
    510    {
    511        return getJobEntryTorquePeerImpl().doSelectSingleRecord(criteria, connection);
    512    }
    513
    514    /**
    515     * Selects at most a single row from a database an maps them to objects.
    516     *
    517     * @param criteria A Criteria specifying the records to select, not null.
    518     * @param mapper The mapper creating the objects from the resultSet,
    519     *        not null.
    520     *
    521     * @return The selected row, or null if no records was selected.
    522     *
    523     * @throws TorqueException if querying the database fails.
    524     */
    525    public static <T> T doSelectSingleRecord(
    526                org.apache.torque.criteria.Criteria criteria,
    527                RecordMapper<T> mapper)
    528            throws TorqueException
    529    {
    530        return getJobEntryTorquePeerImpl().doSelectSingleRecord(
    531                criteria,
    532                mapper);
    533    }
    534
    535    /**
    536     * Selects at most a single row from a database an maps them to objects.
    537     *
    538     * @param criteria A Criteria specifying the records to select, not null.
    539     * @param mapper The mapper creating the objects from the resultSet,
    540     *        not null.
    541     * @param connection the database connection, not null.
    542     *
    543     * @return The selected row, or null if no records was selected.
    544     *
    545     * @throws TorqueException if querying the database fails.
    546     */
    547    public static <T> T doSelectSingleRecord(
    548                org.apache.torque.criteria.Criteria criteria,
    549                RecordMapper<T> mapper,
    550                Connection connection)
    551            throws TorqueException
    552    {
    553        return getJobEntryTorquePeerImpl().doSelectSingleRecord(
    554                criteria,
    555                mapper,
    556                connection);
    557    }
    558
    559    /**
    560     * Selects at most one JobEntryTorque object from the database
    561     * which has the same content as the passed object.
    562     *
    563     * @return the selected Object, or null if no object was selected.
    564     *
    565     * @throws TorqueException If more than one record is selected or if
    566     *         an error occurs when processing the query.
    567     */
    568    public static JobEntryTorque doSelectSingleRecord(
    569                JobEntryTorque obj)
    570            throws TorqueException
    571    {
    572        return getJobEntryTorquePeerImpl().doSelectSingleRecord(obj);
    573    }
    574
    575
    576    /**
    577     * Returns a new instance of the Data object class
    578     */
    579    public static JobEntryTorque getDbObjectInstance()
    580    {
    581        return getJobEntryTorquePeerImpl().getDbObjectInstance();
    582    }
    583
    584
    585    /**
    586     * Method to do inserts.
    587     *
    588     * @param columnValues the values to insert.
    589     *
    590     * @return the primary key of the inserted row.
    591     *
    592     * @throws TorqueException Any exceptions caught during processing will be
    593     *         rethrown wrapped into a TorqueException.
    594     */
    595    public static ObjectKey doInsert(ColumnValues columnValues)
    596            throws TorqueException
    597    {
    598        return getJobEntryTorquePeerImpl().doInsert(columnValues);
    599    }
    600
    601    /**
    602     * Method to do inserts.  This method is to be used during a transaction,
    603     * otherwise use the doInsert(Criteria) method.
    604     *
    605     * @param columnValues the values to insert.
    606     * @param con the connection to use, not null.
    607     *
    608     * @return the primary key of the inserted row.
    609     *
    610     * @throws TorqueException Any exceptions caught during processing will be
    611     *         rethrown wrapped into a TorqueException.
    612     */
    613    public static ObjectKey doInsert(ColumnValues columnValues, Connection con)
    614            throws TorqueException
    615    {
    616        return getJobEntryTorquePeerImpl().doInsert(columnValues, con);
    617    }
    618    /**
    619     * Method to do inserts
    620     *
    621     * @throws TorqueException Any exceptions caught during processing will be
    622     *         rethrown wrapped into a TorqueException.
    623     */
    624    public static void doInsert(JobEntryTorque obj)
    625            throws TorqueException
    626    {
    627        getJobEntryTorquePeerImpl().doInsert(obj);
    628    }
    629
    630    /**
    631     * Method to do inserts.  This method is to be used during a transaction,
    632     * otherwise use the doInsert(JobEntryTorque) method.  It will take
    633     * care of the connection details internally.
    634     *
    635     * @param obj the data object to insert into the database.
    636     * @param con the connection to use
    637     * @throws TorqueException Any exceptions caught during processing will be
    638     *         rethrown wrapped into a TorqueException.
    639     */
    640    public static void doInsert(JobEntryTorque obj, Connection con)
    641            throws TorqueException
    642    {
    643        getJobEntryTorquePeerImpl().doInsert(obj, con);
    644    }
    645
    646    /**
    647     * Method to do updates.
    648     *
    649     * @param columnValues the values to update plus the primary key
    650     *        identifying the row to update.
    651     * @throws TorqueException Any exceptions caught during processing will be
    652     *         rethrown wrapped into a TorqueException.
    653     */
    654    public static int doUpdate(ColumnValues columnValues) throws TorqueException
    655    {
    656        return getJobEntryTorquePeerImpl().doUpdate(columnValues);
    657    }
    658
    659    /**
    660     * Method to do updates.  This method is to be used during a transaction,
    661     * otherwise use the doUpdate(Criteria) method.  It will take care of
    662     * the connection details internally.
    663     *
    664     * @param columnValues the values to update plus the primary key
    665     *        identifying the row to update.
    666     * @param con the connection to use, not null.
    667     *
    668     * @return the number of affected rows.
    669     *
    670     * @throws TorqueException Any exceptions caught during processing will be
    671     *         rethrown wrapped into a TorqueException.
    672     */
    673    public static int doUpdate(ColumnValues columnValues, Connection con)
    674        throws TorqueException
    675    {
    676        return getJobEntryTorquePeerImpl().doUpdate(columnValues, con);
    677    }
    678
    679    /**
    680     * Executes an update against the database. The rows to be updated
    681     * are selected using <code>criteria</code> and updated using the values
    682     * in <code>updateValues</code>.
    683     *
    684     * @param criteria selects which rows of which table should be updated.
    685     * @param updateValues Which columns to update with which values, not null.
    686     *
    687     * @return the number of affected rows.
    688     *
    689     * @throws TorqueException if updating fails.
    690     */
    691    public static int doUpdate(
    692                Criteria selectCriteria,
    693                ColumnValues updateValues)
    694            throws TorqueException
    695    {
    696        return getJobEntryTorquePeerImpl().doUpdate(
    697            selectCriteria,
    698            updateValues);
    699    }
    700
    701    /**
    702     * Executes an update against the database. The rows to be updated
    703     * are selected using <code>criteria</code> and updated using the values
    704     * in <code>updateValues</code>.
    705     *
    706     * @param criteria selects which rows of which table should be updated.
    707     * @param updateValues Which columns to update with which values, not null.
    708     * @param connection the database connection to use, not null.
    709     *
    710     * @return the number of affected rows.
    711     *
    712     * @throws TorqueException if updating fails.
    713     */
    714    public static int doUpdate(
    715                Criteria criteria,
    716                ColumnValues updateValues,
    717                Connection connection)
    718            throws TorqueException
    719    {
    720        return getJobEntryTorquePeerImpl().doUpdate(
    721            criteria,
    722             updateValues,
    723              connection);
    724    }
    725
    726    /**
    727     * Updates an JobEntryTorque in the database.
    728     * The primary key is used to identify the object to update.
    729     *
    730     * @param obj the data object to update in the database.
    731     *
    732     * @return the number of affected rows.
    733     *
    734     * @throws TorqueException Any exceptions caught during processing will be
    735     *         rethrown wrapped into a TorqueException.
    736     */
    737    public static int doUpdate(JobEntryTorque obj) throws TorqueException
    738    {
    739        return getJobEntryTorquePeerImpl().doUpdate(obj);
    740    }
    741
    742    /**
    743     * Updates a JobEntryTorque in the database.
    744     * The primary key is used to identify the object to update.
    745     * This method is to be used during a transaction,
    746     * otherwise the doUpdate(JobEntryTorque) method can be used.
    747     *
    748     * @param obj the data object to update in the database.
    749     * @param con the connection to use, not null.
    750
    751     * @throws TorqueException Any exceptions caught during processing will be
    752     *         rethrown wrapped into a TorqueException.
    753     */
    754    public static int doUpdate(JobEntryTorque obj, Connection con)
    755        throws TorqueException
    756    {
    757        return getJobEntryTorquePeerImpl().doUpdate(obj, con);
    758    }
    759
    760    /**
    761     * Utility method which executes a given sql statement
    762     * as prepared statement.
    763     * This method should be used for update, insert, and delete statements.
    764     * Use executeQuery() for selects.
    765     *
    766     * @param statementString A String with the sql statement to execute.
    767     *
    768     * @return The number of rows affected.
    769     *
    770     * @throws TorqueException if executing the statement fails
    771     *         or no database connection can be established.
    772     */
    773    public static int executeStatement(String statementString)
    774            throws TorqueException
    775    {
    776        return getJobEntryTorquePeerImpl().executeStatement(statementString);
    777    }
    778
    779    /**
    780     * Utility method which executes a given sql statement
    781     * as prepared statement.
    782     * This method should be used for update, insert, and delete statements.
    783     * Use executeQuery() for selects.
    784     *
    785     * @param statementString A String with the sql statement to execute.
    786     * @param replacementValues values to use as placeholders in the query.
    787     *        or null or empty if no placeholders need to be filled.
    788     *
    789     * @return The number of rows affected.
    790     *
    791     * @throws TorqueException if executing the statement fails
    792     *         or no database connection can be established.
    793     */
    794    public static int executeStatement(
    795                String statementString,
    796                List<JdbcTypedValue> replacementValues)
    797            throws TorqueException
    798    {
    799        return getJobEntryTorquePeerImpl().executeStatement(
    800                statementString,
    801                replacementValues);
    802    }
    803
    804    /**
    805     * Utility method which executes a given sql statement
    806     * as prepared statement.
    807     * This method should be used for update, insert, and delete statements.
    808     * Use executeQuery() for selects.
    809     *
    810     * @param statementString A String with the sql statement to execute.
    811     * @param dbName The name of the database to execute the statement against,
    812     *        or null for the default DB.
    813     * @param replacementValues values to use as placeholders in the query.
    814     *        or null or empty if no placeholders need to be filled.
    815     *
    816     * @return The number of rows affected.
    817     *
    818     * @throws TorqueException if executing the statement fails
    819     *         or no database connection can be established.
    820     */
    821    public static int executeStatement(
    822            String statementString,
    823            String dbName,
    824            List<JdbcTypedValue> replacementValues)
    825        throws TorqueException
    826    {
    827        return getJobEntryTorquePeerImpl().executeStatement(
    828                statementString,
    829                dbName,
    830                replacementValues);
    831    }
    832
    833    /**
    834     * Utility method which executes a given sql statement
    835     * as prepared statement.
    836     * This method should be used for update, insert, and delete statements.
    837     * Use executeQuery() for selects.
    838     *
    839     * @param statementString A String with the sql statement to execute.
    840     * @param con The database connection to use.
    841     * @param replacementValues values to use as placeholders in the query.
    842     *        or null or empty if no placeholders need to be filled.
    843     *
    844     * @return The number of rows affected.
    845     *
    846     * @throws TorqueException if executing the statement fails.
    847     */
    848    public static int executeStatement(
    849            String statementString,
    850            Connection con,
    851            List<JdbcTypedValue> replacementValues)
    852        throws TorqueException
    853    {
    854        return getJobEntryTorquePeerImpl().executeStatement(
    855                statementString,
    856                con,
    857                replacementValues);
    858    }
    859
    860    /**
    861     * Deletes rows from a database table.
    862     *
    863     * @param criteria defines the rows to be deleted, not null.
    864     *
    865     * @return the number of deleted rows.
    866     *
    867     * @throws TorqueException Any exceptions caught during processing will be
    868     *         rethrown wrapped into a TorqueException.
    869     */
    870     public static int doDelete(Criteria criteria) throws TorqueException
    871     {
    872        return getJobEntryTorquePeerImpl().doDelete(criteria);
    873     }
    874
    875    /**
    876     * Deletes rows from a table.
    877     * This method uses the passed connection to delete the rows;
    878     * if a transaction is open in the connection, the deletion happens inside
    879     * this transaction.
    880    *
    881     * @param criteria defines the rows to be deleted, not null.
    882     * @param con the connection to use, not null.
    883     *
    884     * @return the number of deleted rows.
    885     *
    886     * @throws TorqueException Any exceptions caught during processing will be
    887     *         rethrown wrapped into a TorqueException.
    888     */
    889     public static int doDelete(Criteria criteria, Connection con)
    890        throws TorqueException
    891     {
    892        return getJobEntryTorquePeerImpl().doDelete(criteria, con);
    893     }
    894
    895    /**
    896     * Deletes a data object, i.e. a row in a table, in the database.
    897     *
    898     * @param obj the data object to delete in the database, not null.
    899     *
    900     * @return the number of deleted rows.
    901     *
    902     * @throws TorqueException Any exceptions caught during processing will be
    903     *         rethrown wrapped into a TorqueException.
    904     */
    905    public static int doDelete(JobEntryTorque obj) throws TorqueException
    906    {
    907        return getJobEntryTorquePeerImpl().doDelete(obj);
    908    }
    909
    910    /**
    911     * Deletes a data object, i.e. a row in a table, in the database.
    912     * This method uses the passed connection to delete the rows;
    913     * if a transaction is open in the connection, the deletion happens inside
    914     * this transaction.
    915     *
    916     * @param obj the data object to delete in the database, not null.
    917     * @param con the connection to use, not null.
    918     *
    919     * @return the number of deleted rows.
    920     *
    921     * @throws TorqueException Any exceptions caught during processing will be
    922     *         rethrown wrapped into a TorqueException.
    923     */
    924    public static int doDelete(JobEntryTorque obj, Connection con)
    925        throws TorqueException
    926    {
    927        return getJobEntryTorquePeerImpl().doDelete(obj, con);
    928    }
    929
    930    /**
    931     * Deletes data objects, i.e. rows in a table, in the database.
    932     *
    933     * @param objects the datas object to delete in the database, not null,
    934     *        may not contain null.
    935     *
    936     * @return the number of deleted rows.
    937     *
    938     * @throws TorqueException Any exceptions caught during processing will be
    939     *         rethrown wrapped into a TorqueException.
    940     */
    941    public static int doDelete(Collection<JobEntryTorque> objects)
    942            throws TorqueException
    943    {
    944        return getJobEntryTorquePeerImpl().doDelete(objects);
    945    }
    946
    947    /**
    948     * Deletes data objects, i.e. rows in a table, in the database.
    949     * This method uses the passed connection to delete the rows;
    950     * if a transaction is open in the connection, the deletion happens inside
    951     * this transaction.
    952     *
    953     * @param objects the datas object to delete in the database, not null,
    954     *        may not contain null.
    955     * @param con the connection to use for deleting, not null.
    956     *
    957     * @return the number of deleted rows.
    958     *
    959     * @throws TorqueException Any exceptions caught during processing will be
    960     *         rethrown wrapped into a TorqueException.
    961     */
    962    public static int doDelete(
    963            Collection<JobEntryTorque> objects,
    964            Connection con)
    965        throws TorqueException
    966    {
    967        return getJobEntryTorquePeerImpl().doDelete(objects, con);
    968    }
    969
    970    /**
    971     * Deletes a row in the database.
    972     *
    973     * @param pk the ObjectKey that identifies the row to delete.
    974     *
    975     * @return the number of deleted rows.
    976     *
    977     * @throws TorqueException Any exceptions caught during processing will be
    978     *         rethrown wrapped into a TorqueException.
    979     */
    980    public static int doDelete(ObjectKey pk) throws TorqueException
    981    {
    982        return getJobEntryTorquePeerImpl().doDelete(pk);
    983    }
    984
    985    /**
    986     * Deletes a row in the database.
    987     * This method uses the passed connection to delete the rows;
    988     * if a transaction is open in the connection, the deletion happens inside
    989     * this transaction.
    990     *
    991     * @param pk the ObjectKey that identifies the row to delete.
    992     * @param con the connection to use for deleting, not null.
    993     *
    994     * @return the number of deleted rows.
    995     *
    996     * @throws TorqueException Any exceptions caught during processing will be
    997     *         rethrown wrapped into a TorqueException.
    998     */
    999    public static int doDelete(ObjectKey pk, Connection con)
    1000        throws TorqueException
    1001    {
    1002        return getJobEntryTorquePeerImpl().doDelete(pk, con);
    1003    }
    1004
    1005    /**
    1006     * Build a Criteria object which selects all objects which have a given
    1007     * primary key.
    1008     *
    1009     * @param pk the primary key value to build the criteria from, not null.
    1010     */
    1011    public static Criteria buildCriteria(ObjectKey pk)
    1012    {
    1013        return getJobEntryTorquePeerImpl().buildCriteria(pk);
    1014    }
    1015
    1016    /**
    1017     * Build a Criteria object which selects all objects which primary keys
    1018     * are contained in the passed collection.
    1019     *
    1020     * @param pks the primary key values to build the criteria from, not null,
    1021     *        may not contain null.
    1022     */
    1023    public static Criteria buildCriteria(Collection<ObjectKey> pks)
    1024    {
    1025        return getJobEntryTorquePeerImpl().buildCriteria(pks);
    1026    }
    1027
    1028    /**
    1029     * Build a Criteria object which selects all passed objects using their
    1030     * primary key. Objects which do not yet have a primary key are ignored.
    1031     *
    1032     * @param objects the objects to build the criteria from, not null,
    1033     *        may not contain null.
    1034     */
    1035    public static Criteria buildPkCriteria(
    1036            Collection<JobEntryTorque> objects)
    1037    {
    1038        return getJobEntryTorquePeerImpl().buildPkCriteria(objects);
    1039    }
    1040
    1041    /**
    1042     * Build a Criteria object from the data object for this peer.
    1043     *
    1044     * @param obj the object to build the criteria from, not null.
    1045     */
    1046    public static Criteria buildCriteria(JobEntryTorque obj)
    1047    {
    1048        return getJobEntryTorquePeerImpl().buildCriteria(obj);
    1049    }
    1050
    1051    /**
    1052     * Build a Criteria object from the data object for this peer,
    1053     * skipping all binary columns.
    1054     *
    1055     * @param obj the object to build the criteria from, not null.
    1056     */
    1057    public static Criteria buildSelectCriteria(JobEntryTorque obj)
    1058    {
    1059        return getJobEntryTorquePeerImpl().buildSelectCriteria(obj);
    1060    }
    1061
    1062    /**
    1063     * Returns the contents of the object as ColumnValues object
    1064     *
    1065     * @throws TorqueException if the table map cannot be retrieved
    1066     *         (should not happen).
    1067     */
    1068    public static ColumnValues buildColumnValues(JobEntryTorque jobEntryTorque)
    1069            throws TorqueException
    1070    {
    1071
    1072        return getJobEntryTorquePeerImpl().buildColumnValues(jobEntryTorque);
    1073    }
    1074
    1075    /**
    1076     * Retrieve a single object by pk
    1077     *
    1078     * @param pk the primary key
    1079     * @throws TorqueException Any exceptions caught during processing will be
    1080     *         rethrown wrapped into a TorqueException.
    1081     * @throws NoRowsException Primary key was not found in database.
    1082     * @throws TooManyRowsException Primary key was not found in database.
    1083     */
    1084    public static JobEntryTorque retrieveByPK(int pk)
    1085        throws TorqueException, NoRowsException, TooManyRowsException
    1086    {
    1087        return getJobEntryTorquePeerImpl().retrieveByPK(pk);
    1088    }
    1089
    1090    /**
    1091     * Retrieve a single object by pk
    1092     *
    1093     * @param pk the primary key
    1094     * @param con the connection to use
    1095     * @throws TorqueException Any exceptions caught during processing will be
    1096     *         rethrown wrapped into a TorqueException.
    1097     * @throws NoRowsException Primary key was not found in database.
    1098     * @throws TooManyRowsException Primary key was not found in database.
    1099     */
    1100    public static JobEntryTorque retrieveByPK(int pk, Connection con)
    1101        throws TorqueException, NoRowsException, TooManyRowsException
    1102    {
    1103        return getJobEntryTorquePeerImpl().retrieveByPK(pk, con);
    1104    }
    1105
    1106
    1107
    1108
    1109    /**
    1110     * Retrieve a single object by pk
    1111     *
    1112     * @param pk the primary key
    1113     * @throws TorqueException Any exceptions caught during processing will be
    1114     *         rethrown wrapped into a TorqueException.
    1115     * @throws NoRowsException Primary key was not found in database.
    1116     * @throws TooManyRowsException Primary key was not found in database.
    1117     */
    1118    public static JobEntryTorque retrieveByPK(ObjectKey pk)
    1119        throws TorqueException, NoRowsException, TooManyRowsException
    1120    {
    1121        return getJobEntryTorquePeerImpl().retrieveByPK(pk);
    1122    }
    1123
    1124    /**
    1125     * Retrieve a single object by pk
    1126     *
    1127     * @param pk the primary key
    1128     * @param con the connection to use
    1129     * @throws TorqueException Any exceptions caught during processing will be
    1130     *         rethrown wrapped into a TorqueException.
    1131     * @throws NoRowsException Primary key was not found in database.
    1132     * @throws TooManyRowsException Primary key was not found in database.
    1133     */
    1134    public static JobEntryTorque retrieveByPK(ObjectKey pk, Connection con)
    1135        throws TorqueException, NoRowsException, TooManyRowsException
    1136    {
    1137        return getJobEntryTorquePeerImpl().retrieveByPK(pk, con);
    1138    }
    1139
    1140
    1141    /**
    1142     * Retrieve a multiple objects by pk
    1143     *
    1144     * @param pks List of primary keys
    1145     * @throws TorqueException Any exceptions caught during processing will be
    1146     *         rethrown wrapped into a TorqueException.
    1147     */
    1148    public static List<JobEntryTorque> retrieveByPKs(Collection<ObjectKey> pks)
    1149        throws TorqueException
    1150    {
    1151        return getJobEntryTorquePeerImpl().retrieveByPKs(pks);
    1152    }
    1153
    1154    /**
    1155     * Retrieve multiple objects by pk
    1156     *
    1157     * @param pks List of primary keys
    1158     * @param con the connection to use
    1159     * @throws TorqueException Any exceptions caught during processing will be
    1160     *         rethrown wrapped into a TorqueException.
    1161     */
    1162    public static List<JobEntryTorque> retrieveByPKs(Collection<ObjectKey> pks, Connection con)
    1163        throws TorqueException
    1164    {
    1165        return getJobEntryTorquePeerImpl().retrieveByPKs(pks,con);
    1166    }
    1167
    1168
    1169
    1170
    1171
    1172    /**
    1173     * Returns the TableMap related to this peer.
    1174     *
    1175     * @return the table map, not null.
    1176     *
    1177     * @throws TorqueException if the Peer instance does not hold a Table map.
    1178     */
    1179    public static TableMap getTableMap()
    1180        throws TorqueException
    1181    {
    1182        return getJobEntryTorquePeerImpl().getTableMap();
    1183    }
    1184
    1185    public static void initDatabaseMap()
    1186    {
    1187    }
    1188
    1189
    1190}