Java > Open Source Codes > org > tigris > scarab > om > BaseOptionRelationshipPeer


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 BaseOptionRelationshipPeer
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_OPTION_RELATIONSHIP";
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(OptionRelationshipMapBuilder.CLASS_NAME);
55     }
56
57       /** the column name for the RELATIONSHIP_ID field */
58     public static final String RELATIONSHIP_ID;
59       /** the column name for the RELATIONSHIP_NAME field */
60     public static final String RELATIONSHIP_NAME;
61   
62     static
63     {
64           RELATIONSHIP_ID = "SCARAB_OPTION_RELATIONSHIP.RELATIONSHIP_ID";
65           RELATIONSHIP_NAME = "SCARAB_OPTION_RELATIONSHIP.RELATIONSHIP_NAME";
66           if (Torque.isInit())
67         {
68             try
69             {
70                 getMapBuilder(OptionRelationshipMapBuilder.CLASS_NAME);
71             }
72             catch (Exception e)
73             {
74                 log.error("Could not initialize Peer", e);
75             }
76         }
77         else
78         {
79             Torque.registerMapBuilder(OptionRelationshipMapBuilder.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.OptionRelationship";
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 BaseOptionRelationshipPeer
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(RELATIONSHIP_ID);
218           criteria.addSelectColumn(RELATIONSHIP_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 OptionRelationship row2Object(Record row,
231                                              int offset,
232                                              Class cls)
233         throws TorqueException
234     {
235         try
236         {
237             OptionRelationship obj = (OptionRelationship) cls.newInstance();
238             OptionRelationshipPeer.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                                       OptionRelationship obj)
266         throws TorqueException
267     {
268         try
269         {
270                 obj.setRelationshipId(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 BaseOptionRelationshipPeer
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(OptionRelationshipPeer.row2Object(row, 1,
373                 OptionRelationshipPeer.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          BaseOptionRelationshipPeer
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(RELATIONSHIP_ID, criteria.remove(RELATIONSHIP_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          OptionRelationshipPeer
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(OptionRelationship 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(OptionRelationship obj) throws TorqueException
493     {
494           obj.setPrimaryKey(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(OptionRelationship 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(OptionRelationship 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(OptionRelationship) 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(OptionRelationship obj, Connection con)
531         throws TorqueException
532     {
533           obj.setPrimaryKey(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(OptionRelationship) 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(OptionRelationship 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(OptionRelationship) 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(OptionRelationship 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         BaseOptionRelationshipPeer
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(RELATIONSHIP_ID, pk);
605           return criteria;
606      }
607
608     /** Build a Criteria object from the data object for this peer */
609     public static Criteria buildCriteria( OptionRelationship obj )
610     {
611         Criteria criteria = new Criteria(DATABASE_NAME);
612               if (!obj.isNew())
613             criteria.add(RELATIONSHIP_ID, obj.getRelationshipId());
614               criteria.add(RELATIONSHIP_NAME, obj.getName());
615           return criteria;
616     }
617
618     /** Build a Criteria object from the data object for this peer, skipping all binary columns */
619     public static Criteria buildSelectCriteria( OptionRelationship obj )
620     {
621         Criteria criteria = new Criteria(DATABASE_NAME);
622               if (!obj.isNew())
623                     criteria.add(RELATIONSHIP_ID, obj.getRelationshipId());
624                           criteria.add(RELATIONSHIP_NAME, obj.getName());
625               return criteria;
626     }
627  
628     
629         /**
630      * Retrieve a single object by pk
631      *
632      * @param pk the primary key
633      * @throws TorqueException Any exceptions caught during processing will be
634      * rethrown wrapped into a TorqueException.
635      * @throws NoRowsException Primary key was not found in database.
636      * @throws TooManyRowsException Primary key was not found in database.
637      */
638     public static OptionRelationship retrieveByPK(Integer pk)
639         throws TorqueException, NoRowsException, TooManyRowsException
640     {
641         return retrieveByPK(SimpleKey.keyFor(pk));
642     }
643
644     /**
645      * Retrieve a single object by pk
646      *
647      * @param pk the primary key
648      * @param con the connection to use
649      * @throws TorqueException Any exceptions caught during processing will be
650      * rethrown wrapped into a TorqueException.
651      * @throws NoRowsException Primary key was not found in database.
652      * @throws TooManyRowsException Primary key was not found in database.
653      */
654     public static OptionRelationship retrieveByPK(Integer pk, Connection con)
655         throws TorqueException, NoRowsException, TooManyRowsException
656     {
657         return retrieveByPK(SimpleKey.keyFor(pk), con);
658     }
659   
660     /**
661      * Retrieve a single object by pk
662      *
663      * @param pk the primary key
664      * @throws TorqueException Any exceptions caught during processing will be
665      * rethrown wrapped into a TorqueException.
666      * @throws NoRowsException Primary key was not found in database.
667      * @throws TooManyRowsException Primary key was not found in database.
668      */
669     public static OptionRelationship retrieveByPK(ObjectKey pk)
670         throws TorqueException, NoRowsException, TooManyRowsException
671     {
672         Connection db = null;
673         OptionRelationship retVal = null;
674         try
675         {
676             db = Torque.getConnection(DATABASE_NAME);
677             retVal = retrieveByPK(pk, db);
678         }
679         finally
680         {
681             Torque.closeConnection(db);
682         }
683         return(retVal);
684     }
685
686     /**
687      * Retrieve a single object by pk
688      *
689      * @param pk the primary key
690      * @param con the connection to use
691      * @throws TorqueException Any exceptions caught during processing will be
692      * rethrown wrapped into a TorqueException.
693      * @throws NoRowsException Primary key was not found in database.
694      * @throws TooManyRowsException Primary key was not found in database.
695      */
696     public static OptionRelationship retrieveByPK(ObjectKey pk, Connection con)
697         throws TorqueException, NoRowsException, TooManyRowsException
698     {
699         Criteria criteria = buildCriteria(pk);
700         List v = doSelect(criteria, con);
701         if (v.size() == 0)
702         {
703             throw new NoRowsException("Failed to select a row.");
704         }
705         else if (v.size() > 1)
706         {
707             throw new TooManyRowsException("Failed to select only one row.");
708         }
709         else
710         {
711             return (OptionRelationship)v.get(0);
712         }
713     }
714
715     /**
716      * Retrieve a multiple objects by pk
717      *
718      * @param pks List of primary keys
719      * @throws TorqueException Any exceptions caught during processing will be
720      * rethrown wrapped into a TorqueException.
721      */
722     public static List retrieveByPKs(List pks)
723         throws TorqueException
724     {
725         Connection db = null;
726         List retVal = null;
727         try
728         {
729            db = Torque.getConnection(DATABASE_NAME);
730            retVal = retrieveByPKs(pks, db);
731         }
732         finally
733         {
734             Torque.closeConnection(db);
735         }
736         return(retVal);
737     }
738
739     /**
740      * Retrieve a multiple objects by pk
741      *
742      * @param pks List of primary keys
743      * @param dbcon the connection to use
744      * @throws TorqueException Any exceptions caught during processing will be
745      * rethrown wrapped into a TorqueException.
746      */
747     public static List retrieveByPKs( List pks, Connection dbcon )
748         throws TorqueException
749     {
750         List objs = null;
751         if (pks == null || pks.size() == 0)
752         {
753             objs = new LinkedList ();
754         }
755         else
756         {
757             Criteria criteria = new Criteria();
758               criteria.addIn( RELATIONSHIP_ID, pks );
759           objs = doSelect(criteria, dbcon);
760         }
761         return objs;
762     }
763
764  
765
766
767
768         
769   
770   
771     
772   
773       /**
774      * Returns the TableMap related to this peer. This method is not
775      * needed for general use but a specific application could have a need.
776      *
777      * @throws TorqueException Any exceptions caught during processing will be
778      * rethrown wrapped into a TorqueException.
779      */
780     protected static TableMap getTableMap()
781         throws TorqueException
782     {
783         return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME);
784     }
785    
786     private static void setDbName(Criteria crit)
787     {
788         // Set the correct dbName if it has not been overridden
789 // crit.getDbName will return the same object if not set to
790 // another value so == check is okay and faster
791 if (crit.getDbName() == Torque.getDefaultDB())
792         {
793             crit.setDbName(DATABASE_NAME);
794         }
795     }
796 }
797

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags