BaseFrequencyPeer


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