public JDBCEntityBridge(JDBCEntityMetaData metadata,
    JDBCStoreManager manager) throws DeploymentException 
{
       
      this.metadata = metadata;
      this.manager = manager;
      primaryKeyFieldName = metadata.getPrimaryKeyFieldName();
      primaryKeyClass = metadata.getPrimaryKeyClass();
      log = Logger.getLogger(this.getClass().getName() + "." + metadata.getName());
}

 int addTableField(JDBCCMPFieldBridge field) 
{
      JDBCCMPFieldBridge[] tmpFields = tableFields;
      if(tableFields == null)
      {
         tableFields = new JDBCCMPFieldBridge[1];
      }
      else
      {
         tableFields = new JDBCCMPFieldBridge[tableFields.length + 1];
         System.arraycopy(tmpFields, 0, tableFields, 0, tmpFields.length);
      }
      int index = tableFields.length - 1;
      tableFields[index] = field;
      return index;
}

 public  void cascadeDelete(EntityEnterpriseContext ctx,
    Map oldRelations) throws RemoveException, RemoteException 
{
      for(int i = 0; i <  cmrFields.length; ++i)
      {
         JDBCCMRFieldBridge cmrField = cmrFields[i];
         Object value = oldRelations.get(cmrField);
         if(value != null)
            cmrField.cascadeDelete(ctx, (List)value);
      }
}

 public Object createPrimaryKeyInstance() 
{
      if(primaryKeyFieldName == null)
      {
         try
         {
            return primaryKeyClass.newInstance();
         }
         catch(Exception e)
         {
            throw new EJBException("Error creating primary key instance: ", e);
         }
      }
      return null;
}

 public static  void destroyPersistenceContext(EntityEnterpriseContext ctx) 
{
      // If we have an EJB 2.0 dynaymic proxy,
      // notify the handler of the assigned context.
      Object instance = ctx.getInstance();
      if(instance instanceof Proxies.ProxyTarget)
      {
         InvocationHandler handler = ((Proxies.ProxyTarget)instance).getInvocationHandler();
         if(handler instanceof EntityBridgeInvocationHandler)
            ((EntityBridgeInvocationHandler)handler).setContext(null);
      }
      ctx.setPersistenceContext(null);
}

 public Object extractPrimaryKeyFromInstance(EntityEnterpriseContext ctx) 
{
      try
      {
         Object pk = null;
         for(int i = 0; i <  primaryKeyFields.length; ++i)
         {
            JDBCCMPFieldBridge pkField = primaryKeyFields[i];
            Object fieldValue = pkField.getInstanceValue(ctx);
            // updated pk object with return form set primary key value to
            // handle single valued non-composit pks and more complicated behivors.
            pk = pkField.setPrimaryKeyValue(pk, fieldValue);
         }
         return pk;
      }
      catch(EJBException e)
      {
         // to avoid double wrap of EJBExceptions
         throw e;
      }
      catch(Exception e)
      {
         // Non recoverable internal exception
         throw new EJBException("Internal error extracting primary key from " +
            "instance", e);
      }
}

 public String getAbstractSchemaName() 
{
      return metadata.getAbstractSchemaName();
}

 public JDBCCMPFieldBridge getCMPFieldByName(String name) 
{
      for(int i = 0; i <  primaryKeyFields.length; ++i)
      {
         JDBCCMPFieldBridge cmpField = primaryKeyFields[i];
         if(cmpField.getFieldName().equals(name))
            return cmpField;
      }
      for(int i = 0; i <  cmpFields.length; ++i)
      {
         JDBCCMPFieldBridge cmpField = cmpFields[i];
         if(cmpField.getFieldName().equals(name))
            return cmpField;
      }
      return null;
}

 public JDBCCMRFieldBridge getCMRFieldByName(String name) 
{
      for(int i = 0; i <  cmrFields.length; ++i)
      {
         JDBCCMRFieldBridge cmrField = cmrFields[i];
         if(cmrField.getFieldName().equals(name))
            return cmrField;
      }
      return null;
}

 public JDBCAbstractCMRFieldBridge[] getCMRFields() 
{
      return cmrFields;
}

 public JDBCCMPFieldBridge getCreatedPrincipalField() 
{
      return createdPrincipalField;
}

 public JDBCCMPFieldBridge getCreatedTimeField() 
{
      return createdTimeField;
}

 public DataSource getDataSource() 
{
      return dataSource;
}

