Coverage report

  %line %branch
org.apache.turbine.services.schedule.BaseJobEntryPeer
10% 
71% 

 1  
 package org.apache.turbine.services.schedule;
 2  
 
 3  
 import java.math.BigDecimal;
 4  
 import java.sql.Connection;
 5  
 import java.sql.SQLException;
 6  
 import java.util.ArrayList;
 7  
 import java.util.Date;
 8  
 import java.util.Iterator;
 9  
 import java.util.LinkedList;
 10  
 import java.util.List;
 11  
 
 12  
 import org.apache.torque.NoRowsException;
 13  
 import org.apache.torque.TooManyRowsException;
 14  
 import org.apache.torque.Torque;
 15  
 import org.apache.torque.TorqueException;
 16  
 import org.apache.torque.map.MapBuilder;
 17  
 import org.apache.torque.map.TableMap;
 18  
 import org.apache.torque.om.DateKey;
 19  
 import org.apache.torque.om.NumberKey;
 20  
 import org.apache.torque.om.StringKey;
 21  
 import org.apache.torque.om.ObjectKey;
 22  
 import org.apache.torque.om.SimpleKey;
 23  
 import org.apache.torque.util.BasePeer;
 24  
 import org.apache.torque.util.Criteria;
 25  
 
 26  
 import com.workingdogs.village.DataSetException;
 27  
 import com.workingdogs.village.QueryDataSet;
 28  
 import com.workingdogs.village.Record;
 29  
 
 30  
 // Local classes
 31  
 import org.apache.turbine.services.schedule.map.*;
 32  
 
 33  
 
 34  
 /**
 35  
  * This class was autogenerated by Torque on:
 36  
  *
 37  
  * [Mon Oct 03 14:24:57 CEST 2005]
 38  
  *
 39  
  */
 40  4
 public abstract class BaseJobEntryPeer
 41  
     extends BasePeer
 42  
 {
 43  
 
 44  
     /** the default database name for this class */
 45  
     public static final String DATABASE_NAME = "default";
 46  
 
 47  
      /** the table name for this class */
 48  
     public static final String TABLE_NAME = "TURBINE_SCHEDULED_JOB";
 49  
 
 50  
     /**
 51  
      * @return the map builder for this peer
 52  
      * @throws TorqueException Any exceptions caught during processing will be
 53  
      *         rethrown wrapped into a TorqueException.
 54  
      */
 55  
     public static MapBuilder getMapBuilder()
 56  
         throws TorqueException
 57  
     {
 58  0
         return getMapBuilder(JobEntryMapBuilder.CLASS_NAME);
 59  
     }
 60  
 
 61  
       /** the column name for the JOB_ID field */
 62  
     public static final String JOB_ID;
 63  
       /** the column name for the SECOND field */
 64  
     public static final String SECOND;
 65  
       /** the column name for the MINUTE field */
 66  
     public static final String MINUTE;
 67  
       /** the column name for the HOUR field */
 68  
     public static final String HOUR;
 69  
       /** the column name for the WEEK_DAY field */
 70  
     public static final String WEEK_DAY;
 71  
       /** the column name for the DAY_OF_MONTH field */
 72  
     public static final String DAY_OF_MONTH;
 73  
       /** the column name for the TASK field */
 74  
     public static final String TASK;
 75  
       /** the column name for the EMAIL field */
 76  
     public static final String EMAIL;
 77  
       /** the column name for the PROPERTY field */
 78  
     public static final String PROPERTY;
 79  
   
 80  
     static
 81  2
     {
 82  4
           JOB_ID = "TURBINE_SCHEDULED_JOB.JOB_ID";
 83  4
           SECOND = "TURBINE_SCHEDULED_JOB.SECOND";
 84  4
           MINUTE = "TURBINE_SCHEDULED_JOB.MINUTE";
 85  4
           HOUR = "TURBINE_SCHEDULED_JOB.HOUR";
 86  4
           WEEK_DAY = "TURBINE_SCHEDULED_JOB.WEEK_DAY";
 87  4
           DAY_OF_MONTH = "TURBINE_SCHEDULED_JOB.DAY_OF_MONTH";
 88  4
           TASK = "TURBINE_SCHEDULED_JOB.TASK";
 89  4
           EMAIL = "TURBINE_SCHEDULED_JOB.EMAIL";
 90  4
           PROPERTY = "TURBINE_SCHEDULED_JOB.PROPERTY";
 91  4
           if (Torque.isInit())
 92  
         {
 93  
             try
 94  
             {
 95  0
                 getMapBuilder(JobEntryMapBuilder.CLASS_NAME);
 96  
             }
 97  0
             catch (Exception e)
 98  
             {
 99  0
                 log.error("Could not initialize Peer", e);
 100  0
             }
 101  
         }
 102  
         else
 103  
         {
 104  4
             Torque.registerMapBuilder(JobEntryMapBuilder.CLASS_NAME);
 105  
         }
 106  
     }
 107  
  
 108  
     /** number of columns for this peer */
 109  
     public static final int numColumns =  9;
 110  
 
 111  
     /** A class that can be returned by this peer. */
 112  
     protected static final String CLASSNAME_DEFAULT =
 113  
         "org.apache.turbine.services.schedule.JobEntry";
 114  
 
 115  
     /** A class that can be returned by this peer. */
 116  4
     protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT);
 117  
 
 118  
     /**
 119  
      * Class object initialization method.
 120  
      *
 121  
      * @param className name of the class to initialize
 122  
      * @return the initialized class
 123  
      */
 124  
     private static Class initClass(String className)
 125  
     {
 126  4
         Class c = null;
 127  
         try
 128  
         {
 129  4
             c = Class.forName(className);
 130  2
         }
 131  0
         catch (Throwable t)
 132  
         {
 133  0
             log.error("A FATAL ERROR has occurred which should not "
 134  
                 + "have happened under any circumstance.  Please notify "
 135  
                 + "the Torque developers <torque-dev@db.apache.org> "
 136  
                 + "and give as many details as possible (including the error "
 137  
                 + "stack trace).", t);
 138  
 
 139  
             // Error objects should always be propogated.
 140  0
             if (t instanceof Error)
 141  
             {
 142  0
                 throw (Error) t.fillInStackTrace();
 143  
             }
 144  2
         }
 145  4
         return c;
 146  
     }
 147  
 
 148  
     /**
 149  
      * Get the list of objects for a ResultSet.  Please not that your
 150  
      * resultset MUST return columns in the right order.  You can use
 151  
      * getFieldNames() in BaseObject to get the correct sequence.
 152  
      *
 153  
      * @param results the ResultSet
 154  
      * @return the list of objects
 155  
      * @throws TorqueException Any exceptions caught during processing will be
 156  
      *         rethrown wrapped into a TorqueException.
 157  
      */
 158  
     public static List resultSet2Objects(java.sql.ResultSet results)
 159  
             throws TorqueException
 160  
     {
 161  
         try
 162  
         {
 163  0
             QueryDataSet qds = null;
 164  0
             List rows = null;
 165  
             try
 166  
             {
 167  0
                 qds = new QueryDataSet(results);
 168  0
                 rows = getSelectResults(qds);
 169  
             }
 170  
             finally
 171  
             {
 172  0
                 if (qds != null)
 173  
                 {
 174  0
                     qds.close();
 175  
                 }
 176  
             }
 177  
 
 178  0
             return populateObjects(rows);
 179  
         }
 180  0
         catch (SQLException e)
 181  
         {
 182  0
             throw new TorqueException(e);
 183  
         }
 184  0
         catch (DataSetException e)
 185  
         {
 186  0
             throw new TorqueException(e);
 187  
         }
 188  
     }
 189  
 
 190  
 
 191  
   
 192  
     /**
 193  
      * Method to do inserts.
 194  
      *
 195  
      * @param criteria object used to create the INSERT statement.
 196  
      * @throws TorqueException Any exceptions caught during processing will be
 197  
      *         rethrown wrapped into a TorqueException.
 198  
      */
 199  
     public static ObjectKey doInsert(Criteria criteria)
 200  
         throws TorqueException
 201  
     {
 202  0
         return BaseJobEntryPeer
 203  
             .doInsert(criteria, (Connection) null);
 204  
     }
 205  
 
 206  
     /**
 207  
      * Method to do inserts.  This method is to be used during a transaction,
 208  
      * otherwise use the doInsert(Criteria) method.  It will take care of
 209  
      * the connection details internally.
 210  
      *
 211  
      * @param criteria object used to create the INSERT statement.
 212  
      * @param con the connection to use
 213  
      * @throws TorqueException Any exceptions caught during processing will be
 214  
      *         rethrown wrapped into a TorqueException.
 215  
      */
 216  
     public static ObjectKey doInsert(Criteria criteria, Connection con)
 217  
         throws TorqueException
 218  
     {
 219  
                                                         
 220  0
         setDbName(criteria);
 221  
 
 222  0
         if (con == null)
 223  
         {
 224  0
             return BasePeer.doInsert(criteria);
 225  
         }
 226  
         else
 227  
         {
 228  0
             return BasePeer.doInsert(criteria, con);
 229  
         }
 230  
     }
 231  
 
 232  
     /**
 233  
      * Add all the columns needed to create a new object.
 234  
      *
 235  
      * @param criteria object containing the columns to add.
 236  
      * @throws TorqueException Any exceptions caught during processing will be
 237  
      *         rethrown wrapped into a TorqueException.
 238  
      */
 239  
     public static void addSelectColumns(Criteria criteria)
 240  
             throws TorqueException
 241  
     {
 242  0
           criteria.addSelectColumn(JOB_ID);
 243  0
           criteria.addSelectColumn(SECOND);
 244  0
           criteria.addSelectColumn(MINUTE);
 245  0
           criteria.addSelectColumn(HOUR);
 246  0
           criteria.addSelectColumn(WEEK_DAY);
 247  0
           criteria.addSelectColumn(DAY_OF_MONTH);
 248  0
           criteria.addSelectColumn(TASK);
 249  0
           criteria.addSelectColumn(EMAIL);
 250  0
           criteria.addSelectColumn(PROPERTY);
 251  0
       }
 252  
 
 253  
     /**
 254  
      * Create a new object of type cls from a resultset row starting
 255  
      * from a specified offset.  This is done so that you can select
 256  
      * other rows than just those needed for this object.  You may
 257  
      * for example want to create two objects from the same row.
 258  
      *
 259  
      * @throws TorqueException Any exceptions caught during processing will be
 260  
      *         rethrown wrapped into a TorqueException.
 261  
      */
 262  
     public static JobEntry row2Object(Record row,
 263  
                                              int offset,
 264  
                                              Class cls)
 265  
         throws TorqueException
 266  
     {
 267  
         try
 268  
         {
 269  0
             JobEntry obj = (JobEntry) cls.newInstance();
 270  0
             JobEntryPeer.populateObject(row, offset, obj);
 271  0
                   obj.setModified(false);
 272  0
               obj.setNew(false);
 273  
 
 274  0
             return obj;
 275  
         }
 276  0
         catch (InstantiationException e)
 277  
         {
 278  0
             throw new TorqueException(e);
 279  
         }
 280  0
         catch (IllegalAccessException e)
 281  
         {
 282  0
             throw new TorqueException(e);
 283  
         }
 284  
     }
 285  
 
 286  
     /**
 287  
      * Populates an object from a resultset row starting
 288  
      * from a specified offset.  This is done so that you can select
 289  
      * other rows than just those needed for this object.  You may
 290  
      * for example want to create two objects from the same row.
 291  
      *
 292  
      * @throws TorqueException Any exceptions caught during processing will be
 293  
      *         rethrown wrapped into a TorqueException.
 294  
      */
 295  
     public static void populateObject(Record row,
 296  
                                       int offset,
 297  
                                       JobEntry obj)
 298  
         throws TorqueException
 299  
     {
 300  
         try
 301  
         {
 302  0
                 obj.setJobId(row.getValue(offset + 0).asInt());
 303  0
                   obj.setSecond(row.getValue(offset + 1).asInt());
 304  0
                   obj.setMinute(row.getValue(offset + 2).asInt());
 305  0
                   obj.setHour(row.getValue(offset + 3).asInt());
 306  0
                   obj.setWeekDay(row.getValue(offset + 4).asInt());
 307  0
                   obj.setDayOfMonth(row.getValue(offset + 5).asInt());
 308  0
                   obj.setTask(row.getValue(offset + 6).asString());
 309  0
                   obj.setEmail(row.getValue(offset + 7).asString());
 310  0
                   obj.setProperty(row.getValue(offset + 8).asBytes());
 311  
               }
 312  0
         catch (DataSetException e)
 313  
         {
 314  0
             throw new TorqueException(e);
 315  0
         }
 316  0
     }
 317  
 
 318  
     /**
 319  
      * Method to do selects.
 320  
      *
 321  
      * @param criteria object used to create the SELECT statement.
 322  
      * @return List of selected Objects
 323  
      * @throws TorqueException Any exceptions caught during processing will be
 324  
      *         rethrown wrapped into a TorqueException.
 325  
      */
 326  
     public static List doSelect(Criteria criteria) throws TorqueException
 327  
     {
 328  0
         return populateObjects(doSelectVillageRecords(criteria));
 329  
     }
 330  
 
 331  
     /**
 332  
      * Method to do selects within a transaction.
 333  
      *
 334  
      * @param criteria object used to create the SELECT statement.
 335  
      * @param con the connection to use
 336  
      * @return List of selected Objects
 337  
      * @throws TorqueException Any exceptions caught during processing will be
 338  
      *         rethrown wrapped into a TorqueException.
 339  
      */
 340  
     public static List doSelect(Criteria criteria, Connection con)
 341  
         throws TorqueException
 342  
     {
 343  0
         return populateObjects(doSelectVillageRecords(criteria, con));
 344  
     }
 345  
 
 346  
     /**
 347  
      * Grabs the raw Village records to be formed into objects.
 348  
      * This method handles connections internally.  The Record objects
 349  
      * returned by this method should be considered readonly.  Do not
 350  
      * alter the data and call save(), your results may vary, but are
 351  
      * certainly likely to result in hard to track MT bugs.
 352  
      *
 353  
      * @throws TorqueException Any exceptions caught during processing will be
 354  
      *         rethrown wrapped into a TorqueException.
 355  
      */
 356  
     public static List doSelectVillageRecords(Criteria criteria)
 357  
         throws TorqueException
 358  
     {
 359  0
         return BaseJobEntryPeer
 360  
             .doSelectVillageRecords(criteria, (Connection) null);
 361  
     }
 362  
 
 363  
     /**
 364  
      * Grabs the raw Village records to be formed into objects.
 365  
      * This method should be used for transactions
 366  
      *
 367  
      * @param criteria object used to create the SELECT statement.
 368  
      * @param con the connection to use
 369  
      * @throws TorqueException Any exceptions caught during processing will be
 370  
      *         rethrown wrapped into a TorqueException.
 371  
      */
 372  
     public static List doSelectVillageRecords(Criteria criteria, Connection con)
 373  
         throws TorqueException
 374  
     {
 375  0
         if (criteria.getSelectColumns().size() == 0)
 376  
         {
 377  0
             addSelectColumns(criteria);
 378  
         }
 379  
 
 380  
                                                         
 381  0
         setDbName(criteria);
 382  
 
 383  
         // BasePeer returns a List of Value (Village) arrays.  The array
 384  
         // order follows the order columns were placed in the Select clause.
 385  0
         if (con == null)
 386  
         {
 387  0
             return BasePeer.doSelect(criteria);
 388  
         }
 389  
         else
 390  
         {
 391  0
             return BasePeer.doSelect(criteria, con);
 392  
         }
 393  
     }
 394  
 
 395  
     /**
 396  
      * The returned List will contain objects of the default type or
 397  
      * objects that inherit from the default.
 398  
      *
 399  
      * @throws TorqueException Any exceptions caught during processing will be
 400  
      *         rethrown wrapped into a TorqueException.
 401  
      */
 402  
     public static List populateObjects(List records)
 403  
         throws TorqueException
 404  
     {
 405  0
         List results = new ArrayList(records.size());
 406  
 
 407  
         // populate the object(s)
 408  0
         for (int i = 0; i < records.size(); i++)
 409  
         {
 410  0
             Record row = (Record) records.get(i);
 411  0
               results.add(JobEntryPeer.row2Object(row, 1,
 412  
                 JobEntryPeer.getOMClass()));
 413  
           }
 414  0
         return results;
 415  
     }
 416  
  
 417  
 
 418  
     /**
 419  
      * The class that the Peer will make instances of.
 420  
      * If the BO is abstract then you must implement this method
 421  
      * in the BO.
 422  
      *
 423  
      * @throws TorqueException Any exceptions caught during processing will be
 424  
      *         rethrown wrapped into a TorqueException.
 425  
      */
 426  
     public static Class getOMClass()
 427  
         throws TorqueException
 428  
     {
 429  0
         return CLASS_DEFAULT;
 430  
     }
 431  
 
 432  
     /**
 433  
      * Method to do updates.
 434  
      *
 435  
      * @param criteria object containing data that is used to create the UPDATE
 436  
      *        statement.
 437  
      * @throws TorqueException Any exceptions caught during processing will be
 438  
      *         rethrown wrapped into a TorqueException.
 439  
      */
 440  
     public static void doUpdate(Criteria criteria) throws TorqueException
 441  
     {
 442  0
          BaseJobEntryPeer
 443  
             .doUpdate(criteria, (Connection) null);
 444  0
     }
 445  
 
 446  
     /**
 447  
      * Method to do updates.  This method is to be used during a transaction,
 448  
      * otherwise use the doUpdate(Criteria) method.  It will take care of
 449  
      * the connection details internally.
 450  
      *
 451  
      * @param criteria object containing data that is used to create the UPDATE
 452  
      *        statement.
 453  
      * @param con the connection to use
 454  
      * @throws TorqueException Any exceptions caught during processing will be
 455  
      *         rethrown wrapped into a TorqueException.
 456  
      */
 457  
     public static void doUpdate(Criteria criteria, Connection con)
 458  
         throws TorqueException
 459  
     {
 460  0
         Criteria selectCriteria = new Criteria(DATABASE_NAME, 2);
 461  0
                    selectCriteria.put(JOB_ID, criteria.remove(JOB_ID));
 462  
                                                                                       
 463  0
         setDbName(criteria);
 464  
 
 465  0
         if (con == null)
 466  
         {
 467  0
             BasePeer.doUpdate(selectCriteria, criteria);
 468  
         }
 469  
         else
 470  
         {
 471  0
             BasePeer.doUpdate(selectCriteria, criteria, con);
 472  
         }
 473  0
     }
 474  
 
 475  
     /**
 476  
      * Method to do deletes.
 477  
      *
 478  
      * @param criteria object containing data that is used DELETE from database.
 479  
      * @throws TorqueException Any exceptions caught during processing will be
 480  
      *         rethrown wrapped into a TorqueException.
 481  
      */
 482  
      public static void doDelete(Criteria criteria) throws TorqueException
 483  
      {
 484  0
          JobEntryPeer
 485  
             .doDelete(criteria, (Connection) null);
 486  0
      }
 487  
 
 488  
     /**
 489  
      * Method to do deletes.  This method is to be used during a transaction,
 490  
      * otherwise use the doDelete(Criteria) method.  It will take care of
 491  
      * the connection details internally.
 492  
      *
 493  
      * @param criteria object containing data that is used DELETE from database.
 494  
      * @param con the connection to use
 495  
      * @throws TorqueException Any exceptions caught during processing will be
 496  
      *         rethrown wrapped into a TorqueException.
 497  
      */
 498  
      public static void doDelete(Criteria criteria, Connection con)
 499  
         throws TorqueException
 500  
      {
 501  
                                                         
 502  0
         setDbName(criteria);
 503  
 
 504  0
         if (con == null)
 505  
         {
 506  0
             BasePeer.doDelete(criteria);
 507  
         }
 508  
         else
 509  
         {
 510  0
             BasePeer.doDelete(criteria, con);
 511  
         }
 512  0
      }
 513  
 
 514  
     /**
 515  
      * Method to do selects
 516  
      *
 517  
      * @throws TorqueException Any exceptions caught during processing will be
 518  
      *         rethrown wrapped into a TorqueException.
 519  
      */
 520  
     public static List doSelect(JobEntry obj) throws TorqueException
 521  
     {
 522  0
         return doSelect(buildSelectCriteria(obj));
 523  
     }
 524  
 
 525  
     /**
 526  
      * Method to do inserts
 527  
      *
 528  
      * @throws TorqueException Any exceptions caught during processing will be
 529  
      *         rethrown wrapped into a TorqueException.
 530  
      */
 531  
     public static void doInsert(JobEntry obj) throws TorqueException
 532  
     {
 533  0
           obj.setPrimaryKey(doInsert(buildCriteria(obj)));
 534  0
           obj.setNew(false);
 535  0
         obj.setModified(false);
 536  0
     }
 537  
 
 538  
     /**
 539  
      * @param obj the data object to update in the database.
 540  
      * @throws TorqueException Any exceptions caught during processing will be
 541  
      *         rethrown wrapped into a TorqueException.
 542  
      */
 543  
     public static void doUpdate(JobEntry obj) throws TorqueException
 544  
     {
 545  0
         doUpdate(buildCriteria(obj));
 546  0
         obj.setModified(false);
 547  0
     }
 548  
 
 549  
     /**
 550  
      * @param obj the data object to delete in the database.
 551  
      * @throws TorqueException Any exceptions caught during processing will be
 552  
      *         rethrown wrapped into a TorqueException.
 553  
      */
 554  
     public static void doDelete(JobEntry obj) throws TorqueException
 555  
     {
 556  0
         doDelete(buildSelectCriteria(obj));
 557  0
     }
 558  
 
 559  
     /**
 560  
      * Method to do inserts.  This method is to be used during a transaction,
 561  
      * otherwise use the doInsert(JobEntry) method.  It will take
 562  
      * care of the connection details internally.
 563  
      *
 564  
      * @param obj the data object to insert into the database.
 565  
      * @param con the connection to use
 566  
      * @throws TorqueException Any exceptions caught during processing will be
 567  
      *         rethrown wrapped into a TorqueException.
 568  
      */
 569  
     public static void doInsert(JobEntry obj, Connection con)
 570  
         throws TorqueException
 571  
     {
 572  0
           obj.setPrimaryKey(doInsert(buildCriteria(obj), con));
 573  0
           obj.setNew(false);
 574  0
         obj.setModified(false);
 575  0
     }
 576  
 
 577  
     /**
 578  
      * Method to do update.  This method is to be used during a transaction,
 579  
      * otherwise use the doUpdate(JobEntry) method.  It will take
 580  
      * care of the connection details internally.
 581  
      *
 582  
      * @param obj the data object to update in the database.
 583  
      * @param con the connection to use
 584  
      * @throws TorqueException Any exceptions caught during processing will be
 585  
      *         rethrown wrapped into a TorqueException.
 586  
      */
 587  
     public static void doUpdate(JobEntry obj, Connection con)
 588  
         throws TorqueException
 589  
     {
 590  0
         doUpdate(buildCriteria(obj), con);
 591  0
         obj.setModified(false);
 592  0
     }
 593  
 
 594  
     /**
 595  
      * Method to delete.  This method is to be used during a transaction,
 596  
      * otherwise use the doDelete(JobEntry) method.  It will take
 597  
      * care of the connection details internally.
 598  
      *
 599  
      * @param obj the data object to delete in the database.
 600  
      * @param con the connection to use
 601  
      * @throws TorqueException Any exceptions caught during processing will be
 602  
      *         rethrown wrapped into a TorqueException.
 603  
      */
 604  
     public static void doDelete(JobEntry obj, Connection con)
 605  
         throws TorqueException
 606  
     {
 607  0
         doDelete(buildSelectCriteria(obj), con);
 608  0
     }
 609  
 
 610  
     /**
 611  
      * Method to do deletes.
 612  
      *
 613  
      * @param pk ObjectKey that is used DELETE from database.
 614  
      * @throws TorqueException Any exceptions caught during processing will be
 615  
      *         rethrown wrapped into a TorqueException.
 616  
      */
 617  
     public static void doDelete(ObjectKey pk) throws TorqueException
 618  
     {
 619  0
         BaseJobEntryPeer
 620  
            .doDelete(pk, (Connection) null);
 621  0
     }
 622  
 
 623  
     /**
 624  
      * Method to delete.  This method is to be used during a transaction,
 625  
      * otherwise use the doDelete(ObjectKey) method.  It will take
 626  
      * care of the connection details internally.
 627  
      *
 628  
      * @param pk the primary key for the object to delete in the database.
 629  
      * @param con the connection to use
 630  
      * @throws TorqueException Any exceptions caught during processing will be
 631  
      *         rethrown wrapped into a TorqueException.
 632  
      */
 633  
     public static void doDelete(ObjectKey pk, Connection con)
 634  
         throws TorqueException
 635  
     {
 636  0
         doDelete(buildCriteria(pk), con);
 637  0
     }
 638  
 
 639  
     /** Build a Criteria object from an ObjectKey */
 640  
     public static Criteria buildCriteria( ObjectKey pk )
 641  
     {
 642  0
         Criteria criteria = new Criteria();
 643  0
               criteria.add(JOB_ID, pk);
 644  0
           return criteria;
 645  
      }
 646  
 
 647  
     /** Build a Criteria object from the data object for this peer */
 648  
     public static Criteria buildCriteria( JobEntry obj )
 649  
     {
 650  0
         Criteria criteria = new Criteria(DATABASE_NAME);
 651  0
               if (!obj.isNew())
 652  0
             criteria.add(JOB_ID, obj.getJobId());
 653  0
               criteria.add(SECOND, obj.getSecond());
 654  0
               criteria.add(MINUTE, obj.getMinute());
 655  0
               criteria.add(HOUR, obj.getHour());
 656  0
               criteria.add(WEEK_DAY, obj.getWeekDay());
 657  0
               criteria.add(DAY_OF_MONTH, obj.getDayOfMonth());
 658  0
               criteria.add(TASK, obj.getTask());
 659  0
               criteria.add(EMAIL, obj.getEmail());
 660  0
               criteria.add(PROPERTY, obj.getProperty());
 661  0
           return criteria;
 662  
     }
 663  
 
 664  
     /** Build a Criteria object from the data object for this peer, skipping all binary columns */
 665  
     public static Criteria buildSelectCriteria( JobEntry obj )
 666  
     {
 667  0
         Criteria criteria = new Criteria(DATABASE_NAME);
 668  0
               if (!obj.isNew())
 669  0
                     criteria.add(JOB_ID, obj.getJobId());
 670  0
                           criteria.add(SECOND, obj.getSecond());
 671  0
                           criteria.add(MINUTE, obj.getMinute());
 672  0
                           criteria.add(HOUR, obj.getHour());
 673  0
                           criteria.add(WEEK_DAY, obj.getWeekDay());
 674  0
                           criteria.add(DAY_OF_MONTH, obj.getDayOfMonth());
 675  0
                           criteria.add(TASK, obj.getTask());
 676  0
                           criteria.add(EMAIL, obj.getEmail());
 677  0
                         return criteria;
 678  
     }
 679  
  
 680  
     
 681  
         /**
 682  
      * Retrieve a single object by pk
 683  
      *
 684  
      * @param pk the primary key
 685  
      * @throws TorqueException Any exceptions caught during processing will be
 686  
      *         rethrown wrapped into a TorqueException.
 687  
      * @throws NoRowsException Primary key was not found in database.
 688  
      * @throws TooManyRowsException Primary key was not found in database.
 689  
      */
 690  
     public static JobEntry retrieveByPK(int pk)
 691  
         throws TorqueException, NoRowsException, TooManyRowsException
 692  
     {
 693  0
         return retrieveByPK(SimpleKey.keyFor(pk));
 694  
     }
 695  
 
 696  
     /**
 697  
      * Retrieve a single object by pk
 698  
      *
 699  
      * @param pk the primary key
 700  
      * @param con the connection to use
 701  
      * @throws TorqueException Any exceptions caught during processing will be
 702  
      *         rethrown wrapped into a TorqueException.
 703  
      * @throws NoRowsException Primary key was not found in database.
 704  
      * @throws TooManyRowsException Primary key was not found in database.
 705  
      */
 706  
     public static JobEntry retrieveByPK(int pk, Connection con)
 707  
         throws TorqueException, NoRowsException, TooManyRowsException
 708  
     {
 709  0
         return retrieveByPK(SimpleKey.keyFor(pk), con);
 710  
     }
 711  
   
 712  
     /**
 713  
      * Retrieve a single object by pk
 714  
      *
 715  
      * @param pk the primary key
 716  
      * @throws TorqueException Any exceptions caught during processing will be
 717  
      *         rethrown wrapped into a TorqueException.
 718  
      * @throws NoRowsException Primary key was not found in database.
 719  
      * @throws TooManyRowsException Primary key was not found in database.
 720  
      */
 721  
     public static JobEntry retrieveByPK(ObjectKey pk)
 722  
         throws TorqueException, NoRowsException, TooManyRowsException
 723  
     {
 724  0
         Connection db = null;
 725  0
         JobEntry retVal = null;
 726  
         try
 727  
         {
 728  0
             db = Torque.getConnection(DATABASE_NAME);
 729  0
             retVal = retrieveByPK(pk, db);
 730  
         }
 731  
         finally
 732  
         {
 733  0
             Torque.closeConnection(db);
 734  0
         }
 735  0
         return(retVal);
 736  
     }
 737  
 
 738  
     /**
 739  
      * Retrieve a single object by pk
 740  
      *
 741  
      * @param pk the primary key
 742  
      * @param con the connection to use
 743  
      * @throws TorqueException Any exceptions caught during processing will be
 744  
      *         rethrown wrapped into a TorqueException.
 745  
      * @throws NoRowsException Primary key was not found in database.
 746  
      * @throws TooManyRowsException Primary key was not found in database.
 747  
      */
 748  
     public static JobEntry retrieveByPK(ObjectKey pk, Connection con)
 749  
         throws TorqueException, NoRowsException, TooManyRowsException
 750  
     {
 751  0
         Criteria criteria = buildCriteria(pk);
 752  0
         List v = doSelect(criteria, con);
 753  0
         if (v.size() == 0)
 754  
         {
 755  0
             throw new NoRowsException("Failed to select a row.");
 756  
         }
 757  0
         else if (v.size() > 1)
 758  
         {
 759  0
             throw new TooManyRowsException("Failed to select only one row.");
 760  
         }
 761  
         else
 762  
         {
 763  0
             return (JobEntry)v.get(0);
 764  
         }
 765  
     }
 766  
 
 767  
     /**
 768  
      * Retrieve a multiple objects by pk
 769  
      *
 770  
      * @param pks List of primary keys
 771  
      * @throws TorqueException Any exceptions caught during processing will be
 772  
      *         rethrown wrapped into a TorqueException.
 773  
      */
 774  
     public static List retrieveByPKs(List pks)
 775  
         throws TorqueException
 776  
     {
 777  0
         Connection db = null;
 778  0
         List retVal = null;
 779  
         try
 780  
         {
 781  0
            db = Torque.getConnection(DATABASE_NAME);
 782  0
            retVal = retrieveByPKs(pks, db);
 783  
         }
 784  
         finally
 785  
         {
 786  0
             Torque.closeConnection(db);
 787  0
         }
 788  0
         return(retVal);
 789  
     }
 790  
 
 791  
     /**
 792  
      * Retrieve a multiple objects by pk
 793  
      *
 794  
      * @param pks List of primary keys
 795  
      * @param dbcon the connection to use
 796  
      * @throws TorqueException Any exceptions caught during processing will be
 797  
      *         rethrown wrapped into a TorqueException.
 798  
      */
 799  
     public static List retrieveByPKs( List pks, Connection dbcon )
 800  
         throws TorqueException
 801  
     {
 802  0
         List objs = null;
 803  0
         if (pks == null || pks.size() == 0)
 804  
         {
 805  0
             objs = new LinkedList();
 806  
         }
 807  
         else
 808  
         {
 809  0
             Criteria criteria = new Criteria();
 810  0
               criteria.addIn( JOB_ID, pks );
 811  0
           objs = doSelect(criteria, dbcon);
 812  
         }
 813  0
         return objs;
 814  
     }
 815  
 
 816  
  
 817  
 
 818  
 
 819  
 
 820  
         
 821  
   
 822  
   
 823  
     
 824  
   
 825  
       /**
 826  
      * Returns the TableMap related to this peer.  This method is not
 827  
      * needed for general use but a specific application could have a need.
 828  
      *
 829  
      * @throws TorqueException Any exceptions caught during processing will be
 830  
      *         rethrown wrapped into a TorqueException.
 831  
      */
 832  
     protected static TableMap getTableMap()
 833  
         throws TorqueException
 834  
     {
 835  0
         return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME);
 836  
     }
 837  
    
 838  
     private static void setDbName(Criteria crit)
 839  
     {
 840  
         // Set the correct dbName if it has not been overridden
 841  
         // crit.getDbName will return the same object if not set to
 842  
         // another value so == check is okay and faster
 843  0
         if (crit.getDbName() == Torque.getDefaultDB())
 844  
         {
 845  0
             crit.setDbName(DATABASE_NAME);
 846  
         }
 847  0
     }
 848  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.