Source code

001package org.apache.fulcrum.security.torque.om;
002
003import java.sql.Connection;
004import java.util.Collection;
005import java.util.List;
006import java.util.Map;
007import java.util.stream.Stream;
008
009import org.apache.torque.NoRowsException;
010import org.apache.torque.TooManyRowsException;
011import org.apache.torque.Column;
012import org.apache.torque.Torque;
013import org.apache.torque.TorqueException;
014import org.apache.torque.adapter.IDMethod;
015import org.apache.torque.criteria.Criteria;
016import org.apache.torque.map.DatabaseMap;
017import org.apache.torque.map.TableMap;
018import org.apache.torque.map.ColumnMap;
019import org.apache.torque.map.ForeignKeyMap;
020import org.apache.torque.om.mapper.RecordMapper;
021import org.apache.torque.om.ObjectKey;
022import org.apache.torque.util.ColumnValues;
023import org.apache.torque.util.JdbcTypedValue;
024
025
026
027/**
028 * The skeleton for this class was autogenerated by Torque on:
029 *
030 * [Thu Nov 04 13:34:23 CET 2021]
031 *
032 * You should not use this class directly.  It should not even be
033 * extended; all references should be to TorqueTurbineUserGroupRolePeer
034 */
035
036@SuppressWarnings("unused")
037public abstract class BaseTorqueTurbineUserGroupRolePeer
038{
039    /** The default database name for this class. */
040    public static final String DATABASE_NAME;
041
042     /** The table name for this class. */
043    public static final String TABLE_NAME;
044
045     /** The table map for this class. */
046    public static final TableMap TABLE;
047    /** The column for the USER_ID field */
048    public static final ColumnMap USER_ID;
049    /** The column for the GROUP_ID field */
050    public static final ColumnMap GROUP_ID;
051    /** The column for the ROLE_ID field */
052    public static final ColumnMap ROLE_ID;
053
054    /** number of columns for this peer */
055    public static final int numColumns = 3;
056
057
058    /** The implementation of the peer. */
059    private static TorqueTurbineUserGroupRolePeerImpl torqueTurbineUserGroupRolePeerImpl;
060
061
062    static
063    {
064        DatabaseMap dbMap = Torque.getOrCreateDatabase("fulcrum")
065                .getDatabaseMap();
066        if (dbMap.getTable("TURBINE_USER_GROUP_ROLE") == null)
067        {
068            dbMap.addTable("TURBINE_USER_GROUP_ROLE");
069        }
070        DATABASE_NAME = "fulcrum";
071        TABLE_NAME = "TURBINE_USER_GROUP_ROLE";
072
073        TABLE = dbMap.getTable("TURBINE_USER_GROUP_ROLE");
074        TABLE.setJavaName("TorqueTurbineUserGroupRole");
075        TABLE.setOMClass(org.apache.fulcrum.security.torque.om.TorqueTurbineUserGroupRole.class);
076        TABLE.setPeerClass(org.apache.fulcrum.security.torque.om.TorqueTurbineUserGroupRolePeer.class);
077        TABLE.setPrimaryKeyMethod(IDMethod.NO_ID_METHOD);
078        TABLE.setPrimaryKeyMethodInfo(IDMethod.ID_BROKER, TABLE.getName());
079        TABLE.setPrimaryKeyMethodInfo(IDMethod.SEQUENCE, "$sequenceName");
080        TABLE.setPrimaryKeyMethodInfo(IDMethod.AUTO_INCREMENT, "TURBINE_USER_GROUP_ROLE");
081        TABLE.setUseInheritance(true);
082
083
084    // ------------- Column: USER_ID --------------------
085        USER_ID = new ColumnMap("USER_ID", TABLE);
086        USER_ID.setType(Integer.valueOf(0));
087        USER_ID.setTorqueType("INTEGER");
088        USER_ID.setUsePrimitive(false);
089        USER_ID.setPrimaryKey(true);
090        USER_ID.setNotNull(true);
091        USER_ID.setJavaName("UserId");
092        USER_ID.setAutoIncrement(false);
093        USER_ID.setProtected(false);
094        USER_ID.setJavaType( "Integer" );
095        USER_ID.setPosition(1);
096        TABLE.addColumn(USER_ID);
097    // ------------- Column: GROUP_ID --------------------
098        GROUP_ID = new ColumnMap("GROUP_ID", TABLE);
099        GROUP_ID.setType(Integer.valueOf(0));
100        GROUP_ID.setTorqueType("INTEGER");
101        GROUP_ID.setUsePrimitive(false);
102        GROUP_ID.setPrimaryKey(true);
103        GROUP_ID.setNotNull(true);
104        GROUP_ID.setJavaName("GroupId");
105        GROUP_ID.setAutoIncrement(false);
106        GROUP_ID.setProtected(false);
107        GROUP_ID.setJavaType( "Integer" );
108        GROUP_ID.setPosition(2);
109        TABLE.addColumn(GROUP_ID);
110    // ------------- Column: ROLE_ID --------------------
111        ROLE_ID = new ColumnMap("ROLE_ID", TABLE);
112        ROLE_ID.setType(Integer.valueOf(0));
113        ROLE_ID.setTorqueType("INTEGER");
114        ROLE_ID.setUsePrimitive(false);
115        ROLE_ID.setPrimaryKey(true);
116        ROLE_ID.setNotNull(true);
117        ROLE_ID.setJavaName("RoleId");
118        ROLE_ID.setAutoIncrement(false);
119        ROLE_ID.setProtected(false);
120        ROLE_ID.setJavaType( "Integer" );
121        ROLE_ID.setPosition(3);
122        TABLE.addColumn(ROLE_ID);
123
124
125    // ------------- Foreign keys --------------------
126        ForeignKeyMap foreignKeyMap;
127        TableMap foreignTable;
128        String foreignTableName; 
129        foreignTableName = "FULCRUM_TURBINE_USER"; 
130        foreignTable = dbMap.getTable(foreignTableName);
131        if (foreignTable == null)
132        {
133            foreignKeyMap = new ForeignKeyMap(TABLE, foreignTableName);
134            foreignKeyMap.addColumns(new ForeignKeyMap.ColumnPair(
135                foreignKeyMap,
136                TABLE.getColumn("USER_ID"),
137                "USER_ID"));
138        }
139        else
140        {
141            foreignKeyMap = new ForeignKeyMap(TABLE, foreignTable);
142            foreignKeyMap.addColumns(new ForeignKeyMap.ColumnPair(
143                foreignKeyMap,
144                TABLE.getColumn("USER_ID"),
145                foreignTable.getColumn("USER_ID")));
146        }
147        TABLE.addForeignKey(foreignKeyMap);
148        foreignTableName = "FULCRUM_TURBINE_GROUP"; 
149        foreignTable = dbMap.getTable(foreignTableName);
150        if (foreignTable == null)
151        {
152            foreignKeyMap = new ForeignKeyMap(TABLE, foreignTableName);
153            foreignKeyMap.addColumns(new ForeignKeyMap.ColumnPair(
154                foreignKeyMap,
155                TABLE.getColumn("GROUP_ID"),
156                "GROUP_ID"));
157        }
158        else
159        {
160            foreignKeyMap = new ForeignKeyMap(TABLE, foreignTable);
161            foreignKeyMap.addColumns(new ForeignKeyMap.ColumnPair(
162                foreignKeyMap,
163                TABLE.getColumn("GROUP_ID"),
164                foreignTable.getColumn("GROUP_ID")));
165        }
166        TABLE.addForeignKey(foreignKeyMap);
167        foreignTableName = "FULCRUM_TURBINE_ROLE"; 
168        foreignTable = dbMap.getTable(foreignTableName);
169        if (foreignTable == null)
170        {
171            foreignKeyMap = new ForeignKeyMap(TABLE, foreignTableName);
172            foreignKeyMap.addColumns(new ForeignKeyMap.ColumnPair(
173                foreignKeyMap,
174                TABLE.getColumn("ROLE_ID"),
175                "ROLE_ID"));
176        }
177        else
178        {
179            foreignKeyMap = new ForeignKeyMap(TABLE, foreignTable);
180            foreignKeyMap.addColumns(new ForeignKeyMap.ColumnPair(
181                foreignKeyMap,
182                TABLE.getColumn("ROLE_ID"),
183                foreignTable.getColumn("ROLE_ID")));
184        }
185        TABLE.addForeignKey(foreignKeyMap);
186
187
188        initDatabaseMap();
189    }
190
191    /**
192     * Creates a new instance of the  implementation of the peer.
193     *
194     * @return the new instance.
195     */
196    protected static TorqueTurbineUserGroupRolePeerImpl createTorqueTurbineUserGroupRolePeerImpl()
197    {
198        TorqueTurbineUserGroupRolePeerImpl instance = new TorqueTurbineUserGroupRolePeerImpl();
199        return instance;
200    }
201
202
203    /**
204     * Returns an instance of the implementation of the peer.
205     * If no instance is currently cached, a new instance is created and cached.
206     *
207     * @return an instance of the implementation of the peer, not null.
208     */
209    public static TorqueTurbineUserGroupRolePeerImpl getTorqueTurbineUserGroupRolePeerImpl()
210    {
211        TorqueTurbineUserGroupRolePeerImpl peerImplInstance = torqueTurbineUserGroupRolePeerImpl;
212        if (peerImplInstance == null)
213        {
214            peerImplInstance = TorqueTurbineUserGroupRolePeer.createTorqueTurbineUserGroupRolePeerImpl();
215            torqueTurbineUserGroupRolePeerImpl = peerImplInstance;
216            Torque.registerPeerInstance(TorqueTurbineUserGroupRole.class, peerImplInstance);
217        }
218        return peerImplInstance;
219    }
220
221
222
223    /**
224     * Sets the instance of the implementation of the peer.
225     *
226     * @param peerImplInstance an instance of the implementation of the peer, or null
227     *        if a new instance should be created automatically.
228     */
229    public static void setTorqueTurbineUserGroupRolePeerImpl(TorqueTurbineUserGroupRolePeerImpl peerImplInstance)
230    {
231        torqueTurbineUserGroupRolePeerImpl = peerImplInstance;
232    }
233
234
235    /**
236     * Add all the columns needed to create a new object.
237     *
238     * @param criteria object containing the columns to add.
239     */
240    public static void addSelectColumns(Criteria criteria)
241    {
242        getTorqueTurbineUserGroupRolePeerImpl().addSelectColumns(criteria);
243    }
244
245    /**
246     * changes the boolean values in the criteria to the appropriate type,
247     * whenever a booleanchar or booleanint column is involved.
248     * This enables the user to create criteria using Boolean values
249     * for booleanchar or booleanint columns.
250     *
251     * @param criteria the criteria in which the boolean values
252     *        should be corrected.
253     *
254     * @throws TorqueException if the database map for the criteria cannot be 
255               obtained.
256     */
257    public static void correctBooleans(Criteria criteria) throws TorqueException
258    {
259        getTorqueTurbineUserGroupRolePeerImpl().correctBooleans(criteria);
260    }
261
262    /**
263     * Checks all columns in the criteria to see whether
264     * booleanchar and booleanint columns are queried with a boolean.
265     * If yes, the query values are mapped onto values the database
266     * does understand, i.e. 0 and 1 for booleanints and N and Y for
267     * booleanchar columns.
268     *
269     * @param columnValues The value to be checked for booleanint
270     *        and booleanchar columns.
271     * @throws TorqueException if the database map for the criteria cannot be
272     *         retrieved.
273     */
274    public static void correctBooleans(
275            ColumnValues columnValues)
276        throws TorqueException
277    {
278        getTorqueTurbineUserGroupRolePeerImpl().correctBooleans(columnValues);
279    }
280    
281    /**
282     * Selects TorqueTurbineUserGroupRole objects from a database.
283     *
284     * @param criteria object used to create the SELECT statement.
285     *
286     * @return the list of selected objects, not null.
287     *
288     * @throws TorqueException Any exceptions caught during processing will be
289     *         rethrown wrapped into a TorqueException.
290     */
291    public static List<TorqueTurbineUserGroupRole> doSelect(Criteria criteria)
292            throws TorqueException
293    {
294        return getTorqueTurbineUserGroupRolePeerImpl().doSelect(criteria);
295    }
296
297    /**
298     * Selects TorqueTurbineUserGroupRole objects from a database
299     * within a transaction.
300     *
301     * @param criteria object used to create the SELECT statement.
302     * @param connection the connection holding the transaction, not null.
303     *
304     * @return The list of selected objects, not null.
305     *
306     * @throws TorqueException Any exceptions caught during processing will be
307     *         rethrown wrapped into a TorqueException.
308     */
309    public static List<TorqueTurbineUserGroupRole> doSelect(
310                Criteria criteria,
311                Connection connection)
312            throws TorqueException
313    {
314        return getTorqueTurbineUserGroupRolePeerImpl().doSelect(criteria, connection);
315    }
316
317    /**
318     * Selects TorqueTurbineUserGroupRole objects from a database
319     * within a transaction.
320     *
321     * This method returns a stream that <b>must</b> be closed after use.
322     * All resources used by this method will be closed when the stream is
323     * closed.
324     *
325     * @param criteria object used to create the SELECT statement.
326     * @param connection the connection holding the transaction, not null.
327     *
328     * @return The results of the query as a Stream, not null.
329     *
330     * @throws TorqueException Any exceptions caught during processing will be
331     *         rethrown wrapped into a TorqueException.
332     */
333    public static Stream<TorqueTurbineUserGroupRole> doSelectAsStream(
334                Criteria criteria,
335                Connection connection)
336            throws TorqueException
337    {
338        return getTorqueTurbineUserGroupRolePeerImpl().doSelectAsStream(criteria, connection);
339    }
340
341    /**
342     * Selects rows from a database an maps them to objects.
343     *
344     * @param criteria A Criteria specifying the records to select, not null.
345     * @param mapper The mapper creating the objects from the resultSet,
346     *        not null.
347     *
348     * @return The results of the query, not null.
349     *
350     * @throws TorqueException if querying the database fails.
351     */
352    public static <T> List<T> doSelect(
353                Criteria criteria,
354                RecordMapper<T> mapper)
355            throws TorqueException
356    {
357        return getTorqueTurbineUserGroupRolePeerImpl().doSelect(criteria, mapper);
358    }
359
360    /**
361     * Selects rows from a database an maps them to objects.
362     *
363     * @param criteria A Criteria specifying the records to select, not null.
364     * @param mapper The mapper creating the objects from the resultSet,
365     *        not null.
366     * @param connection the database connection for selecting records,
367     *        not null.
368     *
369     * @return The results of the query, not null.
370     *
371     * @throws TorqueException Error performing database query.
372     */
373    public static <T> List<T> doSelect(
374            Criteria criteria,
375            RecordMapper<T> mapper,
376            Connection connection)
377        throws TorqueException
378    {
379        return getTorqueTurbineUserGroupRolePeerImpl().doSelect(
380                criteria,
381                mapper,
382                connection);
383    }
384
385    /**
386     * Selects rows from a database an maps them to objects.
387     *
388     * This method returns a stream that <b>must</b> be closed after use.
389     * All resources used by this method will be closed when the stream is
390     * closed.
391     *
392     * @param criteria A Criteria specifying the records to select, not null.
393     * @param mapper The mapper creating the objects from the resultSet,
394     *        not null.
395     * @param connection the database connection for selecting records,
396     *        not null.
397     *
398     * @return The results of the query as a Stream, not null.
399     *
400     * @throws TorqueException Error performing database query.
401     */
402    public static <T> Stream<T> doSelectAsStream(
403            Criteria criteria,
404            RecordMapper<T> mapper,
405            Connection connection)
406        throws TorqueException
407    {
408        return getTorqueTurbineUserGroupRolePeerImpl().doSelectAsStream(
409                criteria,
410                mapper,
411                connection);
412    }
413
414    /**
415     * Selects rows from a database an maps them to objects.
416     *
417     * @param query the sql query to execute, not null.
418     * @param mapper The mapper creating the objects from the resultSet,
419     *        not null.
420     * @param dbName The name of the database to create the connection for,
421     *        or null for the default SDB.
422     *
423     * @return The results of the query, not null.
424     *
425     * @throws TorqueException if querying the database fails.
426     */
427    public static <T> List<T> doSelect(
428                String query,
429                RecordMapper<T> mapper,
430                String dbName)
431            throws TorqueException
432    {
433        return getTorqueTurbineUserGroupRolePeerImpl().doSelect(
434                query,
435                mapper,
436                dbName);
437    }
438
439    /**
440     * Selects rows from a database an maps them to objects.
441     *
442     * @param query the SQL Query to execute, not null.
443     * @param mapper The mapper creating the objects from the resultSet,
444     *        not null.
445     * @param connection the database connection, not null.
446     *
447     * @return The results of the query, not null.
448     *
449     * @throws TorqueException if querying the database fails.
450     */
451    public static <T> List<T> doSelect(
452                String query,
453                RecordMapper<T> mapper,
454                Connection connection)
455            throws TorqueException
456    {
457        return getTorqueTurbineUserGroupRolePeerImpl().doSelect(
458                query,
459                mapper,
460                connection);
461    }
462
463    /**
464     * Selects rows from a database an maps them to objects.
465     *
466     * This method returns a stream that <b>must</b> be closed after use.
467     * All resources used by this method will be closed when the stream is
468     * closed.
469     *
470     * @param query the SQL Query to execute, not null.
471     * @param mapper The mapper creating the objects from the resultSet,
472     *        not null.
473     * @param connection the database connection, not null.
474     *
475     * @return The results of the query as a Stream, not null.
476     *
477     * @throws TorqueException if querying the database fails.
478     */
479    public static <T> Stream<T> doSelectAsStream(
480                String query,
481                RecordMapper<T> mapper,
482                Connection connection)
483            throws TorqueException
484    {
485        return getTorqueTurbineUserGroupRolePeerImpl().doSelectAsStream(
486                query,
487                mapper,
488                connection);
489    }
490
491    /**
492     * Selects TorqueTurbineUserGroupRole objects from the database which have
493     * the same content as the passed object.
494     *
495     * @return The list of selected objects, not null.
496     *
497     * @throws TorqueException Any exceptions caught during processing will be
498     *         rethrown wrapped into a TorqueException.
499     */
500    public static List<TorqueTurbineUserGroupRole> doSelect(TorqueTurbineUserGroupRole obj)
501            throws TorqueException
502    {
503        return getTorqueTurbineUserGroupRolePeerImpl().doSelect(obj);
504    }
505
506    /**
507     * Selects at most one TorqueTurbineUserGroupRole object from a database.
508     *
509     * @param criteria object used to create the SELECT statement.
510     *
511     * @return the selected Object, or null if no object was selected.
512     *
513     * @throws TorqueException If more than one record is selected or if
514     *         an error occurs when processing the query.
515     */
516    public static TorqueTurbineUserGroupRole doSelectSingleRecord(
517                Criteria criteria)
518            throws TorqueException
519    {
520        return getTorqueTurbineUserGroupRolePeerImpl().doSelectSingleRecord(criteria);
521    }
522
523    /**
524     * Selects at most one TorqueTurbineUserGroupRole object from a database
525     * within a transaction.
526     *
527     * @param criteria object used to create the SELECT statement.
528     * @param connection the connection holding the transaction, not null.
529     *
530     * @return the selected Object, or null if no object was selected.
531     *
532     * @throws TorqueException If more than one record is selected or if
533     *         an error occurs when processing the query.
534     */
535    public static TorqueTurbineUserGroupRole doSelectSingleRecord(
536                Criteria criteria,
537                Connection connection)
538            throws TorqueException
539    {
540        return getTorqueTurbineUserGroupRolePeerImpl().doSelectSingleRecord(criteria, connection);
541    }
542
543    /**
544     * Selects at most a single row from a database an maps them to objects.
545     *
546     * @param criteria A Criteria specifying the records to select, not null.
547     * @param mapper The mapper creating the objects from the resultSet,
548     *        not null.
549     *
550     * @return The selected row, or null if no records was selected.
551     *
552     * @throws TorqueException if querying the database fails.
553     */
554    public static <T> T doSelectSingleRecord(
555                org.apache.torque.criteria.Criteria criteria,
556                RecordMapper<T> mapper)
557            throws TorqueException
558    {
559        return getTorqueTurbineUserGroupRolePeerImpl().doSelectSingleRecord(
560                criteria,
561                mapper);
562    }
563
564    /**
565     * Selects at most a single row from a database an maps them to objects.
566     *
567     * @param criteria A Criteria specifying the records to select, not null.
568     * @param mapper The mapper creating the objects from the resultSet,
569     *        not null.
570     * @param connection the database connection, not null.
571     *
572     * @return The selected row, or null if no records was selected.
573     *
574     * @throws TorqueException if querying the database fails.
575     */
576    public static <T> T doSelectSingleRecord(
577                org.apache.torque.criteria.Criteria criteria,
578                RecordMapper<T> mapper,
579                Connection connection)
580            throws TorqueException
581    {
582        return getTorqueTurbineUserGroupRolePeerImpl().doSelectSingleRecord(
583                criteria,
584                mapper,
585                connection);
586    }
587
588    /**
589     * Selects at most one TorqueTurbineUserGroupRole object from the database
590     * which has the same content as the passed object.
591     *
592     * @return the selected Object, or null if no object was selected.
593     *
594     * @throws TorqueException If more than one record is selected or if
595     *         an error occurs when processing the query.
596     */
597    public static TorqueTurbineUserGroupRole doSelectSingleRecord(
598                TorqueTurbineUserGroupRole obj)
599            throws TorqueException
600    {
601        return getTorqueTurbineUserGroupRolePeerImpl().doSelectSingleRecord(obj);
602    }
603
604
605    /**
606     * Returns a new instance of the Data object class
607     */
608    public static TorqueTurbineUserGroupRole getDbObjectInstance()
609    {
610        return getTorqueTurbineUserGroupRolePeerImpl().getDbObjectInstance();
611    }
612
613
614    /**
615     * Method to do inserts.
616     *
617     * @param columnValues the values to insert.
618     *
619     * @return the primary key of the inserted row.
620     *
621     * @throws TorqueException Any exceptions caught during processing will be
622     *         rethrown wrapped into a TorqueException.
623     */
624    public static ObjectKey<?> doInsert(ColumnValues columnValues) 
625            throws TorqueException
626    {
627        return getTorqueTurbineUserGroupRolePeerImpl().doInsert(columnValues);
628    }
629
630    /**
631     * Method to do inserts.  This method is to be used during a transaction,
632     * otherwise use the doInsert(Criteria) method.
633     *
634     * @param columnValues the values to insert.
635     * @param con the connection to use, not null.
636     *
637     * @return the primary key of the inserted row.
638     *
639     * @throws TorqueException Any exceptions caught during processing will be
640     *         rethrown wrapped into a TorqueException.
641     */
642    public static ObjectKey<?> doInsert(ColumnValues columnValues, Connection con)
643            throws TorqueException
644    {
645        return getTorqueTurbineUserGroupRolePeerImpl().doInsert(columnValues, con);
646    }
647    /**
648     * Method to do inserts
649     *
650     * @throws TorqueException Any exceptions caught during processing will be
651     *         rethrown wrapped into a TorqueException.
652     */
653    public static void doInsert(TorqueTurbineUserGroupRole obj)
654            throws TorqueException
655    {
656        getTorqueTurbineUserGroupRolePeerImpl().doInsert(obj);
657    }
658
659    /**
660     * Method to do inserts.  This method is to be used during a transaction,
661     * otherwise use the doInsert(TorqueTurbineUserGroupRole) method.  It will take
662     * care of the connection details internally.
663     *
664     * @param obj the data object to insert into the database.
665     * @param con the connection to use
666     * @throws TorqueException Any exceptions caught during processing will be
667     *         rethrown wrapped into a TorqueException.
668     */
669    public static void doInsert(TorqueTurbineUserGroupRole obj, Connection con)
670            throws TorqueException
671    {
672        getTorqueTurbineUserGroupRolePeerImpl().doInsert(obj, con);
673    }
674
675    /**
676     * Executes a insert into...select statement.
677     *
678     * @param toInsertInto the columns in which to insert, not null.
679     * @param criteria the criteria which selects the values to insert,
680     *        not null.
681     *
682     * @return the number of inserted rows.
683     *
684     * @throws TorqueException if a database error occurs.
685     */
686    public static int doInsert(
687                final Column[] toInsertInto,
688                final Criteria criteria)
689            throws TorqueException
690    {
691        return getTorqueTurbineUserGroupRolePeerImpl().doInsert(toInsertInto, criteria);
692    }
693
694    /**
695     * Executes a insert into...select statement.
696     *
697     * @param toInsertInto the columns in which to insert, not null.
698     * @param criteria the criteria which selects the values to insert,
699     *        not null.
700     * @param dbName the database name, or null to take the database name
701     *        from getDatabaseName().
702     *
703     * @return the number of inserted rows.
704     *
705     * @throws TorqueException if a database error occurs.
706     */
707    public static int doInsert(
708                final Column[] toInsertInto,
709                final Criteria criteria,
710                final String dbName)
711            throws TorqueException
712    {
713        return getTorqueTurbineUserGroupRolePeerImpl().doInsert(toInsertInto, criteria, dbName);
714    }
715
716    /**
717     * Executes a insert into...select statement.
718     *
719     * @param toInsertInto the columns in which to insert, not null.
720     * @param criteria the criteria which selects the values to insert,
721     *        not null.
722     * @param connection the database connection to use, not null.
723     *
724     * @return the number of inserted rows.
725     *
726     * @throws TorqueException if a database error occurs.
727     */
728    public static int doInsert(
729                final Column[] toInsertInto,
730                final Criteria criteria,
731                final Connection connection)
732            throws TorqueException
733    {
734        return getTorqueTurbineUserGroupRolePeerImpl().doInsert(toInsertInto, criteria, connection);
735    }
736
737    /**
738     * Executes a insert into...select statement.
739     *
740     * @param toInsertInto the columns in which to insert, not null.
741     * @param criteria the criteria which selects the values to insert,
742     *        not null.
743     * @param dbName the database name, or null to take the database name
744     *        from getDatabaseName().
745     * @param connection the database connection to use, not null.
746     *
747     * @return the number of inserted rows.
748     *
749     * @throws TorqueException if a database error occurs.
750     */
751    public static int doInsert(
752                final Column[] toInsertInto,
753                final Criteria criteria,
754                String dbName,
755                final Connection connection)
756            throws TorqueException
757    {
758        return getTorqueTurbineUserGroupRolePeerImpl().doInsert(
759                 toInsertInto,
760                 criteria,
761                 dbName,
762                 connection);
763    }
764
765    /**
766     * Method to do updates.
767     *
768     * @param columnValues the values to update plus the primary key
769     *        identifying the row to update.
770     *
771     * @throws TorqueException Any exceptions caught during processing will be
772     *         rethrown wrapped into a TorqueException.
773     */
774    public static int doUpdate(ColumnValues columnValues) throws TorqueException
775    {
776        return getTorqueTurbineUserGroupRolePeerImpl().doUpdate(columnValues);
777    }
778
779    /**
780     * Method to do updates.  This method is to be used during a transaction,
781     * otherwise use the doUpdate(Criteria) method.  It will take care of
782     * the connection details internally.
783     *
784     * @param columnValues the values to update plus the primary key
785     *        identifying the row to update.
786     * @param con the connection to use, not null.
787     *
788     * @return the number of affected rows.
789     *
790     * @throws TorqueException Any exceptions caught during processing will be
791     *         rethrown wrapped into a TorqueException.
792     */
793    public static int doUpdate(ColumnValues columnValues, Connection con)
794        throws TorqueException
795    {
796        return getTorqueTurbineUserGroupRolePeerImpl().doUpdate(columnValues, con);
797    }
798
799    /**
800     * Executes an update against the database. The rows to be updated
801     * are selected using <code>criteria</code> and updated using the values
802     * in <code>updateValues</code>.
803     *
804     * @param selectCriteria selects which rows of which table should be updated.
805     * @param updateValues Which columns to update with which values, not null.
806     *
807     * @return the number of affected rows.
808     *
809     * @throws TorqueException if updating fails.
810     */
811    public static int doUpdate(
812                Criteria selectCriteria,
813                ColumnValues updateValues)
814            throws TorqueException
815    {
816        return getTorqueTurbineUserGroupRolePeerImpl().doUpdate(
817            selectCriteria,
818            updateValues);
819    }
820
821    /**
822     * Executes an update against the database. The rows to be updated
823     * are selected using <code>criteria</code> and updated using the values
824     * in <code>updateValues</code>.
825     *
826     * @param criteria selects which rows of which table should be updated.
827     * @param updateValues Which columns to update with which values, not null.
828     * @param connection the database connection to use, not null.
829     *
830     * @return the number of affected rows.
831     *
832     * @throws TorqueException if updating fails.
833     */
834    public static int doUpdate(
835                Criteria criteria,
836                ColumnValues updateValues,
837                Connection connection)
838            throws TorqueException
839    {
840        return getTorqueTurbineUserGroupRolePeerImpl().doUpdate(
841            criteria,
842             updateValues,
843              connection);
844    }
845
846    /**
847     * Updates an TorqueTurbineUserGroupRole in the database.
848     * The primary key is used to identify the object to update.
849     *
850     * @param obj the data object to update in the database.
851     *
852     * @return the number of affected rows.
853     *
854     * @throws TorqueException Any exceptions caught during processing will be
855     *         rethrown wrapped into a TorqueException.
856     */
857    public static int doUpdate(TorqueTurbineUserGroupRole obj) throws TorqueException
858    {
859        return getTorqueTurbineUserGroupRolePeerImpl().doUpdate(obj);
860    }
861
862    /**
863     * Updates a TorqueTurbineUserGroupRole in the database.
864     * The primary key is used to identify the object to update.
865     * This method is to be used during a transaction,
866     * otherwise the doUpdate(TorqueTurbineUserGroupRole) method can be used.
867     *
868     * @param obj the data object to update in the database.
869     * @param con the connection to use, not null.
870     
871     * @throws TorqueException Any exceptions caught during processing will be
872     *         rethrown wrapped into a TorqueException.
873     */
874    public static int doUpdate(TorqueTurbineUserGroupRole obj, Connection con)
875        throws TorqueException
876    {
877        return getTorqueTurbineUserGroupRolePeerImpl().doUpdate(obj, con);
878    }
879
880    /**
881     * Utility method which executes a given sql statement
882     * as prepared statement.
883     * This method should be used for update, insert, and delete statements.
884     * Use executeQuery() for selects.
885     *
886     * @param statementString A String with the sql statement to execute.
887     *
888     * @return The number of rows affected.
889     *
890     * @throws TorqueException if executing the statement fails
891     *         or no database connection can be established.
892     */
893    public static int executeStatement(String statementString) 
894            throws TorqueException
895    {
896        return getTorqueTurbineUserGroupRolePeerImpl().executeStatement(statementString);
897    }
898
899    /**
900     * Utility method which executes a given sql statement
901     * as prepared statement.
902     * This method should be used for update, insert, and delete statements.
903     * Use executeQuery() for selects.
904     *
905     * @param statementString A String with the sql statement to execute.
906     * @param replacementValues values to use as placeholders in the query.
907     *        or null or empty if no placeholders need to be filled.
908     *
909     * @return The number of rows affected.
910     *
911     * @throws TorqueException if executing the statement fails
912     *         or no database connection can be established.
913     */
914    public static int executeStatement(
915                String statementString,
916                List<JdbcTypedValue> replacementValues)
917            throws TorqueException
918    {
919        return getTorqueTurbineUserGroupRolePeerImpl().executeStatement(
920                statementString, 
921                replacementValues);
922    }
923
924    /**
925     * Utility method which executes a given sql statement
926     * as prepared statement.
927     * This method should be used for update, insert, and delete statements.
928     * Use executeQuery() for selects.
929     *
930     * @param statementString A String with the sql statement to execute.
931     * @param dbName The name of the database to execute the statement against,
932     *        or null for the default DB.
933     * @param replacementValues values to use as placeholders in the query.
934     *        or null or empty if no placeholders need to be filled.
935     *
936     * @return The number of rows affected.
937     *
938     * @throws TorqueException if executing the statement fails
939     *         or no database connection can be established.
940     */
941    public static int executeStatement(
942            String statementString,
943            String dbName,
944            List<JdbcTypedValue> replacementValues)
945        throws TorqueException
946    {
947        return getTorqueTurbineUserGroupRolePeerImpl().executeStatement(
948                statementString, 
949                dbName,
950                replacementValues);
951    }
952
953    /**
954     * Utility method which executes a given sql statement
955     * as prepared statement.
956     * This method should be used for update, insert, and delete statements.
957     * Use executeQuery() for selects.
958     *
959     * @param statementString A String with the sql statement to execute.
960     * @param con The database connection to use.
961     * @param replacementValues values to use as placeholders in the query.
962     *        or null or empty if no placeholders need to be filled.
963     *
964     * @return The number of rows affected.
965     *
966     * @throws TorqueException if executing the statement fails.
967     */
968    public static int executeStatement(
969            String statementString,
970            Connection con,
971            List<JdbcTypedValue> replacementValues)
972        throws TorqueException
973    {
974        return getTorqueTurbineUserGroupRolePeerImpl().executeStatement(
975                statementString, 
976                con,
977                replacementValues);
978    }
979
980    /**
981     * Utility method which executes a given sql statement
982     * as prepared statement.
983     * This method should be used for update, insert, and delete statements.
984     * Use executeQuery() for selects.
985     *
986     * @param statementString A String with the sql statement to execute,
987     *        containing placeholders of the form ":${placeholderName}".
988     *        ${placeholderName} must contain only letters, digits and the underscore
989     *        Each placeholder must be followed by a space, except when it is at the end of the statement.
990     * @param replacementValues a map mapping the placeholder names to values
991     *        to use as placeholders in the query.
992     *        Can be null or empty if no placeholders need to be filled.
993     *
994     * @return The number of rows affected.
995     *
996     * @throws TorqueException if executing the statement fails.
997     */
998    public static int executeStatement(
999            final String statementString,
1000            final Map<String, JdbcTypedValue> replacementValues)
1001        throws TorqueException
1002    {
1003        return getTorqueTurbineUserGroupRolePeerImpl().executeStatement(
1004                statementString,
1005                replacementValues);
1006    }
1007
1008    /**
1009     * Utility method which executes a given sql statement
1010     * as prepared statement.
1011     * This method should be used for update, insert, and delete statements.
1012     * Use executeQuery() for selects.
1013     *
1014     * @param statementString A String with the sql statement to execute,
1015     *        containing placeholders of the form ":${placeholderName}".
1016     *        ${placeholderName} must contain only letters, digits and the underscore
1017     *        Each placeholder must be followed by a space, except when it is at the end of the statement.
1018     * @param dbName The name of the database to execute the statement against,
1019     *        or null for the default DB.
1020     * @param replacementValues a map mapping the placeholder names to values
1021     *        to use as placeholders in the query.
1022     *        Can be null or empty if no placeholders need to be filled.
1023     *
1024     * @return The number of rows affected.
1025     *
1026     * @throws TorqueException if executing the statement fails.
1027     */
1028    public static int executeStatement(
1029                final String statementString,
1030                final String dbName,
1031                final Map<String, JdbcTypedValue> replacementValues)
1032            throws TorqueException
1033        {
1034        return getTorqueTurbineUserGroupRolePeerImpl().executeStatement(
1035                statementString,
1036                dbName,
1037                replacementValues);
1038        }
1039
1040        /**
1041     * Utility method which executes a given sql statement
1042     * as prepared statement.
1043     * This method should be used for update, insert, and delete statements.
1044     * Use executeQuery() for selects.
1045     *
1046     * @param statementString A String with the sql statement to execute,
1047     *        containing placeholders of the form ":${placeholderName}".
1048     *        ${placeholderName} must contain only letters, digits and the underscore
1049     *        Each placeholder must be followed by a space, except when it is at the end of the statement.
1050     * @param con The database connection to use.
1051     * @param replacementValues a map mapping the placeholder names (without leading colons)
1052     *        to values to use as placeholders in the query.
1053     *        Can be null or empty if no placeholders need to be filled.
1054     *
1055     * @return The number of rows affected.
1056     *
1057     * @throws TorqueException if executing the statement fails.
1058     */
1059    public static int executeStatement(
1060                final String statementString,
1061                final Connection con,
1062                final Map<String, JdbcTypedValue> replacementValues)
1063            throws TorqueException
1064    {
1065        return getTorqueTurbineUserGroupRolePeerImpl().executeStatement(
1066                statementString,
1067                con,
1068                replacementValues);
1069    }
1070
1071    
1072    /**
1073     * Deletes rows from a database table.
1074     *
1075     * @param criteria defines the rows to be deleted, not null.
1076     *
1077     * @return the number of deleted rows.
1078     *
1079     * @throws TorqueException Any exceptions caught during processing will be
1080     *         rethrown wrapped into a TorqueException.
1081     */
1082     public static int doDelete(Criteria criteria) throws TorqueException
1083     {
1084        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(criteria);
1085     }
1086
1087    /**
1088     * Deletes rows from a table.
1089     * This method uses the passed connection to delete the rows;
1090     * if a transaction is open in the connection, the deletion happens inside
1091     * this transaction.
1092    *
1093     * @param criteria defines the rows to be deleted, not null.
1094     * @param con the connection to use, not null.
1095     *
1096     * @return the number of deleted rows.
1097     *
1098     * @throws TorqueException Any exceptions caught during processing will be
1099     *         rethrown wrapped into a TorqueException.
1100     */
1101     public static int doDelete(Criteria criteria, Connection con)
1102        throws TorqueException
1103     {
1104        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(criteria, con);
1105     }
1106
1107    /**
1108     * Deletes a data object, i.e. a row in a table, in the database.
1109     *
1110     * @param obj the data object to delete in the database, not null.
1111     *
1112     * @return the number of deleted rows.
1113     *
1114     * @throws TorqueException Any exceptions caught during processing will be
1115     *         rethrown wrapped into a TorqueException.
1116     */
1117    public static int doDelete(TorqueTurbineUserGroupRole obj) throws TorqueException
1118    {
1119        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(obj);
1120    }
1121
1122    /**
1123     * Deletes a data object, i.e. a row in a table, in the database.
1124     * This method uses the passed connection to delete the rows;
1125     * if a transaction is open in the connection, the deletion happens inside
1126     * this transaction.
1127     *
1128     * @param obj the data object to delete in the database, not null.
1129     * @param con the connection to use, not null.
1130     *
1131     * @return the number of deleted rows.
1132     *
1133     * @throws TorqueException Any exceptions caught during processing will be
1134     *         rethrown wrapped into a TorqueException.
1135     */
1136    public static int doDelete(TorqueTurbineUserGroupRole obj, Connection con)
1137        throws TorqueException
1138    {
1139        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(obj, con);
1140    }
1141
1142    /**
1143     * Deletes data objects, i.e. rows in a table, in the database.
1144     *
1145     * @param objects the datas object to delete in the database, not null,
1146     *        may not contain null.
1147     *
1148     * @return the number of deleted rows.
1149     *
1150     * @throws TorqueException Any exceptions caught during processing will be
1151     *         rethrown wrapped into a TorqueException.
1152     */
1153    public static int doDelete(Collection<TorqueTurbineUserGroupRole> objects)
1154            throws TorqueException
1155    {
1156        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(objects);
1157    }
1158
1159    /**
1160     * Deletes data objects, i.e. rows in a table, in the database.
1161     * This method uses the passed connection to delete the rows;
1162     * if a transaction is open in the connection, the deletion happens inside
1163     * this transaction.
1164     *
1165     * @param objects the datas object to delete in the database, not null,
1166     *        may not contain null.
1167     * @param con the connection to use for deleting, not null.
1168     *
1169     * @return the number of deleted rows.
1170     *
1171     * @throws TorqueException Any exceptions caught during processing will be
1172     *         rethrown wrapped into a TorqueException.
1173     */
1174    public static int doDelete(
1175            Collection<TorqueTurbineUserGroupRole> objects,
1176            Connection con)
1177        throws TorqueException
1178    {
1179        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(objects, con);
1180    }
1181
1182    /**
1183     * Deletes a row in the database.
1184     *
1185     * @param pk the ObjectKey that identifies the row to delete.
1186     *
1187     * @return the number of deleted rows.
1188     *
1189     * @throws TorqueException Any exceptions caught during processing will be
1190     *         rethrown wrapped into a TorqueException.
1191     */
1192    public static int doDelete(ObjectKey<?> pk) throws TorqueException
1193    {
1194        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(pk);
1195    }
1196
1197    /**
1198     * Deletes a row in the database.
1199     * This method uses the passed connection to delete the rows;
1200     * if a transaction is open in the connection, the deletion happens inside
1201     * this transaction.
1202     *
1203     * @param pk the ObjectKey that identifies the row to delete.
1204     * @param con the connection to use for deleting, not null.
1205     *
1206     * @return the number of deleted rows.
1207     *
1208     * @throws TorqueException Any exceptions caught during processing will be
1209     *         rethrown wrapped into a TorqueException.
1210     */
1211    public static int doDelete(ObjectKey<?> pk, Connection con)
1212        throws TorqueException
1213    {
1214        return getTorqueTurbineUserGroupRolePeerImpl().doDelete(pk, con);
1215    }
1216
1217    /** 
1218     * Build a Criteria object which selects all objects which have a given
1219     * primary key.
1220     *
1221     * @param pk the primary key value to build the criteria from, not null.
1222     */
1223    public static Criteria buildCriteria(ObjectKey<?> pk)
1224    {
1225        return getTorqueTurbineUserGroupRolePeerImpl().buildCriteria(pk);
1226    }
1227
1228    /** 
1229     * Build a Criteria object which selects all objects which primary keys
1230     * are contained in the passed collection.
1231     *
1232     * @param pks the primary key values to build the criteria from, not null,
1233     *        may not contain null.
1234     */
1235    public static Criteria buildCriteria(Collection<ObjectKey<?>> pks)
1236    {
1237        return getTorqueTurbineUserGroupRolePeerImpl().buildCriteria(pks);
1238    }
1239
1240    /** 
1241     * Build a Criteria object which selects all passed objects using their
1242     * primary key. Objects which do not yet have a primary key are ignored.
1243     *
1244     * @param objects the objects to build the criteria from, not null,
1245     *        may not contain null.
1246     */
1247    public static Criteria buildPkCriteria(
1248            Collection<TorqueTurbineUserGroupRole> objects)
1249    {
1250        return getTorqueTurbineUserGroupRolePeerImpl().buildPkCriteria(objects);
1251    }
1252
1253    /** 
1254     * Build a Criteria object from the data object for this peer.
1255     *
1256     * @param obj the object to build the criteria from, not null.
1257     */
1258    public static Criteria buildCriteria(TorqueTurbineUserGroupRole obj)
1259    {
1260        return getTorqueTurbineUserGroupRolePeerImpl().buildCriteria(obj);
1261    }
1262
1263    /** 
1264     * Build a Criteria object from the data object for this peer,
1265     * skipping all binary columns.
1266     *
1267     * @param obj the object to build the criteria from, not null.
1268     */
1269    public static Criteria buildSelectCriteria(TorqueTurbineUserGroupRole obj)
1270    {
1271        return getTorqueTurbineUserGroupRolePeerImpl().buildSelectCriteria(obj);
1272    }
1273
1274    /** 
1275     * Returns the contents of the object as ColumnValues object
1276     *
1277     * @throws TorqueException if the table map cannot be retrieved
1278     *         (should not happen).
1279     */
1280    public static ColumnValues buildColumnValues(TorqueTurbineUserGroupRole torqueTurbineUserGroupRole)
1281            throws TorqueException
1282    {
1283        
1284        return getTorqueTurbineUserGroupRolePeerImpl().buildColumnValues(torqueTurbineUserGroupRole);
1285    }
1286
1287    /**
1288     * retrieve object using using pk values.
1289     *
1290     * @param userId Integer
1291     * @param groupId Integer
1292     * @param roleId Integer
1293     */
1294    public static TorqueTurbineUserGroupRole retrieveByPK(
1295            Integer userId,
1296            Integer groupId,
1297            Integer roleId)
1298        throws TorqueException
1299    {
1300        return getTorqueTurbineUserGroupRolePeerImpl().retrieveByPK(
1301                userId,
1302                groupId,
1303                roleId);
1304    }
1305
1306    /**
1307     * retrieve object using using pk values.
1308     *
1309     * @param userId Integer
1310     * @param groupId Integer
1311     * @param roleId Integer
1312     * @param con Connection
1313     */
1314    public static TorqueTurbineUserGroupRole retrieveByPK(
1315            Integer userId,
1316            Integer groupId,
1317            Integer roleId,
1318            Connection con) throws TorqueException
1319    {
1320        return getTorqueTurbineUserGroupRolePeerImpl().retrieveByPK(
1321                userId,
1322                groupId,
1323                roleId,
1324                con);
1325    }
1326
1327    /**
1328     * Retrieve a single object by pk
1329     *
1330     * @param pk the primary key
1331     * @throws TorqueException Any exceptions caught during processing will be
1332     *         rethrown wrapped into a TorqueException.
1333     * @throws NoRowsException Primary key was not found in database.
1334     * @throws TooManyRowsException Primary key was not found in database.
1335     */
1336    public static TorqueTurbineUserGroupRole retrieveByPK(ObjectKey<?> pk)
1337        throws TorqueException, NoRowsException, TooManyRowsException
1338    {
1339        return getTorqueTurbineUserGroupRolePeerImpl().retrieveByPK(pk);
1340    }
1341
1342    /**
1343     * Retrieve a single object by pk
1344     *
1345     * @param pk the primary key
1346     * @param con the connection to use
1347     * @throws TorqueException Any exceptions caught during processing will be
1348     *         rethrown wrapped into a TorqueException.
1349     * @throws NoRowsException Primary key was not found in database.
1350     * @throws TooManyRowsException Primary key was not found in database.
1351     */
1352    public static TorqueTurbineUserGroupRole retrieveByPK(ObjectKey<?> pk, Connection con)
1353        throws TorqueException, NoRowsException, TooManyRowsException
1354    {
1355        return getTorqueTurbineUserGroupRolePeerImpl().retrieveByPK(pk, con);
1356    }
1357
1358
1359    /**
1360     * Retrieve a multiple objects by pk.
1361     *
1362     * @param pks List of primary keys
1363     *
1364     * @return the list of matching objects, not null.
1365     *
1366     * @throws TorqueException Any exceptions caught during processing will be
1367     *         rethrown wrapped into a TorqueException.
1368     */
1369    public static List<TorqueTurbineUserGroupRole> retrieveByObjectKeys(Collection<ObjectKey<?>> pks)
1370        throws TorqueException
1371    {
1372        return getTorqueTurbineUserGroupRolePeerImpl().retrieveByObjectKeys(pks);
1373    }
1374
1375    /**
1376     * Retrieve multiple objects by pk.
1377     *
1378     * @param pks List of primary keys
1379     * @param con the connection to use
1380     *
1381     * @return the list of matching objects, not null.
1382     *
1383     * @throws TorqueException Any exceptions caught during processing will be
1384     *         rethrown wrapped into a TorqueException.
1385     */
1386    public static List<TorqueTurbineUserGroupRole> retrieveByObjectKeys(Collection<ObjectKey<?>> pks, Connection con)
1387        throws TorqueException
1388    {
1389        return getTorqueTurbineUserGroupRolePeerImpl().retrieveByObjectKeys(pks, con);
1390    }
1391
1392
1393    /**
1394     * Selects a collection of dbObjectClassName objects pre-filled with their
1395     * TorqueTurbineUser objects.
1396     *
1397     * @throws TorqueException Any exceptions caught during processing will be
1398     *         rethrown wrapped into a TorqueException.
1399     */
1400    public static List<TorqueTurbineUserGroupRole> doSelectJoinTorqueTurbineUser(Criteria criteria)
1401        throws TorqueException
1402    {
1403        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinTorqueTurbineUser(criteria);
1404    }
1405
1406    /**
1407     * Selects a collection of TorqueTurbineUserGroupRole objects pre-filled with their
1408     * TorqueTurbineUser objects.
1409     *
1410     * @throws TorqueException Any exceptions caught during processing will be
1411     *         rethrown wrapped into a TorqueException.
1412     */
1413    public static List<TorqueTurbineUserGroupRole> doSelectJoinTorqueTurbineUser(
1414            Criteria criteria, Connection conn)
1415        throws TorqueException
1416    {
1417        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinTorqueTurbineUser(criteria, conn);
1418    }
1419    /**
1420     * Selects a collection of dbObjectClassName objects pre-filled with their
1421     * TorqueTurbineGroup objects.
1422     *
1423     * @throws TorqueException Any exceptions caught during processing will be
1424     *         rethrown wrapped into a TorqueException.
1425     */
1426    public static List<TorqueTurbineUserGroupRole> doSelectJoinTorqueTurbineGroup(Criteria criteria)
1427        throws TorqueException
1428    {
1429        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinTorqueTurbineGroup(criteria);
1430    }
1431
1432    /**
1433     * Selects a collection of TorqueTurbineUserGroupRole objects pre-filled with their
1434     * TorqueTurbineGroup objects.
1435     *
1436     * @throws TorqueException Any exceptions caught during processing will be
1437     *         rethrown wrapped into a TorqueException.
1438     */
1439    public static List<TorqueTurbineUserGroupRole> doSelectJoinTorqueTurbineGroup(
1440            Criteria criteria, Connection conn)
1441        throws TorqueException
1442    {
1443        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinTorqueTurbineGroup(criteria, conn);
1444    }
1445    /**
1446     * Selects a collection of dbObjectClassName objects pre-filled with their
1447     * TorqueTurbineRole objects.
1448     *
1449     * @throws TorqueException Any exceptions caught during processing will be
1450     *         rethrown wrapped into a TorqueException.
1451     */
1452    public static List<TorqueTurbineUserGroupRole> doSelectJoinTorqueTurbineRole(Criteria criteria)
1453        throws TorqueException
1454    {
1455        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinTorqueTurbineRole(criteria);
1456    }
1457
1458    /**
1459     * Selects a collection of TorqueTurbineUserGroupRole objects pre-filled with their
1460     * TorqueTurbineRole objects.
1461     *
1462     * @throws TorqueException Any exceptions caught during processing will be
1463     *         rethrown wrapped into a TorqueException.
1464     */
1465    public static List<TorqueTurbineUserGroupRole> doSelectJoinTorqueTurbineRole(
1466            Criteria criteria, Connection conn)
1467        throws TorqueException
1468    {
1469        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinTorqueTurbineRole(criteria, conn);
1470    }
1471
1472    /**
1473     * selects a collection of TorqueTurbineUserGroupRole objects pre-filled with
1474     * all related objects.
1475     *
1476     * This method is protected by default in order to keep the public
1477     * api reasonable.  You can provide public methods for those you
1478     * actually need in TorqueTurbineUserGroupRolePeer.
1479     *
1480     * @throws TorqueException Any exceptions caught during processing will be
1481     *         rethrown wrapped into a TorqueException.
1482     */
1483    protected static List<TorqueTurbineUserGroupRole> doSelectJoinAllExceptTorqueTurbineUser(Criteria criteria)
1484        throws TorqueException
1485    {
1486        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinAllExceptTorqueTurbineUser(criteria);
1487    }
1488
1489    /**
1490     * selects a collection of TorqueTurbineUserGroupRole objects pre-filled with
1491     * related objects.
1492     *
1493     * This method is protected by default in order to keep the public
1494     * api reasonable.  You can provide public methods for those you
1495     * actually need in TorqueTurbineUserGroupRolePeer.
1496     *
1497     * @throws TorqueException Any exceptions caught during processing will be
1498     *         rethrown wrapped into a TorqueException.
1499     */
1500    protected static List<TorqueTurbineUserGroupRole> doSelectJoinAllExceptTorqueTurbineUser(Criteria criteria, Connection conn)
1501        throws TorqueException
1502    {
1503        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinAllExceptTorqueTurbineUser(criteria, conn);
1504    }
1505    /**
1506     * selects a collection of TorqueTurbineUserGroupRole objects pre-filled with
1507     * all related objects.
1508     *
1509     * This method is protected by default in order to keep the public
1510     * api reasonable.  You can provide public methods for those you
1511     * actually need in TorqueTurbineUserGroupRolePeer.
1512     *
1513     * @throws TorqueException Any exceptions caught during processing will be
1514     *         rethrown wrapped into a TorqueException.
1515     */
1516    protected static List<TorqueTurbineUserGroupRole> doSelectJoinAllExceptTorqueTurbineGroup(Criteria criteria)
1517        throws TorqueException
1518    {
1519        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinAllExceptTorqueTurbineGroup(criteria);
1520    }
1521
1522    /**
1523     * selects a collection of TorqueTurbineUserGroupRole objects pre-filled with
1524     * related objects.
1525     *
1526     * This method is protected by default in order to keep the public
1527     * api reasonable.  You can provide public methods for those you
1528     * actually need in TorqueTurbineUserGroupRolePeer.
1529     *
1530     * @throws TorqueException Any exceptions caught during processing will be
1531     *         rethrown wrapped into a TorqueException.
1532     */
1533    protected static List<TorqueTurbineUserGroupRole> doSelectJoinAllExceptTorqueTurbineGroup(Criteria criteria, Connection conn)
1534        throws TorqueException
1535    {
1536        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinAllExceptTorqueTurbineGroup(criteria, conn);
1537    }
1538    /**
1539     * selects a collection of TorqueTurbineUserGroupRole objects pre-filled with
1540     * all related objects.
1541     *
1542     * This method is protected by default in order to keep the public
1543     * api reasonable.  You can provide public methods for those you
1544     * actually need in TorqueTurbineUserGroupRolePeer.
1545     *
1546     * @throws TorqueException Any exceptions caught during processing will be
1547     *         rethrown wrapped into a TorqueException.
1548     */
1549    protected static List<TorqueTurbineUserGroupRole> doSelectJoinAllExceptTorqueTurbineRole(Criteria criteria)
1550        throws TorqueException
1551    {
1552        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinAllExceptTorqueTurbineRole(criteria);
1553    }
1554
1555    /**
1556     * selects a collection of TorqueTurbineUserGroupRole objects pre-filled with
1557     * related objects.
1558     *
1559     * This method is protected by default in order to keep the public
1560     * api reasonable.  You can provide public methods for those you
1561     * actually need in TorqueTurbineUserGroupRolePeer.
1562     *
1563     * @throws TorqueException Any exceptions caught during processing will be
1564     *         rethrown wrapped into a TorqueException.
1565     */
1566    protected static List<TorqueTurbineUserGroupRole> doSelectJoinAllExceptTorqueTurbineRole(Criteria criteria, Connection conn)
1567        throws TorqueException
1568    {
1569        return getTorqueTurbineUserGroupRolePeerImpl().doSelectJoinAllExceptTorqueTurbineRole(criteria, conn);
1570    }
1571
1572
1573    /**
1574     * Returns the TableMap related to this peer.
1575     *
1576     * @return the table map, not null.
1577     *
1578     * @throws TorqueException if the Peer instance does not hold a Table map.
1579     */
1580    public static TableMap getTableMap()
1581        throws TorqueException
1582    {
1583        return getTorqueTurbineUserGroupRolePeerImpl().getTableMap();
1584    }
1585
1586    public static void initDatabaseMap()
1587    {
1588    }
1589
1590
1591}