##### Coverage Report - org.apache.turbine.services.security.torque.om.BaseTurbineUserGroupRolePeer

Classes in this File | Line Coverage | Branch Coverage | Complexity
BaseTurbineUserGroupRolePeer |
0% | 0/434
0% | 0/108
| 2.1746031746031744;2,175

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