Returns the datasource for this entity.

 public JDBCEntityBridge.FieldIterator getDirtyIterator(EntityEnterpriseContext ctx) 
{
      int dirtyFields = 0;
      final EntityState entityState = getEntityState(ctx);
      for(int i = 0; i <  tableFields.length; ++i)
      {
         JDBCCMPFieldBridge field = tableFields[i];
         if(entityState.isCheckDirty(i) && field.isDirty(ctx))
         {
            entityState.setUpdateRequired(i);
            ++dirtyFields;
         }
      }
      return dirtyFields  > 0 ? getEntityState(ctx).getDirtyIterator(ctx) : EMPTY_FIELD_ITERATOR;
}

 public boolean[] getEagerLoadMask() 
{
      return eagerLoadGroupMask;
}

 public String getEntityName() 
{
      return metadata.getName();
}

 public int getFetchSize() 
{
      return metadata.getFetchSize();
}

 public FieldBridge getFieldByName(String name) 
{
      FieldBridge field = null;
      for(int i = 0; i <  primaryKeyFields.length; ++i)
      {
         JDBCCMPFieldBridge primaryKeyField = primaryKeyFields[i];
         if(primaryKeyField.getFieldName().equals(name))
         {
            field = primaryKeyField;
            break;
         }
      }
      if(field == null)
      {
         field = getCMPFieldByName(name);
      }
      if(field == null)
      {
         field = getCMRFieldByName(name);
      }
      return field;
}

 public List getFields() 
{
      int fieldsTotal = primaryKeyFields.length + cmpFields.length + cmrFields.length;
      JDBCFieldBridge[] fields = new JDBCFieldBridge[fieldsTotal];
      int position = 0;
      // primary key fields
      System.arraycopy(primaryKeyFields, 0, fields, position, primaryKeyFields.length);
      position += primaryKeyFields.length;
      // cmp fields
      System.arraycopy(cmpFields, 0, fields, position, cmpFields.length);
      position += cmpFields.length;
      // cmr fields
      System.arraycopy(cmrFields, 0, fields, position, cmrFields.length);
      return Arrays.asList(fields);
}

