package org.apache.ojb.broker.accesslayer;
   
   /* Copyright 2003-2005 The Apache Software Foundation
    *
    * Licensed under the Apache License, Version 2.0 (the "License");
    * you may not use this file except in compliance with the License.
    * You may obtain a copy of the License at
    *
    *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  import java.sql.CallableStatement;
  import java.sql.PreparedStatement;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import org.apache.ojb.broker.Identity;
  import org.apache.ojb.broker.OptimisticLockException;
  import org.apache.ojb.broker.PersistenceBroker;
  import org.apache.ojb.broker.PersistenceBrokerException;
  import org.apache.ojb.broker.PersistenceBrokerSQLException;
  import org.apache.ojb.broker.accesslayer.sql.SelectStatement;
  import org.apache.ojb.broker.core.ValueContainer;
  import org.apache.ojb.broker.metadata.ArgumentDescriptor;
  import org.apache.ojb.broker.metadata.ClassDescriptor;
  import org.apache.ojb.broker.metadata.FieldDescriptor;
  import org.apache.ojb.broker.metadata.JdbcType;
  import org.apache.ojb.broker.metadata.ProcedureDescriptor;
  import org.apache.ojb.broker.metadata.fieldaccess.PersistentField;
  import org.apache.ojb.broker.platforms.Platform;
  import org.apache.ojb.broker.query.Query;
  import org.apache.ojb.broker.util.ExceptionHelper;
  import org.apache.ojb.broker.util.logging.Logger;
  import org.apache.ojb.broker.util.logging.LoggerFactory;
  import org.apache.ojb.broker.util.sequence.SequenceManagerException;
  
  /**
   * JdbcAccess is responsible for establishing performing
   * SQL Queries against remote Databases.
   * It hides all knowledge about JDBC from the BrokerImpl
   *
   * @author <a href="mailto:thma@apache.org">Thomas Mahler</a>
   * @version $Id: JdbcAccessImpl.java,v 1.1 2007-08-24 22:17:30 ewestfal Exp $
   */
  public class JdbcAccessImpl implements JdbcAccess
  {
      /**
       * The logger used.
       */
      protected Logger logger;
  
      /**
       * The broker in use.
       */
      protected PersistenceBroker broker;
  
      /**
       * constructor is private, use getInstance to get
       * the singleton instance of this class
       */
      public JdbcAccessImpl(PersistenceBroker broker)
      {
          this.broker = broker;
          logger = LoggerFactory.getLogger(this.getClass());
      }
  
      /**
       * Helper Platform accessor method
       *
       * @return Platform for the current broker connection manager.
       */
      private Platform getPlatform()
      {
          return this.broker.serviceConnectionManager().getSupportedPlatform();
      }
  
      /**
       * performs a DELETE operation against RDBMS.
       * @param cld ClassDescriptor providing mapping information.
       * @param obj The object to be deleted.
       */
      public void executeDelete(ClassDescriptor cld, Object obj) throws PersistenceBrokerException
      {
          if (logger.isDebugEnabled())
          {
              logger.debug("executeDelete: " + obj);
          }
  
          final StatementManagerIF sm = broker.serviceStatementManager();
          PreparedStatement stmt = null;
         try
         {
             stmt = sm.getDeleteStatement(cld);
             if (stmt == null)
             {
                 logger.error("getDeleteStatement returned a null statement");
                 throw new PersistenceBrokerException("JdbcAccessImpl: getDeleteStatement returned a null statement");
             }
 
             sm.bindDelete(stmt, cld, obj);
             if (logger.isDebugEnabled())
                 logger.debug("executeDelete: " + stmt);
 
             // @todo: clearify semantics
             // thma: the following check is not secure. The object could be deleted *or* changed.
             // if it was deleted it makes no sense to throw an OL exception.
             // does is make sense to throw an OL exception if the object was changed?
             if (stmt.executeUpdate() == 0 && cld.isLocking()) //BRJ
             {
                 /**
                  * Kuali Foundation modification -- 6/19/2009
                  */
             	String objToString = "";
             	try {
             		objToString = obj.toString();
             	} catch (Exception ex) {}
                 throw new OptimisticLockException("Object has been modified or deleted by someone else: " + objToString, obj);
                 /**
                  * End of Kuali Foundation modification
                  */
             }
 
             // Harvest any return values.
             harvestReturnValues(cld.getDeleteProcedure(), obj, stmt);
         }
         catch (OptimisticLockException e)
         {
             // Don't log as error
             if (logger.isDebugEnabled())
                 logger.debug("OptimisticLockException during the execution of delete: "
                         + e.getMessage(), e);
             throw e;
         }
         catch (PersistenceBrokerException e)
         {
             logger.error("PersistenceBrokerException during the execution of delete: "
                     + e.getMessage(), e);
             throw e;
         }
         catch (SQLException e)
         {
             final String sql = broker.serviceSqlGenerator().getPreparedDeleteStatement(cld).getStatement();
             throw ExceptionHelper.generateException(e, sql, cld, logger, obj);
         }
         finally
         {
             sm.closeResources(stmt, null);
         }
     }
 
     /**
      * Performs a DELETE operation based on the given {@link Query} against RDBMS.
      * @param query the query string.
      * @param cld ClassDescriptor providing JDBC information.
      */
     public void executeDelete(Query query, ClassDescriptor cld) throws PersistenceBrokerException
     {
         if (logger.isDebugEnabled())
         {
             logger.debug("executeDelete (by Query): " + query);
         }
         final StatementManagerIF sm = broker.serviceStatementManager();
         PreparedStatement stmt = null;
         final String sql = this.broker.serviceSqlGenerator().getPreparedDeleteStatement(query, cld).getStatement();
         try
         {
             stmt = sm.getPreparedStatement(cld, sql,
                     false, StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE, cld.getDeleteProcedure()!=null);
 
             sm.bindStatement(stmt, query, cld, 1);
             if (logger.isDebugEnabled())
                 logger.debug("executeDelete (by Query): " + stmt);
 
             stmt.executeUpdate();
         }
         catch (SQLException e)
         {
             throw ExceptionHelper.generateException(e, sql, cld, null, logger);
         }
         finally
         {
             sm.closeResources(stmt, null);
         }
     }
 
     /**
      * performs an INSERT operation against RDBMS.
      * @param obj The Object to be inserted as a row of the underlying table.
      * @param cld ClassDescriptor providing mapping information.
      */
     public void executeInsert(ClassDescriptor cld, Object obj) throws PersistenceBrokerException
     {
         if (logger.isDebugEnabled())
         {
             logger.debug("executeInsert: " + obj);
         }
         final StatementManagerIF sm = broker.serviceStatementManager();
         PreparedStatement stmt = null;
         try
         {
             stmt = sm.getInsertStatement(cld);
             if (stmt == null)
             {
                 logger.error("getInsertStatement returned a null statement");
                 throw new PersistenceBrokerException("getInsertStatement returned a null statement");
             }
             // before bind values perform autoincrement sequence columns
             assignAutoincrementSequences(cld, obj);
             sm.bindInsert(stmt, cld, obj);
             if (logger.isDebugEnabled())
                 logger.debug("executeInsert: " + stmt);
             stmt.executeUpdate();
             // after insert read and assign identity columns
             assignAutoincrementIdentityColumns(cld, obj);
 
             // Harvest any return values.
             harvestReturnValues(cld.getInsertProcedure(), obj, stmt);
         }
         catch (PersistenceBrokerException e)
         {
             logger.error("PersistenceBrokerException during the execution of the insert: " + e.getMessage(), e);
             throw e;
         }
         catch(SequenceManagerException e)
         {
             throw new PersistenceBrokerException("Error while try to assign identity value", e);
         }
         catch (SQLException e)
         {
             final String sql = broker.serviceSqlGenerator().getPreparedInsertStatement(cld).getStatement();
             throw ExceptionHelper.generateException(e, sql, cld, logger, obj);
         }
         finally
         {
             sm.closeResources(stmt, null);
         }
     }
 
     /**
      * performs a SELECT operation against RDBMS.
      * @param query the query string.
      * @param cld ClassDescriptor providing JDBC information.
      */
     public ResultSetAndStatement executeQuery(Query query, ClassDescriptor cld) throws PersistenceBrokerException
     {
         if (logger.isDebugEnabled())
         {
             logger.debug("executeQuery: " + query);
         }
         /*
 		 * MBAIRD: we should create a scrollable resultset if the start at
 		 * index or end at index is set
 		 */
         boolean scrollable = ((query.getStartAtIndex() > Query.NO_START_AT_INDEX) || (query.getEndAtIndex() > Query.NO_END_AT_INDEX));
         /*
 		 * OR if the prefetching of relationships is being used.
 		 */
         if (query != null && query.getPrefetchedRelationships() != null && !query.getPrefetchedRelationships().isEmpty())
         {
             scrollable = true;
         }
         final StatementManagerIF sm = broker.serviceStatementManager();
         final SelectStatement sql = broker.serviceSqlGenerator().getPreparedSelectStatement(query, cld);
         PreparedStatement stmt = null;
         ResultSet rs = null;
         try
         {
             final int queryFetchSize = query.getFetchSize();
             final boolean isStoredProcedure = isStoredProcedure(sql.getStatement());
             stmt = sm.getPreparedStatement(cld, sql.getStatement() ,
                     scrollable, queryFetchSize, isStoredProcedure);
             if (isStoredProcedure)
             {
                 // Query implemented as a stored procedure, which must return a result set.
                 // Query sytax is: { ?= call PROCEDURE_NAME(?,...,?)}
                 getPlatform().registerOutResultSet((CallableStatement) stmt, 1);
                 sm.bindStatement(stmt, query, cld, 2);
 
                 if (logger.isDebugEnabled())
                     logger.debug("executeQuery: " + stmt);
 
                 stmt.execute();
                 rs = (ResultSet) ((CallableStatement) stmt).getObject(1);
             }
             else
             {
                 sm.bindStatement(stmt, query, cld, 1);
 
                 if (logger.isDebugEnabled())
                     logger.debug("executeQuery: " + stmt);
 
                 rs = stmt.executeQuery();
             }
 
             return new ResultSetAndStatement(sm, stmt, rs, sql);
         }
         catch (PersistenceBrokerException e)
         {
             // release resources on exception
             sm.closeResources(stmt, rs);
             logger.error("PersistenceBrokerException during the execution of the query: " + e.getMessage(), e);
             throw e;
         }
         catch (SQLException e)
         {
             // release resources on exception
             sm.closeResources(stmt, rs);
             throw ExceptionHelper.generateException(e, sql.getStatement(), null, logger, null);
         }
     }
 
     public ResultSetAndStatement executeSQL(
         String sqlStatement,
         ClassDescriptor cld,
         boolean scrollable)
         throws PersistenceBrokerException
     {
         return executeSQL(sqlStatement, cld, null, scrollable);
     }
 
     /**
      * performs a SQL SELECT statement against RDBMS.
      * @param sql the query string.
      * @param cld ClassDescriptor providing meta-information.
      */
     public ResultSetAndStatement executeSQL(
         final String sql,
         ClassDescriptor cld,
         ValueContainer[] values,
         boolean scrollable)
         throws PersistenceBrokerException
     {
         if (logger.isDebugEnabled()) logger.debug("executeSQL: " + sql);
         final boolean isStoredprocedure = isStoredProcedure(sql);
         final StatementManagerIF sm = broker.serviceStatementManager();
         PreparedStatement stmt = null;
         ResultSet rs = null;
         try
         {
             stmt = sm.getPreparedStatement(cld, sql,
                     scrollable, StatementManagerIF.FETCH_SIZE_NOT_EXPLICITLY_SET, isStoredprocedure);
             if (isStoredprocedure)
             {
                 // Query implemented as a stored procedure, which must return a result set.
                 // Query sytax is: { ?= call PROCEDURE_NAME(?,...,?)}
                 getPlatform().registerOutResultSet((CallableStatement) stmt, 1);
                 sm.bindValues(stmt, values, 2);
                 stmt.execute();
                 rs = (ResultSet) ((CallableStatement) stmt).getObject(1);
             }
             else
             {
                 sm.bindValues(stmt, values, 1);
                 rs = stmt.executeQuery();
             }
 
             // as we return the resultset for further operations, we cannot release the statement yet.
             // that has to be done by the JdbcAccess-clients (i.e. RsIterator, ProxyRsIterator and PkEnumeration.)
             return new ResultSetAndStatement(sm, stmt, rs, new SelectStatement()
             {
                 public Query getQueryInstance()
                 {
                     return null;
                 }
 
                 public int getColumnIndex(FieldDescriptor fld)
                 {
                     return JdbcType.MIN_INT;
                 }
 
                 public String getStatement()
                 {
                     return sql;
                 }
             });
         }
         catch (PersistenceBrokerException e)
         {
             // release resources on exception
             sm.closeResources(stmt, rs);
             logger.error("PersistenceBrokerException during the execution of the SQL query: " + e.getMessage(), e);
             throw e;
         }
         catch (SQLException e)
         {
             // release resources on exception
             sm.closeResources(stmt, rs);
             throw ExceptionHelper.generateException(e, sql, cld, values, logger, null);
         }
     }
 
     public int executeUpdateSQL(String sqlStatement, ClassDescriptor cld)
         throws PersistenceBrokerException
     {
         return executeUpdateSQL(sqlStatement, cld, null, null);
     }
 
     /**
      * performs a SQL UPDTE, INSERT or DELETE statement against RDBMS.
      * @param sqlStatement the query string.
      * @param cld ClassDescriptor providing meta-information.
      * @return int returncode
      */
     public int executeUpdateSQL(
         String sqlStatement,
         ClassDescriptor cld,
         ValueContainer[] values1,
         ValueContainer[] values2)
         throws PersistenceBrokerException
     {
         if (logger.isDebugEnabled())
             logger.debug("executeUpdateSQL: " + sqlStatement);
 
         int result;
         int index;
         PreparedStatement stmt = null;
         final StatementManagerIF sm = broker.serviceStatementManager();
         try
         {
             stmt = sm.getPreparedStatement(cld, sqlStatement,
                     Query.NOT_SCROLLABLE, StatementManagerIF.FETCH_SIZE_NOT_APPLICABLE, isStoredProcedure(sqlStatement));
             index = sm.bindValues(stmt, values1, 1);
             sm.bindValues(stmt, values2, index);
             result = stmt.executeUpdate();
         }
         catch (PersistenceBrokerException e)
         {
             logger.error("PersistenceBrokerException during the execution of the Update SQL query: " + e.getMessage(), e);
             throw e;
         }
         catch (SQLException e)
         {
             ValueContainer[] tmp = addValues(values1, values2);
             throw ExceptionHelper.generateException(e, sqlStatement, cld, tmp, logger, null);
         }
         finally
         {
             sm.closeResources(stmt, null);
         }
         return result;
     }
 
     /** Helper method, returns the addition of both arrays (add source to target array) */
     private ValueContainer[] addValues(ValueContainer[] target, ValueContainer[] source)
     {
         ValueContainer[] newArray;
         if(source != null && source.length > 0)
         {
             if(target != null)
             {
                 newArray = new ValueContainer[target.length + source.length];
                 System.arraycopy(target, 0, newArray, 0, target.length);
                 System.arraycopy(source, 0, newArray, target.length, source.length);
             }
             else
             {
                 newArray = source;
             }
         }
         else
         {
             newArray = target;
         }
         return newArray;
     }
 
     /**
      * performs an UPDATE operation against RDBMS.
      * @param obj The Object to be updated in the underlying table.
      * @param cld ClassDescriptor providing mapping information.
      */
     public void executeUpdate(ClassDescriptor cld, Object obj) throws PersistenceBrokerException
     {
         if (logger.isDebugEnabled())
         {
             logger.debug("executeUpdate: " + obj);
         }
 
         // obj with nothing but key fields is not updated
         if (cld.getNonPkRwFields().length == 0)
         {
             return;
         }
 
         final StatementManagerIF sm = broker.serviceStatementManager();
         PreparedStatement stmt = null;
         // BRJ: preserve current locking values
         // locking values will be restored in case of exception
         ValueContainer[] oldLockingValues;
         oldLockingValues = cld.getCurrentLockingValues(obj);
         try
         {
             stmt = sm.getUpdateStatement(cld);
             if (stmt == null)
             {
                 logger.error("getUpdateStatement returned a null statement");
                 throw new PersistenceBrokerException("getUpdateStatement returned a null statement");
             }
 
             sm.bindUpdate(stmt, cld, obj);
             if (logger.isDebugEnabled())
                 logger.debug("executeUpdate: " + stmt);
 
             if ((stmt.executeUpdate() == 0) && cld.isLocking()) //BRJ
             {
                 /**
                  * Kuali Foundation modification -- 6/19/2009
                  */
             	String objToString = "";
             	try {
             		objToString = obj.toString();
             	} catch (Exception ex) {}
                 throw new OptimisticLockException("Object has been modified by someone else: " + objToString, obj);
                 /**
                  * End of Kuali Foundation modification
                  */
             }
 
             // Harvest any return values.
             harvestReturnValues(cld.getUpdateProcedure(), obj, stmt);
         }
         catch (OptimisticLockException e)
         {
             // Don't log as error
             if (logger.isDebugEnabled())
                 logger.debug(
                     "OptimisticLockException during the execution of update: " + e.getMessage(),
                     e);
             throw e;
         }
         catch (PersistenceBrokerException e)
         {
             // BRJ: restore old locking values
             setLockingValues(cld, obj, oldLockingValues);
 
             logger.error(
                 "PersistenceBrokerException during the execution of the update: " + e.getMessage(),
                 e);
             throw e;
         }
         catch (SQLException e)
         {
             final String sql = broker.serviceSqlGenerator().getPreparedUpdateStatement(cld).getStatement();
             throw ExceptionHelper.generateException(e, sql, cld, logger, obj);
         }
         finally
         {
             sm.closeResources(stmt, null);
         }
     }
 
     /**
      * performs a primary key lookup operation against RDBMS and materializes
      * an object from the resulting row. Only skalar attributes are filled from
      * the row, references are not resolved.
      * @param oid contains the primary key info.
      * @param cld ClassDescriptor providing mapping information.
      * @return the materialized object, null if no matching row was found or if
      * any error occured.
      */
     public Object materializeObject(ClassDescriptor cld, Identity oid)
         throws PersistenceBrokerException
     {
         final StatementManagerIF sm = broker.serviceStatementManager();
         final SelectStatement sql = broker.serviceSqlGenerator().getPreparedSelectByPkStatement(cld);
         Object result = null;
         PreparedStatement stmt = null;
         ResultSet rs = null;
         try
         {
             stmt = sm.getSelectByPKStatement(cld);
             if (stmt == null)
             {
                 logger.error("getSelectByPKStatement returned a null statement");
                 throw new PersistenceBrokerException("getSelectByPKStatement returned a null statement");
             }
             /*
             arminw: currently a select by PK could never be a stored procedure,
             thus we can always set 'false'. Is this correct??
             */
             sm.bindSelect(stmt, oid, cld, false);
             rs = stmt.executeQuery();
             // data available read object, else return null
             ResultSetAndStatement rs_stmt = new ResultSetAndStatement(broker.serviceStatementManager(), stmt, rs, sql);
             if (rs.next())
             {
                 Map row = new HashMap();
                 cld.getRowReader().readObjectArrayFrom(rs_stmt, row);
                 result = cld.getRowReader().readObjectFrom(row);
             }
             // close resources
             rs_stmt.close();
         }
         catch (PersistenceBrokerException e)
         {
             // release resources on exception
             sm.closeResources(stmt, rs);
             logger.error("PersistenceBrokerException during the execution of materializeObject: " + e.getMessage(), e);
             throw e;
         }
         catch (SQLException e)
         {
             // release resources on exception
             sm.closeResources(stmt, rs);
             throw ExceptionHelper.generateException(e, sql.getStatement(), cld, logger, null);
         }
         return result;
     }
 
     /**
      * Set the locking values
      * @param cld
      * @param obj
      * @param oldLockingValues
      */
     private void setLockingValues(ClassDescriptor cld, Object obj, ValueContainer[] oldLockingValues)
     {
         FieldDescriptor fields[] = cld.getLockingFields();
 
         for (int i=0; i<fields.length; i++)
         {
             PersistentField field = fields[i].getPersistentField();
             Object lockVal = oldLockingValues[i].getValue();
 
             field.set(obj, lockVal);
         }
     }
 
     /**
      * Harvest any values that may have been returned during the execution
      * of a procedure.
      *
      * @param proc the procedure descriptor that provides info about the procedure
      *      that was invoked.
      * @param obj the object that was persisted
      * @param stmt the statement that was used to persist the object.
      *
      * @throws PersistenceBrokerSQLException if a problem occurs.
      */
     private void harvestReturnValues(
         ProcedureDescriptor proc,
         Object obj,
         PreparedStatement stmt)
         throws PersistenceBrokerSQLException
     {
         // If the procedure descriptor is null or has no return values or
         // if the statement is not a callable statment, then we're done.
         if ((proc == null) || (!proc.hasReturnValues()))
         {
             return;
         }
 
         // Set up the callable statement
         CallableStatement callable = (CallableStatement) stmt;
 
         // This is the index that we'll use to harvest the return value(s).
         int index = 0;
 
         // If the proc has a return value, then try to harvest it.
         if (proc.hasReturnValue())
         {
 
             // Increment the index
             index++;
 
             // Harvest the value.
             this.harvestReturnValue(obj, callable, proc.getReturnValueFieldRef(), index);
         }
 
         // Check each argument.  If it's returned by the procedure,
         // then harvest the value.
         Iterator iter = proc.getArguments().iterator();
         while (iter.hasNext())
         {
             index++;
             ArgumentDescriptor arg = (ArgumentDescriptor) iter.next();
             if (arg.getIsReturnedByProcedure())
             {
                 this.harvestReturnValue(obj, callable, arg.getFieldRef(), index);
             }
         }
     }
 
     /**
      * Harvest a single value that was returned by a callable statement.
      *
      * @param obj the object that will receive the value that is harvested.
      * @param callable the CallableStatement that contains the value to harvest
      * @param fmd the FieldDescriptor that identifies the field where the
      *      harvested value will be stord.
      * @param index the parameter index.
      *
      * @throws PersistenceBrokerSQLException if a problem occurs.
      */
     private void harvestReturnValue(
         Object obj,
         CallableStatement callable,
         FieldDescriptor fmd,
         int index)
         throws PersistenceBrokerSQLException
     {
 
         try
         {
             // If we have a field descriptor, then we can harvest
             // the return value.
             if ((callable != null) && (fmd != null) && (obj != null))
             {
                 // Get the value and convert it to it's appropriate
                 // java type.
                 Object value = fmd.getJdbcType().getObjectFromColumn(callable, index);
 
                 // Set the value of the persistent field.
                 fmd.getPersistentField().set(obj, fmd.getFieldConversion().sqlToJava(value));
 
             }
         }
         catch (SQLException e)
         {
             String msg = "SQLException during the execution of harvestReturnValue"
                 + " class="
                 + obj.getClass().getName()
                 + ","
                 + " field="
                 + fmd.getAttributeName()
                 + " : "
                 + e.getMessage();
             logger.error(msg,e);
             throw new PersistenceBrokerSQLException(msg, e);
         }
     }
 
     /**
      * Check if the specified sql-string is a stored procedure
      * or not.
      * @param sql The sql query to check
      * @return <em>True</em> if the query is a stored procedure, else <em>false</em> is returned.
      */
     protected boolean isStoredProcedure(String sql)
     {
         /*
         Stored procedures start with
         {?= call <procedure-name>[<arg1>,<arg2>, ...]}
         or
         {call <procedure-name>[<arg1>,<arg2>, ...]}
         but also statements with white space like
         { ?= call <procedure-name>[<arg1>,<arg2>, ...]}
         are possible.
         */
         int k = 0, i = 0;
         char c;
         while(k < 3 && i < sql.length())
         {
             c = sql.charAt(i);
             if(c != ' ')
             {
                 switch (k)
                 {
                     case 0:
                         if(c != '{') return false;
                         break;
                     case 1:
                         if(c != '?' && c != 'c') return false;
                         break;
                     case 2:
                         if(c != '=' && c != 'a') return false;
                         break;
                 }
                 k++;
             }
             i++;
         }
         return true;
     }
 
     protected void assignAutoincrementSequences(ClassDescriptor cld, Object target) throws SequenceManagerException
     {
         // TODO: refactor auto-increment handling, auto-increment should only be supported by PK fields?
         // FieldDescriptor[] fields = cld.getPkFields();
         FieldDescriptor[] fields = cld.getFieldDescriptor(false);
         FieldDescriptor field;
         for(int i = 0; i < fields.length; i++)
         {
             field = fields[i];
             if(field.isAutoIncrement() && !field.isAccessReadOnly())
             {
                 Object value = field.getPersistentField().get(target);
                 if(broker.serviceBrokerHelper().representsNull(field, value))
                 {
                     Object id = broker.serviceSequenceManager().getUniqueValue(field);
                     field.getPersistentField().set(target, id);
                 }
             }
         }
     }
 
     protected void assignAutoincrementIdentityColumns(ClassDescriptor cld, Object target) throws SequenceManagerException
     {
         // if database Identity Columns are used, query the id from database
         // other SequenceManager implementations will ignore this call
         if(cld.useIdentityColumnField()) broker.serviceSequenceManager().afterStore(this, cld, target);
     }
 }