View Javadoc

1   package org.apache.turbine.services.schedule;
2   
3   import java.sql.Connection;
4   import java.sql.SQLException;
5   import java.sql.ResultSet;
6   import java.io.IOException;
7   import java.io.InputStream;
8   import java.util.ArrayList;
9   import java.util.Collection;
10  import java.util.Date;
11  import java.util.Iterator;
12  import java.util.List;
13  
14  import org.apache.commons.logging.Log;
15  import org.apache.commons.logging.LogFactory;
16  import org.apache.torque.NoRowsException;
17  import org.apache.torque.TooManyRowsException;
18  import org.apache.torque.Column;
19  import org.apache.torque.Torque;
20  import org.apache.torque.TorqueException;
21  import org.apache.torque.TorqueRuntimeException;
22  import org.apache.torque.adapter.IDMethod;
23  import org.apache.torque.criteria.Criteria;
24  import org.apache.torque.map.DatabaseMap;
25  import org.apache.torque.map.TableMap;
26  import org.apache.torque.map.ColumnMap;
27  import org.apache.torque.map.ForeignKeyMap;
28  import org.apache.torque.map.InheritanceMap;
29  import org.apache.torque.om.mapper.RecordMapper;
30  import org.apache.torque.om.mapper.CompositeMapper;
31  import org.apache.torque.om.DateKey;
32  import org.apache.torque.om.NumberKey;
33  import org.apache.torque.om.StringKey;
34  import org.apache.torque.om.ObjectKey;
35  import org.apache.torque.om.SimpleKey;
36  import org.apache.torque.util.Transaction;
37  import org.apache.torque.util.ColumnValues;
38  import org.apache.torque.util.JdbcTypedValue;
39  
40  
41  
42  /**
43   * The skeleton for this class was autogenerated by Torque on:
44   *
45   * [Mon Dec 21 20:40:21 CET 2015]
46   *
47   * You should not use this class directly.  It should not even be
48   * extended; all references should be to JobEntryTorquePeer
49   */
50  
51  public abstract class BaseJobEntryTorquePeer
52  {
53      /** The class log. */
54      private static Log log = LogFactory.getLog(BaseJobEntryTorquePeerImpl.class);
55      /** The default database name for this class. */
56      public static final String DATABASE_NAME;
57  
58       /** The table name for this class. */
59      public static final String TABLE_NAME;
60  
61       /** The table map for this class. */
62      public static final TableMap TABLE;
63      /** The column for the JOB_ID field */
64      public static final ColumnMap JOB_ID;
65      /** The column for the SECOND field */
66      public static final ColumnMap SECOND;
67      /** The column for the MINUTE field */
68      public static final ColumnMap MINUTE;
69      /** The column for the HOUR field */
70      public static final ColumnMap HOUR;
71      /** The column for the WEEK_DAY field */
72      public static final ColumnMap WEEK_DAY;
73      /** The column for the DAY_OF_MONTH field */
74      public static final ColumnMap DAY_OF_MONTH;
75      /** The column for the TASK field */
76      public static final ColumnMap TASK;
77      /** The column for the EMAIL field */
78      public static final ColumnMap EMAIL;
79      /** The column for the PROPERTY field */
80      public static final ColumnMap PROPERTY;
81  
82      /** number of columns for this peer */
83      public static final int numColumns = 9;
84  
85  
86      /** The implementation of the peer. */
87      private static JobEntryTorquePeerImpl jobEntryTorquePeerImpl;
88  
89  
90      static
91      {
92          DatabaseMap dbMap = Torque.getOrCreateDatabase("default")
93                  .getDatabaseMap();
94          if (dbMap.getTable("TURBINE_SCHEDULED_JOB") == null)
95          {
96              dbMap.addTable("TURBINE_SCHEDULED_JOB");
97          }
98          DATABASE_NAME = "default";
99          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 }