Java > Open Source Codes > org > campware > cream > om > BaseTurbineUserGroupRolePeer


1 package org.campware.cream.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.campware.cream.om.map.*;
32
33
34   
35   
36   
37 /**
38  * This class was autogenerated by Torque on:
39  *
40  * [Wed May 04 09:10:56 CEST 2005]
41  *
42  */
43 public abstract class BaseTurbineUserGroupRolePeer
44     extends BasePeer
45 {
46
47     /** the default database name for this class */
48     public static final String DATABASE_NAME = "cream";
49
50      /** the table name for this class */
51     public static final String TABLE_NAME = "TURBINE_USER_GROUP_ROLE";
52
53     /**
54      * @return the map builder for this peer
55      * @throws TorqueException Any exceptions caught during processing will be
56      * rethrown wrapped into a TorqueException.
57      */
58     public static MapBuilder getMapBuilder()
59         throws TorqueException
60     {
61         return getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME);
62     }
63
64       /** the column name for the USER_ID field */
65     public static final String USER_ID;
66       /** the column name for the GROUP_ID field */
67     public static final String GROUP_ID;
68       /** the column name for the ROLE_ID field */
69     public static final String ROLE_ID;
70   
71     static
72     {
73           USER_ID = "TURBINE_USER_GROUP_ROLE.USER_ID";
74           GROUP_ID = "TURBINE_USER_GROUP_ROLE.GROUP_ID";
75           ROLE_ID = "TURBINE_USER_GROUP_ROLE.ROLE_ID";
76           if (Torque.isInit())
77         {
78             try
79             {
80                 getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME);
81             }
82             catch (Exception e)
83             {
84                 log.error("Could not initialize Peer", e);
85             }
86         }
87         else
88         {
89             Torque.registerMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME);
90         }
91     }
92  
93     /** number of columns for this peer */
94     public static final int numColumns = 3;
95
96     /** A class that can be returned by this peer. */
97     protected static final String CLASSNAME_DEFAULT =
98         "org.campware.cream.om.TurbineUserGroupRole";
99
100     /** A class that can be returned by this peer. */
101     protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT);
102
103     /**
104      * Class object initialization method.
105      *
106      * @param className name of the class to initialize
107      * @return the initialized class
108      */
109     private static Class initClass(String className)
110     {
111         Class c = null;
112         try
113         {
114             c = Class.forName(className);
115         }
116         catch (Throwable t)
117         {
118             log.error("A FATAL ERROR has occurred which should not "
119                 + "have happened under any circumstance. Please notify "
120                 + "the Torque developers <torque-dev@db.apache.org> "
121                 + "and give as many details as possible (including the error "
122                 + "stack trace).", t);
123
124             // Error objects should always be propogated.
125 if (t instanceof Error )
126             {
127                 throw (Error ) t.fillInStackTrace();
128             }
129         }
130         return c;
131     }
132
133     /**
134      * Get the list of objects for a ResultSet. Please not that your
135      * resultset MUST return columns in the right order. You can use
136      * getFieldNames() in BaseObject to get the correct sequence.
137      *
138      * @param results the ResultSet
139      * @return the list of objects
140      * @throws TorqueException Any exceptions caught during processing will be
141      * rethrown wrapped into a TorqueException.
142      */
143     public static List resultSet2Objects(java.sql.ResultSet results)
144             throws TorqueException
145     {
146         try
147         {
148             QueryDataSet qds = null;
149             List rows = null;
150             try
151             {
152                 qds = new QueryDataSet(results);
153                 rows = getSelectResults(qds);
154             }
155             finally
156             {
157                 if (qds != null)
158                 {
159                     qds.close();
160                 }
161             }
162
163             return populateObjects(rows);
164         }
165         catch (SQLException e)
166         {
167             throw new TorqueException(e);
168         }
169         catch (DataSetException e)
170         {
171             throw new TorqueException(e);
172         }
173     }
174
175
176   
177     /**
178      * Method to do inserts.
179      *
180      * @param criteria object used to create the INSERT statement.
181      * @throws TorqueException Any exceptions caught during processing will be
182      * rethrown wrapped into a TorqueException.
183      */
184     public static ObjectKey doInsert(Criteria criteria)
185         throws TorqueException
186     {
187         return BaseTurbineUserGroupRolePeer
188             .doInsert(criteria, (Connection ) null);
189     }
190
191     /**
192      * Method to do inserts. This method is to be used during a transaction,
193      * otherwise use the doInsert(Criteria) method. It will take care of
194      * the connection details internally.
195      *
196      * @param criteria object used to create the INSERT statement.
197      * @param con the connection to use
198      * @throws TorqueException Any exceptions caught during processing will be
199      * rethrown wrapped into a TorqueException.
200      */
201     public static ObjectKey doInsert(Criteria criteria, Connection con)
202         throws TorqueException
203     {
204                     
205         setDbName(criteria);
206
207         if (con == null)
208         {
209             return BasePeer.doInsert(criteria);
210         }
211         else
212         {
213             return BasePeer.doInsert(criteria, con);
214         }
215     }
216
217     /**
218      * Add all the columns needed to create a new object.
219      *
220      * @param criteria object containing the columns to add.
221      * @throws TorqueException Any exceptions caught during processing will be
222      * rethrown wrapped into a TorqueException.
223      */
224     public static void addSelectColumns(Criteria criteria)
225             throws TorqueException
226     {
227           criteria.addSelectColumn(USER_ID);
228           criteria.addSelectColumn(GROUP_ID);
229           criteria.addSelectColumn(ROLE_ID);
230       }
231
232     /**
233      * Create a new object of type cls from a resultset row starting
234      * from a specified offset. This is done so that you can select
235      * other rows than just those needed for this object. You may
236      * for example want to create two objects from the same row.
237      *
238      * @throws TorqueException Any exceptions caught during processing will be
239      * rethrown wrapped into a TorqueException.
240      */
241     public static TurbineUserGroupRole row2Object(Record row,
242                                              int offset,
243                                              Class cls)
244         throws TorqueException
245     {
246         try
247         {
248             TurbineUserGroupRole obj = (TurbineUserGroupRole) cls.newInstance();
249             TurbineUserGroupRolePeer.populateObject(row, offset, obj);
250                   obj.setModified(false);
251               obj.setNew(false);
252
253             return obj;
254         }
255         catch (InstantiationException e)
256         {
257             throw new TorqueException(e);
258         }
259         catch (IllegalAccessException e)
260         {
261             throw new TorqueException(e);
262         }
263     }
264
265     /**
266      * Populates an object from a resultset row starting
267      * from a specified offset. This is done so that you can select
268      * other rows than just those needed for this object. You may
269      * for example want to create two objects from the same row.
270      *
271      * @throws TorqueException Any exceptions caught during processing will be
272      * rethrown wrapped into a TorqueException.
273      */
274     public static void populateObject(Record row,
275                                       int offset,
276                                       TurbineUserGroupRole obj)
277         throws TorqueException
278     {
279         try
280         {
281                 obj.setUserId(row.getValue(offset + 0).asInt());
282                   obj.setGroupId(row.getValue(offset + 1).asInt());
283                   obj.setRoleId(row.getValue(offset + 2).asInt());
284               }
285         catch (DataSetException e)
286         {
287             throw new TorqueException(e);
288         }
289     }
290
291     /**
292      * Method to do selects.
293      *
294      * @param criteria object used to create the SELECT statement.
295      * @return List of selected Objects
296      * @throws TorqueException Any exceptions caught during processing will be
297      * rethrown wrapped into a TorqueException.
298      */
299     public static List doSelect(Criteria criteria) throws TorqueException
300     {
301         return populateObjects(doSelectVillageRecords(criteria));
302     }
303
304     /**
305      * Method to do selects within a transaction.
306      *
307      * @param criteria object used to create the SELECT statement.
308      * @param con the connection to use
309      * @return List of selected Objects
310      * @throws TorqueException Any exceptions caught during processing will be
311      * rethrown wrapped into a TorqueException.
312      */
313     public static List doSelect(Criteria criteria, Connection con)
314         throws TorqueException
315     {
316         return populateObjects(doSelectVillageRecords(criteria, con));
317     }
318
319     /**
320      * Grabs the raw Village records to be formed into objects.
321      * This method handles connections internally. The Record objects
322      * returned by this method should be considered readonly. Do not
323      * alter the data and call save(), your results may vary, but are
324      * certainly likely to result in hard to track MT bugs.
325      *
326      * @throws TorqueException Any exceptions caught during processing will be
327      * rethrown wrapped into a TorqueException.
328      */
329     public static List doSelectVillageRecords(Criteria criteria)
330         throws TorqueException
331     {
332         return BaseTurbineUserGroupRolePeer
333             .doSelectVillageRecords(criteria, (Connection ) null);
334     }
335
336     /**
337      * Grabs the raw Village records to be formed into objects.
338      * This method should be used for transactions
339      *
340      * @param criteria object used to create the SELECT statement.
341      * @param con the connection to use
342      * @throws TorqueException Any exceptions caught during processing will be
343      * rethrown wrapped into a TorqueException.
344      */
345     public static List doSelectVillageRecords(Criteria criteria, Connection con)
346         throws TorqueException
347     {
348         if (criteria.getSelectColumns().size() == 0)
349         {
350             addSelectColumns(criteria);
351         }
352
353                     
354         setDbName(criteria);
355
356         // BasePeer returns a List of Value (Village) arrays. The array
357 // order follows the order columns were placed in the Select clause.
358 if (con == null)
359         {
360             return BasePeer.doSelect(criteria);
361         }
362         else
363         {
364             return BasePeer.doSelect(criteria, con);
365         }
366     }
367
368     /**
369      * The returned List will contain objects of the default type or
370      * objects that inherit from the default.
371      *
372      * @throws TorqueException Any exceptions caught during processing will be
373      * rethrown wrapped into a TorqueException.
374      */
375     public static List populateObjects(List records)
376         throws TorqueException
377     {
378         List results = new ArrayList (records.size());
379
380         // populate the object(s)
381 for (int i = 0; i < records.size(); i++)
382         {
383             Record row = (Record) records.get(i);
384               results.add(TurbineUserGroupRolePeer.row2Object(row, 1,
385                 TurbineUserGroupRolePeer.getOMClass()));
386           }
387         return results;
388     }
389  
390
391     /**
392      * The class that the Peer will make instances of.
393      * If the BO is abstract then you must implement this method
394      * in the BO.
395      *
396      * @throws TorqueException Any exceptions caught during processing will be
397      * rethrown wrapped into a TorqueException.
398      */
399     public static Class getOMClass()
400         throws TorqueException
401     {
402         return CLASS_DEFAULT;
403     }
404
405     /**
406      * Method to do updates.
407      *
408      * @param criteria object containing data that is used to create the UPDATE
409      * statement.
410      * @throws TorqueException Any exceptions caught during processing will be
411      * rethrown wrapped into a TorqueException.
412      */
413     public static void doUpdate(Criteria criteria) throws TorqueException
414     {
415          BaseTurbineUserGroupRolePeer
416             .doUpdate(criteria, (Connection ) null);
417     }
418
419     /**
420      * Method to do updates. This method is to be used during a transaction,
421      * otherwise use the doUpdate(Criteria) method. It will take care of
422      * the connection details internally.
423      *
424      * @param criteria object containing data that is used to create the UPDATE
425      * statement.
426      * @param con the connection to use
427      * @throws TorqueException Any exceptions caught during processing will be
428      * rethrown wrapped into a TorqueException.
429      */
430     public static void doUpdate(Criteria criteria, Connection con)
431         throws TorqueException
432     {
433         Criteria selectCriteria = new Criteria(DATABASE_NAME, 2);
434                    selectCriteria.put(USER_ID, criteria.remove(USER_ID));
435                        selectCriteria.put(GROUP_ID, criteria.remove(GROUP_ID));
436                        selectCriteria.put(ROLE_ID, criteria.remove(ROLE_ID));
437       
438         setDbName(criteria);
439
440         if (con == null)
441         {
442             BasePeer.doUpdate(selectCriteria, criteria);
443         }
444         else
445         {
446             BasePeer.doUpdate(selectCriteria, criteria, con);
447         }
448     }
449
450     /**
451      * Method to do deletes.
452      *
453      * @param criteria object containing data that is used DELETE from database.
454      * @throws TorqueException Any exceptions caught during processing will be
455      * rethrown wrapped into a TorqueException.
456      */
457      public static void doDelete(Criteria criteria) throws TorqueException
458      {
459          TurbineUserGroupRolePeer
460             .doDelete(criteria, (Connection ) null);
461      }
462
463     /**
464      * Method to do deletes. This method is to be used during a transaction,
465      * otherwise use the doDelete(Criteria) method. It will take care of
466      * the connection details internally.
467      *
468      * @param criteria object containing data that is used DELETE from database.
469      * @param con the connection to use
470      * @throws TorqueException Any exceptions caught during processing will be
471      * rethrown wrapped into a TorqueException.
472      */
473      public static void doDelete(Criteria criteria, Connection con)
474         throws TorqueException
475      {
476                     
477         setDbName(criteria);
478
479         if (con == null)
480         {
481             BasePeer.doDelete(criteria);
482         }
483         else
484         {
485             BasePeer.doDelete(criteria, con);
486         }
487      }
488
489     /**
490      * Method to do selects
491      *
492      * @throws TorqueException Any exceptions caught during processing will be
493      * rethrown wrapped into a TorqueException.
494      */
495     public static List doSelect(TurbineUserGroupRole obj) throws TorqueException
496     {
497         return doSelect(buildSelectCriteria(obj));
498     }
499
500     /**
501      * Method to do inserts
502      *
503      * @throws TorqueException Any exceptions caught during processing will be
504      * rethrown wrapped into a TorqueException.
505      */
506     public static void doInsert(TurbineUserGroupRole obj) throws TorqueException
507     {
508           doInsert(buildCriteria(obj));
509           obj.setNew(false);
510         obj.setModified(false);
511     }
512
513     /**
514      * @param obj the data object to update in the database.
515      * @throws TorqueException Any exceptions caught during processing will be
516      * rethrown wrapped into a TorqueException.
517      */
518     public static void doUpdate(TurbineUserGroupRole obj) throws TorqueException
519     {
520         doUpdate(buildCriteria(obj));
521         obj.setModified(false);
522     }
523
524     /**
525      * @param obj the data object to delete in the database.
526      * @throws TorqueException Any exceptions caught during processing will be
527      * rethrown wrapped into a TorqueException.
528      */
529     public static void doDelete(TurbineUserGroupRole obj) throws TorqueException
530     {
531         doDelete(buildSelectCriteria(obj));
532     }
533
534     /**
535      * Method to do inserts. This method is to be used during a transaction,
536      * otherwise use the doInsert(TurbineUserGroupRole) method. It will take
537      * care of the connection details internally.
538      *
539      * @param obj the data object to insert into the database.
540      * @param con the connection to use
541      * @throws TorqueException Any exceptions caught during processing will be
542      * rethrown wrapped into a TorqueException.
543      */
544     public static void doInsert(TurbineUserGroupRole obj, Connection con)
545         throws TorqueException
546     {
547           doInsert(buildCriteria(obj), con);
548           obj.setNew(false);
549         obj.setModified(false);
550     }
551
552     /**
553      * Method to do update. This method is to be used during a transaction,
554      * otherwise use the doUpdate(TurbineUserGroupRole) method. It will take
555      * care of the connection details internally.
556      *
557      * @param obj the data object to update in the database.
558      * @param con the connection to use
559      * @throws TorqueException Any exceptions caught during processing will be
560      * rethrown wrapped into a TorqueException.
561      */
562     public static void doUpdate(TurbineUserGroupRole obj, Connection con)
563         throws TorqueException
564     {
565         doUpdate(buildCriteria(obj), con);
566         obj.setModified(false);
567     }
568
569     /**
570      * Method to delete. This method is to be used during a transaction,
571      * otherwise use the doDelete(TurbineUserGroupRole) method. It will take
572      * care of the connection details internally.
573      *
574      * @param obj the data object to delete in the database.
575      * @param con the connection to use
576      * @throws TorqueException Any exceptions caught during processing will be
577      * rethrown wrapped into a TorqueException.
578      */
579     public static void doDelete(TurbineUserGroupRole obj, Connection con)
580         throws TorqueException
581     {
582         doDelete(buildSelectCriteria(obj), con);
583     }
584
585     /**
586      * Method to do deletes.
587      *
588      * @param pk ObjectKey that is used DELETE from database.
589      * @throws TorqueException Any exceptions caught during processing will be
590      * rethrown wrapped into a TorqueException.
591      */
592     public static void doDelete(ObjectKey pk) throws TorqueException
593     {
594         BaseTurbineUserGroupRolePeer
595            .doDelete(pk, (Connection ) null);
596     }
597
598     /**
599      * Method to delete. This method is to be used during a transaction,
600      * otherwise use the doDelete(ObjectKey) method. It will take
601      * care of the connection details internally.
602      *
603      * @param pk the primary key for the object to delete in the database.
604      * @param con the connection to use
605      * @throws TorqueException Any exceptions caught during processing will be
606      * rethrown wrapped into a TorqueException.
607      */
608     public static void doDelete(ObjectKey pk, Connection con)
609         throws TorqueException
610     {
611         doDelete(buildCriteria(pk), con);
612     }
613
614     /** Build a Criteria object from an ObjectKey */
615     public static Criteria buildCriteria( ObjectKey pk )
616     {
617         Criteria criteria = new Criteria();
618           SimpleKey[] keys = (SimpleKey[])pk.getValue();
619                     criteria.add(USER_ID, keys[0]);
620                       criteria.add(GROUP_ID, keys[1]);
621                       criteria.add(ROLE_ID, keys[2]);
622                     return criteria;
623      }
624
625     /** Build a Criteria object from the data object for this peer */
626     public static Criteria buildCriteria( TurbineUserGroupRole obj )
627     {
628         Criteria criteria = new Criteria(DATABASE_NAME);
629               criteria.add(USER_ID, obj.getUserId());
630               criteria.add(GROUP_ID, obj.getGroupId());
631               criteria.add(ROLE_ID, obj.getRoleId());
632           return criteria;
633     }
634
635     /** Build a Criteria object from the data object for this peer, skipping all binary columns */
636     public static Criteria buildSelectCriteria( TurbineUserGroupRole obj )
637     {
638         Criteria criteria = new Criteria(DATABASE_NAME);
639                       criteria.add(USER_ID, obj.getUserId());
640                           criteria.add(GROUP_ID, obj.getGroupId());
641                           criteria.add(ROLE_ID, obj.getRoleId());
642               return criteria;
643     }
644  
645     
646     
647     /**
648      * Retrieve a single object by pk
649      *
650      * @param pk the primary key
651      * @throws TorqueException Any exceptions caught during processing will be
652      * rethrown wrapped into a TorqueException.
653      * @throws NoRowsException Primary key was not found in database.
654      * @throws TooManyRowsException Primary key was not found in database.
655      */
656     public static TurbineUserGroupRole retrieveByPK(ObjectKey pk)
657         throws TorqueException, NoRowsException, TooManyRowsException
658     {
659         Connection db = null;
660         TurbineUserGroupRole retVal = null;
661         try
662         {
663             db = Torque.getConnection(DATABASE_NAME);
664             retVal = retrieveByPK(pk, db);
665         }
666         finally
667         {
668             Torque.closeConnection(db);
669         }
670         return(retVal);
671     }
672
673     /**
674      * Retrieve a single object by pk
675      *
676      * @param pk the primary key
677      * @param con the connection to use
678      * @throws TorqueException Any exceptions caught during processing will be
679      * rethrown wrapped into a TorqueException.
680      * @throws NoRowsException Primary key was not found in database.
681      * @throws TooManyRowsException Primary key was not found in database.
682      */
683     public static TurbineUserGroupRole retrieveByPK(ObjectKey pk, Connection con)
684         throws TorqueException, NoRowsException, TooManyRowsException
685     {
686         Criteria criteria = buildCriteria(pk);
687         List v = doSelect(criteria, con);
688         if (v.size() == 0)
689         {
690             throw new NoRowsException("Failed to select a row.");
691         }
692         else if (v.size() > 1)
693         {
694             throw new TooManyRowsException("Failed to select only one row.");
695         }
696         else
697         {
698             return (TurbineUserGroupRole)v.get(0);
699         }
700     }
701
702     /**
703      * Retrieve a multiple objects by pk
704      *
705      * @param pks List of primary keys
706      * @throws TorqueException Any exceptions caught during processing will be
707      * rethrown wrapped into a TorqueException.
708      */
709     public static List retrieveByPKs(List pks)
710         throws TorqueException
711     {
712         Connection db = null;
713         List retVal = null;
714         try
715         {
716            db = Torque.getConnection(DATABASE_NAME);
717            retVal = retrieveByPKs(pks, db);
718         }
719         finally
720         {
721             Torque.closeConnection(db);
722         }
723         return(retVal);
724     }
725
726     /**
727      * Retrieve a multiple objects by pk
728      *
729      * @param pks List of primary keys
730      * @param dbcon the connection to use
731      * @throws TorqueException Any exceptions caught during processing will be
732      * rethrown wrapped into a TorqueException.
733      */
734     public static List retrieveByPKs( List pks, Connection dbcon )
735         throws TorqueException
736     {
737         List objs = null;
738         if (pks == null || pks.size() == 0)
739         {
740             objs = new LinkedList ();
741         }
742         else
743         {
744             Criteria criteria = new Criteria();
745               Iterator iter = pks.iterator();
746             while (iter.hasNext())
747             {
748                 ObjectKey pk = (ObjectKey)iter.next();
749                 SimpleKey[] keys = (SimpleKey[])pk.getValue();
750                             Criteria.Criterion c0 = criteria.getNewCriterion(
751                         USER_ID, keys[0], Criteria.EQUAL);
752                                     Criteria.Criterion c1 = criteria.getNewCriterion(
753                         GROUP_ID, keys[1], Criteria.EQUAL);
754                                     c0.and(c1);
755                               Criteria.Criterion c2 = criteria.getNewCriterion(
756                         ROLE_ID, keys[2], Criteria.EQUAL);
757                                     c1.and(c2);
758                           criteria.or(c0);
759             }
760           objs = doSelect(criteria, dbcon);
761         }
762         return objs;
763     }
764
765  
766     /**
767      * retrieve object using using pk values.
768      *
769        * @param user_id int
770        * @param group_id int
771        * @param role_id int
772        */
773     public static TurbineUserGroupRole retrieveByPK(
774        int user_id
775           , int group_id
776           , int role_id
777               ) throws TorqueException
778     {
779         Connection db = null;
780         TurbineUserGroupRole retVal = null;
781         try
782         {
783            db = Torque.getConnection(DATABASE_NAME);
784            retVal = retrieveByPK(
785          user_id
786           , group_id
787           , role_id
788                      , db);
789         }
790         finally
791         {
792             Torque.closeConnection(db);
793         }
794         return(retVal);
795     }
796
797       /**
798      * retrieve object using using pk values.
799      *
800        * @param user_id int
801        * @param group_id int
802        * @param role_id int
803        * @param con Connection
804      */
805     public static TurbineUserGroupRole retrieveByPK(
806        int user_id
807           , int group_id
808           , int role_id
809              ,Connection con) throws TorqueException
810     {
811
812         Criteria criteria = new Criteria(5);
813           criteria.add(USER_ID, user_id);
814           criteria.add(GROUP_ID, group_id);
815           criteria.add(ROLE_ID, role_id);
816           List v = doSelect(criteria, con);
817         if (v.size() != 1)
818         {
819             throw new TorqueException("Failed to select one and only one row.");
820         }
821         else
822         {
823             return (TurbineUserGroupRole) v.get(0);
824         }
825     }
826
827
828
829               
830                                               
831                 
832                 
833
834     /**
835      * selects a collection of TurbineUserGroupRole objects pre-filled with their
836      * TurbineUser objects.
837      *
838      * This method is protected by default in order to keep the public
839      * api reasonable. You can provide public methods for those you
840      * actually need in TurbineUserGroupRolePeer.
841      *
842      * @throws TorqueException Any exceptions caught during processing will be
843      * rethrown wrapped into a TorqueException.
844      */
845     protected static List doSelectJoinTurbineUser(Criteria criteria)
846         throws TorqueException
847     {
848         setDbName(criteria);
849
850         TurbineUserGroupRolePeer.addSelectColumns(criteria);
851         int offset = numColumns + 1;
852         TurbineUserPeer.addSelectColumns(criteria);
853
854
855                         criteria.addJoin(TurbineUserGroupRolePeer.USER_ID,
856             TurbineUserPeer.USER_ID);
857         
858
859                                                               
860         List rows = BasePeer.doSelect(criteria);
861         List results = new ArrayList ();
862
863         for (int i = 0; i < rows.size(); i++)
864         {
865             Record row = (Record) rows.get(i);
866
867                             Class omClass = TurbineUserGroupRolePeer.getOMClass();
868                     TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
869                 .row2Object(row, 1, omClass);
870                      omClass = TurbineUserPeer.getOMClass();
871                     TurbineUser obj2 = (TurbineUser)TurbineUserPeer
872                 .row2Object(row, offset, omClass);
873
874             boolean newObject = true;
875             for (int j = 0; j < results.size(); j++)
876             {
877                 TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
878                 TurbineUser temp_obj2 = (TurbineUser)temp_obj1.getTurbineUser();
879                 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
880                 {
881                     newObject = false;
882                               temp_obj2.addTurbineUserGroupRole(obj1);
883                               break;
884                 }
885             }
886                       if (newObject)
887             {
888                 obj2.initTurbineUserGroupRoles();
889                 obj2.addTurbineUserGroupRole(obj1);
890             }
891                       results.add(obj1);
892         }
893         return results;
894     }
895                                                             
896                 
897                 
898
899     /**
900      * selects a collection of TurbineUserGroupRole objects pre-filled with their
901      * TurbineGroup objects.
902      *
903      * This method is protected by default in order to keep the public
904      * api reasonable. You can provide public methods for those you
905      * actually need in TurbineUserGroupRolePeer.
906      *
907      * @throws TorqueException Any exceptions caught during processing will be
908      * rethrown wrapped into a TorqueException.
909      */
910     protected static List doSelectJoinTurbineGroup(Criteria criteria)
911         throws TorqueException
912     {
913         setDbName(criteria);
914
915         TurbineUserGroupRolePeer.addSelectColumns(criteria);
916         int offset = numColumns + 1;
917         TurbineGroupPeer.addSelectColumns(criteria);
918
919
920                         criteria.addJoin(TurbineUserGroupRolePeer.GROUP_ID,
921             TurbineGroupPeer.GROUP_ID);
922         
923
924                                                               
925         List rows = BasePeer.doSelect(criteria);
926         List results = new ArrayList ();
927
928         for (int i = 0; i < rows.size(); i++)
929         {
930             Record row = (Record) rows.get(i);
931
932                             Class omClass = TurbineUserGroupRolePeer.getOMClass();
933                     TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
934                 .row2Object(row, 1, omClass);
935                      omClass = TurbineGroupPeer.getOMClass();
936                     TurbineGroup obj2 = (TurbineGroup)TurbineGroupPeer
937                 .row2Object(row, offset, omClass);
938
939             boolean newObject = true;
940             for (int j = 0; j < results.size(); j++)
941             {
942                 TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
943                 TurbineGroup temp_obj2 = (TurbineGroup)temp_obj1.getTurbineGroup();
944                 if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
945                 {
946                     newObject = false;
947                               temp_obj2.addTurbineUserGroupRole(obj1);
948                               break;
949                 }
950             }
951                       if (newObject)
952             {
953                 obj2.initTurbineUserGroupRoles();
954                 obj2.addTurbineUserGroupRole(obj1);
955             }
956                       results.add(obj1);
957         }
958         return results;
959     }
960                                                             
961                 
962                 
963
964     /**
965      * selects a collection of TurbineUserGroupRole objects pre-filled with their
966      * TurbineRole objects.
967      *
968      * This method is protected by default in order to keep the public
969      * api reasonable. You can provide public methods for those you
970      * actually need in TurbineUserGroupRolePeer.
971      *
972      * @throws TorqueException Any exceptions caught during processing will be
973      * rethrown wrapped into a TorqueException.
974      */
975     protected static List doSelectJoinTurbineRole(Criteria criteria)
976         throws TorqueException
977     {
978         setDbName(criteria);
979
980         TurbineUserGroupRolePeer.addSelectColumns(criteria);
981         int offset = numColumns + 1;
982         TurbineRolePeer.addSelectColumns(criteria);
983
984
985                         criteria.addJoin(TurbineUserGroupRolePeer.ROLE_ID,
986             TurbineRolePeer.ROLE_ID);
987         
988
989                                                               
990         List rows = BasePeer.doSelect(criteria);
991         List results = new ArrayList ();
992
993         for (int i = 0; i < rows.size(); i++)
994         {
995             Record row = (Record) rows.get(i);
996
997                             Class omClass = TurbineUserGroupRolePeer.getOMClass();
998                     TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
999                 .row2Object(row, 1, omClass);
1000                     omClass = TurbineRolePeer.getOMClass();
1001                    TurbineRole obj2 = (TurbineRole)TurbineRolePeer
1002                .row2Object(row, offset, omClass);
1003
1004            boolean newObject = true;
1005            for (int j = 0; j < results.size(); j++)
1006            {
1007                TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
1008                TurbineRole temp_obj2 = (TurbineRole)temp_obj1.getTurbineRole();
1009                if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1010                {
1011                    newObject = false;
1012                              temp_obj2.addTurbineUserGroupRole(obj1);
1013                              break;
1014                }
1015            }
1016                      if (newObject)
1017            {
1018                obj2.initTurbineUserGroupRoles();
1019                obj2.addTurbineUserGroupRole(obj1);
1020            }
1021                      results.add(obj1);
1022        }
1023        return results;
1024    }
1025                    
1026  
1027                                    
1028          
1029        
1030                                  
1031                
1032
1033    /**
1034     * selects a collection of TurbineUserGroupRole objects pre-filled with
1035     * all related objects.
1036     *
1037     * This method is protected by default in order to keep the public
1038     * api reasonable. You can provide public methods for those you
1039     * actually need in TurbineUserGroupRolePeer.
1040     *
1041     * @throws TorqueException Any exceptions caught during processing will be
1042     * rethrown wrapped into a TorqueException.
1043     */
1044    protected static List doSelectJoinAllExceptTurbineUser(Criteria criteria)
1045        throws TorqueException
1046    {
1047        setDbName(criteria);
1048
1049        addSelectColumns(criteria);
1050        int offset2 = numColumns + 1;
1051                                    
1052                                                  
1053                    TurbineGroupPeer.addSelectColumns(criteria);
1054        int offset3 = offset2 + TurbineGroupPeer.numColumns;
1055                                                                
1056                    TurbineRolePeer.addSelectColumns(criteria);
1057        int offset4 = offset3 + TurbineRolePeer.numColumns;
1058                                                                                                          
1059        List rows = BasePeer.doSelect(criteria);
1060        List results = new ArrayList ();
1061
1062        for (int i = 0; i < rows.size(); i++)
1063        {
1064            Record row = (Record)rows.get(i);
1065
1066                            Class omClass = TurbineUserGroupRolePeer.getOMClass();
1067                    TurbineUserGroupRole obj1 = (TurbineUserGroupRole)TurbineUserGroupRolePeer
1068                .row2Object(row, 1, omClass);
1069                                                
1070                                                                  
1071                                                        
1072                            
1073              
1074                           omClass = TurbineGroupPeer.getOMClass();
1075                          TurbineGroup obj2 = (TurbineGroup)TurbineGroupPeer
1076                .row2Object( row, offset2, omClass);
1077
1078               boolean newObject = true;
1079            for (int j = 0; j < results.size(); j++)
1080            {
1081                TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
1082                TurbineGroup temp_obj2 = (TurbineGroup)temp_obj1.getTurbineGroup();
1083                if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1084                {
1085                    newObject = false;
1086                                    temp_obj2.addTurbineUserGroupRole(obj1);
1087                                    break;
1088                }
1089            }
1090                            if (newObject)
1091            {
1092                obj2.initTurbineUserGroupRoles();
1093                obj2.addTurbineUserGroupRole(obj1);
1094            }
1095                                                                                    
1096                                                        
1097                            
1098              
1099                           omClass = TurbineRolePeer.getOMClass();
1100                          TurbineRole obj3 = (TurbineRole)TurbineRolePeer
1101                .row2Object( row, offset3, omClass);
1102
1103               newObject = true;
1104            for (int j = 0; j < results.size(); j++)
1105            {
1106                TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
1107                TurbineRole temp_obj3 = (TurbineRole)temp_obj1.getTurbineRole();
1108                if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey()))
1109                {
1110                    newObject = false;
1111                                    temp_obj3.addTurbineUserGroupRole(obj1);
1112                                    break;
1113                }
1114            }
1115                            if (newObject)
1116            {
1117                obj3.initTurbineUserGroupRoles();
1118                obj3.addTurbineUserGroupRole(obj1);
1119            }
1120                                                                results.add(obj1);
1121        }
1122        return results;
1123    }
1124        
1125        
1126                                  
1127                
1128
1129    /**
1130     * selects a collection of TurbineUserGroupRole objects pre-filled with
1131     * all related objects.
1132     *
1133     * This method is protected by default in order to keep the public
1134     * api reasonable. You can provide public methods for those you
1135     * actually need in TurbineUserGroupRolePeer.
1136     *
1137     * @throws TorqueException Any exceptions caught during processing will be
1138     * rethrown wrapped into a TorqueException.
1139     */
1140    protected static List doSelectJoinAllExceptTurbineGroup(Criteria criteria)
1141        throws TorqueException
1142    {
1143        setDbName(criteria);
1144
1145        addSelectColumns(criteria);
1146        int offset2 = numColumns + 1;
1147                                    
1148                    TurbineUserPeer.addSelectColumns(criteria);
1149        int offset3 = offset2 + TurbineUserPeer.numColumns;
1150                                                                
1151                                                  
1152                    TurbineRolePeer.addSelectColumns(criteria);
1153        int offset4 = offset3 + TurbineRolePeer.numColumns;
1154                                                                                                          
1155        List rows = BasePeer.doSelect(criteria);
1156        List results = new ArrayList ();
1157
1158        for (int i = 0; i < rows.size(); i++)
1159        {
1160            Record row = (Record)rows.get(i);
1161
1162                            Class omClass = TurbineUserGroupRolePeer.getOMClass();
1163                    TurbineUserGroupRole obj1 = (TurbineUserGroupRole)TurbineUserGroupRolePeer
1164                .row2Object(row, 1, omClass);
1165                                                
1166                                                        
1167                            
1168              
1169                           omClass = TurbineUserPeer.getOMClass();
1170                          TurbineUser obj2 = (TurbineUser)TurbineUserPeer
1171                .row2Object( row, offset2, omClass);
1172
1173               boolean newObject = true;
1174            for (int j = 0; j < results.size(); j++)
1175            {
1176                TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
1177                TurbineUser temp_obj2 = (TurbineUser)temp_obj1.getTurbineUser();
1178                if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1179                {
1180                    newObject = false;
1181                                    temp_obj2.addTurbineUserGroupRole(obj1);
1182                                    break;
1183                }
1184            }
1185                            if (newObject)
1186            {
1187                obj2.initTurbineUserGroupRoles();
1188                obj2.addTurbineUserGroupRole(obj1);
1189            }
1190                                                                                    
1191                                                                  
1192                                                        
1193                            
1194              
1195                           omClass = TurbineRolePeer.getOMClass();
1196                          TurbineRole obj3 = (TurbineRole)TurbineRolePeer
1197                .row2Object( row, offset3, omClass);
1198
1199               newObject = true;
1200            for (int j = 0; j < results.size(); j++)
1201            {
1202                TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
1203                TurbineRole temp_obj3 = (TurbineRole)temp_obj1.getTurbineRole();
1204                if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey()))
1205                {
1206                    newObject = false;
1207                                    temp_obj3.addTurbineUserGroupRole(obj1);
1208                                    break;
1209                }
1210            }
1211                            if (newObject)
1212            {
1213                obj3.initTurbineUserGroupRoles();
1214                obj3.addTurbineUserGroupRole(obj1);
1215            }
1216                                                                results.add(obj1);
1217        }
1218        return results;
1219    }
1220        
1221        
1222                                  
1223                
1224
1225    /**
1226     * selects a collection of TurbineUserGroupRole objects pre-filled with
1227     * all related objects.
1228     *
1229     * This method is protected by default in order to keep the public
1230     * api reasonable. You can provide public methods for those you
1231     * actually need in TurbineUserGroupRolePeer.
1232     *
1233     * @throws TorqueException Any exceptions caught during processing will be
1234     * rethrown wrapped into a TorqueException.
1235     */
1236    protected static List doSelectJoinAllExceptTurbineRole(Criteria criteria)
1237        throws TorqueException
1238    {
1239        setDbName(criteria);
1240
1241        addSelectColumns(criteria);
1242        int offset2 = numColumns + 1;
1243                                    
1244                    TurbineUserPeer.addSelectColumns(criteria);
1245        int offset3 = offset2 + TurbineUserPeer.numColumns;
1246                                                                
1247                    TurbineGroupPeer.addSelectColumns(criteria);
1248        int offset4 = offset3 + TurbineGroupPeer.numColumns;
1249                                                                
1250                                                                                            
1251        List rows = BasePeer.doSelect(criteria);
1252        List results = new ArrayList ();
1253
1254        for (int i = 0; i < rows.size(); i++)
1255        {
1256            Record row = (Record)rows.get(i);
1257
1258                            Class omClass = TurbineUserGroupRolePeer.getOMClass();
1259                    TurbineUserGroupRole obj1 = (TurbineUserGroupRole)TurbineUserGroupRolePeer
1260                .row2Object(row, 1, omClass);
1261                                                
1262                                                        
1263                            
1264              
1265                           omClass = TurbineUserPeer.getOMClass();
1266                          TurbineUser obj2 = (TurbineUser)TurbineUserPeer
1267                .row2Object( row, offset2, omClass);
1268
1269               boolean newObject = true;
1270            for (int j = 0; j < results.size(); j++)
1271            {
1272                TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
1273                TurbineUser temp_obj2 = (TurbineUser)temp_obj1.getTurbineUser();
1274                if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1275                {
1276                    newObject = false;
1277                                    temp_obj2.addTurbineUserGroupRole(obj1);
1278                                    break;
1279                }
1280            }
1281                            if (newObject)
1282            {
1283                obj2.initTurbineUserGroupRoles();
1284                obj2.addTurbineUserGroupRole(obj1);
1285            }
1286                                                                                    
1287                                                        
1288                            
1289              
1290                           omClass = TurbineGroupPeer.getOMClass();
1291                          TurbineGroup obj3 = (TurbineGroup)TurbineGroupPeer
1292                .row2Object( row, offset3, omClass);
1293
1294               newObject = true;
1295            for (int j = 0; j < results.size(); j++)
1296            {
1297                TurbineUserGroupRole temp_obj1 = (TurbineUserGroupRole)results.get(j);
1298                TurbineGroup temp_obj3 = (TurbineGroup)temp_obj1.getTurbineGroup();
1299                if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey()))
1300                {
1301                    newObject = false;
1302                                    temp_obj3.addTurbineUserGroupRole(obj1);
1303                                    break;
1304                }
1305            }
1306                            if (newObject)
1307            {
1308                obj3.initTurbineUserGroupRoles();
1309                obj3.addTurbineUserGroupRole(obj1);
1310            }
1311                                                                                    
1312                                              results.add(obj1);
1313        }
1314        return results;
1315    }
1316                    
1317  
1318      /**
1319     * Returns the TableMap related to this peer. This method is not
1320     * needed for general use but a specific application could have a need.
1321     *
1322     * @throws TorqueException Any exceptions caught during processing will be
1323     * rethrown wrapped into a TorqueException.
1324     */
1325    protected static TableMap getTableMap()
1326        throws TorqueException
1327    {
1328        return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME);
1329    }
1330   
1331    private static void setDbName(Criteria crit)
1332    {
1333        // Set the correct dbName if it has not been overridden
1334 // crit.getDbName will return the same object if not set to
1335 // another value so == check is okay and faster
1336 if (crit.getDbName() == Torque.getDefaultDB())
1337        {
1338            crit.setDbName(DATABASE_NAME);
1339        }
1340    }
1341}
1342

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Free Books   Free Magazines  

Popular Tags