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