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,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  
 }