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 BaseTurbineRolePeer
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(TurbineRoleMapBuilder.CLASS_NAME) instead
061         */
062        public static MapBuilder getMapBuilder()
063            throws TorqueException
064        {
065            return Torque.getMapBuilder(TurbineRoleMapBuilder.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 ROLE_NAME field */
071        public static final String ROLE_NAME;
072    
073        static
074        {
075            DATABASE_NAME = "default";
076            TABLE_NAME = "TURBINE_ROLE";
077    
078            ROLE_ID = "TURBINE_ROLE.ROLE_ID";
079            ROLE_NAME = "TURBINE_ROLE.ROLE_NAME";
080            if (Torque.isInit())
081            {
082                try
083                {
084                    Torque.getMapBuilder(TurbineRoleMapBuilder.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(TurbineRoleMapBuilder.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.TurbineRole";
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<TurbineRole> 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 BaseTurbineRolePeer
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(ROLE_NAME);
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 TurbineRole row2Object(Record row,
261                                                 int offset,
262                                                 Class cls)
263            throws TorqueException
264        {
265            try
266            {
267                TurbineRole obj = (TurbineRole) cls.newInstance();
268                TurbineRolePeer.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                                          TurbineRole obj)
296            throws TorqueException
297        {
298            try
299            {
300                obj.setRoleId(row.getValue(offset + 0).asInt());
301                obj.setName(row.getValue(offset + 1).asString());
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<TurbineRole> 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<TurbineRole> 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 BaseTurbineRolePeer
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<TurbineRole> populateObjects(List<Record> records)
394            throws TorqueException
395        {
396            List<TurbineRole> results = new ArrayList<TurbineRole>(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(TurbineRolePeer.row2Object(row, 1,
403                    TurbineRolePeer.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             BaseTurbineRolePeer
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    
458            setDbName(criteria);
459    
460            if (con == null)
461            {
462                BasePeer.doUpdate(selectCriteria, criteria);
463            }
464            else
465            {
466                BasePeer.doUpdate(selectCriteria, criteria, con);
467            }
468        }
469    
470        /**
471         * Method to do deletes.
472         *
473         * @param criteria object containing data that is used DELETE from database.
474         * @throws TorqueException Any exceptions caught during processing will be
475         *         rethrown wrapped into a TorqueException.
476         */
477         public static void doDelete(Criteria criteria) throws TorqueException
478         {
479             TurbineRolePeer
480                .doDelete(criteria, (Connection) null);
481         }
482    
483        /**
484         * Method to do deletes.  This method is to be used during a transaction,
485         * otherwise use the doDelete(Criteria) method.  It will take care of
486         * the connection details internally.
487         *
488         * @param criteria object containing data that is used DELETE from database.
489         * @param con the connection to use
490         * @throws TorqueException Any exceptions caught during processing will be
491         *         rethrown wrapped into a TorqueException.
492         */
493         public static void doDelete(Criteria criteria, Connection con)
494            throws TorqueException
495         {
496            correctBooleans(criteria);
497    
498            setDbName(criteria);
499    
500            if (con == null)
501            {
502                BasePeer.doDelete(criteria, TABLE_NAME);
503            }
504            else
505            {
506                BasePeer.doDelete(criteria, TABLE_NAME, con);
507            }
508         }
509    
510        /**
511         * Method to do selects
512         *
513         * @throws TorqueException Any exceptions caught during processing will be
514         *         rethrown wrapped into a TorqueException.
515         */
516        public static List<TurbineRole> doSelect(TurbineRole obj) throws TorqueException
517        {
518            return doSelect(buildSelectCriteria(obj));
519        }
520    
521        /**
522         * Method to do inserts
523         *
524         * @throws TorqueException Any exceptions caught during processing will be
525         *         rethrown wrapped into a TorqueException.
526         */
527        public static void doInsert(TurbineRole obj) throws TorqueException
528        {
529            obj.setPrimaryKey(doInsert(buildCriteria(obj)));
530            obj.setNew(false);
531            obj.setModified(false);
532        }
533    
534        /**
535         * @param obj the data object to update in the database.
536         * @throws TorqueException Any exceptions caught during processing will be
537         *         rethrown wrapped into a TorqueException.
538         */
539        public static void doUpdate(TurbineRole obj) throws TorqueException
540        {
541            doUpdate(buildCriteria(obj));
542            obj.setModified(false);
543        }
544    
545        /**
546         * @param obj the data object to delete in the database.
547         * @throws TorqueException Any exceptions caught during processing will be
548         *         rethrown wrapped into a TorqueException.
549         */
550        public static void doDelete(TurbineRole obj) throws TorqueException
551        {
552            doDelete(buildSelectCriteria(obj));
553        }
554    
555        /**
556         * Method to do inserts.  This method is to be used during a transaction,
557         * otherwise use the doInsert(TurbineRole) method.  It will take
558         * care of the connection details internally.
559         *
560         * @param obj the data object to insert into the database.
561         * @param con the connection to use
562         * @throws TorqueException Any exceptions caught during processing will be
563         *         rethrown wrapped into a TorqueException.
564         */
565        public static void doInsert(TurbineRole obj, Connection con)
566            throws TorqueException
567        {
568            obj.setPrimaryKey(doInsert(buildCriteria(obj), con));
569            obj.setNew(false);
570            obj.setModified(false);
571        }
572    
573        /**
574         * Method to do update.  This method is to be used during a transaction,
575         * otherwise use the doUpdate(TurbineRole) method.  It will take
576         * care of the connection details internally.
577         *
578         * @param obj the data object to update in the database.
579         * @param con the connection to use
580         * @throws TorqueException Any exceptions caught during processing will be
581         *         rethrown wrapped into a TorqueException.
582         */
583        public static void doUpdate(TurbineRole obj, Connection con)
584            throws TorqueException
585        {
586            doUpdate(buildCriteria(obj), con);
587            obj.setModified(false);
588        }
589    
590        /**
591         * Method to delete.  This method is to be used during a transaction,
592         * otherwise use the doDelete(TurbineRole) method.  It will take
593         * care of the connection details internally.
594         *
595         * @param obj the data object to delete in the database.
596         * @param con the connection to use
597         * @throws TorqueException Any exceptions caught during processing will be
598         *         rethrown wrapped into a TorqueException.
599         */
600        public static void doDelete(TurbineRole obj, Connection con)
601            throws TorqueException
602        {
603            doDelete(buildSelectCriteria(obj), con);
604        }
605    
606        /**
607         * Method to do deletes.
608         *
609         * @param pk ObjectKey that is used DELETE from database.
610         * @throws TorqueException Any exceptions caught during processing will be
611         *         rethrown wrapped into a TorqueException.
612         */
613        public static void doDelete(ObjectKey pk) throws TorqueException
614        {
615            BaseTurbineRolePeer
616               .doDelete(pk, (Connection) null);
617        }
618    
619        /**
620         * Method to delete.  This method is to be used during a transaction,
621         * otherwise use the doDelete(ObjectKey) method.  It will take
622         * care of the connection details internally.
623         *
624         * @param pk the primary key for the object to delete in the database.
625         * @param con the connection to use
626         * @throws TorqueException Any exceptions caught during processing will be
627         *         rethrown wrapped into a TorqueException.
628         */
629        public static void doDelete(ObjectKey pk, Connection con)
630            throws TorqueException
631        {
632            doDelete(buildCriteria(pk), con);
633        }
634    
635        /** Build a Criteria object from an ObjectKey */
636        public static Criteria buildCriteria( ObjectKey pk )
637        {
638            Criteria criteria = new Criteria();
639                criteria.add(ROLE_ID, pk);
640            return criteria;
641         }
642    
643        /** Build a Criteria object from the data object for this peer */
644        public static Criteria buildCriteria( TurbineRole obj )
645        {
646            Criteria criteria = new Criteria(DATABASE_NAME);
647            if (!obj.isNew())
648            criteria.add(ROLE_ID, obj.getRoleId());
649            criteria.add(ROLE_NAME, obj.getName());
650            return criteria;
651        }
652    
653        /** Build a Criteria object from the data object for this peer, skipping all binary columns */
654        public static Criteria buildSelectCriteria( TurbineRole obj )
655        {
656            Criteria criteria = new Criteria(DATABASE_NAME);
657            if (!obj.isNew())
658            {
659                criteria.add(ROLE_ID, obj.getRoleId());
660            }
661                criteria.add(ROLE_NAME, obj.getName());
662            return criteria;
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 TurbineRole retrieveByPK(int pk)
676            throws TorqueException, NoRowsException, TooManyRowsException
677        {
678            return retrieveByPK(SimpleKey.keyFor(pk));
679        }
680    
681        /**
682         * Retrieve a single object by pk
683         *
684         * @param pk the primary key
685         * @param con the connection to use
686         * @throws TorqueException Any exceptions caught during processing will be
687         *         rethrown wrapped into a TorqueException.
688         * @throws NoRowsException Primary key was not found in database.
689         * @throws TooManyRowsException Primary key was not found in database.
690         */
691        public static TurbineRole retrieveByPK(int pk, Connection con)
692            throws TorqueException, NoRowsException, TooManyRowsException
693        {
694            return retrieveByPK(SimpleKey.keyFor(pk), con);
695        }
696    
697        /**
698         * Retrieve a single object by pk
699         *
700         * @param pk the primary key
701         * @throws TorqueException Any exceptions caught during processing will be
702         *         rethrown wrapped into a TorqueException.
703         * @throws NoRowsException Primary key was not found in database.
704         * @throws TooManyRowsException Primary key was not found in database.
705         */
706        public static TurbineRole retrieveByPK(ObjectKey pk)
707            throws TorqueException, NoRowsException, TooManyRowsException
708        {
709            Connection db = null;
710            TurbineRole retVal = null;
711            try
712            {
713                db = Torque.getConnection(DATABASE_NAME);
714                retVal = retrieveByPK(pk, db);
715            }
716            finally
717            {
718                Torque.closeConnection(db);
719            }
720            return retVal;
721        }
722    
723        /**
724         * Retrieve a single object by pk
725         *
726         * @param pk the primary key
727         * @param con the connection to use
728         * @throws TorqueException Any exceptions caught during processing will be
729         *         rethrown wrapped into a TorqueException.
730         * @throws NoRowsException Primary key was not found in database.
731         * @throws TooManyRowsException Primary key was not found in database.
732         */
733        public static TurbineRole retrieveByPK(ObjectKey pk, Connection con)
734            throws TorqueException, NoRowsException, TooManyRowsException
735        {
736            Criteria criteria = buildCriteria(pk);
737            List<TurbineRole> v = doSelect(criteria, con);
738            if (v.size() == 0)
739            {
740                throw new NoRowsException("Failed to select a row.");
741            }
742            else if (v.size() > 1)
743            {
744                throw new TooManyRowsException("Failed to select only one row.");
745            }
746            else
747            {
748                return (TurbineRole)v.get(0);
749            }
750        }
751    
752        /**
753         * Retrieve a multiple objects by pk
754         *
755         * @param pks List of primary keys
756         * @throws TorqueException Any exceptions caught during processing will be
757         *         rethrown wrapped into a TorqueException.
758         */
759        public static List<TurbineRole> retrieveByPKs(List<ObjectKey> pks)
760            throws TorqueException
761        {
762            Connection db = null;
763            List<TurbineRole> retVal = null;
764            try
765            {
766               db = Torque.getConnection(DATABASE_NAME);
767               retVal = retrieveByPKs(pks, db);
768            }
769            finally
770            {
771                Torque.closeConnection(db);
772            }
773            return retVal;
774        }
775    
776        /**
777         * Retrieve a multiple objects by pk
778         *
779         * @param pks List of primary keys
780         * @param dbcon the connection to use
781         * @throws TorqueException Any exceptions caught during processing will be
782         *         rethrown wrapped into a TorqueException.
783         */
784        public static List<TurbineRole> retrieveByPKs( List<ObjectKey> pks, Connection dbcon )
785            throws TorqueException
786        {
787            List<TurbineRole> objs = null;
788            if (pks == null || pks.size() == 0)
789            {
790                objs = new LinkedList<TurbineRole>();
791            }
792            else
793            {
794                Criteria criteria = new Criteria();
795                criteria.addIn( ROLE_ID, pks );
796            objs = doSelect(criteria, dbcon);
797            }
798            return objs;
799        }
800    
801     
802    
803    
804    
805    
806    
807    
808    
809    
810        /**
811         * Returns the TableMap related to this peer.
812         *
813         * @throws TorqueException Any exceptions caught during processing will be
814         *         rethrown wrapped into a TorqueException.
815         */
816        public static TableMap getTableMap()
817            throws TorqueException
818        {
819            return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME);
820        }
821     
822        private static void setDbName(Criteria crit)
823        {
824            // Set the correct dbName if it has not been overridden
825            // crit.getDbName will return the same object if not set to
826            // another value so == check is okay and faster
827            if (crit.getDbName() == Torque.getDefaultDB())
828            {
829                crit.setDbName(DATABASE_NAME);
830            }
831        }
832        
833    
834        // The following methods wrap some methods in BasePeer
835        // to have more support for Java5 generic types in the Peer
836        
837        /**
838         * Utility method which executes a given sql statement.  This
839         * method should be used for select statements only.  Use
840         * executeStatement for update, insert, and delete operations.
841         *
842         * @param queryString A String with the sql statement to execute.
843         * @return List of Record objects.
844         * @throws TorqueException Any exceptions caught during processing will be
845         *         rethrown wrapped into a TorqueException.
846         * @see org.apache.torque.util.BasePeer#executeQuery(String)
847         */
848        public static List<Record> executeQuery(String queryString) throws TorqueException
849        {
850            return BasePeer.executeQuery(queryString);
851        }
852    
853        /**
854         * Utility method which executes a given sql statement.  This
855         * method should be used for select statements only.  Use
856         * executeStatement for update, insert, and delete operations.
857         *
858         * @param queryString A String with the sql statement to execute.
859         * @param dbName The database to connect to.
860         * @return List of Record objects.
861         * @throws TorqueException Any exceptions caught during processing will be
862         *         rethrown wrapped into a TorqueException.
863         * @see org.apache.torque.util.BasePeer#executeQuery(String,String)
864         */
865        public static List<Record> executeQuery(String queryString, String dbName)
866            throws TorqueException
867        {
868            return BasePeer.executeQuery(queryString,dbName);
869        }
870        
871    
872        /**
873         * Method for performing a SELECT.  Returns all results.
874         *
875         * @param queryString A String with the sql statement to execute.
876         * @param dbName The database to connect to.
877         * @param singleRecord Whether or not we want to select only a
878         * single record.
879         * @return List of Record objects.
880         * @throws TorqueException Any exceptions caught during processing will be
881         *         rethrown wrapped into a TorqueException.
882         * @see org.apache.torque.util.BasePeer#executeQuery(String,String,boolean)
883         */
884        public static List<Record> executeQuery(
885            String queryString,
886            String dbName,
887            boolean singleRecord)
888            throws TorqueException
889        {
890            return BasePeer.executeQuery(queryString,dbName,singleRecord);
891        }
892    
893        /**
894         * Method for performing a SELECT.  Returns all results.
895         *
896         * @param queryString A String with the sql statement to execute.
897         * @param singleRecord Whether or not we want to select only a
898         * single record.
899         * @param con A Connection.
900         * @return List of Record objects.
901         * @throws TorqueException Any exceptions caught during processing will be
902         *         rethrown wrapped into a TorqueException.
903         * @see org.apache.torque.util.BasePeer#executeQuery(String,boolean,Connection)
904         */
905        public static List<Record> executeQuery(
906            String queryString,
907            boolean singleRecord,
908            Connection con)
909            throws TorqueException
910        {
911            return BasePeer.executeQuery(queryString,singleRecord,con);
912        }
913    
914        /**
915         * Method for performing a SELECT.
916         *
917         * @param queryString A String with the sql statement to execute.
918         * @param start The first row to return.
919         * @param numberOfResults The number of rows to return.
920         * @param dbName The database to connect to.
921         * @param singleRecord Whether or not we want to select only a
922         * single record.
923         * @return List of Record objects.
924         * @throws TorqueException Any exceptions caught during processing will be
925         *         rethrown wrapped into a TorqueException.
926         * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean)
927         */
928        public static List<Record> executeQuery(
929            String queryString,
930            int start,
931            int numberOfResults,
932            String dbName,
933            boolean singleRecord)
934            throws TorqueException
935        {
936            return BasePeer.executeQuery(queryString,start,numberOfResults,dbName,singleRecord);
937        }
938    
939        /**
940         * Method for performing a SELECT.  Returns all results.
941         *
942         * @param queryString A String with the sql statement to execute.
943         * @param start The first row to return.
944         * @param numberOfResults The number of rows to return.
945         * @param singleRecord Whether or not we want to select only a
946         * single record.
947         * @param con A Connection.
948         * @return List of Record objects.
949         * @throws TorqueException Any exceptions caught during processing will be
950         *         rethrown wrapped into a TorqueException.
951         * @see org.apache.torque.util.BasePeer#executeQuery(String,int,int,String,boolean,Connection)
952         */
953        public static List<Record> executeQuery(
954            String queryString,
955            int start,
956            int numberOfResults,
957            boolean singleRecord,
958            Connection con)
959            throws TorqueException
960        {
961            return BasePeer.executeQuery(queryString,start,numberOfResults,singleRecord,con);
962        }
963    
964        /**
965         * Returns all records in a QueryDataSet as a List of Record
966         * objects.  Used for functionality like util.LargeSelect.
967         *
968         * @see #getSelectResults(QueryDataSet, int, int, boolean)
969         * @param qds the QueryDataSet
970         * @return a List of Record objects
971         * @throws TorqueException Any exceptions caught during processing will be
972         *         rethrown wrapped into a TorqueException.
973         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet)
974         */
975        public static List<Record> getSelectResults(QueryDataSet qds)
976            throws TorqueException
977        {
978            return BasePeer.getSelectResults(qds);
979        }
980        
981        /**
982         * Returns all records in a QueryDataSet as a List of Record
983         * objects.  Used for functionality like util.LargeSelect.
984         *
985         * @see #getSelectResults(QueryDataSet, int, int, boolean)
986         * @param qds the QueryDataSet
987         * @param singleRecord
988         * @return a List of Record objects
989         * @throws TorqueException Any exceptions caught during processing will be
990         *         rethrown wrapped into a TorqueException.
991         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,boolean)
992         */
993        public static List<Record> getSelectResults(QueryDataSet qds, boolean singleRecord)
994            throws TorqueException
995        {
996            return BasePeer.getSelectResults(qds,singleRecord);
997        }
998        
999        /**
1000         * Returns numberOfResults records in a QueryDataSet as a List
1001         * of Record objects.  Starting at record 0.  Used for
1002         * functionality like util.LargeSelect.
1003         *
1004         * @see #getSelectResults(QueryDataSet, int, int, boolean)
1005         * @param qds the QueryDataSet
1006         * @param numberOfResults
1007         * @param singleRecord
1008         * @return a List of Record objects
1009         * @throws TorqueException Any exceptions caught during processing will be
1010         *         rethrown wrapped into a TorqueException.
1011         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,boolean)
1012         */
1013        public static List<Record> getSelectResults(
1014            QueryDataSet qds,
1015            int numberOfResults,
1016            boolean singleRecord)
1017            throws TorqueException
1018        {
1019            return BasePeer.getSelectResults(qds,numberOfResults,singleRecord);
1020        }
1021    
1022        /**
1023         * Returns numberOfResults records in a QueryDataSet as a List
1024         * of Record objects.  Starting at record start.  Used for
1025         * functionality like util.LargeSelect.
1026         *
1027         * @param qds The <code>QueryDataSet</code> to extract results
1028         * from.
1029         * @param start The index from which to start retrieving
1030         * <code>Record</code> objects from the data set.
1031         * @param numberOfResults The number of results to return (or
1032         * <code> -1</code> for all results).
1033         * @param singleRecord Whether or not we want to select only a
1034         * single record.
1035         * @return A <code>List</code> of <code>Record</code> objects.
1036         * @exception TorqueException If any <code>Exception</code> occurs.
1037         * @see org.apache.torque.util.BasePeer#getSelectResults(QueryDataSet,int,int,boolean)
1038         */
1039        public static List getSelectResults(
1040            QueryDataSet qds,
1041            int start,
1042            int numberOfResults,
1043            boolean singleRecord)
1044            throws TorqueException
1045        {
1046            return BasePeer.getSelectResults(qds,start,numberOfResults,singleRecord);
1047        }
1048    
1049        /**
1050         * Performs a SQL <code>select</code> using a PreparedStatement.
1051         * Note: this method does not handle null criteria values.
1052         *
1053         * @param criteria
1054         * @param con
1055         * @return a List of Record objects.
1056         * @throws TorqueException Error performing database query.
1057         * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria,Connection)
1058         */
1059        public static List<Record> doPSSelect(Criteria criteria, Connection con)
1060            throws TorqueException
1061        {
1062            return BasePeer.doPSSelect(criteria,con);
1063        }
1064    
1065        /**
1066         * Do a Prepared Statement select according to the given criteria
1067         *
1068         * @param criteria
1069         * @return a List of Record objects.
1070         * @throws TorqueException Any exceptions caught during processing will be
1071         *         rethrown wrapped into a TorqueException.
1072         * @see org.apache.torque.util.BasePeer#doPSSelect(Criteria)
1073         */
1074        public static List<Record> doPSSelect(Criteria criteria) throws TorqueException
1075        {
1076            return BasePeer.doPSSelect(criteria);
1077        }
1078    }