001    package org.apache.turbine.services.security.torque.om;
002    
003    import java.math.BigDecimal;
004    import java.sql.Connection;
005    import java.sql.SQLException;
006    import java.util.ArrayList;
007    import java.util.Date;
008    import java.util.Iterator;
009    import java.util.LinkedList;
010    import java.util.List;
011    
012    import org.apache.torque.NoRowsException;
013    import org.apache.torque.TooManyRowsException;
014    import org.apache.torque.Torque;
015    import org.apache.torque.TorqueException;
016    import org.apache.torque.TorqueRuntimeException;
017    import org.apache.torque.map.MapBuilder;
018    import org.apache.torque.map.TableMap;
019    import org.apache.torque.om.DateKey;
020    import org.apache.torque.om.NumberKey;
021    import org.apache.torque.om.StringKey;
022    import org.apache.torque.om.ObjectKey;
023    import org.apache.torque.om.SimpleKey;
024    import org.apache.torque.util.BasePeer;
025    import org.apache.torque.util.Criteria;
026    
027    import com.workingdogs.village.DataSetException;
028    import com.workingdogs.village.QueryDataSet;
029    import com.workingdogs.village.Record;
030    
031    // Local classes
032    import org.apache.turbine.services.security.torque.om.map.*;
033    
034    
035    
036    
037    /**
038     * This class was autogenerated by Torque on:
039     *
040     * [Thu Jun 23 17:25:46 CEST 2011]
041     *
042     */
043    public abstract class BaseTurbineUserGroupRolePeer
044        extends BasePeer
045    {
046        /** Serial version */
047        private static final long serialVersionUID = 1308842746584L;
048    
049    
050        /** the default database name for this class */
051        public static final String DATABASE_NAME;
052    
053         /** the table name for this class */
054        public static final String TABLE_NAME;
055    
056        /**
057         * @return the map builder for this peer
058         * @throws TorqueException Any exceptions caught during processing will be
059         *         rethrown wrapped into a TorqueException.
060         * @deprecated Torque.getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME) instead
061         */
062        public static MapBuilder getMapBuilder()
063            throws TorqueException
064        {
065            return Torque.getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME);
066        }
067    
068        /** the column name for the USER_ID field */
069        public static final String USER_ID;
070        /** the column name for the GROUP_ID field */
071        public static final String GROUP_ID;
072        /** the column name for the ROLE_ID field */
073        public static final String ROLE_ID;
074    
075        static
076        {
077            DATABASE_NAME = "default";
078            TABLE_NAME = "TURBINE_USER_GROUP_ROLE";
079    
080            USER_ID = "TURBINE_USER_GROUP_ROLE.USER_ID";
081            GROUP_ID = "TURBINE_USER_GROUP_ROLE.GROUP_ID";
082            ROLE_ID = "TURBINE_USER_GROUP_ROLE.ROLE_ID";
083            if (Torque.isInit())
084            {
085                try
086                {
087                    Torque.getMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME);
088                }
089                catch (TorqueException e)
090                {
091                    log.error("Could not initialize Peer", e);
092                    throw new TorqueRuntimeException(e);
093                }
094            }
095            else
096            {
097                Torque.registerMapBuilder(TurbineUserGroupRoleMapBuilder.CLASS_NAME);
098            }
099        }
100     
101        /** number of columns for this peer */
102        public static final int numColumns =  3;
103    
104        /** A class that can be returned by this peer. */
105        protected static final String CLASSNAME_DEFAULT =
106            "org.apache.turbine.services.security.torque.om.TurbineUserGroupRole";
107    
108        /** A class that can be returned by this peer. */
109        protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT);
110    
111        /**
112         * Class object initialization method.
113         *
114         * @param className name of the class to initialize
115         * @return the initialized class
116         */
117        private static Class initClass(String className)
118        {
119            Class c = null;
120            try
121            {
122                c = Class.forName(className);
123            }
124            catch (Throwable t)
125            {
126                log.error("A FATAL ERROR has occurred which should not "
127                    + "have happened under any circumstance.  Please notify "
128                    + "the Torque developers <torque-dev@db.apache.org> "
129                    + "and give as many details as possible (including the error "
130                    + "stack trace).", t);
131    
132                // Error objects should always be propagated.
133                if (t instanceof Error)
134                {
135                    throw (Error) t.fillInStackTrace();
136                }
137            }
138            return c;
139        }
140    
141        /**
142         * Get the list of objects for a ResultSet.  Please not that your
143         * resultset MUST return columns in the right order.  You can use
144         * getFieldNames() in BaseObject to get the correct sequence.
145         *
146         * @param results the ResultSet
147         * @return the list of objects
148         * @throws TorqueException Any exceptions caught during processing will be
149         *         rethrown wrapped into a TorqueException.
150         */
151        public static List<TurbineUserGroupRole> resultSet2Objects(java.sql.ResultSet results)
152                throws TorqueException
153        {
154            try
155            {
156                QueryDataSet qds = null;
157                List<Record> rows = null;
158                try
159                {
160                    qds = new QueryDataSet(results);
161                    rows = getSelectResults(qds);
162                }
163                finally
164                {
165                    if (qds != null)
166                    {
167                        qds.close();
168                    }
169                }
170    
171                return populateObjects(rows);
172            }
173            catch (SQLException e)
174            {
175                throw new TorqueException(e);
176            }
177            catch (DataSetException e)
178            {
179                throw new TorqueException(e);
180            }
181        }
182    
183    
184    
185        /**
186         * Method to do inserts.
187         *
188         * @param criteria object used to create the INSERT statement.
189         * @throws TorqueException Any exceptions caught during processing will be
190         *         rethrown wrapped into a TorqueException.
191         */
192        public static ObjectKey doInsert(Criteria criteria)
193            throws TorqueException
194        {
195            return BaseTurbineUserGroupRolePeer
196                .doInsert(criteria, (Connection) null);
197        }
198    
199        /**
200         * Method to do inserts.  This method is to be used during a transaction,
201         * otherwise use the doInsert(Criteria) method.  It will take care of
202         * the connection details internally.
203         *
204         * @param criteria object used to create the INSERT statement.
205         * @param con the connection to use
206         * @throws TorqueException Any exceptions caught during processing will be
207         *         rethrown wrapped into a TorqueException.
208         */
209        public static ObjectKey doInsert(Criteria criteria, Connection con)
210            throws TorqueException
211        {
212            correctBooleans(criteria);
213    
214            setDbName(criteria);
215    
216            if (con == null)
217            {
218                return BasePeer.doInsert(criteria);
219            }
220            else
221            {
222                return BasePeer.doInsert(criteria, con);
223            }
224        }
225    
226        /**
227         * Add all the columns needed to create a new object.
228         *
229         * @param criteria object containing the columns to add.
230         * @throws TorqueException Any exceptions caught during processing will be
231         *         rethrown wrapped into a TorqueException.
232         */
233        public static void addSelectColumns(Criteria criteria)
234                throws TorqueException
235        {
236            criteria.addSelectColumn(USER_ID);
237            criteria.addSelectColumn(GROUP_ID);
238            criteria.addSelectColumn(ROLE_ID);
239        }
240    
241        /**
242         * changes the boolean values in the criteria to the appropriate type,
243         * whenever a booleanchar or booleanint column is involved.
244         * This enables the user to create criteria using Boolean values
245         * for booleanchar or booleanint columns
246         * @param criteria the criteria in which the boolean values should be corrected
247         * @throws TorqueException if the database map for the criteria cannot be 
248                   obtained.
249         */
250        public static void correctBooleans(Criteria criteria) throws TorqueException
251        {
252            correctBooleans(criteria, getTableMap());
253        }
254    
255        /**
256         * Create a new object of type cls from a resultset row starting
257         * from a specified offset.  This is done so that you can select
258         * other rows than just those needed for this object.  You may
259         * for example want to create two objects from the same row.
260         *
261         * @throws TorqueException Any exceptions caught during processing will be
262         *         rethrown wrapped into a TorqueException.
263         */
264        public static TurbineUserGroupRole row2Object(Record row,
265                                                 int offset,
266                                                 Class cls)
267            throws TorqueException
268        {
269            try
270            {
271                TurbineUserGroupRole obj = (TurbineUserGroupRole) cls.newInstance();
272                TurbineUserGroupRolePeer.populateObject(row, offset, obj);
273                    obj.setModified(false);
274                obj.setNew(false);
275    
276                return obj;
277            }
278            catch (InstantiationException e)
279            {
280                throw new TorqueException(e);
281            }
282            catch (IllegalAccessException e)
283            {
284                throw new TorqueException(e);
285            }
286        }
287    
288        /**
289         * Populates an object from a resultset row starting
290         * from a specified offset.  This is done so that you can select
291         * other rows than just those needed for this object.  You may
292         * for example want to create two objects from the same row.
293         *
294         * @throws TorqueException Any exceptions caught during processing will be
295         *         rethrown wrapped into a TorqueException.
296         */
297        public static void populateObject(Record row,
298                                          int offset,
299                                          TurbineUserGroupRole obj)
300            throws TorqueException
301        {
302            try
303            {
304                obj.setUserId(row.getValue(offset + 0).asInt());
305                obj.setGroupId(row.getValue(offset + 1).asInt());
306                obj.setRoleId(row.getValue(offset + 2).asInt());
307            }
308            catch (DataSetException e)
309            {
310                throw new TorqueException(e);
311            }
312        }
313    
314        /**
315         * Method to do selects.
316         *
317         * @param criteria object used to create the SELECT statement.
318         * @return List of selected Objects
319         * @throws TorqueException Any exceptions caught during processing will be
320         *         rethrown wrapped into a TorqueException.
321         */
322        public static List<TurbineUserGroupRole> doSelect(Criteria criteria) throws TorqueException
323        {
324            return populateObjects(doSelectVillageRecords(criteria));
325        }
326    
327        /**
328         * Method to do selects within a transaction.
329         *
330         * @param criteria object used to create the SELECT statement.
331         * @param con the connection to use
332         * @return List of selected Objects
333         * @throws TorqueException Any exceptions caught during processing will be
334         *         rethrown wrapped into a TorqueException.
335         */
336        public static List<TurbineUserGroupRole> doSelect(Criteria criteria, Connection con)
337            throws TorqueException
338        {
339            return populateObjects(doSelectVillageRecords(criteria, con));
340        }
341    
342        /**
343         * Grabs the raw Village records to be formed into objects.
344         * This method handles connections internally.  The Record objects
345         * returned by this method should be considered readonly.  Do not
346         * alter the data and call save(), your results may vary, but are
347         * certainly likely to result in hard to track MT bugs.
348         *
349         * @throws TorqueException Any exceptions caught during processing will be
350         *         rethrown wrapped into a TorqueException.
351         */
352        public static List<Record> doSelectVillageRecords(Criteria criteria)
353            throws TorqueException
354        {
355            return BaseTurbineUserGroupRolePeer
356                .doSelectVillageRecords(criteria, (Connection) null);
357        }
358    
359        /**
360         * Grabs the raw Village records to be formed into objects.
361         * This method should be used for transactions
362         *
363         * @param criteria object used to create the SELECT statement.
364         * @param con the connection to use
365         * @throws TorqueException Any exceptions caught during processing will be
366         *         rethrown wrapped into a TorqueException.
367         */
368        public static List<Record> doSelectVillageRecords(Criteria criteria, Connection con)
369            throws TorqueException
370        {
371            if (criteria.getSelectColumns().size() == 0)
372            {
373                addSelectColumns(criteria);
374            }
375            correctBooleans(criteria);
376    
377            setDbName(criteria);
378    
379            // BasePeer returns a List of Value (Village) arrays.  The array
380            // order follows the order columns were placed in the Select clause.
381            if (con == null)
382            {
383                return BasePeer.doSelect(criteria);
384            }
385            else
386            {
387                return BasePeer.doSelect(criteria, con);
388            }
389        }
390    
391        /**
392         * The returned List will contain objects of the default type or
393         * objects that inherit from the default.
394         *
395         * @throws TorqueException Any exceptions caught during processing will be
396         *         rethrown wrapped into a TorqueException.
397         */
398        public static List<TurbineUserGroupRole> populateObjects(List<Record> records)
399            throws TorqueException
400        {
401            List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>(records.size());
402    
403            // populate the object(s)
404            for (int i = 0; i < records.size(); i++)
405            {
406                Record row =  records.get(i);
407                results.add(TurbineUserGroupRolePeer.row2Object(row, 1,
408                    TurbineUserGroupRolePeer.getOMClass()));
409            }
410            return results;
411        }
412     
413    
414        /**
415         * The class that the Peer will make instances of.
416         * If the BO is abstract then you must implement this method
417         * in the BO.
418         *
419         * @throws TorqueException Any exceptions caught during processing will be
420         *         rethrown wrapped into a TorqueException.
421         */
422        public static Class getOMClass()
423            throws TorqueException
424        {
425            return CLASS_DEFAULT;
426        }
427    
428        /**
429         * Method to do updates.
430         *
431         * @param criteria object containing data that is used to create the UPDATE
432         *        statement.
433         * @throws TorqueException Any exceptions caught during processing will be
434         *         rethrown wrapped into a TorqueException.
435         */
436        public static void doUpdate(Criteria criteria) throws TorqueException
437        {
438             BaseTurbineUserGroupRolePeer
439                .doUpdate(criteria, (Connection) null);
440        }
441    
442        /**
443         * Method to do updates.  This method is to be used during a transaction,
444         * otherwise use the doUpdate(Criteria) method.  It will take care of
445         * the connection details internally.
446         *
447         * @param criteria object containing data that is used to create the UPDATE
448         *        statement.
449         * @param con the connection to use
450         * @throws TorqueException Any exceptions caught during processing will be
451         *         rethrown wrapped into a TorqueException.
452         */
453        public static void doUpdate(Criteria criteria, Connection con)
454            throws TorqueException
455        {
456            Criteria selectCriteria = new Criteria(DATABASE_NAME, 2);
457            correctBooleans(criteria);
458    
459    
460             selectCriteria.put(USER_ID, criteria.remove(USER_ID));
461    
462             selectCriteria.put(GROUP_ID, criteria.remove(GROUP_ID));
463    
464             selectCriteria.put(ROLE_ID, criteria.remove(ROLE_ID));
465    
466            setDbName(criteria);
467    
468            if (con == null)
469            {
470                BasePeer.doUpdate(selectCriteria, criteria);
471            }
472            else
473            {
474                BasePeer.doUpdate(selectCriteria, criteria, con);
475            }
476        }
477    
478        /**
479         * Method to do deletes.
480         *
481         * @param criteria object containing data that is used DELETE from database.
482         * @throws TorqueException Any exceptions caught during processing will be
483         *         rethrown wrapped into a TorqueException.
484         */
485         public static void doDelete(Criteria criteria) throws TorqueException
486         {
487             TurbineUserGroupRolePeer
488                .doDelete(criteria, (Connection) null);
489         }
490    
491        /**
492         * Method to do deletes.  This method is to be used during a transaction,
493         * otherwise use the doDelete(Criteria) method.  It will take care of
494         * the connection details internally.
495         *
496         * @param criteria object containing data that is used DELETE from database.
497         * @param con the connection to use
498         * @throws TorqueException Any exceptions caught during processing will be
499         *         rethrown wrapped into a TorqueException.
500         */
501         public static void doDelete(Criteria criteria, Connection con)
502            throws TorqueException
503         {
504            correctBooleans(criteria);
505    
506            setDbName(criteria);
507    
508            if (con == null)
509            {
510                BasePeer.doDelete(criteria, TABLE_NAME);
511            }
512            else
513            {
514                BasePeer.doDelete(criteria, TABLE_NAME, con);
515            }
516         }
517    
518        /**
519         * Method to do selects
520         *
521         * @throws TorqueException Any exceptions caught during processing will be
522         *         rethrown wrapped into a TorqueException.
523         */
524        public static List<TurbineUserGroupRole> doSelect(TurbineUserGroupRole obj) throws TorqueException
525        {
526            return doSelect(buildSelectCriteria(obj));
527        }
528    
529        /**
530         * Method to do inserts
531         *
532         * @throws TorqueException Any exceptions caught during processing will be
533         *         rethrown wrapped into a TorqueException.
534         */
535        public static void doInsert(TurbineUserGroupRole obj) throws TorqueException
536        {
537            doInsert(buildCriteria(obj));
538            obj.setNew(false);
539            obj.setModified(false);
540        }
541    
542        /**
543         * @param obj the data object to update in the database.
544         * @throws TorqueException Any exceptions caught during processing will be
545         *         rethrown wrapped into a TorqueException.
546         */
547        public static void doUpdate(TurbineUserGroupRole obj) throws TorqueException
548        {
549            doUpdate(buildCriteria(obj));
550            obj.setModified(false);
551        }
552    
553        /**
554         * @param obj the data object to delete in the database.
555         * @throws TorqueException Any exceptions caught during processing will be
556         *         rethrown wrapped into a TorqueException.
557         */
558        public static void doDelete(TurbineUserGroupRole obj) throws TorqueException
559        {
560            doDelete(buildSelectCriteria(obj));
561        }
562    
563        /**
564         * Method to do inserts.  This method is to be used during a transaction,
565         * otherwise use the doInsert(TurbineUserGroupRole) method.  It will take
566         * care of the connection details internally.
567         *
568         * @param obj the data object to insert into the database.
569         * @param con the connection to use
570         * @throws TorqueException Any exceptions caught during processing will be
571         *         rethrown wrapped into a TorqueException.
572         */
573        public static void doInsert(TurbineUserGroupRole obj, Connection con)
574            throws TorqueException
575        {
576            doInsert(buildCriteria(obj), con);
577            obj.setNew(false);
578            obj.setModified(false);
579        }
580    
581        /**
582         * Method to do update.  This method is to be used during a transaction,
583         * otherwise use the doUpdate(TurbineUserGroupRole) method.  It will take
584         * care of the connection details internally.
585         *
586         * @param obj the data object to update in the database.
587         * @param con the connection to use
588         * @throws TorqueException Any exceptions caught during processing will be
589         *         rethrown wrapped into a TorqueException.
590         */
591        public static void doUpdate(TurbineUserGroupRole obj, Connection con)
592            throws TorqueException
593        {
594            doUpdate(buildCriteria(obj), con);
595            obj.setModified(false);
596        }
597    
598        /**
599         * Method to delete.  This method is to be used during a transaction,
600         * otherwise use the doDelete(TurbineUserGroupRole) method.  It will take
601         * care of the connection details internally.
602         *
603         * @param obj the data 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(TurbineUserGroupRole obj, Connection con)
609            throws TorqueException
610        {
611            doDelete(buildSelectCriteria(obj), con);
612        }
613    
614        /**
615         * Method to do deletes.
616         *
617         * @param pk ObjectKey that is used DELETE from database.
618         * @throws TorqueException Any exceptions caught during processing will be
619         *         rethrown wrapped into a TorqueException.
620         */
621        public static void doDelete(ObjectKey pk) throws TorqueException
622        {
623            BaseTurbineUserGroupRolePeer
624               .doDelete(pk, (Connection) null);
625        }
626    
627        /**
628         * Method to delete.  This method is to be used during a transaction,
629         * otherwise use the doDelete(ObjectKey) method.  It will take
630         * care of the connection details internally.
631         *
632         * @param pk the primary key for the object to delete in the database.
633         * @param con the connection to use
634         * @throws TorqueException Any exceptions caught during processing will be
635         *         rethrown wrapped into a TorqueException.
636         */
637        public static void doDelete(ObjectKey pk, Connection con)
638            throws TorqueException
639        {
640            doDelete(buildCriteria(pk), con);
641        }
642    
643        /** Build a Criteria object from an ObjectKey */
644        public static Criteria buildCriteria( ObjectKey pk )
645        {
646            Criteria criteria = new Criteria();
647            SimpleKey[] keys = (SimpleKey[])pk.getValue();
648                criteria.add(USER_ID, keys[0]);
649                criteria.add(GROUP_ID, keys[1]);
650                criteria.add(ROLE_ID, keys[2]);
651            return criteria;
652         }
653    
654        /** Build a Criteria object from the data object for this peer */
655        public static Criteria buildCriteria( TurbineUserGroupRole obj )
656        {
657            Criteria criteria = new Criteria(DATABASE_NAME);
658            criteria.add(USER_ID, obj.getUserId());
659            criteria.add(GROUP_ID, obj.getGroupId());
660            criteria.add(ROLE_ID, obj.getRoleId());
661            return criteria;
662        }
663    
664        /** Build a Criteria object from the data object for this peer, skipping all binary columns */
665        public static Criteria buildSelectCriteria( TurbineUserGroupRole obj )
666        {
667            Criteria criteria = new Criteria(DATABASE_NAME);
668                criteria.add(USER_ID, obj.getUserId());
669                criteria.add(GROUP_ID, obj.getGroupId());
670                criteria.add(ROLE_ID, obj.getRoleId());
671            return criteria;
672        }
673     
674    
675    
676        /**
677         * Retrieve a single object by pk
678         *
679         * @param pk the primary key
680         * @throws TorqueException Any exceptions caught during processing will be
681         *         rethrown wrapped into a TorqueException.
682         * @throws NoRowsException Primary key was not found in database.
683         * @throws TooManyRowsException Primary key was not found in database.
684         */
685        public static TurbineUserGroupRole retrieveByPK(ObjectKey pk)
686            throws TorqueException, NoRowsException, TooManyRowsException
687        {
688            Connection db = null;
689            TurbineUserGroupRole retVal = null;
690            try
691            {
692                db = Torque.getConnection(DATABASE_NAME);
693                retVal = retrieveByPK(pk, db);
694            }
695            finally
696            {
697                Torque.closeConnection(db);
698            }
699            return retVal;
700        }
701    
702        /**
703         * Retrieve a single object by pk
704         *
705         * @param pk the primary key
706         * @param con the connection to use
707         * @throws TorqueException Any exceptions caught during processing will be
708         *         rethrown wrapped into a TorqueException.
709         * @throws NoRowsException Primary key was not found in database.
710         * @throws TooManyRowsException Primary key was not found in database.
711         */
712        public static TurbineUserGroupRole retrieveByPK(ObjectKey pk, Connection con)
713            throws TorqueException, NoRowsException, TooManyRowsException
714        {
715            Criteria criteria = buildCriteria(pk);
716            List<TurbineUserGroupRole> v = doSelect(criteria, con);
717            if (v.size() == 0)
718            {
719                throw new NoRowsException("Failed to select a row.");
720            }
721            else if (v.size() > 1)
722            {
723                throw new TooManyRowsException("Failed to select only one row.");
724            }
725            else
726            {
727                return (TurbineUserGroupRole)v.get(0);
728            }
729        }
730    
731        /**
732         * Retrieve a multiple objects by pk
733         *
734         * @param pks List of primary keys
735         * @throws TorqueException Any exceptions caught during processing will be
736         *         rethrown wrapped into a TorqueException.
737         */
738        public static List<TurbineUserGroupRole> retrieveByPKs(List<ObjectKey> pks)
739            throws TorqueException
740        {
741            Connection db = null;
742            List<TurbineUserGroupRole> retVal = null;
743            try
744            {
745               db = Torque.getConnection(DATABASE_NAME);
746               retVal = retrieveByPKs(pks, db);
747            }
748            finally
749            {
750                Torque.closeConnection(db);
751            }
752            return retVal;
753        }
754    
755        /**
756         * Retrieve a multiple objects by pk
757         *
758         * @param pks List of primary keys
759         * @param dbcon the connection to use
760         * @throws TorqueException Any exceptions caught during processing will be
761         *         rethrown wrapped into a TorqueException.
762         */
763        public static List<TurbineUserGroupRole> retrieveByPKs( List<ObjectKey> pks, Connection dbcon )
764            throws TorqueException
765        {
766            List<TurbineUserGroupRole> objs = null;
767            if (pks == null || pks.size() == 0)
768            {
769                objs = new LinkedList<TurbineUserGroupRole>();
770            }
771            else
772            {
773                Criteria criteria = new Criteria();
774                Iterator<ObjectKey> iter = pks.iterator();
775                while (iter.hasNext())
776                {
777                    ObjectKey pk =  iter.next();
778                    SimpleKey[] keys = (SimpleKey[])pk.getValue();
779                        Criteria.Criterion c0 = criteria.getNewCriterion(
780                            USER_ID, keys[0], Criteria.EQUAL);
781                        Criteria.Criterion c1 = criteria.getNewCriterion(
782                            GROUP_ID, keys[1], Criteria.EQUAL);
783                            c0.and(c1);
784                        Criteria.Criterion c2 = criteria.getNewCriterion(
785                            ROLE_ID, keys[2], Criteria.EQUAL);
786                            c1.and(c2);
787                    criteria.or(c0);
788                }
789            objs = doSelect(criteria, dbcon);
790            }
791            return objs;
792        }
793    
794     
795        /**
796         * retrieve object using using pk values.
797         *
798         * @param userId int
799         * @param groupId int
800         * @param roleId int
801         */
802        public static TurbineUserGroupRole retrieveByPK(
803     int userId
804    , int groupId
805    , int roleId
806            ) throws TorqueException
807        {
808            Connection db = null;
809            TurbineUserGroupRole retVal = null;
810            try
811            {
812               db = Torque.getConnection(DATABASE_NAME);
813               retVal = retrieveByPK(
814     userId
815    , groupId
816    , roleId
817                   , db);
818            }
819            finally
820            {
821                Torque.closeConnection(db);
822            }
823            return retVal;
824        }
825    
826        /**
827         * retrieve object using using pk values.
828         *
829         * @param userId int
830         * @param groupId int
831         * @param roleId int
832         * @param con Connection
833         */
834        public static TurbineUserGroupRole retrieveByPK(
835     int userId
836    , int groupId
837    , int roleId
838           ,Connection con) throws TorqueException
839        {
840    
841            Criteria criteria = new Criteria(5);
842            criteria.add(USER_ID, userId);
843            criteria.add(GROUP_ID, groupId);
844            criteria.add(ROLE_ID, roleId);
845            List<TurbineUserGroupRole> v = doSelect(criteria, con);
846            if (v.size() == 1)
847            {
848                return  v.get(0);
849            }
850            else
851            {
852                throw new TorqueException("Failed to select one and only one row.");
853            }
854        }
855    
856    
857    
858    
859    
860    
861    
862    
863        /**
864         * selects a collection of TurbineUserGroupRole objects pre-filled with their
865         * TurbineUser objects.
866         *
867         * This method is protected by default in order to keep the public
868         * api reasonable.  You can provide public methods for those you
869         * actually need in TurbineUserGroupRolePeer.
870         *
871         * @throws TorqueException Any exceptions caught during processing will be
872         *         rethrown wrapped into a TorqueException.
873         */
874        protected static List<TurbineUserGroupRole> doSelectJoinTurbineUser(Criteria criteria)
875            throws TorqueException
876        {
877            return doSelectJoinTurbineUser(criteria, null);
878        }
879    
880        /**
881         * selects a collection of TurbineUserGroupRole objects pre-filled with their
882         * TurbineUser objects.
883         *
884         * This method is protected by default in order to keep the public
885         * api reasonable.  You can provide public methods for those you
886         * actually need in TurbineUserGroupRolePeer.
887         *
888         * @throws TorqueException Any exceptions caught during processing will be
889         *         rethrown wrapped into a TorqueException.
890         */
891        protected static List<TurbineUserGroupRole> doSelectJoinTurbineUser(Criteria criteria, Connection conn)
892            throws TorqueException
893        {
894            setDbName(criteria);
895    
896            TurbineUserGroupRolePeer.addSelectColumns(criteria);
897            int offset = numColumns + 1;
898            TurbineUserPeer.addSelectColumns(criteria);
899    
900            criteria.addJoin(TurbineUserGroupRolePeer.USER_ID,
901                TurbineUserPeer.USER_ID);
902    
903            correctBooleans(criteria);
904    
905            List<Record> rows;
906            if (conn == null)
907            {
908                rows = BasePeer.doSelect(criteria);
909            }
910            else
911            {
912                rows = BasePeer.doSelect(criteria,conn);
913            }
914    
915            List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>();
916    
917            for (int i = 0; i < rows.size(); i++)
918            {
919                Record row =  rows.get(i);
920    
921                Class omClass = TurbineUserGroupRolePeer.getOMClass();
922                TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
923                    .row2Object(row, 1, omClass);
924                 omClass = TurbineUserPeer.getOMClass();
925                TurbineUser obj2 = (TurbineUser) TurbineUserPeer
926                    .row2Object(row, offset, omClass);
927    
928                boolean newObject = true;
929                for (int j = 0; j < results.size(); j++)
930                {
931                    TurbineUserGroupRole temp_obj1 =  results.get(j);
932                    TurbineUser temp_obj2 = (TurbineUser) temp_obj1.getTurbineUser();
933                    if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
934                    {
935                        newObject = false;
936                        temp_obj2.addTurbineUserGroupRole(obj1);
937                        break;
938                    }
939                }
940                if (newObject)
941                {
942                    obj2.initTurbineUserGroupRoles();
943                    obj2.addTurbineUserGroupRole(obj1);
944                }
945                results.add(obj1);
946            }
947            return results;
948        }
949    
950    
951    
952    
953        /**
954         * selects a collection of TurbineUserGroupRole objects pre-filled with their
955         * TurbineGroup objects.
956         *
957         * This method is protected by default in order to keep the public
958         * api reasonable.  You can provide public methods for those you
959         * actually need in TurbineUserGroupRolePeer.
960         *
961         * @throws TorqueException Any exceptions caught during processing will be
962         *         rethrown wrapped into a TorqueException.
963         */
964        protected static List<TurbineUserGroupRole> doSelectJoinTurbineGroup(Criteria criteria)
965            throws TorqueException
966        {
967            return doSelectJoinTurbineGroup(criteria, null);
968        }
969    
970        /**
971         * selects a collection of TurbineUserGroupRole objects pre-filled with their
972         * TurbineGroup objects.
973         *
974         * This method is protected by default in order to keep the public
975         * api reasonable.  You can provide public methods for those you
976         * actually need in TurbineUserGroupRolePeer.
977         *
978         * @throws TorqueException Any exceptions caught during processing will be
979         *         rethrown wrapped into a TorqueException.
980         */
981        protected static List<TurbineUserGroupRole> doSelectJoinTurbineGroup(Criteria criteria, Connection conn)
982            throws TorqueException
983        {
984            setDbName(criteria);
985    
986            TurbineUserGroupRolePeer.addSelectColumns(criteria);
987            int offset = numColumns + 1;
988            TurbineGroupPeer.addSelectColumns(criteria);
989    
990            criteria.addJoin(TurbineUserGroupRolePeer.GROUP_ID,
991                TurbineGroupPeer.GROUP_ID);
992    
993            correctBooleans(criteria);
994    
995            List<Record> rows;
996            if (conn == null)
997            {
998                rows = BasePeer.doSelect(criteria);
999            }
1000            else
1001            {
1002                rows = BasePeer.doSelect(criteria,conn);
1003            }
1004    
1005            List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>();
1006    
1007            for (int i = 0; i < rows.size(); i++)
1008            {
1009                Record row =  rows.get(i);
1010    
1011                Class omClass = TurbineUserGroupRolePeer.getOMClass();
1012                TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
1013                    .row2Object(row, 1, omClass);
1014                 omClass = TurbineGroupPeer.getOMClass();
1015                TurbineGroup obj2 = (TurbineGroup) TurbineGroupPeer
1016                    .row2Object(row, offset, omClass);
1017    
1018                boolean newObject = true;
1019                for (int j = 0; j < results.size(); j++)
1020                {
1021                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1022                    TurbineGroup temp_obj2 = (TurbineGroup) temp_obj1.getTurbineGroup();
1023                    if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1024                    {
1025                        newObject = false;
1026                        temp_obj2.addTurbineUserGroupRole(obj1);
1027                        break;
1028                    }
1029                }
1030                if (newObject)
1031                {
1032                    obj2.initTurbineUserGroupRoles();
1033                    obj2.addTurbineUserGroupRole(obj1);
1034                }
1035                results.add(obj1);
1036            }
1037            return results;
1038        }
1039    
1040    
1041    
1042    
1043        /**
1044         * selects a collection of TurbineUserGroupRole objects pre-filled with their
1045         * TurbineRole objects.
1046         *
1047         * This method is protected by default in order to keep the public
1048         * api reasonable.  You can provide public methods for those you
1049         * actually need in TurbineUserGroupRolePeer.
1050         *
1051         * @throws TorqueException Any exceptions caught during processing will be
1052         *         rethrown wrapped into a TorqueException.
1053         */
1054        protected static List<TurbineUserGroupRole> doSelectJoinTurbineRole(Criteria criteria)
1055            throws TorqueException
1056        {
1057            return doSelectJoinTurbineRole(criteria, null);
1058        }
1059    
1060        /**
1061         * selects a collection of TurbineUserGroupRole objects pre-filled with their
1062         * TurbineRole objects.
1063         *
1064         * This method is protected by default in order to keep the public
1065         * api reasonable.  You can provide public methods for those you
1066         * actually need in TurbineUserGroupRolePeer.
1067         *
1068         * @throws TorqueException Any exceptions caught during processing will be
1069         *         rethrown wrapped into a TorqueException.
1070         */
1071        protected static List<TurbineUserGroupRole> doSelectJoinTurbineRole(Criteria criteria, Connection conn)
1072            throws TorqueException
1073        {
1074            setDbName(criteria);
1075    
1076            TurbineUserGroupRolePeer.addSelectColumns(criteria);
1077            int offset = numColumns + 1;
1078            TurbineRolePeer.addSelectColumns(criteria);
1079    
1080            criteria.addJoin(TurbineUserGroupRolePeer.ROLE_ID,
1081                TurbineRolePeer.ROLE_ID);
1082    
1083            correctBooleans(criteria);
1084    
1085            List<Record> rows;
1086            if (conn == null)
1087            {
1088                rows = BasePeer.doSelect(criteria);
1089            }
1090            else
1091            {
1092                rows = BasePeer.doSelect(criteria,conn);
1093            }
1094    
1095            List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>();
1096    
1097            for (int i = 0; i < rows.size(); i++)
1098            {
1099                Record row =  rows.get(i);
1100    
1101                Class omClass = TurbineUserGroupRolePeer.getOMClass();
1102                TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
1103                    .row2Object(row, 1, omClass);
1104                 omClass = TurbineRolePeer.getOMClass();
1105                TurbineRole obj2 = (TurbineRole) TurbineRolePeer
1106                    .row2Object(row, offset, omClass);
1107    
1108                boolean newObject = true;
1109                for (int j = 0; j < results.size(); j++)
1110                {
1111                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1112                    TurbineRole temp_obj2 = (TurbineRole) temp_obj1.getTurbineRole();
1113                    if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1114                    {
1115                        newObject = false;
1116                        temp_obj2.addTurbineUserGroupRole(obj1);
1117                        break;
1118                    }
1119                }
1120                if (newObject)
1121                {
1122                    obj2.initTurbineUserGroupRoles();
1123                    obj2.addTurbineUserGroupRole(obj1);
1124                }
1125                results.add(obj1);
1126            }
1127            return results;
1128        }
1129    
1130    
1131    
1132    
1133    
1134    
1135    
1136        /**
1137         * selects a collection of TurbineUserGroupRole objects pre-filled with
1138         * all related objects.
1139         *
1140         * This method is protected by default in order to keep the public
1141         * api reasonable.  You can provide public methods for those you
1142         * actually need in TurbineUserGroupRolePeer.
1143         *
1144         * @throws TorqueException Any exceptions caught during processing will be
1145         *         rethrown wrapped into a TorqueException.
1146         */
1147        protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineUser(Criteria criteria)
1148            throws TorqueException
1149        {
1150            return doSelectJoinAllExceptTurbineUser(criteria, null);
1151        }
1152    
1153        /**
1154         * selects a collection of TurbineUserGroupRole objects pre-filled with
1155         * all related objects.
1156         *
1157         * This method is protected by default in order to keep the public
1158         * api reasonable.  You can provide public methods for those you
1159         * actually need in TurbineUserGroupRolePeer.
1160         *
1161         * @throws TorqueException Any exceptions caught during processing will be
1162         *         rethrown wrapped into a TorqueException.
1163         */
1164        protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineUser(Criteria criteria, Connection conn)
1165            throws TorqueException
1166        {
1167            setDbName(criteria);
1168    
1169            addSelectColumns(criteria);
1170            int offset2 = numColumns + 1;
1171    
1172    
1173            TurbineGroupPeer.addSelectColumns(criteria);
1174            criteria.addJoin(TurbineUserGroupRolePeer.GROUP_ID, TurbineGroupPeer.GROUP_ID);
1175            int offset3 = offset2 + TurbineGroupPeer.numColumns;
1176    
1177            TurbineRolePeer.addSelectColumns(criteria);
1178            criteria.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePeer.ROLE_ID);
1179    
1180            correctBooleans(criteria);
1181    
1182            List<Record> rows;
1183            if (conn == null)
1184            {
1185                rows = BasePeer.doSelect(criteria);
1186            }
1187            else
1188            {
1189                rows = BasePeer.doSelect(criteria,conn);
1190            }
1191    
1192            List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>();
1193    
1194            for (int i = 0; i < rows.size(); i++)
1195            {
1196                Record row =  rows.get(i);
1197    
1198                Class omClass = TurbineUserGroupRolePeer.getOMClass();
1199                TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
1200                    .row2Object(row, 1, omClass);
1201    
1202    
1203    
1204    
1205    
1206                 omClass = TurbineGroupPeer.getOMClass();
1207                TurbineGroup obj2 = (TurbineGroup) TurbineGroupPeer
1208                    .row2Object( row, offset2, omClass);
1209    
1210     boolean  newObject = true;
1211                for (int j = 0; j < results.size(); j++)
1212                {
1213                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1214                    TurbineGroup temp_obj2 = (TurbineGroup) temp_obj1.getTurbineGroup();
1215                    if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1216                    {
1217                        newObject = false;
1218                        temp_obj2.addTurbineUserGroupRole(obj1);
1219                        break;
1220                    }
1221                }
1222                if (newObject)
1223                {
1224                    obj2.initTurbineUserGroupRoles();
1225                    obj2.addTurbineUserGroupRole(obj1);
1226                }
1227    
1228    
1229    
1230    
1231                 omClass = TurbineRolePeer.getOMClass();
1232                TurbineRole obj3 = (TurbineRole) TurbineRolePeer
1233                    .row2Object( row, offset3, omClass);
1234    
1235     newObject = true;
1236                for (int j = 0; j < results.size(); j++)
1237                {
1238                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1239                    TurbineRole temp_obj3 = (TurbineRole) temp_obj1.getTurbineRole();
1240                    if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey()))
1241                    {
1242                        newObject = false;
1243                        temp_obj3.addTurbineUserGroupRole(obj1);
1244                        break;
1245                    }
1246                }
1247                if (newObject)
1248                {
1249                    obj3.initTurbineUserGroupRoles();
1250                    obj3.addTurbineUserGroupRole(obj1);
1251                }
1252                results.add(obj1);
1253            }
1254            return results;
1255        }
1256    
1257    
1258    
1259    
1260        /**
1261         * selects a collection of TurbineUserGroupRole objects pre-filled with
1262         * all related objects.
1263         *
1264         * This method is protected by default in order to keep the public
1265         * api reasonable.  You can provide public methods for those you
1266         * actually need in TurbineUserGroupRolePeer.
1267         *
1268         * @throws TorqueException Any exceptions caught during processing will be
1269         *         rethrown wrapped into a TorqueException.
1270         */
1271        protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineGroup(Criteria criteria)
1272            throws TorqueException
1273        {
1274            return doSelectJoinAllExceptTurbineGroup(criteria, null);
1275        }
1276    
1277        /**
1278         * selects a collection of TurbineUserGroupRole objects pre-filled with
1279         * all related objects.
1280         *
1281         * This method is protected by default in order to keep the public
1282         * api reasonable.  You can provide public methods for those you
1283         * actually need in TurbineUserGroupRolePeer.
1284         *
1285         * @throws TorqueException Any exceptions caught during processing will be
1286         *         rethrown wrapped into a TorqueException.
1287         */
1288        protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineGroup(Criteria criteria, Connection conn)
1289            throws TorqueException
1290        {
1291            setDbName(criteria);
1292    
1293            addSelectColumns(criteria);
1294            int offset2 = numColumns + 1;
1295    
1296            TurbineUserPeer.addSelectColumns(criteria);
1297            criteria.addJoin(TurbineUserGroupRolePeer.USER_ID, TurbineUserPeer.USER_ID);
1298            int offset3 = offset2 + TurbineUserPeer.numColumns;
1299    
1300    
1301            TurbineRolePeer.addSelectColumns(criteria);
1302            criteria.addJoin(TurbineUserGroupRolePeer.ROLE_ID, TurbineRolePeer.ROLE_ID);
1303    
1304            correctBooleans(criteria);
1305    
1306            List<Record> rows;
1307            if (conn == null)
1308            {
1309                rows = BasePeer.doSelect(criteria);
1310            }
1311            else
1312            {
1313                rows = BasePeer.doSelect(criteria,conn);
1314            }
1315    
1316            List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>();
1317    
1318            for (int i = 0; i < rows.size(); i++)
1319            {
1320                Record row =  rows.get(i);
1321    
1322                Class omClass = TurbineUserGroupRolePeer.getOMClass();
1323                TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
1324                    .row2Object(row, 1, omClass);
1325    
1326    
1327    
1328    
1329                 omClass = TurbineUserPeer.getOMClass();
1330                TurbineUser obj2 = (TurbineUser) TurbineUserPeer
1331                    .row2Object( row, offset2, omClass);
1332    
1333     boolean  newObject = true;
1334                for (int j = 0; j < results.size(); j++)
1335                {
1336                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1337                    TurbineUser temp_obj2 = (TurbineUser) temp_obj1.getTurbineUser();
1338                    if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1339                    {
1340                        newObject = false;
1341                        temp_obj2.addTurbineUserGroupRole(obj1);
1342                        break;
1343                    }
1344                }
1345                if (newObject)
1346                {
1347                    obj2.initTurbineUserGroupRoles();
1348                    obj2.addTurbineUserGroupRole(obj1);
1349                }
1350    
1351    
1352    
1353    
1354    
1355                 omClass = TurbineRolePeer.getOMClass();
1356                TurbineRole obj3 = (TurbineRole) TurbineRolePeer
1357                    .row2Object( row, offset3, omClass);
1358    
1359     newObject = true;
1360                for (int j = 0; j < results.size(); j++)
1361                {
1362                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1363                    TurbineRole temp_obj3 = (TurbineRole) temp_obj1.getTurbineRole();
1364                    if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey()))
1365                    {
1366                        newObject = false;
1367                        temp_obj3.addTurbineUserGroupRole(obj1);
1368                        break;
1369                    }
1370                }
1371                if (newObject)
1372                {
1373                    obj3.initTurbineUserGroupRoles();
1374                    obj3.addTurbineUserGroupRole(obj1);
1375                }
1376                results.add(obj1);
1377            }
1378            return results;
1379        }
1380    
1381    
1382    
1383    
1384        /**
1385         * selects a collection of TurbineUserGroupRole objects pre-filled with
1386         * all related objects.
1387         *
1388         * This method is protected by default in order to keep the public
1389         * api reasonable.  You can provide public methods for those you
1390         * actually need in TurbineUserGroupRolePeer.
1391         *
1392         * @throws TorqueException Any exceptions caught during processing will be
1393         *         rethrown wrapped into a TorqueException.
1394         */
1395        protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineRole(Criteria criteria)
1396            throws TorqueException
1397        {
1398            return doSelectJoinAllExceptTurbineRole(criteria, null);
1399        }
1400    
1401        /**
1402         * selects a collection of TurbineUserGroupRole objects pre-filled with
1403         * all related objects.
1404         *
1405         * This method is protected by default in order to keep the public
1406         * api reasonable.  You can provide public methods for those you
1407         * actually need in TurbineUserGroupRolePeer.
1408         *
1409         * @throws TorqueException Any exceptions caught during processing will be
1410         *         rethrown wrapped into a TorqueException.
1411         */
1412        protected static List<TurbineUserGroupRole> doSelectJoinAllExceptTurbineRole(Criteria criteria, Connection conn)
1413            throws TorqueException
1414        {
1415            setDbName(criteria);
1416    
1417            addSelectColumns(criteria);
1418            int offset2 = numColumns + 1;
1419    
1420            TurbineUserPeer.addSelectColumns(criteria);
1421            criteria.addJoin(TurbineUserGroupRolePeer.USER_ID, TurbineUserPeer.USER_ID);
1422            int offset3 = offset2 + TurbineUserPeer.numColumns;
1423    
1424            TurbineGroupPeer.addSelectColumns(criteria);
1425            criteria.addJoin(TurbineUserGroupRolePeer.GROUP_ID, TurbineGroupPeer.GROUP_ID);
1426    
1427    
1428            correctBooleans(criteria);
1429    
1430            List<Record> rows;
1431            if (conn == null)
1432            {
1433                rows = BasePeer.doSelect(criteria);
1434            }
1435            else
1436            {
1437                rows = BasePeer.doSelect(criteria,conn);
1438            }
1439    
1440            List<TurbineUserGroupRole> results = new ArrayList<TurbineUserGroupRole>();
1441    
1442            for (int i = 0; i < rows.size(); i++)
1443            {
1444                Record row =  rows.get(i);
1445    
1446                Class omClass = TurbineUserGroupRolePeer.getOMClass();
1447                TurbineUserGroupRole obj1 = (TurbineUserGroupRole) TurbineUserGroupRolePeer
1448                    .row2Object(row, 1, omClass);
1449    
1450    
1451    
1452    
1453                 omClass = TurbineUserPeer.getOMClass();
1454                TurbineUser obj2 = (TurbineUser) TurbineUserPeer
1455                    .row2Object( row, offset2, omClass);
1456    
1457     boolean  newObject = true;
1458                for (int j = 0; j < results.size(); j++)
1459                {
1460                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1461                    TurbineUser temp_obj2 = (TurbineUser) temp_obj1.getTurbineUser();
1462                    if (temp_obj2.getPrimaryKey().equals(obj2.getPrimaryKey()))
1463                    {
1464                        newObject = false;
1465                        temp_obj2.addTurbineUserGroupRole(obj1);
1466                        break;
1467                    }
1468                }
1469                if (newObject)
1470                {
1471                    obj2.initTurbineUserGroupRoles();
1472                    obj2.addTurbineUserGroupRole(obj1);
1473                }
1474    
1475    
1476    
1477    
1478                 omClass = TurbineGroupPeer.getOMClass();
1479                TurbineGroup obj3 = (TurbineGroup) TurbineGroupPeer
1480                    .row2Object( row, offset3, omClass);
1481    
1482     newObject = true;
1483                for (int j = 0; j < results.size(); j++)
1484                {
1485                    TurbineUserGroupRole temp_obj1 =  results.get(j);
1486                    TurbineGroup temp_obj3 = (TurbineGroup) temp_obj1.getTurbineGroup();
1487                    if (temp_obj3.getPrimaryKey().equals(obj3.getPrimaryKey()))
1488                    {
1489                        newObject = false;
1490                        temp_obj3.addTurbineUserGroupRole(obj1);
1491                        break;
1492                    }
1493                }
1494                if (newObject)
1495                {
1496                    obj3.initTurbineUserGroupRoles();
1497                    obj3.addTurbineUserGroupRole(obj1);
1498                }
1499    
1500                results.add(obj1);
1501            }
1502            return results;
1503        }
1504    
1505    
1506        /**
1507         * Returns the TableMap related to this peer.
1508         *
1509         * @throws TorqueException Any exceptions caught during processing will be
1510         *         rethrown wrapped into a TorqueException.
1511         */
1512        public static TableMap getTableMap()
1513            throws TorqueException
1514        {
1515            return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME);
1516        }
1517     
1518        private static void setDbName(Criteria crit)
1519        {
1520            // Set the correct dbName if it has not been overridden
1521            // crit.getDbName will return the same object if not set to
1522            // another value so == check is okay and faster
1523            if (crit.getDbName() == Torque.getDefaultDB())
1524            {
1525                crit.setDbName(DATABASE_NAME);
1526            }
1527        }
1528        
1529    
1530        // The following methods wrap some methods in BasePeer
1531        // to have more support for Java5 generic types in the Peer
1532        
1533        /**
1534         * Utility method which executes a given sql statement.  This
1535         * method should be used for select statements only.  Use
1536         * executeStatement for update, insert, and delete operations.
1537         *
1538         * @param queryString A String with the sql statement to execute.
1539         * @return List of Record objects.
1540         * @throws TorqueException Any exceptions caught during processing will be
1541         *         rethrown wrapped into a TorqueException.
1542         * @see org.apache.torque.util.BasePeer#executeQuery(String)
1543         */
1544        public static List<Record> executeQuery(String queryString) throws TorqueException
1545        {
1546            return BasePeer.executeQuery(queryString);
1547        }
1548    
1549        /**
1550         * Utility method which executes a given sql statement.  This
1551         * method should be used for select statements only.  Use
1552         * executeStatement for update, insert, and delete operations.
1553         *
1554         * @param queryString A String with the sql statement to execute.
1555         * @param dbName The database to connect to.
1556         * @return List of Record objects.
1557         * @throws TorqueException Any exceptions caught during processing will be
1558         *         rethrown wrapped into a TorqueException.
1559         * @see org.apache.torque.util.BasePeer#executeQuery(String,String)
1560         */
1561        public static List<Record> executeQuery(String queryString, String dbName)
1562            throws TorqueException
1563        {
1564            return BasePeer.executeQuery(queryString,dbName);
1565        }
1566        
1567    
1568        /**
1569         * Method for performing a SELECT.  Returns all results.
1570         *
1571         * @param queryString A String with the sql statement to execute.
1572         * @param dbName The database to connect to.
1573         * @param singleRecord Whether or not we want to select only a
1574         * single record.
1575         * @return List of Record objects.
1576         * @throws TorqueException Any exceptions caught during processing will be
1577         *         rethrown wrapped into a TorqueException.
1578         * @see org.apache.torque.util.BasePeer#executeQuery(String,String,boolean)
1579         */
1580        public static List<Record> executeQuery(
1581            String queryString,
1582            String dbName,
1583            boolean singleRecord)
1584            throws TorqueException
1585        {
1586            return BasePeer.executeQuery(queryString,dbName,singleRecord);
1587        }
1588    
1589        /**
1590         * Method for performing a SELECT.  Returns all results.
1591         *
1592         * @param queryString A String with the sql statement to execute.
1593         * @param singleRecord Whether or not we want to select only a
1594         * single record.
1595         * @param con A Connection.
1596         * @return List of Record objects.
1597         * @throws TorqueException Any exceptions caught during processing will be
1598         *         rethrown wrapped into a TorqueException.
1599         * @see org.apache.torque.util.BasePeer#executeQuery(String,boolean,Connection)
1600         */
1601        public static List<Record> executeQuery(
1602            String queryString,
1603            boolean singleRecord,
1604            Connection con)
1605            throws TorqueException
1606        {
1607            return BasePeer.executeQuery(queryString,singleRecord,con);
1608        }
1609    
1610        /**
1611         * Method for performing a SELECT.
1612         *
1613         * @param queryString A String with the sql statement to execute.
1614         * @param start The first row to return.
1615         * @param numberOfResults The number of rows to return.
1616         * @param dbName The database to connect to.
1617         * @param singleRecord Whether or not we want to select only a
1618         * single record.
1619         * @return List of Record objects.
1620         * @throws TorqueException Any exceptions caught during processing will be
1621         *         rethrown wrapped into a TorqueException.
1622         * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean)
1623         */
1624        public static List<Record> executeQuery(
1625            String queryString,
1626            int start,
1627            int numberOfResults,
1628            String dbName,
1629            boolean singleRecord)
1630            throws TorqueException
1631        {
1632            return BasePeer.executeQuery(queryString,start,numberOfResults,dbName,singleRecord);
1633        }
1634    
1635        /**
1636         * Method for performing a SELECT.  Returns all results.
1637         *
1638         * @param queryString A String with the sql statement to execute.
1639         * @param start The first row to return.
1640         * @param numberOfResults The number of rows to return.
1641         * @param singleRecord Whether or not we want to select only a
1642         * single record.
1643         * @param con A Connection.
1644         * @return List of Record objects.
1645         * @throws TorqueException Any exceptions caught during processing will be
1646         *         rethrown wrapped into a TorqueException.
1647         * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean,Connection)
1648         */
1649        public static List<Record> executeQuery(
1650            String queryString,
1651            int start,
1652            int numberOfResults,
1653            boolean singleRecord,
1654            Connection con)
1655            throws TorqueException
1656        {
1657            return BasePeer.executeQuery(queryString,start,numberOfResults,singleRecord,con);
1658        }
1659    
1660        /**
1661         * Returns all records in a QueryDataSet as a List of Record
1662         * objects.  Used for functionality like util.LargeSelect.
1663         *
1664         * @see #getSelectResults(QueryDataSet, int, int, boolean)
1665         * @param qds the QueryDataSet
1666         * @return a List of Record objects
1667         * @throws TorqueException Any exceptions caught during processing will be
1668         *         rethrown wrapped into a TorqueException.
1669         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet)
1670         */
1671        public static List<Record> getSelectResults(QueryDataSet qds)
1672            throws TorqueException
1673        {
1674            return BasePeer.getSelectResults(qds);
1675        }
1676        
1677        /**
1678         * Returns all records in a QueryDataSet as a List of Record
1679         * objects.  Used for functionality like util.LargeSelect.
1680         *
1681         * @see #getSelectResults(QueryDataSet, int, int, boolean)
1682         * @param qds the QueryDataSet
1683         * @param singleRecord
1684         * @return a List of Record objects
1685         * @throws TorqueException Any exceptions caught during processing will be
1686         *         rethrown wrapped into a TorqueException.
1687         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,boolean)
1688         */
1689        public static List<Record> getSelectResults(QueryDataSet qds, boolean singleRecord)
1690            throws TorqueException
1691        {
1692            return BasePeer.getSelectResults(qds,singleRecord);
1693        }
1694        
1695        /**
1696         * Returns numberOfResults records in a QueryDataSet as a List
1697         * of Record objects.  Starting at record 0.  Used for
1698         * functionality like util.LargeSelect.
1699         *
1700         * @see #getSelectResults(QueryDataSet, int, int, boolean)
1701         * @param qds the QueryDataSet
1702         * @param numberOfResults
1703         * @param singleRecord
1704         * @return a List of Record objects
1705         * @throws TorqueException Any exceptions caught during processing will be
1706         *         rethrown wrapped into a TorqueException.
1707         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,boolean)
1708         */
1709        public static List<Record> getSelectResults(
1710            QueryDataSet qds,
1711            int numberOfResults,
1712            boolean singleRecord)
1713            throws TorqueException
1714        {
1715            return BasePeer.getSelectResults(qds,numberOfResults,singleRecord);
1716        }
1717    
1718        /**
1719         * Returns numberOfResults records in a QueryDataSet as a List
1720         * of Record objects.  Starting at record start.  Used for
1721         * functionality like util.LargeSelect.
1722         *
1723         * @param qds The <code>QueryDataSet</code> to extract results
1724         * from.
1725         * @param start The index from which to start retrieving
1726         * <code>Record</code> objects from the data set.
1727         * @param numberOfResults The number of results to return (or
1728         * <code> -1</code> for all results).
1729         * @param singleRecord Whether or not we want to select only a
1730         * single record.
1731         * @return A <code>List</code> of <code>Record</code> objects.
1732         * @exception TorqueException If any <code>Exception</code> occurs.
1733         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,int,boolean)
1734         */
1735        public static List getSelectResults(
1736            QueryDataSet qds,
1737            int start,
1738            int numberOfResults,
1739            boolean singleRecord)
1740            throws TorqueException
1741        {
1742            return BasePeer.getSelectResults(qds,start,numberOfResults,singleRecord);
1743        }
1744    
1745        /**
1746         * Performs a SQL <code>select</code> using a PreparedStatement.
1747         * Note: this method does not handle null criteria values.
1748         *
1749         * @param criteria
1750         * @param con
1751         * @return a List of Record objects.
1752         * @throws TorqueException Error performing database query.
1753         * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria,Connection)
1754         */
1755        public static List<Record> doPSSelect(Criteria criteria, Connection con)
1756            throws TorqueException
1757        {
1758            return BasePeer.doPSSelect(criteria,con);
1759        }
1760    
1761        /**
1762         * Do a Prepared Statement select according to the given criteria
1763         *
1764         * @param criteria
1765         * @return a List of Record objects.
1766         * @throws TorqueException Any exceptions caught during processing will be
1767         *         rethrown wrapped into a TorqueException.
1768         * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria)
1769         */
1770        public static List<Record> doPSSelect(Criteria criteria) throws TorqueException
1771        {
1772            return BasePeer.doPSSelect(criteria);
1773        }
1774    }