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