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