    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 BaseTurbinePermissionPeer
    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(TurbinePermissionMapBuilder.CLASS_NAME) instead
    061         */
    062        public static MapBuilder getMapBuilder()
    063            throws TorqueException
    064        {
    065            return Torque.getMapBuilder(TurbinePermissionMapBuilder.CLASS_NAME);
    066        }
    067
    068        /** the column name for the PERMISSION_ID field */
    069        public static final String PERMISSION_ID;
    070        /** the column name for the PERMISSION_NAME field */
    071        public static final String PERMISSION_NAME;
    072
    073        static
    074        {
    075            DATABASE_NAME = "default";
    076            TABLE_NAME = "TURBINE_PERMISSION";
    077
    078            PERMISSION_ID = "TURBINE_PERMISSION.PERMISSION_ID";
    079            PERMISSION_NAME = "TURBINE_PERMISSION.PERMISSION_NAME";
    080            if (Torque.isInit())
    081            {
    082                try
    083                {
    084                    Torque.getMapBuilder(TurbinePermissionMapBuilder.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(TurbinePermissionMapBuilder.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.TurbinePermission";
    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<TurbinePermission> 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 BaseTurbinePermissionPeer
    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(PERMISSION_ID);
    234            criteria.addSelectColumn(PERMISSION_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 TurbinePermission row2Object(Record row,
    261                                                 int offset,
    262                                                 Class cls)
    263            throws TorqueException
    264        {
    265            try
    266            {
    267                TurbinePermission obj = (TurbinePermission) cls.newInstance();
    268                TurbinePermissionPeer.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                                          TurbinePermission obj)
    296            throws TorqueException
    297        {
    298            try
    299            {
    300                obj.setPermissionId(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<TurbinePermission> 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<TurbinePermission> 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 BaseTurbinePermissionPeer
    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<TurbinePermission> populateObjects(List<Record> records)
    394            throws TorqueException
    395        {
    396            List<TurbinePermission> results = new ArrayList<TurbinePermission>(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(TurbinePermissionPeer.row2Object(row, 1,
    403                    TurbinePermissionPeer.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             BaseTurbinePermissionPeer
    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(PERMISSION_ID, criteria.remove(PERMISSION_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             TurbinePermissionPeer
    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<TurbinePermission> doSelect(TurbinePermission 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(TurbinePermission 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(TurbinePermission 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(TurbinePermission 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(TurbinePermission) 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(TurbinePermission 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(TurbinePermission) 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(TurbinePermission 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(TurbinePermission) 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(TurbinePermission 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            BaseTurbinePermissionPeer
    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(PERMISSION_ID, pk);
    640            return criteria;
    641         }
    642
    643        /** Build a Criteria object from the data object for this peer */
    644        public static Criteria buildCriteria( TurbinePermission obj )
    645        {
    646            Criteria criteria = new Criteria(DATABASE_NAME);
    647            if (!obj.isNew())
    648            criteria.add(PERMISSION_ID, obj.getPermissionId());
    649            criteria.add(PERMISSION_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( TurbinePermission obj )
    655        {
    656            Criteria criteria = new Criteria(DATABASE_NAME);
    657            if (!obj.isNew())
    658            {
    659                criteria.add(PERMISSION_ID, obj.getPermissionId());
    660            }
    661                criteria.add(PERMISSION_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 TurbinePermission 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 TurbinePermission 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 TurbinePermission retrieveByPK(ObjectKey pk)
    707            throws TorqueException, NoRowsException, TooManyRowsException
    708        {
    709            Connection db = null;
    710            TurbinePermission 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 TurbinePermission retrieveByPK(ObjectKey pk, Connection con)
    734            throws TorqueException, NoRowsException, TooManyRowsException
    735        {
    736            Criteria criteria = buildCriteria(pk);
    737            List<TurbinePermission> 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 (TurbinePermission)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<TurbinePermission> retrieveByPKs(List<ObjectKey> pks)
    760            throws TorqueException
    761        {
    762            Connection db = null;
    763            List<TurbinePermission> 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<TurbinePermission> retrieveByPKs( List<ObjectKey> pks, Connection dbcon )
    785            throws TorqueException
    786        {
    787            List<TurbinePermission> objs = null;
    788            if (pks == null || pks.size() == 0)
    789            {
    790                objs = new LinkedList<TurbinePermission>();
    791            }
    792            else
    793            {
    794                Criteria criteria = new Criteria();
    795                criteria.addIn( PERMISSION_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    }