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    }