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