gt:             Record row =  rows.get(i);
context: /**
   * Genji Scrum Tool and Issue Tracker
   * Copyright (C) 2015 Steinbeis GmbH & Co. KG Task Management Solutions
  
   * <a href="http://www.trackplus.com">Genji Scrum Tool</a>
   *
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program. If not, see <http://www.gnu.org/licenses/>.
   */
  
  /* $Id:$ */
  
  package com.aurel.track.persist;
  
  import java.math.BigDecimal;
  import java.sql.Connection;
  import java.sql.SQLException;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.apache.torque.NoRowsException;
  import org.apache.torque.TooManyRowsException;
  import org.apache.torque.Torque;
  import org.apache.torque.TorqueException;
  import org.apache.torque.TorqueRuntimeException;
  import org.apache.torque.map.MapBuilder;
  import org.apache.torque.map.TableMap;
  import org.apache.torque.om.DateKey;
  import org.apache.torque.om.NumberKey;
  import org.apache.torque.om.StringKey;
  import org.apache.torque.om.ObjectKey;
  import org.apache.torque.om.SimpleKey;
  import org.apache.torque.util.BasePeer;
  import org.apache.torque.util.Criteria;
  
  import com.workingdogs.village.DataSetException;
  import com.workingdogs.village.QueryDataSet;
  import com.workingdogs.village.Record;
  
  // Local classes
  import com.aurel.track.persist.map.*;
  
  
  
  
  /**
   */
  public abstract class BaseTAttributeValuePeer
      extends BasePeer
  {
  
      /** the default database name for this class */
      public static final String DATABASE_NAME;
  
       /** the table name for this class */
      public static final String TABLE_NAME;
  
      /**
       * @return the map builder for this peer
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @deprecated Torque.getMapBuilder(TAttributeValueMapBuilder.CLASS_NAME) instead
       */
      public static MapBuilder getMapBuilder()
          throws TorqueException
      {
          return Torque.getMapBuilder(TAttributeValueMapBuilder.CLASS_NAME);
      }
  
      /** the column name for the OBJECTID field */
      public static final String OBJECTID;
      /** the column name for the FIELDKEY field */
      public static final String FIELDKEY;
      /** the column name for the WORKITEM field */
      public static final String WORKITEM;
      /** the column name for the TEXTVALUE field */
      public static final String TEXTVALUE;
      /** the column name for the INTEGERVALUE field */
      public static final String INTEGERVALUE;
      /** the column name for the DOUBLEVALUE field */
      public static final String DOUBLEVALUE;
      /** the column name for the DATEVALUE field */
      public static final String DATEVALUE;
      /** the column name for the CHARACTERVALUE field */
      public static final String CHARACTERVALUE;
      /** the column name for the LONGTEXTVALUE field */
      public static final String LONGTEXTVALUE;
      /** the column name for the SYSTEMOPTIONID field */
      public static final String SYSTEMOPTIONID;
      /** the column name for the SYSTEMOPTIONTYPE field */
      public static final String SYSTEMOPTIONTYPE;
      /** the column name for the CUSTOMOPTIONID field */
      public static final String CUSTOMOPTIONID;
      /** the column name for the PARAMETERCODE field */
      public static final String PARAMETERCODE;
      /** the column name for the VALIDVALUE field */
      public static final String VALIDVALUE;
      /** the column name for the LASTEDIT field */
      public static final String LASTEDIT;
      /** the column name for the TPUUID field */
      public static final String TPUUID;
  
      static
      {
          DATABASE_NAME = "track";
          TABLE_NAME = "TATTRIBUTEVALUE";
  
          OBJECTID = "TATTRIBUTEVALUE.OBJECTID";
          FIELDKEY = "TATTRIBUTEVALUE.FIELDKEY";
          WORKITEM = "TATTRIBUTEVALUE.WORKITEM";
          TEXTVALUE = "TATTRIBUTEVALUE.TEXTVALUE";
          INTEGERVALUE = "TATTRIBUTEVALUE.INTEGERVALUE";
          DOUBLEVALUE = "TATTRIBUTEVALUE.DOUBLEVALUE";
          DATEVALUE = "TATTRIBUTEVALUE.DATEVALUE";
          CHARACTERVALUE = "TATTRIBUTEVALUE.CHARACTERVALUE";
          LONGTEXTVALUE = "TATTRIBUTEVALUE.LONGTEXTVALUE";
          SYSTEMOPTIONID = "TATTRIBUTEVALUE.SYSTEMOPTIONID";
          SYSTEMOPTIONTYPE = "TATTRIBUTEVALUE.SYSTEMOPTIONTYPE";
          CUSTOMOPTIONID = "TATTRIBUTEVALUE.CUSTOMOPTIONID";
          PARAMETERCODE = "TATTRIBUTEVALUE.PARAMETERCODE";
          VALIDVALUE = "TATTRIBUTEVALUE.VALIDVALUE";
          LASTEDIT = "TATTRIBUTEVALUE.LASTEDIT";
          TPUUID = "TATTRIBUTEVALUE.TPUUID";
          if (Torque.isInit())
          {
              try
              {
                  Torque.getMapBuilder(TAttributeValueMapBuilder.CLASS_NAME);
              }
              catch (TorqueException e)
              {
                  log.error("Could not initialize Peer", e);
                  throw new TorqueRuntimeException(e);
              }
          }
          else
          {
              Torque.registerMapBuilder(TAttributeValueMapBuilder.CLASS_NAME);
          }
      }
   
      /** number of columns for this peer */
      public static final int numColumns =  16;
  
      /** A class that can be returned by this peer. */
      protected static final String CLASSNAME_DEFAULT =
          "com.aurel.track.persist.TAttributeValue";
  
      /** A class that can be returned by this peer. */
      protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT);
  
      /**
       * Class object initialization method.
       *
       * @param className name of the class to initialize
       * @return the initialized class
       */
      private static Class initClass(String className)
      {
          Class c = null;
          try
          {
              c = Class.forName(className);
          }
          catch (Throwable t)
          {
              log.error("A FATAL ERROR has occurred which should not "
                  + "have happened under any circumstance.  Please notify "
                  + "the Torque developers <torque-dev@db.apache.org> "
                  + "and give as many details as possible (including the error "
                  + "stack trace).", t);
  
              // Error objects should always be propagated.
              if (t instanceof Error)
              {
                  throw (Error) t.fillInStackTrace();
              }
          }
          return c;
      }
  
      /**
       * Get the list of objects for a ResultSet.  Please not that your
       * resultset MUST return columns in the right order.  You can use
       * getFieldNames() in BaseObject to get the correct sequence.
       *
       * @param results the ResultSet
       * @return the list of objects
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<TAttributeValue> resultSet2Objects(java.sql.ResultSet results)
              throws TorqueException
      {
          try
          {
              QueryDataSet qds = null;
              List<Record> rows = null;
              try
              {
                  qds = new QueryDataSet(results);
                  rows = getSelectResults(qds);
              }
              finally
              {
                  if (qds != null)
                  {
                      qds.close();
                  }
              }
  
              return populateObjects(rows);
          }
          catch (SQLException e)
          {
              throw new TorqueException(e);
          }
          catch (DataSetException e)
          {
              throw new TorqueException(e);
          }
      }
  
  
  
      /**
       * Method to do inserts.
       *
       * @param criteria object used to create the INSERT statement.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static ObjectKey doInsert(Criteria criteria)
          throws TorqueException
      {
          return BaseTAttributeValuePeer
              .doInsert(criteria, (Connection) null);
      }
  
      /**
       * Method to do inserts.  This method is to be used during a transaction,
       * otherwise use the doInsert(Criteria) method.  It will take care of
       * the connection details internally.
       *
       * @param criteria object used to create the INSERT statement.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static ObjectKey doInsert(Criteria criteria, Connection con)
          throws TorqueException
      {
          correctBooleans(criteria);
  
          setDbName(criteria);
  
          if (con == null)
          {
              return BasePeer.doInsert(criteria);
          }
          else
          {
              return BasePeer.doInsert(criteria, con);
          }
      }
  
      /**
       * Add all the columns needed to create a new object.
       *
       * @param criteria object containing the columns to add.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void addSelectColumns(Criteria criteria)
              throws TorqueException
      {
          criteria.addSelectColumn(OBJECTID);
          criteria.addSelectColumn(FIELDKEY);
          criteria.addSelectColumn(WORKITEM);
          criteria.addSelectColumn(TEXTVALUE);
          criteria.addSelectColumn(INTEGERVALUE);
          criteria.addSelectColumn(DOUBLEVALUE);
          criteria.addSelectColumn(DATEVALUE);
          criteria.addSelectColumn(CHARACTERVALUE);
          criteria.addSelectColumn(LONGTEXTVALUE);
          criteria.addSelectColumn(SYSTEMOPTIONID);
          criteria.addSelectColumn(SYSTEMOPTIONTYPE);
          criteria.addSelectColumn(CUSTOMOPTIONID);
          criteria.addSelectColumn(PARAMETERCODE);
          criteria.addSelectColumn(VALIDVALUE);
          criteria.addSelectColumn(LASTEDIT);
          criteria.addSelectColumn(TPUUID);
      }
  
      /**
       * changes the boolean values in the criteria to the appropriate type,
       * whenever a booleanchar or booleanint column is involved.
       * This enables the user to create criteria using Boolean values
       * for booleanchar or booleanint columns
       * @param criteria the criteria in which the boolean values should be corrected
       * @throws TorqueException if the database map for the criteria cannot be 
                 obtained.
       */
      public static void correctBooleans(Criteria criteria) throws TorqueException
      {
          correctBooleans(criteria, getTableMap());
      }
  
      /**
       * Create a new object of type cls from a resultset row starting
       * from a specified offset.  This is done so that you can select
       * other rows than just those needed for this object.  You may
       * for example want to create two objects from the same row.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static TAttributeValue row2Object(Record row,
                                               int offset,
                                               Class cls)
          throws TorqueException
      {
          try
          {
              TAttributeValue obj = (TAttributeValue) cls.newInstance();
              TAttributeValuePeer.populateObject(row, offset, obj);
                  obj.setModified(false);
              obj.setNew(false);
  
              return obj;
          }
          catch (InstantiationException e)
          {
              throw new TorqueException(e);
          }
          catch (IllegalAccessException e)
          {
              throw new TorqueException(e);
          }
      }
  
      /**
       * Populates an object from a resultset row starting
       * from a specified offset.  This is done so that you can select
       * other rows than just those needed for this object.  You may
       * for example want to create two objects from the same row.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void populateObject(Record row,
                                        int offset,
                                        TAttributeValue obj)
          throws TorqueException
      {
          try
          {
              obj.setObjectID(row.getValue(offset + 0).asIntegerObj());
              obj.setField(row.getValue(offset + 1).asIntegerObj());
              obj.setWorkItem(row.getValue(offset + 2).asIntegerObj());
              obj.setTextValue(row.getValue(offset + 3).asString());
              obj.setIntegerValue(row.getValue(offset + 4).asIntegerObj());
              obj.setDoubleValue(row.getValue(offset + 5).asDoubleObj());
              obj.setDateValue(row.getValue(offset + 6).asUtilDate());
              obj.setCharacterValue(row.getValue(offset + 7).asString());
              obj.setLongTextValue(row.getValue(offset + 8).asString());
              obj.setSystemOptionID(row.getValue(offset + 9).asIntegerObj());
              obj.setSystemOptionType(row.getValue(offset + 10).asIntegerObj());
              obj.setCustomOptionID(row.getValue(offset + 11).asIntegerObj());
              obj.setParameterCode(row.getValue(offset + 12).asIntegerObj());
              obj.setValidValue(row.getValue(offset + 13).asIntegerObj());
              obj.setLastEdit(row.getValue(offset + 14).asUtilDate());
              obj.setUuid(row.getValue(offset + 15).asString());
          }
          catch (DataSetException e)
          {
              throw new TorqueException(e);
          }
      }
  
      /**
       * Method to do selects.
       *
       * @param criteria object used to create the SELECT statement.
       * @return List of selected Objects
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<TAttributeValue> doSelect(Criteria criteria) throws TorqueException
      {
          return populateObjects(doSelectVillageRecords(criteria));
      }
  
      /**
       * Method to do selects within a transaction.
       *
       * @param criteria object used to create the SELECT statement.
       * @param con the connection to use
       * @return List of selected Objects
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<TAttributeValue> doSelect(Criteria criteria, Connection con)
          throws TorqueException
      {
          return populateObjects(doSelectVillageRecords(criteria, con));
      }
  
      /**
       * Grabs the raw Village records to be formed into objects.
       * This method handles connections internally.  The Record objects
       * returned by this method should be considered readonly.  Do not
       * alter the data and call save(), your results may vary, but are
       * certainly likely to result in hard to track MT bugs.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<Record> doSelectVillageRecords(Criteria criteria)
          throws TorqueException
      {
          return BaseTAttributeValuePeer
              .doSelectVillageRecords(criteria, (Connection) null);
      }
  
      /**
       * Grabs the raw Village records to be formed into objects.
       * This method should be used for transactions
       *
       * @param criteria object used to create the SELECT statement.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<Record> doSelectVillageRecords(Criteria criteria, Connection con)
          throws TorqueException
      {
          if (criteria.getSelectColumns().size() == 0)
          {
              addSelectColumns(criteria);
          }
          correctBooleans(criteria);
  
          setDbName(criteria);
  
          // BasePeer returns a List of Value (Village) arrays.  The array
          // order follows the order columns were placed in the Select clause.
          if (con == null)
          {
              return BasePeer.doSelect(criteria);
          }
          else
          {
              return BasePeer.doSelect(criteria, con);
          }
      }
  
      /**
       * The returned List will contain objects of the default type or
       * objects that inherit from the default.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<TAttributeValue> populateObjects(List<Record> records)
          throws TorqueException
      {
          List<TAttributeValue> results = new ArrayList<TAttributeValue>(records.size());
  
          // populate the object(s)
          for (int i = 0; i < records.size(); i++)
          {
              Record row =  records.get(i);
              results.add(TAttributeValuePeer.row2Object(row, 1,
                  TAttributeValuePeer.getOMClass()));
          }
          return results;
      }
   
  
      /**
       * The class that the Peer will make instances of.
       * If the BO is abstract then you must implement this method
       * in the BO.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static Class getOMClass()
          throws TorqueException
      {
          return CLASS_DEFAULT;
      }
  
      /**
       * Method to do updates.
       *
       * @param criteria object containing data that is used to create the UPDATE
       *        statement.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(Criteria criteria) throws TorqueException
      {
           BaseTAttributeValuePeer
              .doUpdate(criteria, (Connection) null);
      }
  
      /**
       * Method to do updates.  This method is to be used during a transaction,
       * otherwise use the doUpdate(Criteria) method.  It will take care of
       * the connection details internally.
       *
       * @param criteria object containing data that is used to create the UPDATE
       *        statement.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(Criteria criteria, Connection con)
          throws TorqueException
      {
          Criteria selectCriteria = new Criteria(DATABASE_NAME, 2);
          correctBooleans(criteria);
  
  
           selectCriteria.put(OBJECTID, criteria.remove(OBJECTID));
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
          setDbName(criteria);
  
          if (con == null)
          {
              BasePeer.doUpdate(selectCriteria, criteria);
          }
          else
          {
              BasePeer.doUpdate(selectCriteria, criteria, con);
          }
      }
  
      /**
       * Method to do deletes.
       *
       * @param criteria object containing data that is used DELETE from database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
       public static void doDelete(Criteria criteria) throws TorqueException
       {
           TAttributeValuePeer
              .doDelete(criteria, (Connection) null);
       }
  
      /**
       * Method to do deletes.  This method is to be used during a transaction,
       * otherwise use the doDelete(Criteria) method.  It will take care of
       * the connection details internally.
       *
       * @param criteria object containing data that is used DELETE from database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
       public static void doDelete(Criteria criteria, Connection con)
          throws TorqueException
       {
          correctBooleans(criteria);
  
          setDbName(criteria);
  
          if (con == null)
          {
              BasePeer.doDelete(criteria, TABLE_NAME);
          }
          else
          {
              BasePeer.doDelete(criteria, TABLE_NAME, con);
          }
       }
  
      /**
       * Method to do selects
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<TAttributeValue> doSelect(TAttributeValue obj) throws TorqueException
      {
          return doSelect(buildSelectCriteria(obj));
      }
  
      /**
       * Method to do inserts
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doInsert(TAttributeValue obj) throws TorqueException
      {
          obj.setPrimaryKey(doInsert(buildCriteria(obj)));
          obj.setNew(false);
          obj.setModified(false);
      }
  
      /**
       * @param obj the data object to update in the database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(TAttributeValue obj) throws TorqueException
      {
          doUpdate(buildCriteria(obj));
          obj.setModified(false);
      }
  
      /**
       * @param obj the data object to delete in the database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(TAttributeValue obj) throws TorqueException
      {
          doDelete(buildSelectCriteria(obj));
      }
  
      /**
       * Method to do inserts.  This method is to be used during a transaction,
       * otherwise use the doInsert(TAttributeValue) method.  It will take
       * care of the connection details internally.
       *
       * @param obj the data object to insert into the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doInsert(TAttributeValue obj, Connection con)
          throws TorqueException
      {
          obj.setPrimaryKey(doInsert(buildCriteria(obj), con));
          obj.setNew(false);
          obj.setModified(false);
      }
  
      /**
       * Method to do update.  This method is to be used during a transaction,
       * otherwise use the doUpdate(TAttributeValue) method.  It will take
       * care of the connection details internally.
       *
       * @param obj the data object to update in the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doUpdate(TAttributeValue obj, Connection con)
          throws TorqueException
      {
          doUpdate(buildCriteria(obj), con);
          obj.setModified(false);
      }
  
      /**
       * Method to delete.  This method is to be used during a transaction,
       * otherwise use the doDelete(TAttributeValue) method.  It will take
       * care of the connection details internally.
       *
       * @param obj the data object to delete in the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(TAttributeValue obj, Connection con)
          throws TorqueException
      {
          doDelete(buildSelectCriteria(obj), con);
      }
  
      /**
       * Method to do deletes.
       *
       * @param pk ObjectKey that is used DELETE from database.
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(ObjectKey pk) throws TorqueException
      {
          BaseTAttributeValuePeer
             .doDelete(pk, (Connection) null);
      }
  
      /**
       * Method to delete.  This method is to be used during a transaction,
       * otherwise use the doDelete(ObjectKey) method.  It will take
       * care of the connection details internally.
       *
       * @param pk the primary key for the object to delete in the database.
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static void doDelete(ObjectKey pk, Connection con)
          throws TorqueException
      {
          doDelete(buildCriteria(pk), con);
      }
  
      /** Build a Criteria object from an ObjectKey */
      public static Criteria buildCriteria( ObjectKey pk )
      {
          Criteria criteria = new Criteria();
              criteria.add(OBJECTID, pk);
          return criteria;
       }
  
      /** Build a Criteria object from the data object for this peer */
      public static Criteria buildCriteria( TAttributeValue obj )
      {
          Criteria criteria = new Criteria(DATABASE_NAME);
          if (!obj.isNew())
          criteria.add(OBJECTID, obj.getObjectID());
          criteria.add(FIELDKEY, obj.getField());
          criteria.add(WORKITEM, obj.getWorkItem());
          criteria.add(TEXTVALUE, obj.getTextValue());
          criteria.add(INTEGERVALUE, obj.getIntegerValue());
          criteria.add(DOUBLEVALUE, obj.getDoubleValue());
          criteria.add(DATEVALUE, obj.getDateValue());
          criteria.add(CHARACTERVALUE, obj.getCharacterValue());
          criteria.add(LONGTEXTVALUE, obj.getLongTextValue());
          criteria.add(SYSTEMOPTIONID, obj.getSystemOptionID());
          criteria.add(SYSTEMOPTIONTYPE, obj.getSystemOptionType());
          criteria.add(CUSTOMOPTIONID, obj.getCustomOptionID());
          criteria.add(PARAMETERCODE, obj.getParameterCode());
          criteria.add(VALIDVALUE, obj.getValidValue());
          criteria.add(LASTEDIT, obj.getLastEdit());
          criteria.add(TPUUID, obj.getUuid());
          return criteria;
      }
  
      /** Build a Criteria object from the data object for this peer, skipping all binary columns */
      public static Criteria buildSelectCriteria( TAttributeValue obj )
      {
          Criteria criteria = new Criteria(DATABASE_NAME);
          if (!obj.isNew())
          {
              criteria.add(OBJECTID, obj.getObjectID());
          }
              criteria.add(FIELDKEY, obj.getField());
              criteria.add(WORKITEM, obj.getWorkItem());
              criteria.add(TEXTVALUE, obj.getTextValue());
              criteria.add(INTEGERVALUE, obj.getIntegerValue());
              criteria.add(DOUBLEVALUE, obj.getDoubleValue());
              criteria.add(DATEVALUE, obj.getDateValue());
              criteria.add(CHARACTERVALUE, obj.getCharacterValue());
              criteria.add(LONGTEXTVALUE, obj.getLongTextValue());
              criteria.add(SYSTEMOPTIONID, obj.getSystemOptionID());
              criteria.add(SYSTEMOPTIONTYPE, obj.getSystemOptionType());
              criteria.add(CUSTOMOPTIONID, obj.getCustomOptionID());
              criteria.add(PARAMETERCODE, obj.getParameterCode());
              criteria.add(VALIDVALUE, obj.getValidValue());
              criteria.add(LASTEDIT, obj.getLastEdit());
              criteria.add(TPUUID, obj.getUuid());
          return criteria;
      }
   
  
      /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static TAttributeValue retrieveByPK(Integer pk)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          return retrieveByPK(SimpleKey.keyFor(pk));
      }
  
      /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static TAttributeValue retrieveByPK(Integer pk, Connection con)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          return retrieveByPK(SimpleKey.keyFor(pk), con);
      }
  
      /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static TAttributeValue retrieveByPK(ObjectKey pk)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          Connection db = null;
          TAttributeValue retVal = null;
          try
          {
              db = Torque.getConnection(DATABASE_NAME);
              retVal = retrieveByPK(pk, db);
          }
          finally
          {
              Torque.closeConnection(db);
          }
          return retVal;
      }
  
      /**
       * Retrieve a single object by pk
       *
       * @param pk the primary key
       * @param con the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       * @throws NoRowsException Primary key was not found in database.
       * @throws TooManyRowsException Primary key was not found in database.
       */
      public static TAttributeValue retrieveByPK(ObjectKey pk, Connection con)
          throws TorqueException, NoRowsException, TooManyRowsException
      {
          Criteria criteria = buildCriteria(pk);
          List<TAttributeValue> v = doSelect(criteria, con);
          if (v.size() == 0)
          {
              throw new NoRowsException("Failed to select a row.");
          }
          else if (v.size() > 1)
          {
              throw new TooManyRowsException("Failed to select only one row.");
          }
          else
          {
              return (TAttributeValue)v.get(0);
          }
      }
  
      /**
       * Retrieve a multiple objects by pk
       *
       * @param pks List of primary keys
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<TAttributeValue> retrieveByPKs(List<ObjectKey> pks)
          throws TorqueException
      {
          Connection db = null;
          List<TAttributeValue> retVal = null;
          try
          {
             db = Torque.getConnection(DATABASE_NAME);
             retVal = retrieveByPKs(pks, db);
          }
          finally
          {
              Torque.closeConnection(db);
          }
          return retVal;
      }
  
      /**
       * Retrieve a multiple objects by pk
       *
       * @param pks List of primary keys
       * @param dbcon the connection to use
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      public static List<TAttributeValue> retrieveByPKs( List<ObjectKey> pks, Connection dbcon )
          throws TorqueException
      {
          List<TAttributeValue> objs = null;
          if (pks == null || pks.size() == 0)
          {
              objs = new LinkedList<TAttributeValue>();
          }
          else
          {
              Criteria criteria = new Criteria();
              criteria.addIn( OBJECTID, pks );
          objs = doSelect(criteria, dbcon);
          }
          return objs;
      }
  
   
  
  
  
  
  
  
  
  
      /**
       * selects a collection of TAttributeValue objects pre-filled with their
       * TField objects.
       *
       * This method is protected by default in order to keep the public
       * api reasonable.  You can provide public methods for those you
       * actually need in TAttributeValuePeer.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      protected static List<TAttributeValue> doSelectJoinTField(Criteria criteria)
          throws TorqueException
      {
          return doSelectJoinTField(criteria, null);
      }
  
      /**
       * selects a collection of TAttributeValue objects pre-filled with their
       * TField objects.
       *
       * This method is protected by default in order to keep the public
       * api reasonable.  You can provide public methods for those you
       * actually need in TAttributeValuePeer.
       *
       * @throws TorqueException Any exceptions caught during processing will be
       *         rethrown wrapped into a TorqueException.
       */
      protected static List<TAttributeValue> doSelectJoinTField(Criteria criteria, Connection conn)
          throws TorqueException
      {
          setDbName(criteria);
  
          TAttributeValuePeer.addSelectColumns(criteria);
          int offset = numColumns + 1;
          TFieldPeer.addSelectColumns(criteria);
  
          criteria.addJoin(TAttributeValuePeer.FIELDKEY,
              TFieldPeer.OBJECTID);
  
          correctBooleans(criteria);
  
          List<Record> rows;
          if (conn == null)
          {
              rows = BasePeer.doSelect(criteria);
          }
          else
          {
              rows = BasePeer.doSelect(criteria,conn);
          }
  
          List<TAttributeValue> results = new ArrayList<TAttributeValue>();
  
          for (int i = 0; i < rows.size(); i++)
          {
  