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