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