This method is called only at deployment time, not called at runtime.

 public Iterator getLazyLoadGroupMasks() 
{
      return lazyLoadGroupMasks.iterator();
}

 public int getListCacheMax() 
{
      return metadata.getListCacheMax();
}

 public boolean[] getLoadGroupMask(String name) 
{
      boolean[] mask = (boolean[])loadGroupMasks.get(name);
      if(mask == null)
      {
         throw new IllegalStateException(
            "Load group '" + name + "' is not defined. Defined load groups: " + loadGroupMasks.keySet()
         );
      }
      return mask;
}

 public JDBCEntityBridge.FieldIterator getLoadIterator(JDBCCMPFieldBridge requiredField,
    JDBCReadAheadMetaData readahead,
    EntityEnterpriseContext ctx) 
{
      boolean[] loadGroup;
      if(requiredField == null)
      {
         if(readahead != null && !readahead.isNone())
         {
            if(log.isTraceEnabled())
            {
               log.trace("Eager-load for entity: readahead=" + readahead);
            }
            loadGroup = getLoadGroupMask(readahead.getEagerLoadGroup());
         }
         else
         {
            if(log.isTraceEnabled())
            {
               log.trace("Default eager-load for entity: readahead=" + readahead);
            }
            loadGroup = eagerLoadGroupMask;
         }
      }
      else
      {
         loadGroup = new boolean[tableFields.length];
         int requiredInd = requiredField.getTableIndex();
         loadGroup[requiredInd] = true;
         for(Iterator groups = lazyLoadGroupMasks.iterator(); groups.hasNext();)
         {
            boolean[] lazyGroup = (boolean[])groups.next();
            if(lazyGroup[requiredInd])
            {
               for(int i = 0; i <  loadGroup.length; ++i)
                  loadGroup[i] = loadGroup[i] || lazyGroup[i];
            }
         }
      }
      FieldIterator loadIter;
      if(loadGroup != null)
      {
         // filter
         int fieldsToLoad = 0;
         EntityState entityState = getEntityState(ctx);
         for(int i = 0; i <  tableFields.length; ++i)
         {
            JDBCCMPFieldBridge field = tableFields[i];
            if(loadGroup[i] && !field.isPrimaryKeyMember() && !field.isLoaded(ctx))
            {
               entityState.setLoadRequired(i);
               ++fieldsToLoad;
            }
         }
         loadIter = (fieldsToLoad  > 0 ? entityState.getLoadIterator(ctx) : EMPTY_FIELD_ITERATOR);
      }
      else
      {
         loadIter = EMPTY_FIELD_ITERATOR;
      }
      return loadIter;
}

 public Class getLocalInterface() 
{
      return metadata.getLocalClass();
}

 public JDBCEntityBridge.FieldIterator getLockedIterator(EntityEnterpriseContext ctx) 
{
      return getEntityState(ctx).getLockedIterator(ctx);
}

 public JDBCEntityPersistenceStore getManager() 
{
      return manager;
}

 public JDBCEntityMetaData getMetaData() 
{
      return metadata;
}

 int getNextJDBCContextIndex() 
{
      return jdbcContextSize++;
}

 public Class getPrimaryKeyClass() 
{
      return primaryKeyClass;
}

 public JDBCFieldBridge[] getPrimaryKeyFields() 
{
      return primaryKeyFields;
}

 public String getQualifiedTableName() 
{
      return qualifiedTableName;
}

 public Class getRemoteInterface() 
{
      return metadata.getRemoteClass();
}

 public Collection getSelectors() 
{
      return selectorsByMethod.values();
}

 public JDBCFieldBridge[] getTableFields() 
{
      return tableFields;
}

 public String getTableName() 
{
      return tableName;
}

 public JDBCCMPFieldBridge getUpdatedPrincipalField() 
{
      return updatedPrincipalField;
}

 public JDBCCMPFieldBridge getUpdatedTimeField() 
{
      return updatedTimeField;
}

 public JDBCCMPFieldBridge getVersionField() 
{
      return versionField;
}

 public boolean hasLockedFields(EntityEnterpriseContext ctx) 
{
      return getEntityState(ctx).hasLockedFields();
}

 public  void init() throws DeploymentException 
{
      try
      {
         InitialContext ic = new InitialContext();
         dataSource = (DataSource)ic.lookup(metadata.getDataSourceName());
      }
      catch(NamingException e)
      {
         throw new DeploymentException("Error: can't find data source: " +
            metadata.getDataSourceName(), e);
      }
      qualifiedTableName = SQLUtil.fixTableName(metadata.getDefaultTableName(), dataSource);
      int dotIndex = qualifiedTableName.indexOf('.");
      tableName = dotIndex == -1 ? qualifiedTableName : qualifiedTableName.substring(dotIndex + 1);
      // CMP fields
      loadCMPFields(metadata);
      // CMR fields
      loadCMRFields(metadata);
      // create locking field
      JDBCOptimisticLockingMetaData lockMetaData = metadata.getOptimisticLocking();
      if(lockMetaData != null && lockMetaData.getLockingField() != null)
      {
         Integer strategy = lockMetaData.getLockingStrategy();
         JDBCCMPFieldMetaData versionMD = lockMetaData.getLockingField();
         versionField = getCMPFieldByName(versionMD.getFieldName());
         boolean hidden = versionField == null;
         if(strategy == JDBCOptimisticLockingMetaData.VERSION_COLUMN_STRATEGY)
         {
            if(hidden)
               versionField = new JDBCLongVersionFieldBridge(manager, versionMD);
            else
               versionField = new JDBCLongVersionFieldBridge((JDBCCMP2xFieldBridge)versionField);
         }
         else if(strategy == JDBCOptimisticLockingMetaData.TIMESTAMP_COLUMN_STRATEGY)
         {
            if(hidden)
               versionField = new JDBCTimestampVersionFieldBridge(manager, versionMD);
            else
               versionField = new JDBCTimestampVersionFieldBridge((JDBCCMP2xFieldBridge)versionField);
         }
         else if(strategy == JDBCOptimisticLockingMetaData.KEYGENERATOR_COLUMN_STRATEGY)
         {
            if(hidden)
               versionField = new JDBCKeyGenVersionFieldBridge(
                  manager, versionMD, lockMetaData.getKeyGeneratorFactory());
            else
               versionField = new JDBCKeyGenVersionFieldBridge(
                  (JDBCCMP2xFieldBridge)versionField, lockMetaData.getKeyGeneratorFactory());
         }
         if(hidden)
            addCMPField(versionField);
         else
            tableFields[versionField.getTableIndex()] = versionField;
      }
      // audit fields
      JDBCAuditMetaData auditMetaData = metadata.getAudit();
      if(auditMetaData != null)
      {
         JDBCCMPFieldMetaData auditField = auditMetaData.getCreatedPrincipalField();
         if(auditField != null)
         {
            createdPrincipalField = getCMPFieldByName(auditField.getFieldName());
            if(createdPrincipalField == null)
            {
               createdPrincipalField = new JDBCCMP2xFieldBridge(manager, auditField);
               addCMPField(createdPrincipalField);
            }
         }
         else
         {
            createdPrincipalField = null;
         }
         auditField = auditMetaData.getCreatedTimeField();
         if(auditField != null)
         {
            createdTimeField = getCMPFieldByName(auditField.getFieldName());
            if(createdTimeField == null)
            {
               createdTimeField = new JDBCCMP2xFieldBridge(manager, auditField, JDBCTypeFactory.EQUALS, false);
               addCMPField(createdTimeField);
            }
            else
            {
               // just to override state factory and check-dirty-after-get
               createdTimeField = new JDBCCMP2xFieldBridge(
                  (JDBCCMP2xFieldBridge)createdTimeField, JDBCTypeFactory.EQUALS, false);
               tableFields[createdTimeField.getTableIndex()] = createdTimeField;
            }
         }
         else
         {
            createdTimeField = null;
         }
         auditField = auditMetaData.getUpdatedPrincipalField();
         if(auditField != null)
         {
            updatedPrincipalField = getCMPFieldByName(auditField.getFieldName());
            if(updatedPrincipalField == null)
            {
               updatedPrincipalField = new JDBCCMP2xUpdatedPrincipalFieldBridge(manager, auditField);
               addCMPField(updatedPrincipalField);
            }
            else
            {
               updatedPrincipalField = new JDBCCMP2xUpdatedPrincipalFieldBridge(
                  (JDBCCMP2xFieldBridge)updatedPrincipalField);
               tableFields[updatedPrincipalField.getTableIndex()] = updatedPrincipalField;
            }
         }
         else
         {
            updatedPrincipalField = null;
         }
         auditField = auditMetaData.getUpdatedTimeField();
         if(auditField != null)
         {
            updatedTimeField = getCMPFieldByName(auditField.getFieldName());
            if(updatedTimeField == null)
            {
               updatedTimeField = new JDBCCMP2xUpdatedTimeFieldBridge(manager, auditField);
               addCMPField(updatedTimeField);
            }
            else
            {
               updatedTimeField = new JDBCCMP2xUpdatedTimeFieldBridge((JDBCCMP2xFieldBridge)updatedTimeField);
               tableFields[updatedTimeField.getTableIndex()] = updatedTimeField;
            }
         }
         else
         {
            updatedTimeField = null;
         }
      }
      // ejbSelect methods
      loadSelectors(metadata);
}

 public  void initInstance(EntityEnterpriseContext ctx) 
{
      for(int i = 0; i <  tableFields.length; ++i)
         tableFields[i].initInstance(ctx);
      //for(int i = 0; i <  primaryKeyFields.length; ++i)
      //   primaryKeyFields[i].initInstance(ctx);
      //for(int i = 0; i <  cmpFields.length; ++i)
      //   cmpFields[i].initInstance(ctx);
      for(int i = 0; i <  cmrFields.length; ++i)
      {
         JDBCCMRFieldBridge cmrField = cmrFields[i];
         cmrField.initInstance(ctx);
      }
}

 public  void initPersistenceContext(EntityEnterpriseContext ctx) 
{
      // If we have an EJB 2.0 dynaymic proxy,
      // notify the handler of the assigned context.
      Object instance = ctx.getInstance();
      if(instance instanceof Proxies.ProxyTarget)
      {
         InvocationHandler handler = ((Proxies.ProxyTarget)instance).getInvocationHandler();
         if(handler instanceof EntityBridgeInvocationHandler)
            ((EntityBridgeInvocationHandler)handler).setContext(ctx);
      }
      ctx.setPersistenceContext(new JDBCContext(jdbcContextSize, new EntityState()));
}

 public  void injectPrimaryKeyIntoInstance(EntityEnterpriseContext ctx,
    Object pk) 
{
      for(int i = 0; i <  primaryKeyFields.length; ++i)
      {
         JDBCCMPFieldBridge pkField = primaryKeyFields[i];
         Object fieldValue = pkField.getPrimaryKeyValue(pk);
         pkField.setInstanceValue(ctx, fieldValue);
      }
}

 public boolean isBeingRemoved(EntityEnterpriseContext ctx) 
{
      return getEntityState(ctx).isBeingRemoved();
}

 public static boolean isEjbCreateDone(EntityEnterpriseContext ctx) 
{
      return getEntityState(ctx).ejbCreateDone;
}

 public boolean isModified(EntityEnterpriseContext ctx) 
{
      boolean invalidateCache = false;
      final EntityState entityState = getEntityState(ctx);
      if(entityState.isCreated())
      {
         invalidateCache = areCmpFieldsDirty(ctx, entityState);
         if(!invalidateCache)
         {
            for(int i = 0; i <  cmrFields.length; ++i)
            {
               if(cmrFields[i].invalidateCache(ctx))
               {
                  invalidateCache = true;
                  break;
               }
            }
         }
      }
      return invalidateCache;
}

This method is used to determined whether the instance was modified. NOTE, even if the method returns true the isStoreRequired for this same instance might return false, e.g. a CMR field that doesn't have a foreign key was modified.

 public boolean isRemoved(EntityEnterpriseContext ctx) 
{
      return getEntityState(ctx).isRemoved();
}

 public boolean isScheduledForBatchCascadeDelete(EntityEnterpriseContext ctx) 
{
      return getEntityState(ctx).isScheduledForBatchCascadeDelete();
}

 public boolean isScheduledForCascadeDelete(EntityEnterpriseContext ctx) 
{
      return getEntityState(ctx).isScheduledForCascadeDelete();
}

 public boolean isStoreRequired(EntityEnterpriseContext ctx) 
{
      boolean modified = false;
      final EntityState entityState = getEntityState(ctx);
      if(entityState.isCreated())
      {
         modified = areCmpFieldsDirty(ctx, entityState);
         if(!modified)
         {
            for(int i = 0; i <  cmrFields.length; ++i)
            {
               if(cmrFields[i].isDirty(ctx))
               {
                  modified = true;
                  break;
               }
            }
         }
      }
      return modified;
}

 public int loadPrimaryKeyResults(ResultSet rs,
    int parameterIndex,
    Object[] pkRef) 
{
      pkRef[0] = createPrimaryKeyInstance();
      for(int i = 0; i <  primaryKeyFields.length; ++i)
         parameterIndex = primaryKeyFields[i].loadPrimaryKeyResults(rs, parameterIndex, pkRef);
      return parameterIndex;
}

 public boolean removeFromRelations(EntityEnterpriseContext ctx,
    Object[] oldRelations) 
{
      boolean removed = false;
      for(int i = 0; i <  cmrFields.length; ++i)
      {
         if(cmrFields[i].removeFromRelations(ctx, oldRelations))
            removed = true;
      }
      return removed;
}

 public  void resetPersistenceContext(EntityEnterpriseContext ctx) 
{
      for(int i = 0; i <  primaryKeyFields.length; ++i)
         primaryKeyFields[i].resetPersistenceContext(ctx);
      for(int i = 0; i <  cmpFields.length; ++i)
         cmpFields[i].resetPersistenceContext(ctx);
      for(int i = 0; i <  cmrFields.length; ++i)
         cmrFields[i].resetPersistenceContext(ctx);
}

This is only called in commit option B

 public  void resolveRelationships() throws DeploymentException 
{
      for(int i = 0; i <  cmrFields.length; ++i)
         cmrFields[i].resolveRelationship();
      // load groups:  cannot be created until relationships have
      // been resolved because loadgroups must check for foreign keys
      loadLoadGroups(metadata);
      loadEagerLoadGroup(metadata);
      loadLazyLoadGroups(metadata);
}

 public  void scheduleForBatchCascadeDelete(EntityEnterpriseContext ctx) 
{
      getEntityState(ctx).scheduleForBatchCascadeDelete();
      if(log.isTraceEnabled())
         log.trace("Scheduled for batch-cascade-delete: " + ctx.getId());
}

Marks the instance as scheduled for batch cascade delete (not for cascade delete)

 public  void scheduleForCascadeDelete(EntityEnterpriseContext ctx) 
{
      getEntityState(ctx).scheduleForCascadeDelete();
      if(log.isTraceEnabled())
         log.trace("Scheduled for cascade-delete: " + ctx.getId());
}

Marks the instance as scheduled for cascade delete (not for batch cascade delete)

 public static  void setCreated(EntityEnterpriseContext ctx) 
{
      getEntityState(ctx).setCreated();
}

 public static  void setEjbCreateDone(EntityEnterpriseContext ctx) 
{
      getEntityState(ctx).ejbCreateDone = true;
}

 public  void setIsBeingRemoved(EntityEnterpriseContext ctx) 
{
      getEntityState(ctx).setIsBeingRemoved();
}

Marks an instance as being removed

 public int setPrimaryKeyParameters(PreparedStatement ps,
    int parameterIndex,
    Object primaryKey) 
{
      for(int i = 0; i <  primaryKeyFields.length; ++i)
         parameterIndex = primaryKeyFields[i].setPrimaryKeyParameters(ps, parameterIndex, primaryKey);
      return parameterIndex;
}

 public  void setRemoved(EntityEnterpriseContext ctx) 
{
      getEntityState(ctx).setRemoved();
}

Marks the context as removed.

 public  void start() throws DeploymentException 
{
      for(int i = 0; i <  cmrFields.length; ++i)
      {
         cmrFields[i].start();
      }
}

The third phase of deployment. The method is called when relationships are already resolved.