Attachment #157311 for bug #298985

This Bugzilla instance is deprecated, and most Eclipse projects now use GitHub or Eclipse GitLab. Please see the deprecation plan for details.





//javase imports
import java.beans.PropertyChangeListener;
import java.util.Vector;

//java extension imports

//EclipseLink imports
import org.eclipse.persistence.descriptors.changetracking.ChangeTracker;
import org.eclipse.persistence.dynamic.DynamicEntity;

    }

    //PersistenceEntity API
    protected Object __pk;
    public Object _persistence_getId() {
    // perf. optimization - cache the __cacheKey and pkVector
    public CacheKey _persistence_getCacheKey() {
        return __cacheKey;
    }
    public void _persistence_setCacheKey(CacheKey cacheKey) {
        this.__cacheKey = cacheKey;
    }
    public Vector _persistence_getPKVector() {
        return __pk;
    }
    public void _persistence_setId(Object pk) {
        this.__pk = pk;
    }
    

        // this will print something like {Emp 10} or {Phone 234-5678 10}
        StringBuilder sb = new StringBuilder(20);
        sb.append('{');
        sb.append(__pk);
        if (__pk != null) {
            for (int i = 0; i < __pk.size(); i++) {
                sb.append(' ');
                sb.append(__pk.elementAt(i));
            }
        }
        sb.append('}');
        return sb.toString();
    }




            HashMap map1 = new HashMap(col1.size());
            HashMap map2 = new HashMap(col2.size());
            
            boolean simplePk = desc.getPrimaryKeyFields().size()==1;
            ObjectBuilder builder = desc.getObjectBuilder();
            Iterator it1 = col1.iterator();
            Iterator it2 = col2.iterator();

                Object obj2 = it2.next();
                Object pk1 = builder.extractPrimaryKeyFromObject(obj1, session);
                Object pk2 = builder.extractPrimaryKeyFromObject(obj2, session);
                if(simplePk) {
                    pk1 = ((Vector)pk1).firstElement();
                    pk2 = ((Vector)pk2).firstElement();
                }
                map1.put(pk1, obj1);
                map2.put(pk2, obj2);
            }

Lines 50-58 Link Here

(-)foundation/eclipselink.core.test/src/org/eclipse/persistence/testing/tests/interfaces/PostCommitEventPrimaryKeyTest.java (-2 / +2 lines)
50	UnitOfWorkChangeSet uowChangeSet = uow.getUnitOfWorkChangeSet();	50	UnitOfWorkChangeSet uowChangeSet = uow.getUnitOfWorkChangeSet();
51	for (Iterator changes = uowChangeSet.getAllChangeSets().keySet().iterator(); changes.hasNext(); ) {	51	for (Iterator changes = uowChangeSet.getAllChangeSets().keySet().iterator(); changes.hasNext(); ) {
52	ObjectChangeSet objChangeSet = (ObjectChangeSet)changes.next();	52	ObjectChangeSet objChangeSet = (ObjectChangeSet)changes.next();
53	Vector objKey = objChangeSet.getPrimaryKeys();	53	Object objKey = objChangeSet.getId();
54		54
55	if (objKey == null \|\| objKey.isEmpty()) {	55	if (objKey == null) {
56	emptyKey = true;	56	emptyKey = true;
57	}	57	}
58	}	58	}

Lines 54-60 Link Here

(-)foundation/eclipselink.core.test/src/org/eclipse/persistence/testing/tests/optimisticlocking/ChangeSetOptimisticLockingUpdateTest.java (-1 / +1 lines)
54	ObjectChangeSet changeSet = (ObjectChangeSet)uow.getUnitOfWorkChangeSet().getObjectChangeSetForClone(originalObject);	54	ObjectChangeSet changeSet = (ObjectChangeSet)uow.getUnitOfWorkChangeSet().getObjectChangeSetForClone(originalObject);
55	Object lockValue =	55	Object lockValue =
56	getSession().getDescriptor(domainClass).getOptimisticLockingPolicy().getWriteLockValue(originalObject,	56	getSession().getDescriptor(domainClass).getOptimisticLockingPolicy().getWriteLockValue(originalObject,
57	changeSet.getPrimaryKeys(),	57	changeSet.getId(),
58	(AbstractSession)getSession());	58	(AbstractSession)getSession());
59	if (lockValue instanceof Number){	59	if (lockValue instanceof Number){
60	if (((Number)changeSet.getWriteLockValue()).longValue() !=((Number)lockValue).longValue()) {	60	if (((Number)changeSet.getWriteLockValue()).longValue() !=((Number)lockValue).longValue()) {

Lines 59-65 Link Here

(-)foundation/eclipselink.core.test/src/org/eclipse/persistence/testing/tests/performance/emulateddb/EmulatedDriver.java (-1 / +1 lines)
59	return null;	59	return null;
60	}	60	}
61	if (connection == null) {	61	if (connection == null) {
62	connection = new EmulatedConnection(DriverManager.getConnection(url.substring("emulate:".length() + 1, url.length()), info));	62	connection = new EmulatedConnection(DriverManager.getConnection(url.substring("emulate:".length(), url.length()), info));
63	}	63	}
64	return connection;	64	return connection;
65	}	65	}




 ******************************************************************************/  
package org.eclipse.persistence.testing.tests.queries;

import java.util.*;
import org.eclipse.persistence.descriptors.*;
import org.eclipse.persistence.testing.models.employee.domain.*;
import org.eclipse.persistence.exceptions.*;

    public Object unwrapObject(Object proxy, AbstractSession session) {
        if (proxy instanceof WrappedEmployee) {
            timesUnwrapCalled++;
            Object primaryKey = ((WrappedEmployee)proxy).getId();
            return session.getIdentityMapAccessor().getFromIdentityMap(primaryKey, Employee.class);
            return session.getIdentityMapAccessor().getFromIdentityMap((Object)primaryKey, Employee.class);
        } else {
            return proxy;
        }




        queryReadObject_1_ByObject.setReferenceClass(Employee.class);
        queryReadObject_1_ByObject.conformResultsInUnitOfWork();
        queryReadObject_1_ByObject.setSelectionObject(emp1);
        Employee result = (Employee)uow.executeQuery(queryReadObject_1_ByObject);
        if (emp1 != result) {
            errorMsg += "queryReadObject_1_ByObject: emp1; ";
        }

        ReadObjectQuery queryReadObject_1_ByKey = new ReadObjectQuery();
        queryReadObject_1_ByKey.setReferenceClass(Employee.class);
        queryReadObject_1_ByKey.conformResultsInUnitOfWork();
        queryReadObject_1_ByKey.setSelectionId(emp1.getId());
        result = (Employee)uow.executeQuery(queryReadObject_1_ByKey);
        if (emp1 != result) {
        if(emp1 != uow.executeQuery(queryReadObject_1_ByKey)) {
            errorMsg += "queryReadObject_1_ByKey: emp1; ";
        }






import java.util.ArrayList;
import java.util.List;
import java.util.Vector;

import org.eclipse.persistence.expressions.Expression;
import org.eclipse.persistence.expressions.ExpressionBuilder;

            uow.registerObject(employee);
            uow.commit();
            
            version[0] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, manager.getId(), getAbstractSession())).longValue();
            pk.add(manager.getId());
            
            version[0] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, pk, getAbstractSession())).longValue();
            
            // test1 - add managed employee, manager's version should increment.
            uow = getSession().acquireUnitOfWork();
            Employee managerClone = (Employee)uow.registerObject(manager);
            Employee employeeClone = (Employee)uow.registerObject(employee);
            managerClone.addManagedEmployee(employeeClone);
            uow.commit();
            version[1] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, manager.getId(), getAbstractSession())).longValue();
            
            // test2 - alter managed employee, manager's version should NOT increment.
            uow = getSession().acquireUnitOfWork();
            employeeClone = (Employee)uow.registerObject(employee);
            employeeClone.setFirstName("Altered");
            uow.commit();
            version[2] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, manager.getId(), getAbstractSession())).longValue();
            
            // test3- remove managed employee, manager's version should increment.
            uow = getSession().acquireUnitOfWork();

            employeeClone = (Employee)uow.registerObject(employee);
            managerClone.removeManagedEmployee(employeeClone);
            uow.commit();
            version[3] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, manager.getId(), getAbstractSession())).longValue();
            
            PhoneNumber phone = new PhoneNumber("home", "613", "1111111");
            

            PhoneNumber phoneClone = (PhoneNumber)uow.registerObject(phone);
            managerClone.addPhoneNumber(phoneClone);
            uow.commit();
            version[4] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, manager.getId(), getAbstractSession())).longValue();
            
            // test5- alter phone, manager's version should increment.
            uow = getSession().acquireUnitOfWork();
            phoneClone = (PhoneNumber)uow.registerObject(phone);
            phoneClone.setType("work");
            uow.commit();
            version[5] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, manager.getId(), getAbstractSession())).longValue();
            
            // test6- remove phone, manager's version should increment.
            uow = getSession().acquireUnitOfWork();

            phoneClone = (PhoneNumber)uow.registerObject(phone);
            managerClone.removePhoneNumber(phoneClone);
            uow.commit();
            version[6] = ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(manager, manager.getId(), getAbstractSession())).longValue();
        }
        public void verify() {
            int numTestsFailed = 0;

        public TargetLockingTest() {
            super();
        }
        long getVersion(Employee emp) {            
            return ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(emp, emp.getId(), getAbstractSession())).longValue();
            pk.add(emp.getId());
            
            return ((Long)getSession().getDescriptor(Employee.class).getOptimisticLockingPolicy().getWriteLockValue(emp, pk, getAbstractSession())).longValue();
        }
        public void reset() {
            UnitOfWork uow = getSession().acquireUnitOfWork();




    </xsd:restriction>
  </xsd:simpleType>

  <xsd:simpleType name="cache-key-type">
    <xsd:annotation>
      <xsd:documentation>
            
            /**
             * Configures what type of Id value is used to store the object in the cache.
             * This can either be the basic Id value for simple singleton Ids,
             * or an optimized CacheKey type.
             * 
             * @see PrimaryKey#cacheKeyType()
             * @see ClassDescriptor#setCacheKeyType(CacheKeyType)
             * @author James Sutherland
             * @since EclipseLink 2.1
             */
            public enum CacheKeyType {
                /**
                 * This can only be used for simple singleton Ids, such as long/int/String.
                 * This is the default for simple singleton Ids.
                 */
                ID_VALUE,
            
                /**
                 * Optimized cache key type that allows composite and complex values.
                 * This is the default for composite or complex Ids.
                 */
                CACHE_KEY,
            
                /**
                 * The cache key type is automatically configured depending on what is optimal for the class.
                 */
                AUTO
            }

      </xsd:documentation>
    </xsd:annotation>

    <xsd:restriction base="xsd:token">
      <xsd:enumeration value="ID_VALUE"/>
      <xsd:enumeration value="CACHE_KEY"/>
      <xsd:enumeration value="AUTO"/>
    </xsd:restriction>
  </xsd:simpleType>
  
  <!-- **************************************************** -->

  <xsd:complexType name="inheritance">

          IdValidation validation() default IdValidation.ZERO; 

          /**
           * (Optional) Configures what cache key type is used to store the object in the cache.
           * By default the type is determined by what type is optimal for the class.
           */
          CacheKeyType cacheKeyType() default CacheKeyType.AUTO;
    
          /**
           * (Optional) Used to specify the primary key columns directly.
           * This can be used instead of @Id if the primary key includes a non basic field,
           * such as a foreign key, or a inheritance discriminator, embedded, or transformation mapped field.

      </xsd:documentation>
    </xsd:annotation>
    <xsd:sequence>
      <xsd:element name="column" type="orm:column" minOccurs="0" maxOccurs="unbounded"/>
    </xsd:sequence>
    <xsd:attribute name="validation" type="orm:id-validation"/>
    <xsd:attribute name="cache-key-type" type="orm:cache-key-type"/>
  </xsd:complexType>

  <!-- **************************************************** -->




/*******************************************************************************
 * Copyright (c) 1998, 2010 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     James Sutherland - allow for zero ids
 ******************************************************************************/
package org.eclipse.persistence.annotations;

import org.eclipse.persistence.descriptors.ClassDescriptor;

/**
 * Configures what type of Id value is used to store the object in the cache.
 * This can either be the basic Id value for simple singleton Ids,
 * or an optimized CacheId type.
 * 
 * @see PrimaryKey#cacheKeyType()
 * @see ClassDescriptor#setCacheKeyType(CacheKeyType)
 * @author James Sutherland
 * @since EclipseLink 2.1
 */
public enum CacheKeyType {
    /**
     * This can only be used for simple singleton Ids, such as long/int/String.
     * This is the default for simple singleton Ids.
     */
    ID_VALUE,

    /**
     * Optimized cache key type that allows composite and complex values.
     * This is the default for composite or complex Ids.
     */
    CACHE_ID,

    /**
     * The cache key type is automatically configured depending on what is optimal for the class.
     */
    AUTO
}

Lines 35-43 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/annotations/PrimaryKey.java (-1 / +7 lines)
35	* (Optional) Configures what id validation is done.	35	* (Optional) Configures what id validation is done.
36	* By default 0 is not a valid id value, this can be used to allow 0 id values.	36	* By default 0 is not a valid id value, this can be used to allow 0 id values.
37	*/	37	*/
38	IdValidation validation() default IdValidation.ZERO;	38	IdValidation validation() default IdValidation.ZERO;
39		39
40	/**	40	/**
		41	* (Optional) Configures what cache key type is used to store the object in the cache.
		42	* By default the type is determined by what type is optimal for the class.
		43	*/
		44	CacheKeyType cacheKeyType() default CacheKeyType.AUTO;
		45
		46	/**
41	* (Optional) Used to specify the primary key columns directly.	47	* (Optional) Used to specify the primary key columns directly.
42	* This can be used instead of @Id if the primary key includes a non basic field,	48	* This can be used instead of @Id if the primary key includes a non basic field,
43	* such as a foreign key, or a inheritance discriminator, embedded, or transformation mapped field.	49	* such as a foreign key, or a inheritance discriminator, embedded, or transformation mapped field.

Lines 87-93 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/changetracking/AttributeChangeTrackingPolicy.java (-1 / +1 lines)
87	}	87	}
88		88
89	// The following code deals with reads that force changes to the flag associated with optimistic locking.	89	// The following code deals with reads that force changes to the flag associated with optimistic locking.
90	if ((descriptor.usesOptimisticLocking()) && (changes.getPrimaryKeys() != null)) {	90	if ((descriptor.usesOptimisticLocking()) && (changes.getId() != null)) {
91	changes.setOptimisticLockingPolicyAndInitialWriteLockValue(descriptor.getOptimisticLockingPolicy(), session);	91	changes.setOptimisticLockingPolicyAndInitialWriteLockValue(descriptor.getOptimisticLockingPolicy(), session);
92	}	92	}
93		93

Lines 101-107 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/changetracking/DeferredChangeDetectionPolicy.java (-2 / +2 lines)
101	}	101	}
102	}	102	}
103	//Check if the user set the PK to null and throw an exception (bug# 4569755)	103	//Check if the user set the PK to null and throw an exception (bug# 4569755)
104	if (changes.getPrimaryKeys() == null && !isNew && !changes.isAggregate()) {	104	if (changes.getId() == null && !isNew && !changes.isAggregate()) {
105	if(!(unitOfWork.isNestedUnitOfWork()) \|\| (unitOfWork.isNestedUnitOfWork() && !((UnitOfWorkImpl)unitOfWork.getParent()).isObjectNew(backUp))) {	105	if(!(unitOfWork.isNestedUnitOfWork()) \|\| (unitOfWork.isNestedUnitOfWork() && !((UnitOfWorkImpl)unitOfWork.getParent()).isObjectNew(backUp))) {
106	throw ValidationException.nullPrimaryKeyInUnitOfWorkClone(clone);	106	throw ValidationException.nullPrimaryKeyInUnitOfWorkClone(clone);
107	}	107	}
Lines 145-151 Link Here
145	ObjectChangeSet changes = builder.createObjectChangeSet(clone, changeSet, isNew, true, session);	145	ObjectChangeSet changes = builder.createObjectChangeSet(clone, changeSet, isNew, true, session);
146		146
147	// The following code deals with reads that force changes to the flag associated with optimistic locking.	147	// The following code deals with reads that force changes to the flag associated with optimistic locking.
148	if ((descriptor.usesOptimisticLocking()) && (changes.getPrimaryKeys() != null)) {	148	if ((descriptor.usesOptimisticLocking()) && (changes.getId() != null)) {
149	changes.setOptimisticLockingPolicyAndInitialWriteLockValue(descriptor.getOptimisticLockingPolicy(), session);	149	changes.setOptimisticLockingPolicyAndInitialWriteLockValue(descriptor.getOptimisticLockingPolicy(), session);
150	}	150	}
151		151

Lines 22-27 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/ClassDescriptor.java (-19 / +43 lines)
22	import java.lang.reflect.*;	22	import java.lang.reflect.*;
23		23
24	import org.eclipse.persistence.internal.descriptors.*;	24	import org.eclipse.persistence.internal.descriptors.*;
		25	import org.eclipse.persistence.internal.oxm.XMLObjectBuilder;
25	import org.eclipse.persistence.internal.sessions.AbstractRecord;	26	import org.eclipse.persistence.internal.sessions.AbstractRecord;
26	import org.eclipse.persistence.sequencing.Sequence;	27	import org.eclipse.persistence.sequencing.Sequence;
27	import org.eclipse.persistence.sessions.Project;	28	import org.eclipse.persistence.sessions.Project;
Lines 39-44 Link Here
39	import org.eclipse.persistence.internal.databaseaccess.*;	40	import org.eclipse.persistence.internal.databaseaccess.*;
40	import org.eclipse.persistence.exceptions.*;	41	import org.eclipse.persistence.exceptions.*;
41	import org.eclipse.persistence.sessions.remote.*;	42	import org.eclipse.persistence.sessions.remote.*;
		43	import org.eclipse.persistence.annotations.CacheKeyType;
42	import org.eclipse.persistence.annotations.IdValidation;	44	import org.eclipse.persistence.annotations.IdValidation;
43	import org.eclipse.persistence.descriptors.copying.*;	45	import org.eclipse.persistence.descriptors.copying.*;
44	import org.eclipse.persistence.descriptors.changetracking.*;	46	import org.eclipse.persistence.descriptors.changetracking.*;
Lines 180-185 Link Here
180	/** Allow zero primary key validation to be configured. */	182	/** Allow zero primary key validation to be configured. */
181	protected IdValidation idValidation;	183	protected IdValidation idValidation;
182		184
		185	/** Allow cache key type to be configured. */
		186	protected CacheKeyType cacheKeyType;
		187
183	// JPA 2.0 Derived identities - map of mappings that act as derived ids	188	// JPA 2.0 Derived identities - map of mappings that act as derived ids
184	protected Map<String, DatabaseMapping> derivesIdMappings;	189	protected Map<String, DatabaseMapping> derivesIdMappings;
185		190
Lines 844-853 Link Here
844	if (!this.isAggregateDescriptor()) {	849	if (!this.isAggregateDescriptor()) {
845	session.getIntegrityChecker().handleError(DescriptorException.referenceDescriptorIsNotAggregate(this.getJavaClass().getName(), mapping));	850	session.getIntegrityChecker().handleError(DescriptorException.referenceDescriptorIsNotAggregate(this.getJavaClass().getName(), mapping));
846	}	851	}
847	for (Enumeration stream = this.getInheritancePolicy().getChildDescriptors().elements();	852	for (ClassDescriptor childDescriptor : this.getInheritancePolicy().getChildDescriptors()) {
848	stream.hasMoreElements();) {
849	ClassDescriptor childDescriptor = (ClassDescriptor)stream.nextElement();
850
851	// recurse down the inheritance tree to its leaves	853	// recurse down the inheritance tree to its leaves
852	childDescriptor.checkInheritanceTreeAggregateSettingsForChildren(session, mapping);	854	childDescriptor.checkInheritanceTreeAggregateSettingsForChildren(session, mapping);
853	}	855	}
Lines 3183-3198 Link Here
3183	// Make sure that child is post initialized,	3185	// Make sure that child is post initialized,
3184	// this initialize bottom up, unlike the two other phases that to top down.	3186	// this initialize bottom up, unlike the two other phases that to top down.
3185	if (hasInheritance()) {	3187	if (hasInheritance()) {
3186	for (Enumeration childEnum = getInheritancePolicy().getChildDescriptors().elements();	3188	for (ClassDescriptor child : getInheritancePolicy().getChildDescriptors()) {
3187	childEnum.hasMoreElements();) {	3189	child.postInitialize(session);
3188	((ClassDescriptor)childEnum.nextElement()).postInitialize(session);
3189	}	3190	}
3190	}	3191	}
3191		3192
3192	// Allow mapping to perform post initialization.	3193	// Allow mapping to perform post initialization.
3193	for (Enumeration mappingsEnum = getMappings().elements(); mappingsEnum.hasMoreElements();) {	3194	for (DatabaseMapping mapping : getMappings()) {
3194	DatabaseMapping mapping = (DatabaseMapping)mappingsEnum.nextElement();
3195
3196	// This causes post init to be called multiple times in inheritance.	3195	// This causes post init to be called multiple times in inheritance.
3197	mapping.postInitialize(session);	3196	mapping.postInitialize(session);
3198	// PERF: computed if deferred locking is required.	3197	// PERF: computed if deferred locking is required.
Lines 3235-3240 Link Here
3235	}	3234	}
3236	}	3235	}
3237	field.setIndex(index);	3236	field.setIndex(index);
		3237	}
		3238	// Set cache key type.
		3239	if (getCacheKeyType() == null) {
		3240	if ((getPrimaryKeyFields().size() > 1) \|\| (getObjectBuilder() instanceof XMLObjectBuilder)) {
		3241	setCacheKeyType(CacheKeyType.CACHE_ID);
		3242	} else if (getPrimaryKeyFields().size() == 1) {
		3243	Class type = getObjectBuilder().getFieldClassification(getPrimaryKeyFields().get(0));
		3244	if ((type == null) \|\| type.isArray()) {
		3245	setCacheKeyType(CacheKeyType.CACHE_ID);
		3246	} else {
		3247	setCacheKeyType(CacheKeyType.ID_VALUE);
		3248	}
		3249	} else {
		3250	setCacheKeyType(CacheKeyType.CACHE_ID);
		3251	}
3238	}	3252	}
3239	getObjectBuilder().postInitialize(session);	3253	getObjectBuilder().postInitialize(session);
3240		3254
Lines 3311-3319 Link Here
3311	}	3325	}
3312		3326
3313	// Allow mapping pre init, must be done before validate.	3327	// Allow mapping pre init, must be done before validate.
3314	for (Enumeration mappingsEnum = getMappings().elements(); mappingsEnum.hasMoreElements();) {	3328	for (DatabaseMapping mapping : getMappings()) {
3315	try {	3329	try {
3316	DatabaseMapping mapping = (DatabaseMapping)mappingsEnum.nextElement();
3317	mapping.preInitialize(session);	3330	mapping.preInitialize(session);
3318	} catch (DescriptorException exception) {	3331	} catch (DescriptorException exception) {
3319	session.getIntegrityChecker().handleError(exception);	3332	session.getIntegrityChecker().handleError(exception);
Lines 3445-3457 Link Here
3445	}	3458	}
3446	getObjectBuilder().initializeJoinedAttributes();	3459	getObjectBuilder().initializeJoinedAttributes();
3447	if (hasInheritance()) {	3460	if (hasInheritance()) {
3448	Vector children = getInheritancePolicy().getChildDescriptors();	3461	for (ClassDescriptor child : getInheritancePolicy().getChildDescriptors()) {
3449	// use indices to avoid synchronization problems.	3462	child.reInitializeJoinedAttributes();
3450	for (int i = 0; i < children.size(); i++) {
3451	// Bug 6001198 - Child descriptors collection contains descriptors
3452	// also use 'i' indice, in order to correctly iterate
3453	ClassDescriptor child = (ClassDescriptor)children.elementAt(i);
3454	child.reInitializeJoinedAttributes();
3455	}	3463	}
3456	}	3464	}
3457	}	3465	}
Lines 5427-5432 Link Here
5427	}	5435	}
5428		5436
5429	/**	5437	/**
		5438	* ADVANCED:
		5439	* Set what cache key type to use to store the object in the cache.
		5440	*/
		5441	public void setCacheKeyType(CacheKeyType cacheKeyType) {
		5442	this.cacheKeyType = cacheKeyType;
		5443	}
		5444
		5445	/**
		5446	* ADVANCED:
		5447	* Return what cache key type to use to store the object in the cache.
		5448	*/
		5449	public CacheKeyType getCacheKeyType() {
		5450	return cacheKeyType;
		5451	}
		5452
		5453	/**
5430	* A Default Query Redirector will be applied to any executing object query	5454	* A Default Query Redirector will be applied to any executing object query
5431	* that does not have a more precise default (like the default	5455	* that does not have a more precise default (like the default
5432	* ReadObjectQuery Redirector) or a redirector set directly on the query.	5456	* ReadObjectQuery Redirector) or a redirector set directly on the query.

Lines 13-21 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/CMPPolicy.java (-12 / +19 lines)
13	package org.eclipse.persistence.descriptors;	13	package org.eclipse.persistence.descriptors;
14		14
15	import java.io.Serializable;	15	import java.io.Serializable;
		16	import java.util.ArrayList;
		17	import java.util.Arrays;
16	import java.util.HashSet;	18	import java.util.HashSet;
		19	import java.util.List;
17	import java.util.Set;	20	import java.util.Set;
18	import java.util.Vector;
19		21
20	import org.eclipse.persistence.exceptions.DescriptorException;	22	import org.eclipse.persistence.exceptions.DescriptorException;
21	import org.eclipse.persistence.mappings.DatabaseMapping;	23	import org.eclipse.persistence.mappings.DatabaseMapping;
Lines 25-30 Link Here
25	import org.eclipse.persistence.queries.UpdateObjectQuery;	27	import org.eclipse.persistence.queries.UpdateObjectQuery;
26	import org.eclipse.persistence.internal.descriptors.ObjectBuilder;	28	import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
27	import org.eclipse.persistence.internal.helper.DatabaseField;	29	import org.eclipse.persistence.internal.helper.DatabaseField;
		30	import org.eclipse.persistence.internal.identitymaps.CacheId;
28	import org.eclipse.persistence.internal.sessions.AbstractSession;	31	import org.eclipse.persistence.internal.sessions.AbstractSession;
29		32
30	/**	33	/**
Lines 295-313 Link Here
295	public Object createPrimaryKeyInstanceFromId(Object key, AbstractSession session) {	298	public Object createPrimaryKeyInstanceFromId(Object key, AbstractSession session) {
296	Object keyInstance = null;	299	Object keyInstance = null;
297	KeyElementAccessor[] pkElementArray = this.getKeyClassFields(getPKClass());	300	KeyElementAccessor[] pkElementArray = this.getKeyClassFields(getPKClass());
298	if (pkElementArray.length == 1 && pkElementArray[0] instanceof KeyIsElementAccessor) {	301	List primaryKeyValues;
		302	if (key instanceof CacheId) {
		303	primaryKeyValues = new ArrayList(Arrays.asList(((CacheId)key).getPrimaryKey()));
		304	} else {
		305	primaryKeyValues = new ArrayList(1);
		306	primaryKeyValues.add(key);
		307	}
		308	if ((pkElementArray.length == 1) && (pkElementArray[0] instanceof KeyIsElementAccessor)) {
299	DatabaseMapping mapping = getDescriptor().getObjectBuilder().getMappingForAttributeName(pkElementArray[0].getAttributeName());	309	DatabaseMapping mapping = getDescriptor().getObjectBuilder().getMappingForAttributeName(pkElementArray[0].getAttributeName());
300	if (mapping.isDirectToFieldMapping()) {	310	if (mapping.isDirectToFieldMapping()) {
301	Converter converter = ((DirectToFieldMapping) mapping).getConverter();	311	Converter converter = ((DirectToFieldMapping) mapping).getConverter();
302	if (converter != null){	312	if (converter != null){
303	return converter.convertDataValueToObjectValue(((Vector)key).get(0), session);	313	return converter.convertDataValueToObjectValue(primaryKeyValues.get(0), session);
304	}	314	}
305	keyInstance = ((Vector)key).get(0);	315	keyInstance = primaryKeyValues.get(0);
306	} else if (mapping.isObjectReferenceMapping()) { // what if mapping comes from derived ID. need to get the derived mapping.	316	} else if (mapping.isObjectReferenceMapping()) { // what if mapping comes from derived ID. need to get the derived mapping.
307	//get reference descriptor and extract pk from target cmp policy	317	//get reference descriptor and extract pk from target cmp policy
308	keyInstance = mapping.getReferenceDescriptor().getCMPPolicy().createPrimaryKeyInstanceFromId(key, session);	318	keyInstance = mapping.getReferenceDescriptor().getCMPPolicy().createPrimaryKeyInstanceFromId(key, session);
309	}	319	}
310	((Vector)key).remove(0); // remove processed key incase keys are complex and derrived	320	primaryKeyValues.remove(0); // remove processed key incase keys are complex and derrived
311	} else {	321	} else {
312	keyInstance = getPKClassInstance();	322	keyInstance = getPKClassInstance();
313	//get clone of Key so we can remove values.	323	//get clone of Key so we can remove values.
Lines 316-327 Link Here
316	DatabaseMapping mapping = getDescriptor().getObjectBuilder().getMappingForAttributeName(accessor.getAttributeName());	326	DatabaseMapping mapping = getDescriptor().getObjectBuilder().getMappingForAttributeName(accessor.getAttributeName());
317	Object fieldValue = null;	327	Object fieldValue = null;
318	if (mapping.isDirectToFieldMapping()) {	328	if (mapping.isDirectToFieldMapping()) {
319	fieldValue = ((Vector)key).get(0);	329	fieldValue = primaryKeyValues.get(0);
320	Converter converter = ((DirectToFieldMapping) mapping).getConverter();	330	Converter converter = ((DirectToFieldMapping) mapping).getConverter();
321	if (converter != null){	331	if (converter != null){
322	fieldValue = converter.convertDataValueToObjectValue(fieldValue, session);	332	fieldValue = converter.convertDataValueToObjectValue(fieldValue, session);
323	}	333	}
324	((Vector)key).remove(0);	334	primaryKeyValues.remove(0);
325	} else if (mapping.isObjectReferenceMapping()) { // what if mapping comes from derived ID. need to get the derived mapping.	335	} else if (mapping.isObjectReferenceMapping()) { // what if mapping comes from derived ID. need to get the derived mapping.
326	//get reference descriptor and extract pk from target cmp policy	336	//get reference descriptor and extract pk from target cmp policy
327	fieldValue = mapping.getReferenceDescriptor().getCMPPolicy().createPrimaryKeyInstanceFromId(key, session);	337	fieldValue = mapping.getReferenceDescriptor().getCMPPolicy().createPrimaryKeyInstanceFromId(key, session);
Lines 397-411 Link Here
397		407
398	/**	408	/**
399	* INTERNAL:	409	* INTERNAL:
400	* Use the key to create a EclipseLink primary key Vector.	410	* Use the key to create a EclipseLink primary key.
401	* If the key is simple (direct mapped) then just add it to a vector,	411	* If the key is simple (direct mapped) then just add it to a vector,
402	* otherwise must go through the inefficient process of copying the key into the bean	412	* otherwise must go through the inefficient process of copying the key into the bean
403	* and extracting the key from the bean.	413	* and extracting the key from the bean.
404	*
405	* @param key Object the primary key to use for creating the vector
406	* @return Vector
407	*/	414	*/
408	public Vector createPkVectorFromKey(Object key, AbstractSession session) {	415	public Object createPrimaryKeyFromId(Object key, AbstractSession session) {
409	// TODO fix this exception so that it is more descriptive	416	// TODO fix this exception so that it is more descriptive
410	// This method only works in CMP3Policy but was added here for separation	417	// This method only works in CMP3Policy but was added here for separation
411	// of components	418	// of components

Lines 334-339 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/DescriptorEvent.java (+1 lines)
334	}	334	}
335	if (eventChangeSet != null) {	335	if (eventChangeSet != null) {
336	eventChangeSet.removeChange(attributeName);	336	eventChangeSet.removeChange(attributeName);
		337	// TODO: Can't see this working with attribute change tracking with no backup clone.
337	eventChangeSet.addChange(mapping.compareForChange(clone, ((UnitOfWorkImpl)getSession()).getBackupClone(clone, getDescriptor()), eventChangeSet, getSession()));	338	eventChangeSet.addChange(mapping.compareForChange(clone, ((UnitOfWorkImpl)getSession()).getBackupClone(clone, getDescriptor()), eventChangeSet, getSession()));
338	eventChangeSet.setShouldRecalculateAfterUpdateEvent(false);	339	eventChangeSet.setShouldRecalculateAfterUpdateEvent(false);
339	}	340	}




    protected Class parentClass;
    protected String parentClassName;
    protected ClassDescriptor parentDescriptor;
    protected List<ClassDescriptor> childDescriptors;
    protected transient DatabaseField classIndicatorField;
    protected transient Map classIndicatorMapping;
    protected transient Map classNameIndicatorMapping;

    protected transient Boolean shouldReadSubclasses;
    protected transient boolean hasMultipleTableChild;
    protected transient DatabaseTable readAllSubclassesView;
    protected transient List<Object> allChildClassIndicators;
    protected transient Expression onlyInstancesExpression;
    protected transient Expression withAllSubclassesExpression;
    // null if there are no childrenTables, otherwise all tables for reference class plus childrenTables
    protected transient Vector allTables;
    // all tables for all subclasses (subclasses of subclasses included), should be in sync with childrenTablesJoinExpressions.
    protected transient List<DatabaseTable> childrenTables;
    // join expression for each child table, keyed by the table, should be in sync with childrenTables.
    protected transient Map<DatabaseTable, Expression> childrenTablesJoinExpressions;
    // all expressions from childrenTablesJoinExpressions ANDed together
    protected transient Expression childrenJoinExpression;


        this.classIndicatorMapping = new HashMap(10);
        this.classNameIndicatorMapping = new HashMap(10);
        this.shouldUseClassNameAsIndicator = false;
        this.allChildClassIndicators = new ArrayList(4);
        this.childDescriptors = new ArrayList(4);
        this.setJoinedStrategy();
    }


     * Add child descriptor to the parent descriptor.
     */
    public void addChildDescriptor(ClassDescriptor childDescriptor) {
        getChildDescriptors().add(childDescriptor);
    }

    /**

     * are created simultaneously and kept in sync.
     */
    protected void addChildTableJoinExpression(DatabaseTable table, Expression expression) {
        if (this.childrenTablesJoinExpressions == null) {
            this.childrenTablesJoinExpressions = new HashMap();
           // childrenTables should've been null, too
            this.childrenTables = new ArrayList();
           // allTables should've been null, too
            this.allTables = new Vector(getDescriptor().getTables());
        }
        this.childrenTables.add(table);
        this.allTables.add(table);
        this.childrenTablesJoinExpressions.put(table, expression);
        this.childrenJoinExpression = expression.and(this.childrenJoinExpression);
    }

    /**


        if (parentDescriptor.getInheritancePolicy().isChildDescriptor()) {
            if (parentDescriptor.getInheritancePolicy().shouldReadSubclasses()) {
                parentDescriptor.getInheritancePolicy().getAllChildClassIndicators().add(indicator);
            }
            parentDescriptor.getInheritancePolicy().addClassIndicatorTypeToParent(indicator);
        }

     * Stores class indicators for all child and children's children.
     * Used for queries on branch classes only.
     */
    protected List<Object> getAllChildClassIndicators() {
        return allChildClassIndicators;
    }


     * subclasses.
     * Required for bug 3019934.
     */
    public List<ClassDescriptor> getAllChildDescriptors() {
        // Guess the number of child descriptors...
        List<ClassDescriptor> allChildDescriptors = new ArrayList(this.getAllChildClassIndicators().size());
        return getAllChildDescriptors(allChildDescriptors);
    }


     * INTERNAL:
     * Recursive subroutine of getAllChildDescriptors.
     */
    protected List<ClassDescriptor> getAllChildDescriptors(List<ClassDescriptor> allChildDescriptors) {
        for (ClassDescriptor childDescriptor : getChildDescriptors()) {
            allChildDescriptors.add(childDescriptor);
            allChildDescriptors.addElement(childDescriptor);
            childDescriptor.getInheritancePolicyOrNull().getAllChildDescriptors(allChildDescriptors);
        }
        return allChildDescriptors;

     * INTERNAL:
     * if reads subclasses, all tables for all read subclasses (indirect included).
     */
    public List<DatabaseTable> getChildrenTables() {
        return childrenTables;
    }
    

     * INTERNAL:
     * join expression for each child table, keyed by the table
     */
    public Map<DatabaseTable, Expression> getChildrenTablesJoinExpressions() {
        return childrenTablesJoinExpressions;
    }
    

     * all tables for reference class plus childrenTables
     */
    public Vector getAllTables() {
        if (allTables == null) {
            return this.getDescriptor().getTables();
        } else {
            return allTables;

     * Return all the immediate child descriptors.  Only descriptors from
     * direct subclasses are returned.
     */
    public List<ClassDescriptor> getChildDescriptors() {
        return childDescriptors;
    }



            if (getClassIndicatorValue() != null) {
                if (shouldReadSubclasses()) {
                    getAllChildClassIndicators().add(getClassIndicatorValue());
                }
                addClassIndicatorTypeToParent(getClassIndicatorValue());
            }

        }

        Vector tempChildren = new Vector(getChildDescriptors().size());
        for (ClassDescriptor childDescriptor : getChildDescriptors()) {
        while (childEnum.hasMoreElements()) {
            ClassDescriptor childDescriptor = (ClassDescriptor)childEnum.nextElement();
            if (session.hasCorrespondingDescriptor(childDescriptor)) {
                tempChildren.addElement(session.getDescriptor(childDescriptor.getJavaClass()));
            } else {

        }

        // Recursively collect all rows from all concrete children and their children.
        for (ClassDescriptor concreteDescriptor : getChildDescriptors()) {
                 childrenEnum.hasMoreElements();) {
            ClassDescriptor concreteDescriptor = (ClassDescriptor)childrenEnum.nextElement();
            Vector concreteRows = concreteDescriptor.getInheritancePolicy().selectAllRowUsingCustomMultipleTableSubclassRead(query);
            rows = Helper.concatenateVectors(rows, concreteRows);
        }

            AbstractRecord row = (AbstractRecord)rowsEnum.nextElement();
            Class concreteClass = classFromRow(row, query.getSession());
            if (!classes.contains(concreteClass)) {//Ensure unique ** we should do a distinct.. we do
                classes.add(concreteClass);
            }
        }


        }

        // Recursively collect all rows from all concrete children and their children.
        for (ClassDescriptor concreteDescriptor : getChildDescriptors()) {
                 childrenEnum.hasMoreElements();) {
            ClassDescriptor concreteDescriptor = (ClassDescriptor)childrenEnum.nextElement();
            AbstractRecord row = concreteDescriptor.getInheritancePolicy().selectOneRowUsingCustomMultipleTableSubclassRead(query);

            if (row != null) {
                return row;
            }

    /**
     * INTERNAL:
     */
    public void setChildDescriptors(List<ClassDescriptor> childDescriptors) {
        this.childDescriptors = childDescriptors;
    }

    /**

Lines 349-354 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/VersionLockingPolicy.java (+3 lines)
349	public Object getWriteLockValue(Object domainObject, Object primaryKey, AbstractSession session) {	349	public Object getWriteLockValue(Object domainObject, Object primaryKey, AbstractSession session) {
350	Number writeLockFieldValue;	350	Number writeLockFieldValue;
351	if (isStoredInCache()) {	351	if (isStoredInCache()) {
		352	if (primaryKey == null) {
		353	return null;
		354	}
352	writeLockFieldValue = (Number)session.getIdentityMapAccessorInstance().getWriteLockValue(primaryKey, domainObject.getClass(), getDescriptor());	355	writeLockFieldValue = (Number)session.getIdentityMapAccessorInstance().getWriteLockValue(primaryKey, domainObject.getClass(), getDescriptor());
353	} else {	356	} else {
354	writeLockFieldValue = (Number)lockValueFromObject(domainObject);	357	writeLockFieldValue = (Number)lockValueFromObject(domainObject);

Lines 387-394 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/eis/EISObjectPersistenceXMLProject.java (-2 / +2 lines)
387	Iterator iterator = associations.iterator();	387	Iterator iterator = associations.iterator();
388	while (iterator.hasNext()) {	388	while (iterator.hasNext()) {
389	Association association = (Association)iterator.next();	389	Association association = (Association)iterator.next();
390	mapping.getSourceToTargetKeyFields().put(association.getKey(), association.getValue());	390	mapping.getSourceToTargetKeyFields().put((DatabaseField)association.getKey(), (DatabaseField)association.getValue());
391	mapping.getTargetToSourceKeyFields().put(association.getValue(), association.getKey());	391	mapping.getTargetToSourceKeyFields().put((DatabaseField)association.getValue(), (DatabaseField)association.getKey());
392	}	392	}
393	}	393	}
394	});	394	});




import org.eclipse.persistence.expressions.Expression;
import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.indirection.EISOneToManyQueryBasedValueHolder;
import org.eclipse.persistence.oxm.XMLField;
import org.eclipse.persistence.internal.oxm.XPathEngine;

        Object primaryKey1 = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(element1, session);
        Object primaryKey2 = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(element2, session);

        if (!primaryKey1.equals(primaryKey2)) {
        CacheKey cacheKey2 = new CacheKey(primaryKey2);

        if (!cacheKey1.equals(cacheKey2)) {
            return false;
        }





import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.persistence.annotations.CacheKeyType;
import org.eclipse.persistence.exceptions.DatabaseException;
import org.eclipse.persistence.exceptions.DescriptorException;
import org.eclipse.persistence.expressions.Expression;
import org.eclipse.persistence.expressions.ExpressionBuilder;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.queries.JoinedAttributeManager;
import org.eclipse.persistence.internal.sessions.AbstractRecord;
import org.eclipse.persistence.internal.sessions.AbstractSession;

 * <p>An EIS one-to-one mapping is a reference mapping that represents the relationship between 
 * a single source object and a single mapped persistent Java object.  The source object usually 
 * contains a foreign key (pointer) to the target object (key on source); alternatively, the target 
 * object may contain a foreign key to the source object (key on target).  Because both the source 
 * and target objects use interactions, they must both be configured as root object types.  
 * 
 * <p><table border="1">

    protected Map sourceToTargetKeyFields;

    /** Maps the target primary/foreign key fields to the source foreign/primary key fields. */
    protected Map<DatabaseField, DatabaseField> targetToSourceKeyFields;

    /** These are used for non-unit of work modification to check if the value of the 1-1 was changed and a deletion is required. */
    protected boolean shouldVerifyDelete;

    /**
     * INTERNAL:
     */
    @Override
    public boolean isEISMapping() {
        return true;
    }

    /**
     * INTERNAL:
     */
    @Override
    public boolean isOneToOneMapping() {
        return true;
    }

    /**
     * PUBLIC:
     * Define the source foreign key relationship in the one-to-one mapping.
     * This method is used to add foreign key relationships to the mapping.
     * Both the source foreign key field name and the corresponding
     * target primary key field name must be specified.
     */
    public void addForeignKeyField(DatabaseField sourceForeignKeyField, DatabaseField targetKeyField) {
        getSourceToTargetKeyFields().put(sourceForeignKeyField, targetKeyField);
        getTargetToSourceKeyFields().put(targetKeyField, sourceForeignKeyField);

        getForeignKeyFields().add(sourceForeignKeyField);
        setIsForeignKeyRelationship(true);
    }

    /**

     * This methods clones all the fields and ensures that each collection refers to
     * the same clones.
     */
    @Override
    public Object clone() {
        EISOneToOneMapping clone = (EISOneToOneMapping)super.clone();
        clone.setForeignKeyFields(org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(getForeignKeyFields().size()));

        Iterator sourceKeyIterator = getSourceToTargetKeyFields().keySet().iterator();
        while (sourceKeyIterator.hasNext()) {
            DatabaseField sourceField = (DatabaseField)sourceKeyIterator.next();
            DatabaseField targetField = getSourceToTargetKeyFields().get(sourceField);

            DatabaseField targetClone = (DatabaseField)setOfFields.get(targetField);
            if (targetClone == null) {

        Iterator targetKeyIterator = getTargetToSourceKeyFields().keySet().iterator();
        while (targetKeyIterator.hasNext()) {
            DatabaseField targetField = (DatabaseField)targetKeyIterator.next();
            DatabaseField sourceField = getTargetToSourceKeyFields().get(targetField);

            DatabaseField targetClone = (DatabaseField)setOfFields.get(targetField);
            if (targetClone == null) {


    /**
     * INTERNAL:
     * Extract the foreign key value from the source row.
     */
    protected Vector extractForeignKeyFromRow(AbstractRecord row, AbstractSession session) {
        Vector key = new Vector();

        Iterator sourceKeyIterator = getSourceToTargetKeyFields().keySet().iterator();
        while (sourceKeyIterator.hasNext()) {
            DatabaseField field = (DatabaseField)sourceKeyIterator.next();
            Object value = row.get(field);

            // Must ensure the classification gets a cache hit.
            try {
                value = session.getDatasourcePlatform().getConversionManager().convertObject(value, getDescriptor().getObjectBuilder().getFieldClassification(field));
            } catch (ConversionException e) {
                throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
            }

            key.addElement(value);
        }

        return key;
    }

    /**
     * INTERNAL:
     * Extract the key value from the reference object.
     */
    protected Vector extractKeyFromReferenceObject(Object object, AbstractSession session) {
        Vector key = new Vector();

        Iterator sourceKeyIterator = getSourceToTargetKeyFields().keySet().iterator();
        while (sourceKeyIterator.hasNext()) {
            DatabaseField field = (DatabaseField)sourceKeyIterator.next();
            if (object == null) {
                key.addElement(null);
            } else {
                key.addElement(getReferenceDescriptor().getObjectBuilder().extractValueFromObjectForField(object, field, session));
            }
        }
        return key;
    }

    /**
     * INTERNAL:
     * Return the primary key for the reference object (i.e. the object
     * object referenced by domainObject and specified by mapping).
     * This key will be used by a RemoteValueHolder.
     */
    @Override
    public Object extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row) {
        List primaryKeyFields = getReferenceDescriptor().getPrimaryKeyFields();
        Object[] result = new  Object[primaryKeyFields.size()];
        for (int index = 0; index < primaryKeyFields.size(); index++) {
            DatabaseField targetKeyField = (DatabaseField)primaryKeyFields.get(index);
            DatabaseField sourceKeyField = getTargetToSourceKeyFields().get(targetKeyField);
            if (sourceKeyField == null) {
                return null;
            }
            result[index] = row.get(sourceKeyField);
            if (getReferenceDescriptor().getCacheKeyType() == CacheKeyType.ID_VALUE) {
                return result[index];
            }
        }
        return new CacheId(result);
    }

    /**
     * INTERNAL:
     * Initialize the mapping.
     */
    @Override
    public void initialize(AbstractSession session) throws DescriptorException {
        super.initialize(session);


        Iterator keyIterator = getSourceToTargetKeyFields().keySet().iterator();
        while (keyIterator.hasNext()) {
            DatabaseField foreignKey = (DatabaseField)keyIterator.next();
            DatabaseField targetKey = getSourceToTargetKeyFields().get(foreignKey);

            Expression expression = builder.getField(targetKey).equal(builder.getParameter(foreignKey));
            criteria = expression.and(getSelectionCriteria());

     * INTERNAL:
     * Reads the private owned object.
     */
    @Override
    protected Object readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery) throws DatabaseException {
        if (modifyQuery.getSession().isUnitOfWork()) {
            return getRealAttributeValueFromObject(modifyQuery.getBackupClone(), modifyQuery.getSession());

     * Return the value of the field from the row or a value holder on the query to obtain the object.
     * Check for batch + aggregation reading.
     */
    @Override
    public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery query, AbstractSession session) throws DatabaseException {
        // If any field in the foreign key is null then it means there are no referenced objects
        // Skip for partial objects as fk may not be present.

     * INTERNAL:
     * Get a value from the object and set that in the respective field of the row.
     */
    @Override
    public void writeFromObjectIntoRow(Object object, AbstractRecord Record, AbstractSession session) {
        if (isReadOnly() || (!isForeignKeyRelationship())) {
            return;


            for (int i = 0; i < getForeignKeyFields().size(); i++) {
                DatabaseField sourceKey = getForeignKeyFields().get(i);
                DatabaseField targetKey = getSourceToTargetKeyFields().get(sourceKey);

                Object referenceValue = null;


     * Return the classifiction for the field contained in the mapping.
     * This is used to convert the row value to a consistent java value.
     */
    @Override
    public Class getFieldClassification(DatabaseField fieldToClassify) throws DescriptorException {
        DatabaseField fieldInTarget = getSourceToTargetKeyFields().get(fieldToClassify);
        if (fieldInTarget == null) {
            return null;// Can be registered as multiple table secondary field mapping
        }

     * INTERNAL:
     * Gets the foreign key fields.
     */
    public Map<DatabaseField, DatabaseField> getSourceToTargetKeyFields() {
        return sourceToTargetKeyFields;
    }


     * INTERNAL:
     * Gets the target foreign key fields.
     */
    public Map<DatabaseField, DatabaseField> getTargetToSourceKeyFields() {
        return targetToSourceKeyFields;
    }


     * INTERNAL:
     * This method is not supported in an EIS environment.
     */
    @Override
    public void setSelectionSQLString(String sqlString) {
        throw DescriptorException.invalidMappingOperation(this, "setSelectionSQLString");
    }

     * INTERNAL:
     * This method is not supported in an EIS environment.
     */
    @Override
    public void setUsesBatchReading(boolean usesBatchReading) {
        if (usesBatchReading) {
            throw DescriptorException.invalidMappingOperation(this, "setUsesBatchReading");
        }
    }

    /**
     * INTERNAL:
     * This method is not supported in an EIS environment.
     */
    @Override
        throw DescriptorException.invalidMappingOperation(this, "shouldUseBatchReading");
    }

    /**
     * INTERNAL:
     * This method is not supported in an EIS environment.
     */
    public void useBatchReading() {
        throw DescriptorException.invalidMappingOperation(this, "useBatchReading");
    }

    /**
     * INTERNAL:
     * This method is not supported in an EIS environment.
     */
    public void dontUseBatchReading() {
        throw DescriptorException.invalidMappingOperation(this, "dontUseBatchReading");
    }

    /**
     * INTERNAL:
     * This method is not supported in an EIS environment.
     */
    public void addAscendingOrdering(String queryKeyName) {
        throw DescriptorException.invalidMappingOperation(this, "addAscendingOrdering");
    }

    /**
     * INTERNAL:
     * This method is not supported in an EIS environment.
     */
    public void addDescendingOrdering(String queryKeyName) {
        throw DescriptorException.invalidMappingOperation(this, "addDescendingOrdering");
    }
}




import java.sql.ResultSetMetaData;
import java.sql.SQLException;

import org.eclipse.persistence.annotations.CacheKeyType;
import org.eclipse.persistence.annotations.IdValidation;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.DescriptorEvent;

    public void clearPrimaryKey(Object object) {
        // PERF: If PersistenceEntity is caching the primary key this must be cleared as the primary key has changed.
        if (object instanceof PersistenceEntity) {
            ((PersistenceEntity)object)._persistence_setId(null);
            ((PersistenceEntity)object)._persistence_setCacheKey(null);
        }
    }


                }
                // PERF: Cache the primary key and cache key if implements PersistenceEntity.
                if (domainObject instanceof PersistenceEntity) {
                    ((PersistenceEntity)domainObject)._persistence_setId(primaryKey);
                    ((PersistenceEntity)domainObject)._persistence_setPKVector((Vector)primaryKey);
                }
            } else {
                if (query.isReadObjectQuery() && ((ReadObjectQuery)query).shouldLoadResultIntoSelectionObject()) {

     * Build the primary key expression from the specified primary key values.
     */
    public Expression buildPrimaryKeyExpressionFromKeys(Object primaryKey, AbstractSession session) {
        Expression expression = null;
        Expression subExpression;
        Expression builder = new ExpressionBuilder();
        List<DatabaseField> primaryKeyFields = this.descriptor.getPrimaryKeyFields();

        if (this.descriptor.getCacheKeyType() == CacheKeyType.ID_VALUE) {
            return builder.getField(primaryKeyFields.get(0)).equal(primaryKey);
        }
        Expression expression = null;
        int size = primaryKeyFields.size();
        Object[] primaryKeyValues = ((CacheId)primaryKey).getPrimaryKey();
        for (int index = 0; index < size; index++) {
            Object value = primaryKeyValues[index];
            DatabaseField field = primaryKeyFields.get(index);
            if (value != null) {
                Expression subExpression = builder.getField(field).equal(value);
                expression = subExpression.and(expression);
            }
        }

    /**
     * Build the row from the primary key values.
     */
    public AbstractRecord writeIntoRowFromPrimaryKeyValues(AbstractRecord row, Object primaryKey, AbstractSession session, boolean convert) {
        List<DatabaseField> primaryKeyFields = this.descriptor.getPrimaryKeyFields();
        if (this.descriptor.getCacheKeyType() == CacheKeyType.ID_VALUE) {
            DatabaseField field = primaryKeyFields.get(0);
            Object value = primaryKey;
            Object value = ((Vector)key).get(index);
            value = session.getPlatform(this.descriptor.getJavaClass()).getConversionManager().convertObject(value, field.getType());
            row.put(field, value);
            return row;
        }
        int size = primaryKeyFields.size();
        Object[] primaryKeyValues = ((CacheId)primaryKey).getPrimaryKey();
        for (int index = 0; index < size; index++) {
            DatabaseField field = primaryKeyFields.get(index);
            Object value = primaryKeyValues[index];
            value = session.getPlatform(this.descriptor.getJavaClass()).getConversionManager().convertObject(value, field.getType());
            row.put(field, value);
        }

        return row;
    }

    /**
     * Build the row from the primary key values.
     */
    public AbstractRecord buildRowFromPrimaryKeyValues(Object key, AbstractSession session) {
        AbstractRecord databaseRow = createRecord(this.descriptor.getPrimaryKeyFields().size(), session);
        return writeIntoRowFromPrimaryKeyValues(databaseRow, key, session, true);
    }

    /**
     * Build the row of all of the fields used for insertion.
     */
    public AbstractRecord buildTemplateInsertRow(AbstractSession session) {

            query.recordCloneForPessimisticLocking(workingClone, unitOfWork);
            // PERF: Cache the primary key if implements PersistenceEntity.
            if (workingClone instanceof PersistenceEntity) {
                ((PersistenceEntity)workingClone)._persistence_setId(primaryKey);
            }
        } finally {
            unitOfWorkCacheKey.release();            

    public Object buildObjectFromResultSet(ObjectBuildingQuery query, JoinedAttributeManager joinManager, ResultSet resultSet, AbstractSession executionSession, DatabaseAccessor accessor, ResultSetMetaData metaData, DatabasePlatform platform) throws SQLException {
        ClassDescriptor descriptor = this.descriptor;
        DatabaseMapping primaryKeyMapping = this.primaryKeyMappings.get(0);
        Object primaryKey = primaryKeyMapping.valueFromResultSet(resultSet, query, executionSession, accessor, metaData, 1, platform);
        Vector primaryKey = new NonSynchronizedVector(1);
        primaryKey.add(primaryKeyObject);

        UnitOfWorkImpl unitOfWork = null;
        AbstractSession session = executionSession;

                    }
                }
                
                primaryKeyMapping.setAttributeValueInObject(object, primaryKey);
                List mappings = descriptor.getMappings();            
                int size = mappings.size();
                for (int index = 1; index < size; index++) {

                    mapping.readFromResultSetIntoObject(resultSet, object, query, session, accessor, metaData, index + 1, platform);
                }
                
                ((PersistenceEntity)object)._persistence_setId(primaryKey);
                if ((unitOfWork != null) && isolated) {
                    ObjectChangePolicy policy = descriptor.getObjectChangePolicy();
                    policy.setChangeListener(object, unitOfWork, descriptor);

            if ((unitOfWork != null) && !isolated) {
                // Need to clone the object in the unit of work.
                Object clone = instantiateWorkingCopyClone(object, unitOfWork);
                ((PersistenceEntity)clone)._persistence_setId(cacheKey.getKey());
                unitOfWork.getCloneMapping().put(clone, clone);
                unitOfWork.getCloneToOriginals().put(clone, object);
                cacheKey.setObject(clone);

        ObjectChangeSet changes = (ObjectChangeSet)uowChangeSet.getObjectChangeSetForClone(clone);
        if (changes == null) {
            if (this.descriptor.isAggregateDescriptor()) {
                changes = new AggregateObjectChangeSet(new CacheId(new Object[0]), this.descriptor, clone, uowChangeSet, isNew);
            } else {
                changes = new ObjectChangeSet(extractPrimaryKeyFromObject(clone, session, true), this.descriptor, clone, uowChangeSet, isNew);
            }

                // If creating a new change set for a new object, the original change set (from change tracking) may have not had the primary key.
                Object primaryKey = extractPrimaryKeyFromObject(clone, session, true);
                if (primaryKey != null) {
                    changes.setId(primaryKey);
                }
            }
        }

            return null;
        }

        Object primaryKey = extractPrimaryKeyFromRow(primaryKeyRow, session);
        if ((primaryKey == null) && isValid) {
            return InvalidObject.instance;
        }
        return primaryKey;
    }

    /**

    public Object extractPrimaryKeyFromObject(Object domainObject, AbstractSession session, boolean shouldReturnNullIfNull) {
        boolean isPersistenceEntity = domainObject instanceof PersistenceEntity;
        if (isPersistenceEntity) {
            Object primaryKey = ((PersistenceEntity)domainObject)._persistence_getId();
            if (primaryKey != null) {
                return primaryKey;
            }
        }
        ClassDescriptor descriptor = this.descriptor;

        // Allow for inheritance, the concrete descriptor must always be used.
        if (descriptor.hasInheritance() && (domainObject.getClass() != descriptor.getJavaClass()) && (!domainObject.getClass().getSuperclass().equals(descriptor.getJavaClass()))) {
            return session.getDescriptor(domainObject).getObjectBuilder().extractPrimaryKeyFromObject(domainObject, session, shouldReturnNullIfNull);
        }
        
        IdValidation idValidation = descriptor.getIdValidation();
        CacheKeyType cacheKeyType = descriptor.getCacheKeyType();
        List<DatabaseField> primaryKeyFields = descriptor.getPrimaryKeyFields();        
        Object[] primaryKeyValues = null;
        if (cacheKeyType != CacheKeyType.ID_VALUE) {
            primaryKeyValues = new Object[primaryKeyFields.size()];
        }

        List<DatabaseMapping> mappings = getPrimaryKeyMappings();
        int size = mappings.size();
        // PERF: optimize simple case of direct mapped singleton primary key.
        if (descriptor.hasSimplePrimaryKey()) {
            // PERF: use index not enumeration.
            for (int index = 0; index < size; index++) {
                AbstractDirectMapping mapping = (AbstractDirectMapping)mappings.get(index);
                Object keyValue = mapping.valueFromObject(domainObject, primaryKeyFields.get(index), session);
                // Only check for 0 for singleton primary keys.
                if ((idValidation != IdValidation.NONE) && ((keyValue == null)
                            || ((idValidation == IdValidation.ZERO) && Helper.isEquivalentToNull(keyValue)))) {
                    if (shouldReturnNullIfNull) {
                        return null;
                        }
                        isNull = true;
                    }
                    isNull = true;
                }
                if (cacheKeyType == CacheKeyType.ID_VALUE) {
                    if (isPersistenceEntity && (!isNull)) {
                        ((PersistenceEntity)domainObject)._persistence_setId(keyValue);
                for (int index = 0; index < size; index++) {
                    DatabaseMapping mapping = (DatabaseMapping)mappings.get(index);
                    // Primary key mapping may be null for aggregate collection.
                    if (mapping != null) {
                        mapping.writeFromObjectIntoRow(domainObject, databaseRow, session);
                    }
                    return keyValue;
                } else {
                    primaryKeyValues[index] = keyValue;
                }
            }
        } else {
            AbstractRecord databaseRow = createRecordForPKExtraction(size, session);
            // PERF: use index not enumeration			
            for (int index = 0; index < size; index++) {
                DatabaseMapping mapping = mappings.get(index);
                // Primary key mapping may be null for aggregate collection.
                if (mapping != null) {
                    mapping.writeFromObjectIntoRow(domainObject, databaseRow, session);
                }
            }
            List<Class> primaryKeyClassifications = getPrimaryKeyClassifications();
            Platform platform = session.getPlatform(domainObject.getClass());
            // PERF: use index not enumeration
            for (int index = 0; index < size; index++) {
                // Ensure that the type extracted from the object is the same type as in the descriptor,
                // the main reason for this is that 1-1 can optimize on vh by getting from the row as the row-type.
                Class classification = primaryKeyClassifications.get(index);
                Object value = databaseRow.get(primaryKeyFields.get(index));
                // Only check for 0 for singleton primary keys.
                if ((idValidation != IdValidation.NONE) && ((value == null)
                        || ((idValidation == IdValidation.ZERO) && Helper.isEquivalentToNull(value)))) {
                    if (shouldReturnNullIfNull) {
                        return null;
                    }
                    isNull = true;
                    primaryKeyValues.add(platform.convertObject(value, classification));
                }
                value = platform.convertObject(value, classification);
                if (cacheKeyType == CacheKeyType.ID_VALUE) {
                    if (isPersistenceEntity && (!isNull)) {
                        ((PersistenceEntity)domainObject)._persistence_setId(value);
                    }
                    return value;
                } else {
                    primaryKeyValues[index] = value;
                }
            }
            if (isPersistenceEntity && (!isNull)) {
                ((PersistenceEntity)domainObject)._persistence_setPKVector(primaryKeyValues);
            }
            return primaryKeyValues;
        }
        CacheId id = new CacheId(primaryKeyValues);
        if (isPersistenceEntity && (!isNull)) {
            ((PersistenceEntity)domainObject)._persistence_setId(id);
        }
        return id;
    }

    /**

     * null is returned if the row does not contain the key.
     */
    public Object extractPrimaryKeyFromRow(AbstractRecord databaseRow, AbstractSession session) {
        List<DatabaseField> primaryKeyFields = this.descriptor.getPrimaryKeyFields();
        List<Class> primaryKeyClassifications = getPrimaryKeyClassifications();
        int size = primaryKeyFields.size();
        Object[] primaryKeyValues = null;
        CacheKeyType cacheKeyType = this.descriptor.getCacheKeyType();
        if (cacheKeyType != CacheKeyType.ID_VALUE) {
            primaryKeyValues = new Object[size];
        }
        int numberOfNulls = 0;

        // PERF: use index not enumeration
        for (int index = 0; index < size; index++) {
            DatabaseField field = primaryKeyFields.get(index);

            // Ensure that the type extracted from the row is the same type as in the object.
            Class classification = primaryKeyClassifications.get(index);
            Object value = databaseRow.get(field);
            if (value != null) {
                if (value.getClass() != classification) {
                    value = session.getPlatform(this.descriptor.getJavaClass()).convertObject(value, classification);
                }
                if (cacheKeyType == CacheKeyType.ID_VALUE) {
                    return value;
                }
                primaryKeyValues[index] = value;
            } else {
                if (this.mayHaveNullInPrimaryKey) {
                    numberOfNulls++;
                    if (numberOfNulls < size) {
                        primaryKeyValues[index] = null;
                    } else {
                        // Must have some non null elements. If all elements are null return null.
                        return null;

            }
        }

        return new CacheId(primaryKeyValues);
    }

    /**




 ******************************************************************************/  
package org.eclipse.persistence.internal.descriptors;


import java.util.Vector;

import org.eclipse.persistence.internal.identitymaps.CacheKey;

/**
 * Define an interface for utility methods weaved into the persistence classes.
 * These general methods are used to optimize performance, such as caching the key in the object.

 * @author  mmacivor
 * @since   10.1.3
 */
public interface PersistenceEntity {    
    Object _persistence_getId();
    void _persistence_setId(Object primaryKey);    
    
    Vector _persistence_getPKVector();
    void _persistence_setPKVector(Vector pk);    
}




import java.beans.PropertyChangeListener;
import java.util.Collection;
import java.util.Map;
import java.util.Vector;

//EclipseLink imports
import org.eclipse.persistence.descriptors.changetracking.ChangeTracker;

import org.eclipse.persistence.indirection.ValueHolderInterface;
import org.eclipse.persistence.internal.descriptors.PersistenceEntity;
import org.eclipse.persistence.internal.helper.Helper;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.mappings.CollectionMapping;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.mappings.ForeignReferenceMapping;


    //PersistenceEntity API
    /**
     * Cache the CacheKey within the entity
     * 
     * @see PersistenceEntity#_persistence_setCacheKey(CacheKey)
     */
    private CacheKey cacheKey;
    /**
     * Cache the primary key within the entity
     * 
     * @see PersistenceEntity#_persistence_setId(Object)
     */
    private Object primaryKey;
    
        return this.cacheKey;
    }
    public void _persistence_setCacheKey(CacheKey key) {
        this.cacheKey = key;
    }
    @SuppressWarnings("unchecked")
    public Object _persistence_getId() {
        return this.primaryKey;
    }
    @SuppressWarnings("unchecked")
    public void _persistence_setId(Object pk) {
        this.primaryKey = pk;
    }
    

        StringBuilder sb = new StringBuilder(20);
        sb.append('{');
        sb.append(getShortClassName(this.getClass()));
        sb.append(this.primaryKey);
        if (primaryKey != null && primaryKey.size() > 0) {
            for (int i = 0, len = primaryKey.size(); i < len; i++) {
                sb.append(' ');
                sb.append(primaryKey.elementAt(i));
            }
        }
        sb.append('}');
        return sb.toString();
    }

Lines 98-104 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/expressions/ObjectExpression.java (-1 / +1 lines)
98	List childrenTables = getDescriptor().getInheritancePolicy().getChildrenTables();	98	List childrenTables = getDescriptor().getInheritancePolicy().getChildrenTables();
99	for( int i=0; i < childrenTables.size(); i++) {	99	for( int i=0; i < childrenTables.size(); i++) {
100	DatabaseTable table = (DatabaseTable)childrenTables.get(i);	100	DatabaseTable table = (DatabaseTable)childrenTables.get(i);
101	Expression joinExpression = (Expression)getDescriptor().getInheritancePolicy().getChildrenTablesJoinExpressions().get(table);	101	Expression joinExpression = getDescriptor().getInheritancePolicy().getChildrenTablesJoinExpressions().get(table);
102	if (getBaseExpression() != null){	102	if (getBaseExpression() != null){
103	joinExpression = getBaseExpression().twist(joinExpression, this);	103	joinExpression = getBaseExpression().twist(joinExpression, this);
104	} else {	104	} else {




        Vector tables = getDescriptor().getTables();
        // skip the main table - start with i=1
        int tablesSize = tables.size();
        if (shouldUseOuterJoin()) {
            for (int i=1; i < tablesSize; i++) {
                DatabaseTable table = (DatabaseTable)tables.elementAt(i);
                Expression joinExpression = (Expression)getDescriptor().getQueryManager().getTablesJoinExpressions().get(table);
                joinExpression = getBaseExpression().twist(joinExpression, this);
                tablesJoinExpressions.put(table, joinExpression);
            }
        }
        if (isUsingOuterJoinForMultitableInheritance()) {
            List childrenTables = getDescriptor().getInheritancePolicy().getChildrenTables();
            tablesSize = childrenTables.size();
            for (int i=0; i < tablesSize; i++) {
                DatabaseTable table = (DatabaseTable)childrenTables.get(i);
                Expression joinExpression = getDescriptor().getInheritancePolicy().getChildrenTablesJoinExpressions().get(table);
                joinExpression = getBaseExpression().twist(joinExpression, this);
                tablesJoinExpressions.put(table, joinExpression);
            }




import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.internal.sessions.AbstractRecord;
import org.eclipse.persistence.internal.sessions.AbstractSession;

        Object leftPrimaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(leftValue, session);
        Object rightPrimaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(rightValue, session);

        return performSelector(leftPrimaryKey.equals(rightPrimaryKey));
        CacheKey leftCacheKey = new org.eclipse.persistence.internal.identitymaps.CacheKey(leftPrimaryKey);

        return performSelector(rightCacheKey.equals(leftCacheKey));

    }

    /**

Lines 272-278 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/expressions/SQLSelectStatement.java (-1 / +1 lines)
272	}	272	}
273	} else {	273	} else {
274	sourceTable = ((ClassDescriptor)getDescriptorsForMultitableInheritanceOnly().get(index)).getTables().firstElement();	274	sourceTable = ((ClassDescriptor)getDescriptorsForMultitableInheritanceOnly().get(index)).getTables().firstElement();
275	targetTable = (DatabaseTable)((ClassDescriptor)getDescriptorsForMultitableInheritanceOnly().get(index)).getInheritancePolicy().getChildrenTables().get(0);	275	targetTable = ((ClassDescriptor)getDescriptorsForMultitableInheritanceOnly().get(index)).getInheritancePolicy().getChildrenTables().get(0);
276	Expression exp = (Expression)((Map)getOuterJoinedAdditionalJoinCriteria().elementAt(index)).get(targetTable);	276	Expression exp = (Expression)((Map)getOuterJoinedAdditionalJoinCriteria().elementAt(index)).get(targetTable);
277	sourceAlias = exp.aliasForTable(sourceTable);	277	sourceAlias = exp.aliasForTable(sourceTable);
278	targetAlias = exp.aliasForTable(targetTable);	278	targetAlias = exp.aliasForTable(targetTable);




                for (Map<ObjectChangeSet, ObjectChangeSet> changeSets : changeSet.getObjectChanges().values()) {
                    ClassDescriptor descriptor = null;
                    for (ObjectChangeSet objectChangeSet : changeSets.values()) {
                        if (objectChangeSet.getId() == null) {
                            //skip this process as we will be unable to acquire the correct cachekey anyway
                            //this is a new object with identity after write sequencing
                            continue;

                        if (descriptor.shouldIsolateObjectsInUnitOfWork()) {
                            break;
                        }
                        CacheKey activeCacheKey = attemptToAcquireLock(descriptor, objectChangeSet.getId(), session);
                        if (activeCacheKey == null) {
                            // if cacheKey is null then the lock was not available no need to synchronize this block,because if the
                            // check fails then this thread will just return to the queue until it gets woken up.
                            if (this.prevailingQueue.getFirst() == mergeManager) {
                                // wait on this object until it is free,  or until wait time expires because
                                // this thread is the prevailing thread
                                activeCacheKey = waitOnObjectLock(descriptor, objectChangeSet.getId(), session, (int)Math.round((Math.random()*500)));
                            }
                            if (activeCacheKey == null) {
                                // failed to acquire lock, release all acquired
                                // locks and place thread on waiting list
                                releaseAllAcquiredLocks(mergeManager);
                                // get cacheKey
                                activeCacheKey = session.getIdentityMapAccessorInstance().getCacheKeyForObjectForLock(objectChangeSet.getId(), descriptor.getJavaClass(), descriptor);
                                if (session.shouldLog(SessionLog.FINER, SessionLog.CACHE)) {
                                    Object[] params = new Object[3];
                                    params[0] = descriptor.getJavaClass();
                                    params[1] = objectChangeSet.getId();
                                    params[2] = Thread.currentThread().getName();
                                    session.log(SessionLog.FINER, SessionLog.CACHE, "dead_lock_encountered_on_write_no_cachekey", params, null, true);
                                }


                                // set the cache key on the merge manager for
                                // the object that could not be acquired
                                mergeManager.setWriteLockQueued(objectChangeSet.getId());
                                try {
                                    if (activeCacheKey != null){
                                        //wait on the lock of the object that we couldn't get.

     * a new object that was not locked previously.  Unlike the other methods
     * within this class this method will lock only this object.
     */
    public Object appendLock(Object primaryKey, Object objectToLock, ClassDescriptor descriptor, MergeManager mergeManager, AbstractSession session) {
        CacheKey lockedCacheKey = session.getIdentityMapAccessorInstance().acquireLockNoWait(primaryKey, descriptor.getJavaClass(), true, descriptor);
        if (lockedCacheKey == null) {
            session.getIdentityMapAccessorInstance().getWriteLockManager().transitionToDeferredLocks(mergeManager);
            lockedCacheKey = session.getIdentityMapAccessorInstance().acquireDeferredLock(primaryKey, descriptor.getJavaClass(), descriptor);
            Object cachedObject = lockedCacheKey.getObject();
            if (cachedObject == null) {
                cachedObject = lockedCacheKey.waitForObject();

     * This method performs the operations of finding the cacheKey and locking it if possible.
     * Returns True if the lock was acquired, false otherwise
     */
    protected CacheKey attemptToAcquireLock(ClassDescriptor descriptor, Object primaryKey, AbstractSession session) {
        return session.getIdentityMapAccessorInstance().acquireLockNoWait(primaryKey, descriptor.getJavaClass(), true, descriptor);
    }

    /**

     * This method performs the operations of finding the cacheKey and locking it if possible.
     * Waits until the lock can be acquired
     */
    protected CacheKey waitOnObjectLock(ClassDescriptor descriptor, Object primaryKey, AbstractSession session, int waitTime) {
        return session.getIdentityMapAccessorInstance().acquireLockWithWait(primaryKey, descriptor.getJavaClass(), true, descriptor, waitTime);
    }
}




     * Other threads will get deferred locks, all threads will wait until all other threads are complete before releasing their locks.
     */
    public CacheKey acquireDeferredLock(Object primaryKey) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
        newCacheKey.acquireDeferredLock();
        // PERF: To avoid synchronization, getIfAbsentPut is used.
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        // Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
        if (cacheKey == null) {
            // Create and lock a new cacheKey.
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            newCacheKey.acquireDeferredLock();
            // PERF: To avoid synchronization, getIfAbsentPut is used.
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            // Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
            if (cacheKey == null) {
                return newCacheKey;
            } else {
                newCacheKey.releaseDeferredLock();
            }
        }
        // Acquire a lock on the cache key.
        cacheKey.acquireDeferredLock();

     * This is used by reading (when using indirection or no relationships) and by merge.
     */
    public CacheKey acquireLock(Object primaryKey, boolean forMerge) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
        newCacheKey.acquire(forMerge);
        // PERF: To avoid synchronization, getIfAbsentPut is used.
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        // Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
        if (cacheKey == null) {
            // Create and lock a new cacheKey.
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            newCacheKey.acquire(forMerge);
            // PERF: To avoid synchronization, getIfAbsentPut is used.
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            // Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
            if (cacheKey == null) {
                return newCacheKey;
            } else {
                newCacheKey.release();
            }
        }
        // Acquire a lock on the cache key.
        cacheKey.acquire();

     * This is used by merge for missing existing objects.
     */
    public CacheKey acquireLockNoWait(Object primaryKey, boolean forMerge) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
        newCacheKey.acquire(forMerge);
        // PERF: To avoid synchronization, getIfAbsentPut is used.
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        // Return if the newCacheKey was put as already lock, otherwise must still lock.
        if (cacheKey == null) {
            // Create and lock a new cacheKey.
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            newCacheKey.acquire(forMerge);
            // PERF: To avoid synchronization, getIfAbsentPut is used.
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            // Return if the newCacheKey was put as already lock, otherwise must still lock.
            if (cacheKey == null) {
                return newCacheKey;
            } else {
                newCacheKey.release();
            }
        }
        // Acquire a lock on the cache key.
        // Return null if already locked.

     * This is used by merge for missing existing objects.
     */
    public CacheKey acquireLockWithWait(Object primaryKey, boolean forMerge, int wait) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
        newCacheKey.acquire(forMerge);
        // PERF: To avoid synchronization, getIfAbsentPut is used.
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        // Return if the newCacheKey was put as already lock, otherwise must still lock.
        if (cacheKey == null) {
            // Create and lock a new cacheKey.
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            newCacheKey.acquire(forMerge);
            // PERF: To avoid synchronization, getIfAbsentPut is used.
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            // Return if the newCacheKey was put as already lock, otherwise must still lock.
            if (cacheKey == null) {
                return newCacheKey;
            } else {
                newCacheKey.release();
            }
        }
        // Acquire a lock on the cache key.
        // Return null if already locked.

     * This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.
     */
    public CacheKey acquireReadLockOnCacheKey(Object primaryKey) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey cacheKey = getCacheKey(newCacheKey);
        if (cacheKey == null) {
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            // Lock new cacheKey.
            newCacheKey.acquireReadLock();
            // Create one but not put it in the cache, as we are only reading

     * This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.
     */
    public CacheKey acquireReadLockOnCacheKeyNoWait(Object primaryKey) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey cacheKey = getCacheKey(newCacheKey);
        if (cacheKey == null) {
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            // Lock new cacheKey.
            newCacheKey.acquireReadLock();
            // Create one but not put it in the cache, as we are only reading

    /**
     * Get the cache key (with object) for the primary key.
     */
    public abstract CacheKey getCacheKey(Object primaryKey);
        CacheKey searchKey = new CacheKey(primaryKey);
        return getCacheKey(searchKey);
    }

    /**
     * Get the cache key (with object) for the primary key.

    public CacheKey getCacheKeyForLock(Object primaryKey) {
        return getCacheKey(primaryKey);
    }

    /**
     * Return the cache key (with object) matching the searchKey.
     */
    protected abstract CacheKey getCacheKey(CacheKey searchKey);
    
    /**
     * Return the CacheKey (with object) matching the searchKey.
     * If the CacheKey is missing then put the searchKey in the map.
     * The searchKey should have already been locked. 
     */
    protected abstract CacheKey putCacheKeyIfAbsent(CacheKey cacheKey);

    /**
     * Get the cache key (with object) for the primary key with read lock.




/*******************************************************************************
 * Copyright (c) 1998, 2010 Oracle. All rights reserved.
 * This program and the accompanying materials are made available under the 
 * terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0 
 * which accompanies this distribution. 
 * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
 * and the Eclipse Distribution License is available at 
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * Contributors:
 *     James Sutherland - initial API and implementation
 ******************************************************************************/  
package org.eclipse.persistence.internal.identitymaps;

import java.io.*;
import java.util.Arrays;

import org.eclipse.persistence.internal.helper.*;

/**
 * Defines a wrapper for a primary key (Id) to use as a key in the cache.
 * 
 * @since EclipseLink 2.1
 * @author James Sutherland
 */
public class CacheId implements Serializable {

    /** The primary key values. */
    protected Object[] primaryKey;

    /** Cached hashcode. */
    protected int hash;
    
    public CacheId(Object[] primaryKey) {
        this.primaryKey = primaryKey;
        this.hash = computeHash(primaryKey);
    }

    public Object[] getPrimaryKey() {
        return primaryKey;
    }

    public void setPrimaryKey(Object[] primaryKey) {
        this.primaryKey = primaryKey;
        this.hash = computeHash(primaryKey);
    }
    
    /**
     * Append the value to the end of the primary key values.
     */
    public void add(Object value) {
        Object[] array = new Object[this.primaryKey.length + 1];
        System.arraycopy(this.primaryKey, 0, array, 0, this.primaryKey.length);
        array[this.primaryKey.length] = value;
        setPrimaryKey(array);
    }
    
    /**
     * Set the value in the primary key values.
     */
    public void set(int index, Object value) {
        this.primaryKey[index] = value;
        setPrimaryKey(this.primaryKey);
    }
    
    /**
     * Pre-compute the hash to optimize hash calls.
     */
    protected int computeHash(Object[] primaryKey) {
        int hashValue = 0;
        for (Object value : primaryKey) {
            if (value != null) {
            	//bug5709489, gf bug 1193: fix to handle array hashcodes properly
            	if (value.getClass().isArray()) {
            	    hashValue = hashValue ^ computeArrayHashCode(value);
            	} else {
            	    hashValue = hashValue ^ value.hashCode();
            	}
            }
        }
        return hashValue;
    }

    /**
     * Compute the hashcode for supported array types.
     */
    private int computeArrayHashCode(Object obj) {
        if (obj.getClass() == ClassConstants.APBYTE) {
            return Arrays.hashCode((byte[]) obj);
        } else if (obj.getClass() == ClassConstants.APCHAR) {
            return Arrays.hashCode((char[]) obj);
        } else {
            return Arrays.hashCode((Object[]) obj);
        }
    }

    /**
     * Return the precomputed hashcode.
     */
    @Override
    public int hashCode() {
        return this.hash;
    }
    
    /**
     * Determine if the receiver is equal to anObject.
     * If anObject is a CacheKey, do further comparison, otherwise, return false.
     * @see CacheKey#equals(CacheKey)
     */
    @Override
    public boolean equals(Object object) {
        try {
            return equals((CacheId)object);
        } catch (ClassCastException incorrectType) {
            return false;
        }
    }

    /**
     * Determine if the receiver is equal to key.
     * Use an index compare, because it is much faster than enumerations.
     */
    public boolean equals(CacheId id) {
        if (this == id) {
            return true;
        }
        if (this.hash != id.hash) {
            return false;
        }
        // PERF: Using direct variable access.
        int size = this.primaryKey.length;
        Object[] otherKey = id.primaryKey;
        if (size == otherKey.length) {
            for (int index = 0; index < size; index++) {
                Object value = this.primaryKey[index];
                Object otherValue = otherKey[index];
                if (value == null) {
                    if (otherValue != null) {
                        return false;
                    } else {
                        continue;
                    }
                } else if (otherValue == null) {
                    return false;
                }
                Class valueClass = value.getClass();
                Class otherClass = otherValue.getClass();
                if (valueClass.isArray()) {
                    //gf bug 1193: fix array comparison logic to exit if they don't match, and continue the loop if they do
                    if (((valueClass == ClassConstants.APBYTE) && (otherClass == ClassConstants.APBYTE)) ) {
                        if (!Helper.compareByteArrays((byte[])value, (byte[])otherValue)){
                            return false;
                        }
                    } else if (((valueClass == ClassConstants.APCHAR) && (otherClass == ClassConstants.APCHAR)) ) {
                        if (!Helper.compareCharArrays((char[])value, (char[])otherValue)){
                            return false;
                        }
                    } else {
                        if (!Helper.compareArrays((Object[])value, (Object[])otherValue)) {
                            return false;
                        }
                    }
                } else {
                    if (!(value.equals(otherValue))) {
                        return false;
                    }
                }
            }
            return true;
        }
        return false;
    }

    public String toString() {
        return "[" + Arrays.asList(this.primaryKey) + ": " + this.hash + "]";
    }
}




 ******************************************************************************/  
package org.eclipse.persistence.internal.identitymaps;

import java.util.*;

import org.eclipse.persistence.descriptors.ClassDescriptor;

/**
 * <p><b>Purpose</b>: A fixed size LRU cache<p>
 * Using a linked list as well as the map from the superclass a LRU cache is maintained.
 * When a get is executed the LRU list is updated and when a new object is inserted the object
 * at the start of the list is deleted (provided the maxSize has been reached).
 * <p><b>Responsibilities</b>:<ul>
 *    <li> Guarantees identity through primary key values
 *    <li> Keeps the LRU linked list updated.
 * </ul>
 * @since TOPLink/Java 1.0
 */

     */
    public CacheIdentityMap(int size) {
        super(size);
        this.first = new LinkedCacheKey(new CacheId(new Object[0]), null, null, 0);
        this.last = new LinkedCacheKey(new CacheId(new Object[0]), null, null, 0);
        this.first.setNext(this.last);
        this.last.setPrevious(this.first);
    };

    public CacheIdentityMap(int size, ClassDescriptor descriptor) {
        super(size, descriptor);
        this.first = new LinkedCacheKey(new CacheId(new Object[0]), null, null, 0);
        this.last = new LinkedCacheKey(new CacheId(new Object[0]), null, null, 0);
        this.first.setNext(this.last);
        this.last.setPrevious(this.first);
    }

    @Override
    public CacheKey createCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        return new LinkedCacheKey(primaryKey, object, writeLockValue, readTime);
    }

    /**

    /**
     * Also insert the link if the cacheKey is put.
     */
    protected CacheKey putCacheKeyIfAbsent(CacheKey searchKey) {
        CacheKey cacheKey = super.putCacheKeyIfAbsent(searchKey);
        if (cacheKey == null) {
            insertLink((LinkedCacheKey)searchKey);
            ensureFixedSize();




package org.eclipse.persistence.internal.identitymaps;

import java.io.*;
import java.util.Arrays;
import java.util.Vector;

import org.eclipse.persistence.exceptions.ConcurrencyException;
import org.eclipse.persistence.internal.helper.*;

public class CacheKey implements Serializable, Cloneable {

    /** The key holds the vector of primary key values for the object. */
    protected Object key;

    /** Calculated hash value for CacheKey from primary key values. */
    protected int hash;
    protected Object object;
    
    //used to store a reference to the map this cachekey is in in cases where the

    }
    
    public CacheKey(Object primaryKey) {
        this.key = primaryKey;
        this.hash = computeHash((Vector)primaryKey);
    }

    public CacheKey(Object primaryKey, Object object, Object lockValue) {
        this.key = primaryKey;
        this.hash = computeHash((Vector)primaryKey);
        this.writeLockValue = lockValue;
        //bug4649617  use setter instead of this.object = object to avoid hard reference on object in subclasses
        if (object != null) {

    }

    public CacheKey(Object primaryKey, Object object, Object lockValue, long readTime) {
        this.key = primaryKey;
        this.hash = computeHash((Vector)primaryKey);
        this.writeLockValue = lockValue;
        //bug4649617  use setter instead of this.object = object to avoid hard reference on object in subclasses
        if (object != null) {

    }

    /**
     * Compute a hash value for the CacheKey dependent upon the values of the primary key
     * instead of the identity of the receiver.
     * This method is intended for use by constructors only.
     */
    protected int computeHash(Vector primaryKey) {
        int computedHashValue = 0;
        int size = primaryKey.size();
        for (int index = 0; index < size; index++) {
            Object value = primaryKey.get(index);
            if (value != null) {
            	//bug5709489, gf bug 1193: fix to handle array hashcodes properly
            	if (value.getClass().isArray()) {
            		computedHashValue = computedHashValue ^ computeArrayHashCode(value);
            	} else {
            		computedHashValue = computedHashValue ^ (value.hashCode());
            	}
            }
        }
        return computedHashValue;
    }

    /**
     * Compute the hashcode for supported array types
     * @param obj - an array
     * @return hashCode value
     */
    private int computeArrayHashCode(Object obj) {
        if (obj.getClass() == ClassConstants.APBYTE) {
            return Arrays.hashCode((byte []) obj);
        } else if (obj.getClass() == ClassConstants.APCHAR) {
            return Arrays.hashCode((char []) obj);
        } else {
            return Arrays.hashCode((Object []) obj);
        }
    }

    /**
     * Determine if the receiver is equal to anObject.
     * If anObject is a CacheKey, do further comparison, otherwise, return false.
     * @see CacheKey#equals(CacheKey)

        if (this == key) {
            return true;
        }
        return this.key.equals(key.key);
        int size = this.key.size();
        if (size == key.key.size()) {
            for (int index = 0; index < size; index++) {
                Object myValue = this.key.get(index);
                Object comparisionValue = key.key.get(index);

                if (myValue == null) {
                    if (comparisionValue != null) {
                        return false;
                    }
                } else if (myValue.getClass().isArray()) {
                    //gf bug 1193: fix array comparison logic to exit if they don't match, and continue the loop if they do
                    if (((myValue.getClass() == ClassConstants.APBYTE) && (comparisionValue.getClass() == ClassConstants.APBYTE)) ) {
                        if (!Helper.compareByteArrays((byte[])myValue, (byte[])comparisionValue)){
                            return false;
                        }
                    } else if (((myValue.getClass() == ClassConstants.APCHAR) && (comparisionValue.getClass() == ClassConstants.APCHAR)) ) {
                        if (!Helper.compareCharArrays((char[])myValue, (char[])comparisionValue)){
                            return false;
                        }
                    } else {
                        if (!Helper.compareArrays((Object[])myValue, (Object[])comparisionValue)) {
                            return false;
                        }
                    }
                } else {
                    if (!(myValue.equals(comparisionValue))) {
                        return false;
                    }
                }
            }
            return true;
        }
        return false;
    }

    /**

        return this.lastUpdatedQueryId;
    }

    public Object getKey() {
        return key;
    }


     * Overrides hashCode() in Object to use the primaryKey's hashCode for storage in data structures.
     */
    public int hashCode() {
        return this.key.hashCode();
    }

    /**

        this.lastUpdatedQueryId = id;
    }

    public void setKey(Object key) {
        this.key = key;
        this.hash = computeHash(key);
    }

    /**




public class FullIdentityMap extends AbstractIdentityMap {

    /** Map of CacheKeys stored using their key. */
    protected Map<Object, CacheKey> cacheKeys;

    public FullIdentityMap() {}
    

    @Override
    public Object clone() {
        FullIdentityMap clone = (FullIdentityMap)super.clone();
        clone.setCacheKeys(new ConcurrentHashMap(this.cacheKeys.size()));

        for (Iterator cacheKeysIterator = this.cacheKeys.values().iterator(); cacheKeysIterator.hasNext();) {
            CacheKey key = (CacheKey)((CacheKey)cacheKeysIterator.next()).clone();
            clone.getCacheKeys().put(key.getKey(), key);
        }

        return clone;

     */
    @Override
    public void collectLocks(HashMap threadList) {
        Iterator cacheKeyIterator = this.cacheKeys.values().iterator();
        while (cacheKeyIterator.hasNext()) {
            CacheKey cacheKey = (CacheKey)cacheKeyIterator.next();
            if (cacheKey.isAcquired()) {

     * If no object for the key exists, return null.
     */
    @Override
    public CacheKey getCacheKey(Object searchKey) {
        return this.cacheKeys.get(searchKey);
    }    
        
    /**

     * The searchKey should have already been locked. 
     */
    @Override
    protected CacheKey putCacheKeyIfAbsent(CacheKey searchKey) {
        searchKey.setOwningMap(this);
        return (CacheKey)((ConcurrentMap)this.cacheKeys).putIfAbsent(searchKey.getKey(), searchKey);
        if (cacheKey == null) {
            searchKey.setOwningMap(this);
            cacheKey = (CacheKey)((ConcurrentMap)getCacheKeys()).putIfAbsent(searchKey, searchKey);
        }
        return cacheKey;
    }

    /**
     * Return the cache keys.
     */
    public Map<Object, CacheKey> getCacheKeys() {
        return cacheKeys;
    }


    @Override
    public int getSize(Class myClass, boolean recurse) {
        int count = 0;
        Iterator keys = this.cacheKeys.values().iterator();

        while (keys.hasNext()) {
            CacheKey key = (CacheKey)keys.next();

    public CacheKey put(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        CacheKey newCacheKey = createCacheKey(primaryKey, object, writeLockValue, readTime);
        // Find the cache key in the map, reset it, or put the new one.
        CacheKey cacheKey = putCacheKeyIfAbsent(newCacheKey);
        if (cacheKey != null) {
            // The cache key is locked inside resetCacheKey() to keep other threads from accessing the object.
            resetCacheKey(cacheKey, object, writeLockValue, readTime);

        if (cacheKey != null) {
            // Cache key needs to be locked when removing from the map.
            cacheKey.acquire();
            this.cacheKeys.remove(cacheKey.getKey());
            // Cache key needs to be released after removing from the map.
            cacheKey.release();
            return cacheKey.getObject();

        key.release();
    }

    protected void setCacheKeys(Map<Object, CacheKey> cacheKeys) {
        this.cacheKeys = cacheKeys;
    }
}




 ******************************************************************************/  
package org.eclipse.persistence.internal.identitymaps;

import java.util.*;

import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.helper.linkedlist.*;


     */
    @Override
    public CacheKey createCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        return new ReferenceCacheKey(primaryKey, object, writeLockValue, readTime);
    }

    /**

    public class ReferenceCacheKey extends WeakCacheKey {
        protected LinkedNode referenceNode;

        public ReferenceCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime) {
            super(primaryKey, object, writeLockValue, readTime);
        }


Lines 114-119 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/identitymaps/IdentityMapManager.java (-12 / +58 lines)
114	* called with true from the merge process, if true then the refresh will not refresh the object.	114	* called with true from the merge process, if true then the refresh will not refresh the object.
115	*/	115	*/
116	public CacheKey acquireLock(Object primaryKey, Class domainClass, boolean forMerge, ClassDescriptor descriptor) {	116	public CacheKey acquireLock(Object primaryKey, Class domainClass, boolean forMerge, ClassDescriptor descriptor) {
		117	if (primaryKey == null) {
		118	CacheKey cacheKey = new CacheKey(primaryKey);
		119	cacheKey.acquire();
		120	return cacheKey;
		121	}
117	CacheKey cacheKey = null;	122	CacheKey cacheKey = null;
118	if (this.isCacheAccessPreCheckRequired) {	123	if (this.isCacheAccessPreCheckRequired) {
119	this.session.startOperationProfile(SessionProfiler.CACHE);	124	this.session.startOperationProfile(SessionProfiler.CACHE);
Lines 136-141 Link Here
136	* called with true from the merge process, if true then the refresh will not refresh the object.	141	* called with true from the merge process, if true then the refresh will not refresh the object.
137	*/	142	*/
138	public CacheKey acquireLockNoWait(Object primaryKey, Class domainClass, boolean forMerge, ClassDescriptor descriptor) {	143	public CacheKey acquireLockNoWait(Object primaryKey, Class domainClass, boolean forMerge, ClassDescriptor descriptor) {
		144	if (primaryKey == null) {
		145	CacheKey cacheKey = new CacheKey(primaryKey);
		146	cacheKey.acquire();
		147	return cacheKey;
		148	}
139	CacheKey cacheKey = null;	149	CacheKey cacheKey = null;
140	if (this.isCacheAccessPreCheckRequired) {	150	if (this.isCacheAccessPreCheckRequired) {
141	this.session.startOperationProfile(SessionProfiler.CACHE);	151	this.session.startOperationProfile(SessionProfiler.CACHE);
Lines 158-163 Link Here
158	* called with true from the merge process, if true then the refresh will not refresh the object.	168	* called with true from the merge process, if true then the refresh will not refresh the object.
159	*/	169	*/
160	public CacheKey acquireLockWithWait(Object primaryKey, Class domainClass, boolean forMerge, ClassDescriptor descriptor, int wait) {	170	public CacheKey acquireLockWithWait(Object primaryKey, Class domainClass, boolean forMerge, ClassDescriptor descriptor, int wait) {
		171	if (primaryKey == null) {
		172	CacheKey cacheKey = new CacheKey(primaryKey);
		173	cacheKey.acquire();
		174	return cacheKey;
		175	}
161	CacheKey cacheKey = null;	176	CacheKey cacheKey = null;
162	if (this.isCacheAccessPreCheckRequired) {	177	if (this.isCacheAccessPreCheckRequired) {
163	this.session.startOperationProfile(SessionProfiler.CACHE);	178	this.session.startOperationProfile(SessionProfiler.CACHE);
Lines 208-213 Link Here
208	* the object while the read lock is held.	223	* the object while the read lock is held.
209	*/	224	*/
210	public CacheKey acquireReadLockOnCacheKey(Object primaryKey, Class domainClass, ClassDescriptor descriptor) {	225	public CacheKey acquireReadLockOnCacheKey(Object primaryKey, Class domainClass, ClassDescriptor descriptor) {
		226	if (primaryKey == null) {
		227	CacheKey cacheKey = new CacheKey(primaryKey);
		228	cacheKey.acquireReadLock();
		229	return cacheKey;
		230	}
211	CacheKey cacheKey = null;	231	CacheKey cacheKey = null;
212	if (this.isCacheAccessPreCheckRequired) {	232	if (this.isCacheAccessPreCheckRequired) {
213	this.session.startOperationProfile(SessionProfiler.CACHE);	233	this.session.startOperationProfile(SessionProfiler.CACHE);
Lines 233-238 Link Here
233	* If no readlock can be acquired then do not wait but return null.	253	* If no readlock can be acquired then do not wait but return null.
234	*/	254	*/
235	public CacheKey acquireReadLockOnCacheKeyNoWait(Object primaryKey, Class domainClass, ClassDescriptor descriptor) {	255	public CacheKey acquireReadLockOnCacheKeyNoWait(Object primaryKey, Class domainClass, ClassDescriptor descriptor) {
		256	if (primaryKey == null) {
		257	CacheKey cacheKey = new CacheKey(primaryKey);
		258	cacheKey.acquireReadLock();
		259	return cacheKey;
		260	}
236	CacheKey cacheKey = null;	261	CacheKey cacheKey = null;
237	if (this.isCacheAccessPreCheckRequired) {	262	if (this.isCacheAccessPreCheckRequired) {
238	this.session.startOperationProfile(SessionProfiler.CACHE);	263	this.session.startOperationProfile(SessionProfiler.CACHE);
Lines 574-579 Link Here
574	* Retrieve the cache key for the given identity information.	599	* Retrieve the cache key for the given identity information.
575	*/	600	*/
576	public CacheKey getCacheKeyForObjectForLock(Object primaryKey, Class theClass, ClassDescriptor descriptor) {	601	public CacheKey getCacheKeyForObjectForLock(Object primaryKey, Class theClass, ClassDescriptor descriptor) {
		602	if (primaryKey == null) {
		603	return null;
		604	}
577	IdentityMap map = getIdentityMap(descriptor, true);	605	IdentityMap map = getIdentityMap(descriptor, true);
578	if (map == null) {	606	if (map == null) {
579	return null;	607	return null;
Lines 598-603 Link Here
598	* Retrieve the cache key for the given identity information.	626	* Retrieve the cache key for the given identity information.
599	*/	627	*/
600	public CacheKey getCacheKeyForObject(Object primaryKey, Class theClass, ClassDescriptor descriptor) {	628	public CacheKey getCacheKeyForObject(Object primaryKey, Class theClass, ClassDescriptor descriptor) {
		629	if (primaryKey == null) {
		630	return null;
		631	}
601	IdentityMap map = getIdentityMap(descriptor, true);	632	IdentityMap map = getIdentityMap(descriptor, true);
602	if (map == null) {	633	if (map == null) {
603	return null;	634	return null;
Lines 910-918 Link Here
910	return null;	941	return null;
911	}	942	}
912		943
913	Object lookupParameters = parameters;	944	Object lookupParameters;
914	if (lookupParameters == null) {	945	if (parameters == null) {
915	lookupParameters = new NonSynchronizedVector(0);	946	lookupParameters = new CacheId(new Object[0]);
		947	} else {
		948	lookupParameters = new CacheId(parameters.toArray());
916	}	949	}
917		950
918	CacheKey key = map.getCacheKey(lookupParameters);	951	CacheKey key = map.getCacheKey(lookupParameters);
Lines 967-972 Link Here
967	* Retrieve the write lock value of the cache key associated with the given primary key,	1000	* Retrieve the write lock value of the cache key associated with the given primary key,
968	*/	1001	*/
969	public Object getWriteLockValue(Object primaryKey, Class domainClass, ClassDescriptor descriptor) {	1002	public Object getWriteLockValue(Object primaryKey, Class domainClass, ClassDescriptor descriptor) {
		1003	if (primaryKey == null) {
		1004	return null;
		1005	}
970	IdentityMap map = getIdentityMap(descriptor, false);	1006	IdentityMap map = getIdentityMap(descriptor, false);
971	Object value;	1007	Object value;
972	if (this.isCacheAccessPreCheckRequired) {	1008	if (this.isCacheAccessPreCheckRequired) {
Lines 1028-1040 Link Here
1028	if (descriptor.hasInheritance()) {	1064	if (descriptor.hasInheritance()) {
1029	if (descriptor.getInheritancePolicy().isRootParentDescriptor()) {	1065	if (descriptor.getInheritancePolicy().isRootParentDescriptor()) {
1030	writer.write(LoggingLocalization.buildMessage("includes"));	1066	writer.write(LoggingLocalization.buildMessage("includes"));
1031	Vector childDescriptors;	1067	List<ClassDescriptor> childDescriptors = descriptor.getInheritancePolicy().getChildDescriptors();
1032	childDescriptors = descriptor.getInheritancePolicy().getChildDescriptors();
1033	if ((childDescriptors != null) && (childDescriptors.size() != 0)) {//Bug#2675242	1068	if ((childDescriptors != null) && (childDescriptors.size() != 0)) {//Bug#2675242
1034	Enumeration enum2 = childDescriptors.elements();	1069	Iterator<ClassDescriptor> iterator = childDescriptors.iterator();
1035	writer.write(Helper.getShortClassName(((ClassDescriptor)enum2.nextElement()).getJavaClass()));	1070	writer.write(Helper.getShortClassName(iterator.next().getJavaClass()));
1036	while (enum2.hasMoreElements()) {	1071	while (iterator.hasNext()) {
1037	writer.write(", " + Helper.getShortClassName(((ClassDescriptor)enum2.nextElement()).getJavaClass()));	1072	writer.write(", " + Helper.getShortClassName(iterator.next().getJavaClass()));
1038	}	1073	}
1039	}	1074	}
1040	writer.write(")");	1075	writer.write(")");
Lines 1161-1166 Link Here
1161	* The readTime may also be included in the cache key as it is constructed	1196	* The readTime may also be included in the cache key as it is constructed
1162	*/	1197	*/
1163	public CacheKey putInIdentityMap(Object domainObject, Object keys, Object writeLockValue, long readTime, ClassDescriptor descriptor) {	1198	public CacheKey putInIdentityMap(Object domainObject, Object keys, Object writeLockValue, long readTime, ClassDescriptor descriptor) {
		1199	if (keys == null) {
		1200	return null;
		1201	}
1164	ObjectBuilder builder = descriptor.getObjectBuilder();	1202	ObjectBuilder builder = descriptor.getObjectBuilder();
1165	Object implementation = builder.unwrapObject(domainObject, this.session);	1203	Object implementation = builder.unwrapObject(domainObject, this.session);
1166		1204
Lines 1204-1212 Link Here
1204	}	1242	}
1205	}	1243	}
1206	}	1244	}
1207	Object lookupParameters = parameters;	1245	Object lookupParameters;
1208	if (lookupParameters == null) {	1246	if (parameters == null) {
1209	lookupParameters = new NonSynchronizedVector(0);	1247	lookupParameters = new CacheId(new Object[0]);
		1248	} else {
		1249	lookupParameters = new CacheId(parameters.toArray());
1210	}	1250	}
1211	long queryTime = 0;	1251	long queryTime = 0;
1212	if (query.isObjectLevelReadQuery()) {	1252	if (query.isObjectLevelReadQuery()) {
Lines 1249-1254 Link Here
1249	* Remove the object from the object cache.	1289	* Remove the object from the object cache.
1250	*/	1290	*/
1251	public Object removeFromIdentityMap(Object key, Class domainClass, ClassDescriptor descriptor, Object objectToRemove) {	1291	public Object removeFromIdentityMap(Object key, Class domainClass, ClassDescriptor descriptor, Object objectToRemove) {
		1292	if (key == null) {
		1293	return null;
		1294	}
1252	IdentityMap map = getIdentityMap(descriptor, false);	1295	IdentityMap map = getIdentityMap(descriptor, false);
1253	Object value;	1296	Object value;
1254		1297
Lines 1313-1318 Link Here
1313	* Update the write lock value of the cache key associated with the given primary key,	1356	* Update the write lock value of the cache key associated with the given primary key,
1314	*/	1357	*/
1315	public void setWriteLockValue(Object primaryKey, Class theClass, Object writeLockValue) {	1358	public void setWriteLockValue(Object primaryKey, Class theClass, Object writeLockValue) {
		1359	if (primaryKey == null) {
		1360	return;
		1361	}
1316	ClassDescriptor descriptor = this.session.getDescriptor(theClass);	1362	ClassDescriptor descriptor = this.session.getDescriptor(theClass);
1317	IdentityMap map = getIdentityMap(descriptor, false);	1363	IdentityMap map = getIdentityMap(descriptor, false);
1318		1364




 ******************************************************************************/  
package org.eclipse.persistence.internal.identitymaps;

import java.util.*;

/**
 * <p><b>Purpose</b>: Provides the capability to insert CacheKeys into a Linked List.
 * <p><b>Responsibilities</b>:<ul>
 * <li> Provide same capabilities as superclass.
 * <li> Maintain within linked list.
 * </ul>
 * @see CacheIdentityMap
 * @since TOPLink/Java 1.0
 */
public class LinkedCacheKey extends CacheKey {


    protected LinkedCacheKey next;

    /**
     * Initialize the newly allocated instance of this class.
     * @param object is the domain object.
     * @param writeLockValue is the write lock value number.
     */
    public LinkedCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        super(primaryKey, object, writeLockValue, readTime);
    }


Lines 60-66 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/identitymaps/NoIdentityMap.java (-2 / +2 lines)
60	* Return null as no objects are cached.	60	* Return null as no objects are cached.
61	*/	61	*/
62	@Override	62	@Override
63	protected CacheKey getCacheKey(CacheKey searchKey) {	63	public CacheKey getCacheKey(Object searchKey) {
64	return null;	64	return null;
65	}	65	}
66		66
Lines 68-74 Link Here
68	* Return null as no objects are cached.	68	* Return null as no objects are cached.
69	*/	69	*/
70	@Override	70	@Override
71	protected CacheKey getCacheKeyIfAbsentPut(CacheKey cacheKey) {	71	protected CacheKey putCacheKeyIfAbsent(CacheKey cacheKey) {
72	return null;	72	return null;
73	}	73	}
74		74

Lines 2-8 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/identitymaps/QueueableWeakCacheKey.java (-2 / +1 lines)
2		2
3	import java.lang.ref.ReferenceQueue;	3	import java.lang.ref.ReferenceQueue;
4	import java.lang.ref.WeakReference;	4	import java.lang.ref.WeakReference;
5	import java.util.Vector;
6		5
7	public class QueueableWeakCacheKey extends WeakCacheKey {	6	public class QueueableWeakCacheKey extends WeakCacheKey {
8	// This the reference queue from the owning map that	7	// This the reference queue from the owning map that
Lines 10-16 Link Here
10	// makes for easy cleanup	9	// makes for easy cleanup
11	protected ReferenceQueue referenceQueue;	10	protected ReferenceQueue referenceQueue;
12		11
13	public QueueableWeakCacheKey(Vector primaryKey, Object object, Object writeLockValue, long readTime, ReferenceQueue refQueue) {	12	public QueueableWeakCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime, ReferenceQueue refQueue) {
14	super(primaryKey, object, writeLockValue, readTime);	13	super(primaryKey, object, writeLockValue, readTime);
15	this.referenceQueue = refQueue;	14	this.referenceQueue = refQueue;
16	}	15	}




 ******************************************************************************/  
package org.eclipse.persistence.internal.identitymaps;

import java.util.Vector;

/**
 * Cache key used in the unit of work identity map.
 * This cache avoid locking as the unit of work is single threaded.

 */
public class UnitOfWorkCacheKey extends CacheKey {

    public UnitOfWorkCacheKey(Object primaryKeys) {
        super(primaryKeys);
    }

    public UnitOfWorkCacheKey(Object primaryKey, Object object, Object lockValue) {
        super(primaryKey, object, lockValue);
    }

    public UnitOfWorkCacheKey(Object primaryKey, Object object, Object lockValue, long readTime) {
        super(primaryKey, object, lockValue, readTime);
    }






    @Override
    public CacheKey createCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        return new UnitOfWorkCacheKey(primaryKey, object, writeLockValue, readTime);
    }

    /**

     */
    @Override
    public CacheKey acquireDeferredLock(Object primaryKey) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        if (cacheKey == null) {
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            if (cacheKey == null) {
                return newCacheKey;
            }
        }
        return cacheKey;
    }

     */
    @Override
    public CacheKey acquireLock(Object primaryKey, boolean forMerge) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        if (cacheKey == null) {
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            if (cacheKey == null) {
                return newCacheKey;
            }
        }
        return cacheKey;
    }

     */
    @Override
    public CacheKey acquireLockNoWait(Object primaryKey, boolean forMerge) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        if (cacheKey == null) {
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            if (cacheKey == null) {
                return newCacheKey;
            }
        }
        return cacheKey;
    }

     */
    @Override
    public CacheKey acquireLockWithWait(Object primaryKey, boolean forMerge, int wait) {
        CacheKey cacheKey = getCacheKey(primaryKey);
        CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
        if (cacheKey == null) {
            CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
            cacheKey = putCacheKeyIfAbsent(newCacheKey);
            if (cacheKey == null) {
                return newCacheKey;
            }
        }
        return cacheKey;
    }

    }
    
    /**
     * Use hashmap put, as no concurrency in unit of work.
     * However HashMap is more efficient than a ConcurrentMap so is ok.
     */
    protected CacheKey putCacheKeyIfAbsent(CacheKey searchKey) {
        searchKey.setOwningMap(this);
        this.cacheKeys.put(searchKey.getKey(), searchKey);
        return null;
            getCacheKeys().put(searchKey, searchKey);
            return null;
        }
        return cacheKey;
    }

    /**

    @Override
    public Object remove(CacheKey cacheKey) {
        if (cacheKey != null) {
            this.cacheKeys.remove(cacheKey.getKey());
        } else {
            return null;
        }

Lines 79-86 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/identitymaps/WeakIdentityMap.java (-2 / +2 lines)
79	* Need to check for cleanup on put.	79	* Need to check for cleanup on put.
80	*/	80	*/
81	@Override	81	@Override
82	protected CacheKey getCacheKeyIfAbsentPut(CacheKey searchKey) {	82	protected CacheKey putCacheKeyIfAbsent(CacheKey searchKey) {
83	CacheKey cacheKey = super.getCacheKeyIfAbsentPut(searchKey);	83	CacheKey cacheKey = super.putCacheKeyIfAbsent(searchKey);
84	if (cacheKey == null) {	84	if (cacheKey == null) {
85	checkCleanup();	85	checkCleanup();
86	}	86	}




package org.eclipse.persistence.internal.identitymaps;

import java.lang.ref.ReferenceQueue;
import java.util.Vector;

import org.eclipse.persistence.descriptors.ClassDescriptor;



    @Override
    public CacheKey createCacheKey(Object primaryKey, Object object, Object writeLockValue, long readTime) {
        return new QueueableWeakCacheKey(primaryKey, object, writeLockValue, readTime, referenceQueue);
    }

    /**
     * Need to check for cleanup on put.
     */
    @Override
    protected CacheKey putCacheKeyIfAbsent(CacheKey searchKey) {
        CacheKey cacheKey = super.putCacheKeyIfAbsent(searchKey);
        if (cacheKey == null) {
            checkCleanup();
        }

Lines 217-223 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/indirection/TransparentIndirectionPolicy.java (-1 / +2 lines)
217	* This key will be used by a RemoteValueHolder.	217	* This key will be used by a RemoteValueHolder.
218	* OneToOneMappings should not be using transparent direction.	218	* OneToOneMappings should not be using transparent direction.
219	*/	219	*/
220	public Vector extractPrimaryKeyForReferenceObject(Object referenceObject, AbstractSession session) {	220	@Override
		221	public Object extractPrimaryKeyForReferenceObject(Object referenceObject, AbstractSession session) {
221	throw DescriptorException.invalidUseOfTransparentIndirection(this.getMapping());	222	throw DescriptorException.invalidUseOfTransparentIndirection(this.getMapping());
222	}	223	}
223		224




 ******************************************************************************/  
package org.eclipse.persistence.internal.oxm.documentpreservation;

import java.util.Vector;

import org.w3c.dom.Element;
import org.w3c.dom.Node;


import org.eclipse.persistence.oxm.documentpreservation.DocumentPreservationPolicy;
import org.eclipse.persistence.oxm.mappings.XMLMapping;
import org.eclipse.persistence.oxm.record.DOMRecord;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.oxm.WeakObjectWrapper;
import org.eclipse.persistence.internal.sessions.AbstractSession;

        row.setSession(session);
        Object pk = xmlDescriptor.getObjectBuilder().extractPrimaryKeyFromRow(row, session);
        if (xmlDescriptor.shouldPreserveDocument() || xmlDescriptor.getPrimaryKeyFieldNames().size() > 0) {
            if ((pk == null) || (((CacheId)pk).getPrimaryKey().length == 0)) {
                pk = new CacheId(new Object[]{ new WeakObjectWrapper(obj) });
                ((Vector)pk).add(new WeakObjectWrapper(obj));
            }
            CacheKey key = session.getIdentityMapAccessorInstance().acquireDeferredLock(pk, xmlDescriptor.getJavaClass(), xmlDescriptor);
            if ((xmlDescriptor).shouldPreserveDocument()) {

        XMLDescriptor xmlDescriptor = (XMLDescriptor)session.getDescriptor(obj);
        if(xmlDescriptor.shouldPreserveDocument()) {
            Object pk = xmlDescriptor.getObjectBuilder().extractPrimaryKeyFromObject(obj, session);
            if ((pk == null) || (pk instanceof CacheId) && (((CacheId)pk).getPrimaryKey().length == 0)) {
                pk = new CacheId(new Object[]{ new WeakObjectWrapper(obj) });
                ((Vector)pk).addElement(new WeakObjectWrapper(obj));
            }
            CacheKey cacheKey = session.getIdentityMapAccessorInstance().getCacheKeyForObject(pk, xmlDescriptor.getJavaClass(), xmlDescriptor);
            if(cacheKey != null && cacheKey.getRecord() != null) {




package org.eclipse.persistence.internal.oxm;

import java.util.HashMap;
import java.util.Vector;
import org.eclipse.persistence.oxm.mappings.XMLMapping;
import org.eclipse.persistence.oxm.sequenced.Setting;


	protected XMLMapping mapping;		// mapping associated with this reference
	protected Object sourceObject;		// the source object instance
	protected Class targetClass;		// the reference class
	protected Object primaryKey;		// primary key values for cache lookup - used in single case
	protected HashMap primaryKeyMap;	// map of primary key values for cache lookup - used in collection case
	private Setting setting;


	/**
	 * Constructor typically used in the single case.
	 */
	public Reference(XMLMapping mapping, Object source, Class target, Object primaryKey) {
		this.mapping = mapping;
		sourceObject = source;
		targetClass = target;
		this.primaryKey = primaryKey;
	}

	/**

	 * 
	 * @return
	 */
	public Object getPrimaryKey() {
		return primaryKey;
	}

	/**

	}
	
	/**
	 * Set the primary key value required to lookup
	 * the reference class in the cache.
	 * 
	 * @param primaryKeys
	 */
	public void setPrimaryKey(Object primaryKey) {
		this.primaryKey = primaryKey;
	}
}




import java.util.Iterator;
import java.util.Vector;

import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.queries.ContainerPolicy;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.mappings.AttributeAccessor;


    /**
     * INTERNAL:
     * Create primary key values to be used for cache lookup.  The map
     * of primary keys on the reference is keyed on the reference descriptors primary
     * key field names.  Each of these primary keys contains all of the values for a
     * particular key - in the order that they we read in from the document.  For
     * example, if the key field names are A, B, and C, and there are three reference
     * object instances, then the hashmap would have the following:

    		return;
    	}

    	CacheId pkVals;
    	boolean init = true;

    	// for each primary key field name
    	for (Iterator pkFieldNameIt = pkFields.iterator(); pkFieldNameIt.hasNext(); ) {
    		pkVals = (CacheId) reference.getPrimaryKeyMap().get(pkFieldNameIt.next());

    		if (pkVals == null) {
    			return;
    		}
    		// initialize the list of pk vectors once and only once
    		if (init) {
    			for (int i=0; i<pkVals.getPrimaryKey().length; i++) {
    				pks.add(new CacheId(new Object[0]));
    			}
    			init = false;
    		}

    		// now add each value for the current target key to it's own vector
        	for (int i=0; i<pkVals.getPrimaryKey().length; i++) {
    			Object val = pkVals.getPrimaryKey()[i];
                        ((CacheId)pks.get(i)).add(val);
    		}
    	}
    	reference.primaryKey = pks;
    }

    /**

                // create vectors of primary key values - one vector per reference instance
                createPKVectorsFromMap(reference);
                // loop over each pk vector and get object from cache - then add to collection and set on object
                for (Iterator pkIt = ((Vector)reference.getPrimaryKey()).iterator(); pkIt.hasNext();) {
                    Object primaryKey = pkIt.next();
                    Object value = session.getIdentityMapAccessor().getFromIdentityMap(primaryKey, reference.getTargetClass());

                    if (value != null) {
                        cPolicy.addInto(value, container,  session);

                    }
                }
            } else if (reference.getMapping() instanceof XMLObjectReferenceMapping) {
                Object value = session.getIdentityMapAccessor().getFromIdentityMap(reference.getPrimaryKey(), reference.getTargetClass());
                XMLObjectReferenceMapping mapping = (XMLObjectReferenceMapping)reference.getMapping();
                if (value != null) {
                    mapping.setAttributeValueInObject(reference.getSourceObject(), value);




import java.util.ArrayList;
import java.util.Enumeration;
import java.util.List;
import java.util.Vector;
import java.util.Map.Entry;

import javax.xml.namespace.QName;

import org.eclipse.persistence.internal.descriptors.Namespace;
import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.oxm.WeakObjectWrapper;
import org.eclipse.persistence.internal.queries.JoinedAttributeManager;

    public AbstractRecord buildRow(Object object, AbstractSession session, DatabaseField xmlField, XMLRecord parentRecord, boolean addXsiType) {
        if (isXmlDescriptor() && ((XMLDescriptor)getDescriptor()).shouldPreserveDocument()) {
            Object pk = extractPrimaryKeyFromObject(object, session);
            if ((pk == null) || (pk instanceof CacheId) && (((CacheId)pk).getPrimaryKey().length == 0)) {
                pk = new CacheId(new Object[]{ new WeakObjectWrapper(object) });
                ((Vector)pk).add(new WeakObjectWrapper(object));
            }
            CacheKey cacheKey = session.getIdentityMapAccessorInstance().getCacheKeyForObject(pk, getDescriptor().getJavaClass(), getDescriptor());
            if ((cacheKey != null) && (cacheKey.getRecord() != null)) {

        }
        concreteDescriptor.getObjectBuilder().buildAttributesIntoObject(domainObject, databaseRow, query, joinManager, false);
        if (isXmlDescriptor() && ((XMLDescriptor)concreteDescriptor).getPrimaryKeyFieldNames().size() > 0) {
            if ((pk == null) || (((CacheId)pk).getPrimaryKey().length == 0)) {
                pk = new CacheId(new Object[]{ new WeakObjectWrapper(domainObject) });
                ((Vector)pk).add(new WeakObjectWrapper(domainObject));
            }
            CacheKey key = query.getSession().getIdentityMapAccessorInstance().acquireDeferredLock(pk, concreteDescriptor.getJavaClass(), concreteDescriptor);
            if (((XMLDescriptor)concreteDescriptor).shouldPreserveDocument()) {

    }

    public void writeOutMappings(XMLRecord row, Object object, AbstractSession session) {
        List<DatabaseMapping> mappings = getDescriptor().getMappings();
        for (int index = 0; index < mappings.size(); index++) {
            DatabaseMapping mapping = mappings.get(index);
            mapping.writeFromObjectIntoRow(object, row, session);
        }
    }




import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.sessions.DatabaseRecord;
import org.eclipse.persistence.tools.profiler.QueryMonitor;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.exceptions.*;

        
        ClassDescriptor descriptor = getDescriptor();
        List<DatabaseField> primaryKeyFields = descriptor.getPrimaryKeyFields();
        Vector primaryKeyValues = new Vector(primaryKeyFields.size());
        
        // Check that the query is by primary key.
        for (DatabaseField primaryKeyField : primaryKeyFields) {
            if (!queryFields.contains(primaryKeyField)) {
                Object value = translationRow.get(primaryKeyField);
            
                if (value == null) {
                    return null;
                } else {
                    primaryKeyValues.add(value);    
                }
            } else {
                return null;
            }
        }
        Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromRow(translationRow, session);
        if (primaryKey == null) {
            return null;
        }
        
        if (descriptor.shouldAcquireCascadedLocks()) {
            return session.getIdentityMapAccessorInstance().getFromIdentityMapWithDeferredLock(primaryKey, getReadObjectQuery().getReferenceClass(), false, descriptor);
        } else {
            return session.getIdentityMapAccessorInstance().getFromIdentityMap(primaryKey, getReadObjectQuery().getReferenceClass(), false, descriptor);
        }        
    }


            if (objectChangeSet != null) {
                updateChangeSet(getDescriptor(), objectChangeSet, row, object);
                if (primaryKey != null) {
                    objectChangeSet.setId(primaryKey);
                }
            }
        }

            }
            if (objectChangeSet != null) {
                updateChangeSet(descriptor, objectChangeSet, sequenceNumberField, object);
                objectChangeSet.setId(primaryKey);
            }
        }
    }

Lines 712-717 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/queries/ExpressionQueryMechanism.java (-9 / +10 lines)
712	* This is only called from read object query.	712	* This is only called from read object query.
713	* The query has already checked that the cache should be checked.	713	* The query has already checked that the cache should be checked.
714	*/	714	*/
		715	@Override
715	public Object checkCacheForObject(AbstractRecord translationRow, AbstractSession session) {	716	public Object checkCacheForObject(AbstractRecord translationRow, AbstractSession session) {
716	// For bug 2782991 a list of nearly 20 problems with this method have	717	// For bug 2782991 a list of nearly 20 problems with this method have
717	// been fixed.	718	// been fixed.
Lines 760-769 Link Here
760	} else {	761	} else {
761	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMap(selectionKey, query.getReferenceClass(), false, descriptor);	762	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMap(selectionKey, query.getReferenceClass(), false, descriptor);
762	}	763	}
763	// Also check if key is null, cannot exist.
764	if (((Vector)selectionKey).contains(null)) {
765	return InvalidObject.instance;
766	}
767	} else {	764	} else {
768	// 2: If selection criteria null, take any instance in cache.	765	// 2: If selection criteria null, take any instance in cache.
769	//	766	//
Lines 781-796 Link Here
781	// primary key only this will become the final check.	778	// primary key only this will become the final check.
782	if ((selectionKey != null) \|\| query.shouldCheckCacheByExactPrimaryKey()) {	779	if ((selectionKey != null) \|\| query.shouldCheckCacheByExactPrimaryKey()) {
783	if (selectionKey != null) {	780	if (selectionKey != null) {
		781	// Check if key is invalid (null), cannot exist.
		782	if (selectionKey == InvalidObject.instance) {
		783	return selectionKey;
		784	}
784	if (descriptor.shouldAcquireCascadedLocks()) {	785	if (descriptor.shouldAcquireCascadedLocks()) {
785	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMapWithDeferredLock(selectionKey, query.getReferenceClass(), false, descriptor);	786	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMapWithDeferredLock(selectionKey, query.getReferenceClass(), false, descriptor);
786	} else {	787	} else {
787	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMap(selectionKey, query.getReferenceClass(), false, descriptor);	788	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMap(selectionKey, query.getReferenceClass(), false, descriptor);
788	}	789	}
789	// Because it was exact primary key if the lookup failed then it is not there.	790	// Because it was exact primary key if the lookup failed then it is not there.
790	// Also check if key is null, cannot exist.
791	if (((Vector)selectionKey).contains(null)) {
792	return InvalidObject.instance;
793	}
794	}	791	}
795	} else {	792	} else {
796	// 4: If can extract inexact primary key, find one object by primary key and	793	// 4: If can extract inexact primary key, find one object by primary key and
Lines 798-803 Link Here
798	// rule out a cache hit.	795	// rule out a cache hit.
799	Object inexactSelectionKey = descriptor.getObjectBuilder().extractPrimaryKeyFromExpression(false, selectionCriteria, translationRow, session);// Check for any primary key in expression, may have other stuff.	796	Object inexactSelectionKey = descriptor.getObjectBuilder().extractPrimaryKeyFromExpression(false, selectionCriteria, translationRow, session);// Check for any primary key in expression, may have other stuff.
800	if (inexactSelectionKey != null) {	797	if (inexactSelectionKey != null) {
		798	// Check if key is invalid (null), cannot exist.
		799	if (selectionKey == InvalidObject.instance) {
		800	return selectionKey;
		801	}
801	// PERF: Only use deferred lock when required.	802	// PERF: Only use deferred lock when required.
802	if (descriptor.shouldAcquireCascadedLocks()) {	803	if (descriptor.shouldAcquireCascadedLocks()) {
803	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMapWithDeferredLock(inexactSelectionKey, query.getReferenceClass(), false, descriptor);	804	cachedObject = session.getIdentityMapAccessorInstance().getFromIdentityMapWithDeferredLock(inexactSelectionKey, query.getReferenceClass(), false, descriptor);




import org.eclipse.persistence.internal.expressions.ForUpdateOfClause;
import org.eclipse.persistence.exceptions.QueryException;
import org.eclipse.persistence.internal.helper.NonSynchronizedSubVector;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.queries.ObjectBuildingQuery;
import org.eclipse.persistence.queries.ObjectLevelReadQuery;

    protected transient List<AbstractRecord> dataResults;

    /** Stored all row results to -m joining by cache key. */
    protected transient Map<Object, List<AbstractRecord>> dataResultsByPrimaryKey;
    
    /** Stores the descriptor that these joins apply on */
    protected transient ClassDescriptor descriptor;

    /**
     * Return all of the rows fetched by the query by cache-key, used for 1-m joining.
     */
    public Map<Object, List<AbstractRecord>> getDataResultsByPrimaryKey() {
        return dataResultsByPrimaryKey;
    }
    
    /**
     * Set all of the rows fetched by the query by cache-key, used for 1-m joining.
     */
    protected void setDataResultsByPrimaryKey(Map<Object, List<AbstractRecord>> dataResultsByPrimaryKey) {
        this.dataResultsByPrimaryKey = dataResultsByPrimaryKey;
    }
    

    protected void processDataResults(AbstractSession session) {
        this.dataResultsByPrimaryKey = new HashMap();
        int size = this.dataResults.size();
        Object lastKey = null;
        List<AbstractRecord> childRows = null;
        ObjectBuilder builder = getDescriptor().getObjectBuilder();
        int parentIndex = getParentResultIndex();
        for (int dataResultsIndex = 0; dataResultsIndex < size; dataResultsIndex++) {

            Object sourceKey = builder.extractPrimaryKeyFromRow(parentRow, session);
            // May be any outer-join so ignore null.
            if (sourceKey != null) {
                if ((lastKey != null) && lastKey.equals(sourceKey)) {
                if ((lastCacheKey != null) && lastCacheKey.equals(sourceCacheKey)) {
                    childRows.add(row);
                    if (shouldFilterDuplicates()) {
                        // Also null out the row because it is a duplicate to avoid object building processing it.
                        this.dataResults.set(dataResultsIndex, null);
                    }
                } else {
                    childRows =  this.dataResultsByPrimaryKey.get(sourceKey);
                    if (childRows == null) {
                        childRows = new ArrayList();
                        this.dataResultsByPrimaryKey.put(sourceKey, childRows);
                    } else {
                        if (shouldFilterDuplicates()) {
                            // Also null out the row because it is a duplicate to avoid object building processing it.

                        }
                    }
                    childRows.add(row);
                    lastKey = sourceKey;
                }
            }
        }




                        
                        //if objectToRemove is null, we can't look it up in the collection. 
                        // This should not happen unless identity is lost.
                        if (objectToRemove != null) {
                            Integer index = changeObject.getIndex();
                            if (index!=null){
                                if (objectToRemove.equals(get(index, valueOfTarget, mergeManager.getSession()))) {
                                    removeFromAtIndex(index, valueOfTarget);
                                } else {
                                    // Object is in the cache, but the collection doesn't have it at the location we expect
                                    // Collection is invalid with respect to these changes, so invalidate the parent and abort 
                                    Object key = changeRecord.getOwner().getId();
                                    parentSession.getIdentityMapAccessor().invalidateObject(key, changeRecord.getOwner().getClassType(parentSession));
                                    return;
                                }
                            } else {
                                removeFrom(objectToRemove, valueOfTarget, parentSession);
                            }
                            
                            if ((! mergeManager.shouldMergeChangesIntoDistributedCache()) && changeRecord.getMapping().isPrivateOwned()) {
                                // Check that the object was actually removed and not moved.
                                if (objectRemoved) {
                                    mergeManager.registerRemovedNewObjectIfRequired(objectChanges.getUnitOfWorkClone());

                        }
                        
                        
                    } else { //getChangeType == add
                        boolean objectAdded = changeRecord.getAddObjectList().containsKey(objectChanges);
                        Object object = null;
                        // The object was actually added and not moved.

                        
                            //Object is either not in the cache, or not at the location we expect
                            // Collection is invalid with respect to these changes, so invalidate the parent and abort 
                            Object key = changeRecord.getOwner().getId();
                            parentSession.getIdentityMapAccessor().invalidateObject(key, changeRecord.getOwner().getClassType(parentSession));
                            return;
                        }

Lines 13-19 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/AggregateObjectChangeSet.java (-2 / +2 lines)
13	package org.eclipse.persistence.internal.sessions;	13	package org.eclipse.persistence.internal.sessions;
14		14
15	import org.eclipse.persistence.descriptors.ClassDescriptor;	15	import org.eclipse.persistence.descriptors.ClassDescriptor;
16	import org.eclipse.persistence.internal.identitymaps.CacheKey;
17		16
18	public class AggregateObjectChangeSet extends ObjectChangeSet {	17	public class AggregateObjectChangeSet extends ObjectChangeSet {
19		18
Lines 31-37 Link Here
31	super(primaryKey, descriptor, cloneObject, parent, isNew);	30	super(primaryKey, descriptor, cloneObject, parent, isNew);
32	}	31	}
33		32
34	public CacheKey CacheKey() {	33	@Override
		34	public Object getId() {
35	return null;	35	return null;
36	}	36	}
37		37

Lines 205-215 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/CommitOrderDependencyNode.java (-3 / +3 lines)
205	results.addElement(node);	205	results.addElement(node);
206		206
207	if (node.getDescriptor().hasInheritance()) {	207	if (node.getDescriptor().hasInheritance()) {
208	InheritancePolicy p = node.getDescriptor().getInheritancePolicy();	208	InheritancePolicy policy = node.getDescriptor().getInheritancePolicy();
209		209
210	// For bug 3019934 replace getChildDescriptors with getAllChildDescriptors.	210	// For bug 3019934 replace getChildDescriptors with getAllChildDescriptors.
211	for (Enumeration e = p.getAllChildDescriptors().elements(); e.hasMoreElements();) {	211	for (ClassDescriptor child : policy.getAllChildDescriptors()) {
212	results.addElement(getOwner().nodeFor((ClassDescriptor)e.nextElement()));	212	results.add(getOwner().nodeFor(child));
213	}	213	}
214	}	214	}
215	return results;	215	return results;




    }

    /**
     * Convert the primary key Vector into a primary key object.
     * This is used to support the old deprecated Vector API.
     */
    public Object primaryKeyFromVector(Vector primaryKeyVector) {
        if (primaryKeyVector == null) {
            return null;
        } else if (primaryKeyVector.size() == 1) {
            return primaryKeyVector.get(0);            
        } else {
            return new CacheId(primaryKeyVector.toArray());
        }
    }
    
    /**
     * ADVANCED:
     * Return if their is an object for the primary key.
     */
    @Deprecated
    public boolean containsObjectInIdentityMap(Vector primaryKey, Class theClass) {
        return containsObjectInIdentityMap(primaryKeyFromVector(primaryKey), theClass);
        return containsObjectInIdentityMap(primaryKey, theClass, descriptor);
    }

    /**

     */
    @Deprecated
    public Object getFromIdentityMap(Vector primaryKey, Class theClass) {
        return getFromIdentityMap(primaryKeyFromVector(primaryKey), theClass);
    }

    /**

     */
    @Deprecated
    public Object getFromIdentityMap(Vector primaryKey, Class theClass, boolean shouldReturnInvalidatedObjects) {
        return getFromIdentityMap(primaryKeyFromVector(primaryKey), theClass, shouldReturnInvalidatedObjects);
    }

    /**

     */
    @Deprecated
    public Object getWriteLockValue(Vector primaryKey, Class theClass) {
        return getWriteLockValue(primaryKeyFromVector(primaryKey), theClass);
    }

    /**

     */
    @Deprecated
    public void invalidateObject(Vector primaryKey, Class theClass, boolean invalidateCluster) {
        invalidateObject(primaryKeyFromVector(primaryKey), theClass, invalidateCluster);
    }

    /**

     */
    @Deprecated
    public void invalidateObject(Vector primaryKey, Class theClass) {
        invalidateObject(primaryKeyFromVector(primaryKey), theClass);
    }

    /**

     * @param invalidateCluster if true the invalidation will be broadcast to each server in the cluster.
     */
    public void invalidateObject(Object primaryKey, Class theClass, boolean invalidateCluster) {
        if (primaryKey == null) {
            return;
        }
        ClassDescriptor descriptor = getSession().getDescriptor(theClass);
        //forward the call to getCacheKeyForObject locally in case subclasses overload
        CacheKey key = getCacheKeyForObjectForLock(primaryKey, theClass, descriptor);
        if (key != null) {
            key.setInvalidationState(CacheKey.CACHE_KEY_INVALID);
        }

     */
    @Deprecated
    public boolean isValid(Vector primaryKey, Class theClass) {
        return isValid(primaryKeyFromVector(primaryKey), theClass);
    }

    /**

     */
    @Deprecated
    public Object putInIdentityMap(Object object, Vector key) {
        return putInIdentityMap(object, primaryKeyFromVector(key));
    }

    /**

     */
    @Deprecated
    public Object putInIdentityMap(Object object, Vector key, Object writeLockValue, long readTime) {
        return putInIdentityMap(object, primaryKeyFromVector(key), writeLockValue, readTime);
        return putInIdentityMap(object, key, writeLockValue, readTime, descriptor);
    }

    /**

     */
    @Deprecated
    public Object removeFromIdentityMap(Vector key, Class theClass) {
        return removeFromIdentityMap(primaryKeyFromVector(key), theClass);
        return removeFromIdentityMap(key, theClass, descriptor, null);
    }
    
    /**

     */
    @Deprecated
    public void updateWriteLockValue(Vector primaryKey, Class theClass, Object writeLockValue) {
        updateWriteLockValue(primaryKeyFromVector(primaryKey), theClass, writeLockValue);
    }

    /**




import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.helper.linkedlist.LinkedNode;
import org.eclipse.persistence.queries.DoesExistQuery;
import org.eclipse.persistence.sessions.remote.*;
import org.eclipse.persistence.internal.sessions.remote.*;
import org.eclipse.persistence.internal.queries.ContainerPolicy;

    /** Used to store the list of locks that this merge manager has acquired for this merge */
    protected ArrayList<CacheKey> acquiredLocks;

    /** If this variable is not null then the mergemanager is waiting on a particular primary key */
    protected Object writeLockQueued;

    /** Stores the node that holds this mergemanager within the WriteLocksManager queue */
    protected LinkedNode queueNode;

     * INTENRAL:
     * Used to get the object that the merge manager is waiting on, in order to acquire locks
     */
    public Object getWriteLockQueued() {
        return this.writeLockQueued;
    }
    


        // Perform invalidation of a cached object (when set on the ChangeSet) to avoid refreshing or merging
        if (changeSet.getSynchronizationType() == ClassDescriptor.INVALIDATE_CHANGED_OBJECTS) {
            session.getIdentityMapAccessorInstance().invalidateObject(changeSet.getId(), localClassType);
            return original;
        }
        

                // Rebuild the version value from user format i.e the change set was converted to XML
                changeSet.rebuildWriteLockValueFromUserFormat(descriptor, session);
            }
            int difference = descriptor.getOptimisticLockingPolicy().getVersionDifference(changeSet.getInitialWriteLockValue(), original, changeSet.getId(), session);
            
            // Should be = 0 if was a good update, otherwise was already refreshed, or a version change was lost.
            if (difference < 0) {
                // The current version is newer than the one on the remote system, was refreshed already, ignore change.
                session.log(SessionLog.FINEST, SessionLog.PROPAGATION, "change_from_remote_server_older_than_current_version", changeSet.getClassName(), changeSet.getId());
                return original;
            } else if (difference > 0) {
                // If the current version is much older than the remote system, so invalidate the object as a change was missed.
                session.log(SessionLog.FINEST, SessionLog.PROPAGATION, "current_version_much_older_than_change_from_remote_server", changeSet.getClassName(), changeSet.getId());
                session.getIdentityMapAccessorInstance().invalidateObject(changeSet.getId(), localClassType);
                return original;
            }
        }

        // Always merge into the original.
        session.log(SessionLog.FINEST, SessionLog.PROPAGATION, "Merging_from_remote_server", changeSet.getClassName(), changeSet.getId());

        if (changeSet.isNew() || (changeSet.getSynchronizationType() != ClassDescriptor.DO_NOT_SEND_CHANGES)) {
            descriptor.getObjectBuilder().mergeChangesIntoObject(original, changeSet, null, this, false);
            Object primaryKey = changeSet.getId();

            // PERF: Get the cached cache-key from the change-set.
            CacheKey cacheKey = changeSet.getActiveCacheKey();

        }
        //update the change policies with the refresh
        descriptor.getObjectChangePolicy().revertChanges(clone, descriptor, (UnitOfWorkImpl)this.session, ((UnitOfWorkImpl)this.session).getCloneMapping());
        Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(clone, this.session, true);
        if (primaryKey == null) {
            return clone;
        }
        
        if (descriptor.usesOptimisticLocking()) {
            descriptor.getOptimisticLockingPolicy().mergeIntoParentCache((UnitOfWorkImpl)this.session, primaryKey, clone);
        }

        CacheKey parentCacheKey = ((UnitOfWorkImpl)this.session).getParent().getIdentityMapAccessorInstance().getCacheKeyForObjectForLock(primaryKey, clone.getClass(), descriptor);
        CacheKey uowCacheKey = this.session.getIdentityMapAccessorInstance().getCacheKeyForObjectForLock(primaryKey, clone.getClass(), descriptor);


                    // lock it to prevent a reading thread from creating it as well
                    // there will be no deadlock situation because no other threads
                    // will be able to reference this object.
                    original = parent.getIdentityMapAccessorInstance().getWriteLockManager().appendLock(objectChangeSet.getId(), original, descriptor, this, parent);
                    objectBuilder.mergeIntoObject(original, true, clone, this, false, !descriptor.getCopyPolicy().buildsNewInstance());
                } else {
                    objectBuilder.mergeChangesIntoObject(original, objectChangeSet, clone, this, !descriptor.getCopyPolicy().buildsNewInstance());

            } else {
                // Invalidate any object that was marked invalid during the change calculation, even if it was new as multiple flushes 
                // and custom SQL could still produce invalid new objects.
                if (objectChangeSet.shouldInvalidateObject(original, parent) && (!unitOfWork.isNestedUnitOfWork())) {
                    parent.getIdentityMapAccessor().invalidateObject(original);
                    // no need to update cacheKey properties here
                }

    protected Object registerObjectForMergeCloneIntoWorkingCopy(Object clone) {
        UnitOfWorkImpl unitOfWork = (UnitOfWorkImpl)this.session;
        ClassDescriptor descriptor = unitOfWork.getDescriptor(clone.getClass());
        Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(clone, unitOfWork, true);

        // Must use the java class as this may be a bean that we are merging and it may not have the same class as the
        // objects in the cache.  As of EJB 2.0.
        Object objectFromCache = null;
        if (primaryKey != null) {
            objectFromCache = unitOfWork.getIdentityMapAccessorInstance().getFromIdentityMap(primaryKey, descriptor.getJavaClass(), false, descriptor);
        }
        if (objectFromCache == null) {
            // Ensure we return the working copy if this has already been registered.
            objectFromCache = unitOfWork.checkIfAlreadyRegistered(clone, descriptor);

                if (shouldMergeCloneIntoWorkingCopy() || shouldMergeCloneWithReferencesIntoWorkingCopy()) {
                    throw new IllegalArgumentException(ExceptionLocalization.buildMessage("cannot_merge_removed_entity", new Object[] { clone }));
                }
            }            
            
            return objectFromCache;
        }

        DoesExistQuery existQuery = descriptor.getQueryManager().getDoesExistQuery();
        // Optimize cache option to avoid executing the does exist query.
        if (existQuery.shouldCheckCacheForDoesExist()) {
            checkNewObjectLockVersion(clone, primaryKey, descriptor, unitOfWork);
            Object registeredObject = unitOfWork.internalRegisterObject(clone, descriptor);            
                Object baseValue = policy.getBaseValue();
                Object objectLockValue = policy.getWriteLockValue(clone, primaryKey, unitOfWork);
                if ( policy.isNewerVersion(objectLockValue, baseValue) ) {
                    throw OptimisticLockException.objectChangedSinceLastMerge(clone);
                }
            }
            Object registeredObject = unitOfWork.internalRegisterObject(clone, descriptor);
            
            if (unitOfWork.hasNewObjects() && unitOfWork.getNewObjectsOriginalToClone().containsKey(clone)) {
                this.mergedNewObjects.put(registeredObject, registeredObject);
            }            
            
            return registeredObject;
        }

        // Check early return to check if it is a new object, i.e. null primary key.
        Boolean doesExist = Boolean.FALSE;
        if (primaryKey != null) {
            doesExist = (Boolean)existQuery.checkEarlyReturn(clone, primaryKey, unitOfWork, null);
        }
        if (doesExist == Boolean.FALSE) {
            checkNewObjectLockVersion(clone, primaryKey, descriptor, unitOfWork);
            if (descriptor.usesVersionLocking()){
                VersionLockingPolicy policy = (VersionLockingPolicy)descriptor.getOptimisticLockingPolicy();
                Object baseValue = policy.getBaseValue();
                Object objectLockValue = policy.getWriteLockValue(clone, primaryKey, unitOfWork);
                if ( policy.isNewerVersion(objectLockValue, baseValue) ) {
                    throw OptimisticLockException.objectChangedSinceLastMerge(clone);
                }
            }
            Object registeredObject = unitOfWork.internalRegisterObject(clone, descriptor);
            this.mergedNewObjects.put(registeredObject, registeredObject);
            return registeredObject;
        }
    
        // Otherwise it is existing and not in the cache so it must be read.
        Object object = unitOfWork.readObject(clone);
        if (object == null) {
            checkNewObjectLockVersion(clone, primaryKey, descriptor, unitOfWork);
            if (descriptor.usesVersionLocking()){
                VersionLockingPolicy policy = (VersionLockingPolicy)descriptor.getOptimisticLockingPolicy();
                Object baseValue = policy.getBaseValue();
                Object objectLockValue = policy.getWriteLockValue(clone, primaryKey, unitOfWork);
                if ( policy.isNewerVersion(objectLockValue, baseValue) ) {
                    throw OptimisticLockException.objectChangedSinceLastMerge(clone);
                }
            }
            
            //bug6180972: avoid internal register's existence check and be sure to put the new object in the mergedNewObjects collection
            object =  unitOfWork.cloneAndRegisterNewObject(clone);
            this.mergedNewObjects.put(object, object);
        }
        return object;
    }

    /**
     * Check if the new object's version has been set, if so, then it was an existing object that was deleted.
     * Raise an error instead of reincarnating the object.
     */
    public void checkNewObjectLockVersion(Object clone, Object primaryKey, ClassDescriptor descriptor, UnitOfWorkImpl unitOfWork) {
        //bug272704: throw an exception if this object is new yet has a version set to avoid merging in deleted objects
        if (descriptor.usesVersionLocking()){
            VersionLockingPolicy policy = (VersionLockingPolicy)descriptor.getOptimisticLockingPolicy();
            Object baseValue = policy.getBaseValue();
            Object objectLockValue = policy.getWriteLockValue(clone, primaryKey, unitOfWork);
            if (policy.isNewerVersion(objectLockValue, baseValue)) {
                throw OptimisticLockException.objectChangedSinceLastMerge(clone);
            }
        }
    }
    
    /**
     * Determine if the object is a registered new object, and that this is a nested unit of work
     * merge into the parent.  In this case private mappings will register the object as being removed.
     */

     * Used to set the object that the merge manager is waiting on, in order to acquire locks
     * If this value is null then the merge manager is not waiting on any locks.
     */
    public void setWriteLockQueued(Object primaryKey) {
        this.writeLockQueued = primaryKey;
    }

    /**




import org.eclipse.persistence.descriptors.VersionLockingPolicy;
import org.eclipse.persistence.descriptors.TimestampLockingPolicy;
import org.eclipse.persistence.mappings.*;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;


    protected List<org.eclipse.persistence.sessions.changesets.ChangeRecord> changes;
    protected transient Map<String, ChangeRecord> attributesToChanges;
    protected boolean shouldBeDeleted;
    protected Object id;
    protected transient Class classType;
    protected String className;
    protected boolean isNew;

        this.cloneObject = cloneObject;
        this.isNew = isNew;
        this.shouldBeDeleted = false;
        this.id = primaryKey;
            this.cacheKey = new CacheKey(primaryKey);
        }
        this.classType = descriptor.getJavaClass();
        this.className = this.classType.getName();
        this.descriptor = descriptor;

    /**
     * Ensure change sets with the same primary key are equal.
     */
    public boolean equals(ObjectChangeSet objectChange) {
        if (this == objectChange) {
            return true;
        } else if (this.id == null) {
            //new objects are compared based on identity
            return false;
        }

        return (this.id.equals(objectChange.id));
    }

    /**

    }

    /**
     * Return the CacheKey for the object that this is a change set for.
     */
    public CacheKey getCacheKey() {
        // this must not be lazy initialized as newness of the ObjectChangeSet and
        //equality are determined by the existence of a cachekey - GY
        return cacheKey;
    }

    /**
     * ADVANCED:
     * This method will return a collection of the attributes changed in the object.
     */

     * ADVANCED:
     * This method returns the primary keys for the object that this change set represents.
     */
    @Deprecated
    public Vector getPrimaryKeys() {
        if (this.id instanceof CacheId) {
            return new Vector(Arrays.asList(((CacheId)this.id).getPrimaryKey()));
        }
        Vector primaryKey = new Vector(1);
        primaryKey.add(this.id);
        return primaryKey;
    }
    
    /**
     * ADVANCED:
     * This method returns the primary key for the object that this change set represents.
     */
    public Object getId() {
        return this.id;
    }

    public int getSynchronizationType() {
        return cacheSynchronizationType;

                }
            } else {
                // It is not a unitOfWork so we must be merging into a distributed cache.
                attributeValue = session.getIdentityMapAccessorInstance().getIdentityMapManager().getFromIdentityMap(getId(), getClassType(session), descriptor);
            }
        
            if ((attributeValue == null) && (shouldRead)) {

                ReadObjectQuery query = new ReadObjectQuery();
                query.setShouldUseWrapperPolicy(false);
                query.setReferenceClass(getClassType(session));
                query.setSelectionId(getId());
                attributeValue = session.executeQuery(query);
            }
        }

     * cache key, otherwise return the identity hashcode of this object.
     */
    public int hashCode() {
        if (getId() == null) {
            //new objects are compared based on identity
            return System.identityHashCode(this);
        }
        return getId().hashCode();
    }

    /**

     */
    public void readIdentityInformation(java.io.ObjectInputStream stream) throws java.io.IOException, ClassNotFoundException {
        // bug 3526981 - avoid side effects of setter methods by directly assigning variables
        this.id = stream.readObject();
        this.className = (String)stream.readObject();
        this.writeLockValue = stream.readObject();
        this.initialWriteLockValue = stream.readObject();

    }

    /**
     * Set the id of the object for this change set.
     */
    public void setId(Object id) {
        this.id = id;
    }

    /**

        // ignore optimistic locking policy if it can't compare lock values (like FieldsLockingPolicy).
        if(optimisticLockingPolicy.supportsWriteLockValuesComparison()) {
            this.optimisticLockingPolicy = optimisticLockingPolicy;
            this.initialWriteLockValue = optimisticLockingPolicy.getWriteLockValue(cloneObject, getId(), session);
        }
    }


     * This method is used to set the initial writeLock value for an ObjectChangeSet.
     * The initial value will only be set once, and can not be overwritten.
     */
    public void setInitialWriteLockValue(Object initialWriteLockValue) {
        if (this.initialWriteLockValue == null) {
            this.initialWriteLockValue = initialWriteLockValue;
        }

     * ObjectChangeSet to the stream
     */
    public void writeIdentityInformation(java.io.ObjectOutputStream stream) throws java.io.IOException {
        stream.writeObject(this.id);
        stream.writeObject(this.className);
        stream.writeObject(this.writeLockValue);
        stream.writeObject(this.initialWriteLockValue);

    }

    /**
     * INTERNAL:
     */
    public void setPrimaryKeys(Vector key) {
        if (key == null) {
            return;
        }
        if (getCacheKey() == null) {
            setCacheKey(new CacheKey(key));
        } else {
            getCacheKey().setKey(key);
        }
    }

    /**
     * This set contains the list of attributes that must be calculated at commit time.
     */
    public Set<String> getDeferredSet() {

     * Remove object represent this change set from identity map.  If change set is in XML format, rebuild pk to the correct class type from String
     */
    protected void removeFromIdentityMap(AbstractSession session) {
        session.getIdentityMapAccessor().removeFromIdentityMap(getId(), getClassType(session));
    }

    /**

            return true;
        }
        
        Object originalWriteLockValue = optimisticLockingPolicy.getWriteLockValue(original, getId(), session);
        
        // initialWriteLockValue and originalWriteLockValue are not equal.
        // Example: 

Lines 14-20 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/remote/RemoteValueHolder.java (-2 / +1 lines)
14		14
15	import java.rmi.server.ObjID;	15	import java.rmi.server.ObjID;
16	import java.io.*;	16	import java.io.*;
17	import java.util.*;
18	import org.eclipse.persistence.sessions.remote.*;	17	import org.eclipse.persistence.sessions.remote.*;
19	import org.eclipse.persistence.queries.*;	18	import org.eclipse.persistence.queries.*;
20	import org.eclipse.persistence.descriptors.ClassDescriptor;	19	import org.eclipse.persistence.descriptors.ClassDescriptor;
Lines 57-63 Link Here
57	return false;	56	return false;
58	}	57	}
59		58
60	return (getTargetObjectPrimaryKeys() != null) && (!((Vector)getTargetObjectPrimaryKeys()).isEmpty()) && getMapping().isOneToOneMapping() && (!getQuery().shouldRefreshIdentityMapResult()) && (!getQuery().shouldRefreshRemoteIdentityMapResult()) && (getQuery().shouldMaintainCache());	59	return (getTargetObjectPrimaryKeys() != null) && getMapping().isOneToOneMapping() && (!getQuery().shouldRefreshIdentityMapResult()) && (!getQuery().shouldRefreshRemoteIdentityMapResult()) && (getQuery().shouldMaintainCache());
61	}	60	}
62		61
63	/**	62	/**




import java.io.*;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.helper.CustomObjectInputStream;
import org.eclipse.persistence.internal.identitymaps.CacheKey;

/**
 * <p>

                        getAllChangeSets().put(objectChanges, objectChanges);
                    }
         
                    if (objectChanges.getId() != null) {
                        Map<ObjectChangeSet, ObjectChangeSet> map = getObjectChanges().get(objectChanges.getClassType());

                        if (map == null) {

        }
        ObjectChangeSet localChangeSet = this.findObjectChangeSet(tofind, mergeFromChangeSet);
        if (localChangeSet == null) {//not found locally then replace it with the one from the merging changeset
            localChangeSet = new ObjectChangeSet(tofind.getId(), tofind.getDescriptor(), tofind.getUnitOfWorkClone(), this, tofind.isNew());
            this.addObjectChangeSetForIdentity(localChangeSet, localChangeSet.getUnitOfWorkClone());
        }
        return localChangeSet;

     */
    public void putNewObjectInChangesList(ObjectChangeSet objectChangeSet, AbstractSession session) {
        // Must reset the cache key for new objects assigned in insert.
        if (objectChangeSet.getId() == null) {
            Object clone = objectChangeSet.getUnitOfWorkClone();
            objectChangeSet.setId(session.getDescriptor(clone.getClass()).getObjectBuilder().extractPrimaryKeyFromObject(clone, session, false));
        }
        addObjectChangeSet(objectChangeSet, session, false);
        removeObjectChangeSetFromNewList(objectChangeSet, session);
    }





import java.io.*;

import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.annotations.CacheKeyType;
import org.eclipse.persistence.descriptors.*;
import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.descriptors.DescriptorIterator.CascadeCondition;


        // Also mark all subclasses as read-only.
        if (descriptor.hasInheritance()) {
            for (ClassDescriptor childDescriptor : descriptor.getInheritancePolicy().getChildDescriptors()) {
                     childEnum.hasMoreElements();) {
                ClassDescriptor childDescriptor = (ClassDescriptor)childEnum.nextElement();
                addReadOnlyClass(childDescriptor.getJavaClass());
            }
        }

     * The unit of work cache key is passed to the normal cloneAndRegisterObject method.
     */
    public Object cloneAndRegisterObject(Object original, CacheKey parentCacheKey, ClassDescriptor descriptor) {
        CacheKey unitOfWorkCacheKey = null;
        if (parentCacheKey.getKey() == null) {
            // The primary key may be null for nested units of work with new parent objects.
            unitOfWorkCacheKey = new UnitOfWorkCacheKey(null);
            unitOfWorkCacheKey.acquire();
        } else {
            unitOfWorkCacheKey = getIdentityMapAccessorInstance().acquireLock(parentCacheKey.getKey(), original.getClass(), descriptor);
        }
        try {
            return cloneAndRegisterObject(original, parentCacheKey, unitOfWorkCacheKey, descriptor);
        } finally {

            workingClone = builder.instantiateWorkingCopyClone(original, this);
            // PERF: Cache the primary key if implements PersistenceEntity.
            if (workingClone instanceof PersistenceEntity) {
                ((PersistenceEntity)workingClone)._persistence_setId(parentCacheKey.getKey());
            }

            // This must be registered before it is built to avoid really obscure cycles.

                 newObjectsEnum.hasNext();) {
            Object object = newObjectsEnum.next();
            if (theClass.isInstance(object)) {
                Object primaryKey = objectBuilder.extractPrimaryKeyFromObject(object, this, true);
                if ((primaryKey != null) && primaryKey.equals(selectionKey)) {
                if (new CacheKey(primaryKey).equals(new CacheKey(selectionKey))) {
                    return object;
                }
            }

        if (!hasNewObjects()) {
            return null;
        }
        for (Object object : getNewObjectsCloneToOriginal().keySet()) {
                 newObjectsEnum.hasNext();) {
            Object object = newObjectsEnum.next();
            if (theClass.isInstance(object)) {
                if (selectionCriteria == null) {
                    return object;

     */
    protected Object getObjectFromSharedCacheForMerge(Object implementation, ObjectBuilder builder, ClassDescriptor descriptor){
        Object original = null;
        Object primaryKey = builder.extractPrimaryKeyFromObject(implementation, this, true);
        if (this.lastUsedMergeManager == null) {
            // not merging into the shared cache so just return object from parent identity map
            // If a nested unit of work, new objects may have null primary keys, and not be in the cache.
            if (primaryKey == null) {
                return null;
            }
            return getParent().getIdentityMapAccessorInstance().getFromIdentityMap(primaryKey, implementation.getClass(), descriptor);
        }
        CacheKey cacheKey = getParent().getIdentityMapAccessorInstance().getCacheKeyForObject(primaryKey, implementation.getClass(), descriptor);
        if (cacheKey != null) {
            if (cacheKey.acquireReadLockNoWait()) {
                original = cacheKey.getObject();
                cacheKey.releaseReadLock();
            } else {
                if (!getMergeManager().isTransitionedToDeferredLocks()) {
                    getParent().getIdentityMapAccessorInstance().getWriteLockManager().transitionToDeferredLocks(getMergeManager());
                }
                cacheKey.acquireDeferredLock();
                original = cacheKey.getObject();
                if (original == null) {

            Map deletedObjects = this.unitOfWorkChangeSet.getDeletedObjects();
            for (Iterator removedObjects = deletedObjects.keySet().iterator(); removedObjects.hasNext(); ) {
                ObjectChangeSet removedObjectChangeSet = (ObjectChangeSet) removedObjects.next();
                Object primaryKey = removedObjectChangeSet.getId();
                ClassDescriptor descriptor = removedObjectChangeSet.getDescriptor();
                // PERF: Do not remove if uow is isolated.
                if (!descriptor.shouldIsolateObjectsInUnitOfWork()) {
                    this.parent.getIdentityMapAccessorInstance().removeFromIdentityMap(primaryKey, descriptor.getJavaClass(), descriptor, removedObjectChangeSet.getUnitOfWorkClone());
                }
            }
        }

            if (registeredObject == null) {
                // Check if object is existing, if it is it must be cloned into the unit of work
                // otherwise it is a new object
                Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(objectToRegister, this, true);
                // The primary key may be null for a new object in a nested unit of work (is existing in nested, new in parent).
                if (primaryKey != null) {
                    // Always check the cache first.
                    registeredObject = getIdentityMapAccessorInstance().getFromIdentityMap(primaryKey, objectToRegister.getClass(), descriptor);
                }
                if (registeredObject == null) {
                    // This is a case where the object is not in the session cache,
                    // so a new cache-key is used as there is no original to use for locking.

                }
                
                // Check if object exists in the IM.
                Object primaryKey = getCurrentDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(object, UnitOfWorkImpl.this, true);
                if (primaryKey != null) {
                    // If object exists in IM remove it from the IM and also from clone mapping.
                    getIdentityMapAccessorInstance().removeFromIdentityMap(primaryKey, object.getClass(), getCurrentDescriptor(), object);
                }
                getCloneMapping().remove(object);
                
                //remove from deleted objects.

     * The instance will be lazy when it does not exist in the cache, and supports fetch groups.
     * @param primaryKey - The primary key of the object, either as a List, singleton, IdClass or an instance of the object.
     */
    public Object getReference(Class theClass, Object id) {
        ClassDescriptor descriptor = getDescriptor(theClass);
        if (descriptor == null || descriptor.isDescriptorTypeAggregate()) {
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage("unknown_bean_class", new Object[] { theClass }));
        }
        Object reference;
        if (id == null) { //gf721 - check for null PK
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage("null_pk"));
        }
        Object primaryKey;
        if (id instanceof List) {
            if (descriptor.getCacheKeyType() == CacheKeyType.ID_VALUE) {
                if (((List)id).isEmpty()) {
                    primaryKey = null;
                } else {
                    primaryKey = ((List)id).get(0);
                }
            } else {
                primaryKey = new CacheId(((List)id).toArray());
            }
        } else if (id instanceof CacheId) {
            primaryKey = id;
        } else {
            if (descriptor.getCMPPolicy() != null) {
                if (descriptor.getCMPPolicy().getPKClass() != null && !descriptor.getCMPPolicy().getPKClass().isAssignableFrom(id.getClass())) {
                    throw new IllegalArgumentException(ExceptionLocalization.buildMessage("invalid_pk_class", new Object[] { descriptor.getCMPPolicy().getPKClass(), id.getClass() }));
                }
                primaryKey = descriptor.getCMPPolicy().createPrimaryKeyFromId(id, this);
            } else {
                if (!id.getClass().equals(theClass)) {
                    primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(id, this);
                } else {
                    primaryKey = id;
                    ((Vector)primaryKeyValues).add(primaryKey);
                }
            }
        }
        // If the class supports fetch groups then return a un-fetched instance.
        if (ClassConstants.FetchGroupTracker_class.isAssignableFrom(theClass)) {
            reference = getIdentityMapAccessor().getFromIdentityMap(primaryKey, theClass);
            if (reference == null) {
                if ((id instanceof List) || (id instanceof CacheId) || (descriptor.getCMPPolicy() != null)) {
                    AbstractRecord row = descriptor.getObjectBuilder().buildRowFromPrimaryKeyValues(primaryKey, this);
                    reference = descriptor.getObjectBuilder().buildNewInstance();
                    descriptor.getObjectBuilder().buildPrimaryKeyAttributesIntoObject(reference, row, new ReadObjectQuery(), this);
                } else {
                    reference = descriptor.getCMPPolicy().createBeanUsingKey(id, this);
                }
                ((FetchGroupTracker)reference)._persistence_setSession(this);
                FetchGroup fetchGroup = new FetchGroup();

            }
        } else {
            ReadObjectQuery query = new ReadObjectQuery(descriptor.getJavaClass());
            query.setSelectionId(primaryKey);
            query.conformResultsInUnitOfWork();
            query.setIsExecutionClone(true);
            reference = executeQuery(query);




            shouldRepairOrder = ((IndirectList)currentList).isListOrderBrokenInDb();
        }
        
        HashMap<Object, Object[]> previousAndCurrentByKey = new HashMap<Object, Object[]>();
        int pkSize = getReferenceDescriptor().getPrimaryKeyFields().size();
        
        // First index the current objects by their primary key.
        for (int i=0; i < currentList.size(); i++) {
            Object currentObject = currentList.get(i);
            try {
                CacheId primaryKey = (CacheId)getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(currentObject, query.getSession());
                primaryKey.add(i);
                CacheKey key = new CacheKey(primaryKey);
                Object[] previousAndCurrent = new Object[]{null, currentObject};
                previousAndCurrentByKey.put(primaryKey, previousAndCurrent);
            } catch (NullPointerException e) {
                // For CR#2646 quietly discard nulls added to a collection mapping.
                // This try-catch is essentially a null check on currentObject, for

            }
        }

        if (shouldRepairOrder) {
            ((DeleteAllQuery)getDeleteAllQuery()).executeDeleteAll(query.getSession().getSessionForClass(getReferenceClass()), query.getTranslationRow(), new Vector(previousList));
        } else {
            // Next index the previous objects (read from db or from backup in uow)
            for(int i=0; i < previousList.size(); i++) {
                Object previousObject = previousList.get(i);
                CacheId primaryKey = (CacheId)getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(previousObject, query.getSession());
                primaryKey.add(i);
                Object[] previousAndCurrent = previousAndCurrentByKey.get(primaryKey);
                if (previousAndCurrent == null) {
                if(previousAndCurrent == null) {
                    // there's no current object - that means that previous object should be deleted
                    DatabaseRecord extraData = new DatabaseRecord(1);
                    extraData.put(this.listOrderField, i);

            }
        }

        Iterator<Map.Entry<Object, Object[]>> it = previousAndCurrentByKey.entrySet().iterator();
        while(it.hasNext()) {
            Map.Entry<Object, Object[]> entry = it.next();
            Object key = entry.getKey();
            Object[] previousAndCurrent = entry.getValue();
            // previousObject may be null, meaning currentObject has been added to the list
            Object previousObject = previousAndCurrent[0];

            if(previousObject == null) {
                // there's no previous object - that means that current object should be added.
                // index of currentObject in currentList
                int iCurrent = (Integer)((CacheId)key).getPrimaryKey()[pkSize];
                DatabaseRecord extraData = new DatabaseRecord(1);
                extraData.put(this.listOrderField, iCurrent);
                

        }
        
        // Object[] = {previousObject, currentObject, previousIndex, currentIndex}
        HashMap<Object, Object[]> previousAndCurrentByKey = new HashMap<Object, Object[]>();
        // a SortedMap, current index mapped by previous index, both indexes must exist and be not equal.
        TreeMap<Integer, Integer> currentIndexByPreviousIndex = new TreeMap<Integer, Integer>();


            Object currentObject = currentList.get(i);
            try {
                Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(currentObject, query.getSession());
                CacheKey key = new CacheKey(primaryKey);
                Object[] previousAndCurrent = new Object[]{null, currentObject, null, i};
                previousAndCurrentByKey.put(primaryKey, previousAndCurrent);
            } catch (NullPointerException e) {
                // For CR#2646 quietly discard nulls added to a collection mapping.
                // This try-catch is essentially a null check on currentObject, for

        for(int i=0; i < previousList.size(); i++) {
            Object previousObject = previousList.get(i);
            Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(previousObject, query.getSession());
            Object[] previousAndCurrent = previousAndCurrentByKey.get(primaryKey);
            Object[] previousAndCurrent = previousAndCurrentByKey.get(key);
            if(previousAndCurrent == null) {
                // there's no current object - that means that previous object should be deleted
                objectRemovedDuringUpdate(query, previousObject, null);

            }

            if(shouldUpdateOrderUsingPk) {
                Iterator<Map.Entry<Object, Object[]>> it = previousAndCurrentByKey.entrySet().iterator();
                while(it.hasNext()) {
                    Map.Entry<Object, Object[]> entry = it.next();
                    Object key = entry.getKey();
                    Object[] previousAndCurrent = entry.getValue();
                    // previousObject may be null, meaning currentObject has been added to the list
                    Object previousObject = previousAndCurrent[0];                    

            } else {
                // update the objects - but not their order values
                if(!this.isEntireObjectPK) {
                    Iterator<Map.Entry<Object, Object[]>> iterator = previousAndCurrentByKey.entrySet().iterator();
                    while (iterator.hasNext()) {
                        Map.Entry<Object, Object[]> entry = iterator.next();
                        Object[] previousAndCurrent = entry.getValue();
                        // previousObject may be null, meaning currentObject has been added to the list
                        Object previousObject = previousAndCurrent[0];

        }
        
        // Add the new objects
        Iterator<Map.Entry<Object, Object[]>> iterator = previousAndCurrentByKey.entrySet().iterator();
        while (iterator.hasNext()) {
            Map.Entry<Object, Object[]> entry = iterator.next();
            Object[] previousAndCurrent = entry.getValue();
            // previousObject may be null, meaning currentObject has been added to the list
            Object previousObject = previousAndCurrent[0];

        return (Integer)query.getSession().executeQuery(updateQuery, translationRow);
    }

    protected int objectChangedListOrderDuringUpdate(WriteObjectQuery query, Object key, int newOrderValue) {
        AbstractRecord translationRow = (AbstractRecord)query.getTranslationRow().clone();
        translationRow.put(this.listOrderField, newOrderValue);
        getReferenceDescriptor().getObjectBuilder().writeIntoRowFromPrimaryKeyValues(translationRow, key, query.getSession(), true);
        List<DatabaseField> pkFields = getReferenceDescriptor().getPrimaryKeyFields(); 
        int size = pkFields.size();
        for(int i=0; i < size; i++) {
            translationRow.put(pkFields.get(i), pkValues.get(i));
        }
        return (Integer)query.getSession().executeQuery(this.pkUpdateListOrderFieldQuery, translationRow);
    }


     * Extract the source primary key value from the target row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
        int size = this.targetForeignKeyFields.size();
        Object[] key = new Object[size];

        for (int index = 0; index < size; index++) {
            DatabaseField targetField = this.targetForeignKeyFields.get(index);
            DatabaseField sourceField = this.sourceKeyFields.get(index);
            Object value = row.get(targetField);

            // Must ensure the classification gets a cache hit.
            try {
                value = session.getDatasourcePlatform().getConversionManager().convertObject(value, this.descriptor.getObjectBuilder().getFieldClassification(sourceField));
            } catch (ConversionException e) {
                throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
            }

            key[index] = value;
        }
        return new CacheId(key);
        return key;
    }

    /**

     * Extract the primary key value from the source row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {
        int size = this.sourceKeyFields.size();
        Object[] key = new Object[size];
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();

        for (int index = 0; index < size; index++) {
            DatabaseField field = this.sourceKeyFields.get(index);
            Object value = row.get(field);

            // Must ensure the classification gets a cache hit.
            try {
                value = conversionManager.convertObject(value, this.descriptor.getObjectBuilder().getFieldClassification(field));
            } catch (ConversionException e) {
                throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
            }

            key[index] = value;
        }
        
        return new CacheId(key);
    }

    /**

     * descriptor is part of an inheritance tree.
     */
    public ClassDescriptor getReferenceDescriptor() {
        if (referenceDescriptor == null) {
            referenceDescriptor = remoteReferenceDescriptor;
        }
        return referenceDescriptor;

     */
    public void initialize(AbstractSession session) throws DescriptorException {
        super.initialize(session);
        if (getDescriptor() != null) { // descriptor will only be null in special case where the mapping has not been added to a descriptor prior to initialization.
            getDescriptor().addMappingsPostCalculateChanges(this); // always equivalent to Private Owned
            if (getDescriptor().hasInheritance()) {
                for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
                    descriptor.addMappingsPostCalculateChanges(this);
                }
            }

        //recursive call to further children descriptors
        if (parentDescriptor.getInheritancePolicy().hasChildren()) {
            //setFields(clonedChildDescriptor.getFields());		
            List<ClassDescriptor> childDescriptors = parentDescriptor.getInheritancePolicy().getChildDescriptors();
            List<ClassDescriptor> cloneChildDescriptors = new ArrayList(childDescriptors.size());
            for (ClassDescriptor childDescriptor : childDescriptors) {
                ClassDescriptor clonedChildDescriptor = (ClassDescriptor)childDescriptor.clone();
                if (fieldTranslation != null) {
                    translateTablesAndFields(clonedChildDescriptor, fieldTranslation, tableTranslation); 
                }
                
                updateNestedAggregateMappings(clonedChildDescriptor, session);
                
                if (clonedChildDescriptor.isAggregateDescriptor()) {
                    clonedChildDescriptor.descriptorIsAggregateCollection();
                }
                if (!clonedChildDescriptor.isAggregateCollectionDescriptor()) {

                clonedChildDescriptor.getInheritancePolicy().setParentDescriptor(parentDescriptor);
                clonedChildDescriptor.preInitialize(session);
                clonedChildDescriptor.initialize(session);
                cloneChildDescriptors.add(clonedChildDescriptor);
                initializeChildInheritance(clonedChildDescriptor, session, fieldTranslation, tableTranslation);
            }
            parentDescriptor.getInheritancePolicy().setChildDescriptors(cloneChildDescriptors);

     * INTERNAL:
     * An object is still in the collection, update it as it may have changed.
     */
    @Override
    protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query, Object object, Map backupCloneKeyedCache, Object cachedKey) throws DatabaseException, OptimisticLockException {
        // Always write for updates, either private or in uow if calling this method.
        UpdateObjectQuery updateQuery = new UpdateObjectQuery();
        updateQuery.setIsExecutionClone(true);

        prepareModifyQueryForUpdate(query, updateQuery, object);
        query.getSession().executeQuery(updateQuery, updateQuery.getTranslationRow());
    }
    
    protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query, Object object, Object backupClone) throws DatabaseException, OptimisticLockException {
        // Always write for updates, either private or in uow if calling this method.
        UpdateObjectQuery updateQuery = new UpdateObjectQuery();




        AbstractRecord result = getReferenceDescriptor().getObjectBuilder().buildTemplateInsertRow(session);
        List processedMappings = (List)getReferenceDescriptor().getMappings().clone();
        if (getReferenceDescriptor().hasInheritance()) {
            for (ClassDescriptor child : getReferenceDescriptor().getInheritancePolicy().getChildDescriptors()) {
                for (DatabaseMapping mapping : child.getMappings()) {
                Enumeration mappings = ((ClassDescriptor)children.nextElement()).getMappings().elements();
                while (mappings.hasMoreElements()) {
                    DatabaseMapping mapping = (DatabaseMapping)mappings.nextElement();

                    // Only write mappings once.
                    if (!processedMappings.contains(mapping)) {
                        mapping.writeInsertFieldsIntoRow(result, session);

        //recursive call to the further children descriptors
        if (parentDescriptor.getInheritancePolicy().hasChildren()) {
            //setFields(clonedChildDescriptor.getFields());		
            List<ClassDescriptor> childDescriptors = parentDescriptor.getInheritancePolicy().getChildDescriptors();
            List<ClassDescriptor> cloneChildDescriptors = new ArrayList();
            for (ClassDescriptor child : childDescriptors) {
                ClassDescriptor clonedChildDescriptor = (ClassDescriptor)child.clone();
                clonedChildDescriptor.getInheritancePolicy().setParentDescriptor(parentDescriptor);
                initializeReferenceDescriptor(clonedChildDescriptor);
                clonedChildDescriptor.preInitialize(session);
                clonedChildDescriptor.initialize(session);
                translateFields(clonedChildDescriptor, session);
                cloneChildDescriptors.add(clonedChildDescriptor);
                initializeChildInheritance(clonedChildDescriptor, session);
            }
            parentDescriptor.getInheritancePolicy().setChildDescriptors(cloneChildDescriptors);




import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.*;
import org.eclipse.persistence.internal.indirection.*;
import org.eclipse.persistence.internal.queries.*;
import org.eclipse.persistence.internal.sessions.remote.*;

                        containerPolicy.propogatePostUpdate(query, addedChangeSet.getNewKey());
                    }
                }
                if (listOrderField != null) {
                    List previousList = (List)previousObjects;
                    int previousSize = previousList.size();
                    List currentList = (List)currentObjects;

                            }
                        }
                    } else {
                        for (int i=0; i < previousSize; i++) {
                            // TODO: should we check for previousObject != null? 
                            Object prevObject = previousList.get(i);
                            Object currentObject = null;

                            }
                        }
                    }
                    if (shouldRepairOrder) {
                        ((IndirectList)currentList).setIsListOrderBrokenInDb(false);
                        record.setOrderHasBeenRepaired(true);
                    }

            return;
        }
        
        if (this.listOrderField != null && this.isAggregateCollectionMapping()) {
            this.compareListsAndWrite((List)previousObjects, (List)currentObjects, query);
            return;
        }
        
        ContainerPolicy cp = this.containerPolicy;

        Map previousObjectsByKey = new HashMap(cp.sizeFor(previousObjects)); // Read from db or from backup in uow.
        Map currentObjectsByKey = new HashMap(cp.sizeFor(currentObjects)); // Current value of object's attribute (clone in uow).

        Map keysOfCurrentObjects = new IdentityHashMap(cp.sizeFor(currentObjects) + 1);

        // First index the current objects by their primary key.
        for (Object currentObjectsIter = cp.iteratorFor(currentObjects);

            Object currentObject = cp.next(currentObjectsIter, query.getSession());
            try {
                Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(currentObject, query.getSession());
                currentObjectsByKey.put(primaryKey, currentObject);
                keysOfCurrentObjects.put(currentObject, primaryKey);
                cacheKeysOfCurrentObjects.put(currentObject, key);
            } catch (NullPointerException e) {
                // For CR#2646 quietly discard nulls added to a collection mapping.
                // This try-catch is essentially a null check on currentObject, for

            Map mapKeyFields = containerPolicy.getKeyMappingDataForWriteQuery(wrappedObject, query.getSession());
            Object previousObject = containerPolicy.unwrapIteratorResult(wrappedObject);
            Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(previousObject, query.getSession());
            previousObjectsByKey.put(primaryKey, previousObject);
            previousObjectsByKey.put(key, previousObject);
            // Delete must occur first, in case object with same pk is removed and added,
            // (technically should not happen, but same applies to unique constraints)
            if (!currentObjectsByKey.containsKey(primaryKey)) {
                objectRemovedDuringUpdate(query, wrappedObject, mapKeyFields);
                cp.propogatePostUpdate(query, wrappedObject);
            }

            Object currentObject = containerPolicy.unwrapIteratorResult(wrappedObject);
            try {
                Map mapKeyFields = containerPolicy.getKeyMappingDataForWriteQuery(wrappedObject, query.getSession());
                Object primaryKey = keysOfCurrentObjects.get(currentObject);

                if (!(previousObjectsByKey.containsKey(primaryKey))) {
                    objectAddedDuringUpdate(query, currentObject, null, mapKeyFields);
                    cp.propogatePostUpdate(query, wrappedObject);
                } else {
                    objectUnchangedDuringUpdate(query, currentObject, previousObjectsByKey, primaryKey);
                }
            } catch (NullPointerException e) {
                // For CR#2646 skip currentObject if it is null.

        Object firstIter = cp.iteratorFor(firstCollection);
        Object secondIter = cp.iteratorFor(secondCollection);

        Set keyValue = new HashSet();

        while (cp.hasNext(secondIter)) {
            Object secondObject = cp.next(secondIter, session);
            Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondObject, session);
            keyValue.add(primaryKey);
        }

        while (cp.hasNext(firstIter)) {
            Object firstObject = cp.next(firstIter, session);
            Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstObject, session);

            if (!keyValue.contains(primaryKey)) {
                return false;
            }
        }

        Object firstIter = cp.iteratorFor(firstCollection);
        Object secondIter = cp.iteratorFor(secondCollection);

        Map keyValueToObject = new HashMap(cp.sizeFor(firstCollection));
        CacheKey cacheKey;

        while (cp.hasNext(secondIter)) {
            Object secondObject = cp.next(secondIter, session);
            Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondObject, session);
            keyValueToObject.put(primaryKey, secondObject);
        }

        while (cp.hasNext(firstIter)) {
            Object firstObject = cp.next(firstIter, session);
            Object primaryKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstObject, session);
            
            if (keyValueToObject.containsKey(primaryKey)) {
                Object object = keyValueToObject.get(primaryKey);

            if (keyValueToObject.containsKey(cacheKey)) {
                Object object = keyValueToObject.get(cacheKey);

                if (!session.compareObjects(firstObject, object)) {
                    return false;
                }

                    return false;
                }
            } else {
                Object firstKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstObject, session);
                Object secondKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondObject, session);
                if (!firstKey.equals(secondKey)) {
                    return false;
                }
            }

     */
    public Object extractResultFromBatchQuery(DatabaseQuery query, AbstractRecord databaseRow, AbstractSession session, AbstractRecord argumentRow) {
        //this can be null, because either one exists in the query or it will be created
        Map<Object, Object> referenceObjectsByKey = null;
        synchronized (query) {
            referenceObjectsByKey = getBatchReadObjects(query, session);
            if (referenceObjectsByKey == null) {

                ComplexQueryResult complexResult = (ComplexQueryResult)session.executeQuery(batchQuery, argumentRow);
                Object results = complexResult.getResult();
                referenceObjectsByKey = new Hashtable();
                Iterator<AbstractRecord> rowsIterator = ((List<AbstractRecord>)complexResult.getData()).iterator();
                ContainerPolicy queryContainerPolicy = batchQuery.getContainerPolicy();
                if (this.containerPolicy.shouldAddAll()) {
                    Map<Object, List[]> referenceObjectsAndRowsByKey = new HashMap();
                    for (Object elementsIterator = queryContainerPolicy.iteratorFor(results); queryContainerPolicy.hasNext(elementsIterator);) {
                        Object eachReferenceObject = queryContainerPolicy.next(elementsIterator, session);
                        AbstractRecord row = rowsIterator.next();
                        Object eachReferenceKey = extractKeyFromTargetRow(row, session);                        
                        
                        List[] objectsAndRows = referenceObjectsAndRowsByKey.get(eachReferenceKey);
                        if (objectsAndRows == null) {
                            objectsAndRows = new List[]{new ArrayList(), new ArrayList()};
                            referenceObjectsAndRowsByKey.put(eachReferenceKey, objectsAndRows);
                        }

                        objectsAndRows[1].add(row);
                    }

                    Iterator<Map.Entry<Object, List[]>> it = referenceObjectsAndRowsByKey.entrySet().iterator();
                    while (it.hasNext()) {
                        Map.Entry<Object, List[]> entry = it.next();
                        Object eachReferenceKey = entry.getKey(); 
                        List objects = entry.getValue()[0];
                        List<AbstractRecord> rows = entry.getValue()[1];
                        Object container = this.containerPolicy.containerInstance(objects.size());

                } else {
                    for (Object elementsIterator = queryContainerPolicy.iteratorFor(results); queryContainerPolicy.hasNext(elementsIterator);) {
                        Object eachReferenceObject = queryContainerPolicy.next(elementsIterator, session);
                        AbstractRecord row = rowsIterator.next();
                        Object eachReferenceKey = extractKeyFromTargetRow(row, session);
                        
                        Object container = referenceObjectsByKey.get(eachReferenceKey);
                        if (container == null) {

                query.setSession(null);
            }
        }
        Object result = referenceObjectsByKey.get(extractPrimaryKeyFromRow(databaseRow, session));

        // The source object might not have any target objects
        if (result == null) {

     * The method should be overridden by classes that use batch reading: 
     * for those classes extractResultFromBatchQuery method is called. 
     */
    protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
        return null;
    }

        /**

     * The method should be overridden by classes that use batch reading: 
     * for those classes extractResultFromBatchQuery method is called. 
     */
    protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {
        return null;
    }
    
    /**

     * INTERNAL:
     * An object is still in the collection, update it as it may have changed.
     */
    protected void objectUnchangedDuringUpdate(ObjectLevelModifyQuery query, Object object, Map backupclones, Object key) throws DatabaseException, OptimisticLockException {
        objectUnchangedDuringUpdate(query, object);
    }


        ContainerPolicy cp = this.containerPolicy;
        Object result = cp.containerInstance(pks.length);
        for (int index = 0; index < pks.length; ++index){
            Object pk = null;
            if (getReferenceDescriptor().hasCMPPolicy()){
                pk = getReferenceDescriptor().getCMPPolicy().createPrimaryKeyFromId(pks[index], session);
            }else{
                pk = pks[index];
            }
            ReadObjectQuery query = new ReadObjectQuery();
            query.setReferenceClass(getReferenceClass());


        Object value = this.containerPolicy.containerInstance();
        // Extract the primary key of the source object, to filter only the joined rows for that object.
        Object sourceKey = this.descriptor.getObjectBuilder().extractPrimaryKeyFromRow(row, executionSession);
        CacheKey sourceCacheKey = new CacheKey(sourceKey);
        // If the query was using joining, all of the result rows by primary key will have been computed.
        List<AbstractRecord> rows = joinManager.getDataResultsByPrimaryKey().get(sourceKey);
        int size = rows.size();
        if (size > 0) {
            // A nested query must be built to pass to the descriptor that looks like the real query execution would,
            // these should be cached on the query during prepare.
            ObjectLevelReadQuery nestedQuery = prepareNestedJoinQueryClone(row, rows, joinManager, sourceQuery, executionSession);
            
            // A set of target cache keys must be maintained to avoid duplicates from multiple 1-m joins.
            Set targetPrimaryKeys = new HashSet();
            
            ArrayList targetObjects = null;
            ArrayList<AbstractRecord> targetRows = null;
            boolean shouldAddAll = this.containerPolicy.shouldAddAll();
            if (shouldAddAll) {
                targetObjects = new ArrayList(size);
                targetRows = new ArrayList(size);
            }
            
            // For each rows, extract the target row and build the target object and add to the collection.
            for (int index = 0; index < size; index++) {
                AbstractRecord sourceRow = rows.get(index);
                AbstractRecord targetRow = sourceRow;
                // The field for many objects may be in the row,
                // so build the subpartion of the row through the computed values in the query,

                    return this.indirectionPolicy.valueFromRow(value);
                }
                
                CacheKey targetCacheKey = new CacheKey(targetKey);            
                // Only build/add the target object once, skip duplicates from multiple 1-m joins.
                if (!targetPrimaryKeys.contains(targetKey)) {
                    nestedQuery.setTranslationRow(targetRow);
                    targetPrimaryKeys.add(targetKey);
                    Object targetObject = getReferenceDescriptor().getObjectBuilder().buildObject(nestedQuery, targetRow);
                    Object targetMapKey = this.containerPolicy.buildKeyFromJoinedRow(targetRow, joinManager, nestedQuery, executionSession);
                    nestedQuery.setTranslationRow(null);
                    if (targetMapKey == null){
                        if (shouldAddAll) {
                            targetObjects.add(targetObject);
                            targetRows.add(targetRow);
                        } else {

                    }
                }
            }
            if (shouldAddAll) {
                this.containerPolicy.addAll(targetObjects, value, executionSession, targetRows, nestedQuery);
            }
        }




     * Return the value of the field from the row or a value holder on the query to obtain the object.
     */
    protected Object valueFromRowInternalWithJoin(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery sourceQuery, AbstractSession executionSession) throws DatabaseException {

        ContainerPolicy policy = getContainerPolicy();
        Object value = policy.containerInstance();
        ObjectBuilder objectBuilder = this.descriptor.getObjectBuilder();
        // Extract the primary key of the source object, to filter only the joined rows for that object.
        Object sourceKey = objectBuilder.extractPrimaryKeyFromRow(row, executionSession);
        CacheKey sourceCacheKey = new CacheKey(sourceKey);
        // If the query was using joining, all of the result rows by primary key will have been computed.
        List<AbstractRecord> rows = joinManager.getDataResultsByPrimaryKey().get(sourceKey);
        int size = rows.size();
        
        if(size > 0) {

            boolean containsNull = false;
            // For each rows, extract the target row and build the target object and add to the collection.
            for (int index = 0; index < size; index++) {
                AbstractRecord sourceRow = rows.get(index);
                AbstractRecord targetRow = sourceRow;            
                // The field for many objects may be in the row,
                // so build the subpartion of the row through the computed values in the query,

                targetRow = trimRowForJoin(targetRow, joinManager, executionSession);            
                // Partial object queries must select the primary key of the source and related objects.
                // If the target joined rows in null (outerjoin) means an empty collection.
                Object directValue = targetRow.get(this.directField);
                if (directValue == null) {
                    if (size == 1) {
                        // A null direct value means an empty collection returned as nulls from an outerjoin.
                        return getIndirectionPolicy().valueFromRow(value);
                    } else {

                    if (valueConverter != null) {
                        directValue = valueConverter.convertDataValueToObjectValue(directValue, executionSession);
                    }
                    if (shouldAddAll) {
                        directValuesList.add(directValue);
                        targetRows.add(targetRow);
                    } else {

                    }
                }
            }
            if (shouldAddAll) {
                // if collection contains a single element which is null then return an empty collection
                if (!(containsNull && targetRows.size() == 1)) {
                    policy.addAll(directValuesList, value, executionSession, targetRows, sourceQuery);
                }
            } else {
                // if collection contains a single element which is null then return an empty collection
                if (containsNull && policy.sizeFor(value) == 1) {
                    policy.clear(value);
                }
            }

     * Extract the source primary key value from the reference direct row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
        int size = this.referenceKeyFields.size();
        Object[] key = new Object[size];

        for (int index = 0; index < size; index++) {
            DatabaseField relationField = this.referenceKeyFields.get(index);
            DatabaseField sourceField = this.sourceKeyFields.get(index);
            Object value = row.get(relationField);

            // Must ensure the classification gets a cache hit.
            try {
                value = session.getDatasourcePlatform().getConversionManager().convertObject(value, this.descriptor.getObjectBuilder().getFieldClassification(sourceField));
            } catch (ConversionException e) {
                throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
            }

            key[index] = value;
        }

        return new CacheId(key);
    }

    /**

     * Extract the primary key value from the source row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {
        int size = this.sourceKeyFields.size();
        Object[] key = new Object[size];
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();

        for (int index = 0; index < size; index++) {
            DatabaseField field = this.sourceKeyFields.get(index);
            Object value = row.get(field);

            // Must ensure the classification to get a cache hit.
            try {
                value = conversionManager.convertObject(value, this.descriptor.getObjectBuilder().getFieldClassification(field));
            } catch (ConversionException e) {
                throw ConversionException.couldNotBeConverted(this, this.descriptor, e);
            }

            key[index] = value;
        }
        
        return new CacheId(key);
    }

    /**

     */
    public Object extractResultFromBatchQuery(DatabaseQuery query, AbstractRecord databaseRow, AbstractSession session, AbstractRecord argumentRow) {
        //this can be null, because either one exists in the query or it will be created
        Map<Object, Object> referenceDataByKey = null;
        ContainerPolicy mappingContainerPolicy = getContainerPolicy();
        synchronized (query) {
            referenceDataByKey = getBatchReadObjects(query, session);
            mappingContainerPolicy = getContainerPolicy();
            if (referenceDataByKey == null) {
                List rows = (List)session.executeQuery(query, argumentRow);
                int size = rows.size();
                referenceDataByKey = new Hashtable();
                if (mappingContainerPolicy.shouldAddAll()) {
                    if (size > 0) {
                        Map<Object, List[]> referenceDataAndRowsByKey = new HashMap();
                        for (int i = 0; i < size; i++) {
                            AbstractRecord referenceRow = (AbstractRecord)rows.get(i);
                            Object referenceValue = referenceRow.get(getDirectField());
                            Object eachReferenceKey = extractKeyFromTargetRow(referenceRow, session);
        
                            // Allow for value conversion.
                            if (getValueConverter() != null) {

                            valuesAndRows[1].add(referenceRow);
                        }

                        Iterator<Map.Entry<Object, List[]>> it = referenceDataAndRowsByKey.entrySet().iterator();
                        while(it.hasNext()) {
                            Map.Entry<Object, List[]> entry = it.next();
                            Object eachReferenceKey = entry.getKey();
                            List referenceValues = entry.getValue()[0];
                            List<AbstractRecord> referenceRows = entry.getValue()[1];
                            Object container = mappingContainerPolicy.containerInstance(referenceValues.size());

                    for (int i=0; i < size; i++) {
                        AbstractRecord referenceRow = (AbstractRecord)rows.get(i);
                        Object referenceValue = referenceRow.get(getDirectField());
                        Object eachReferenceKey = extractKeyFromTargetRow(referenceRow, session);
    
                        Object container = referenceDataByKey.get(eachReferenceKey);
                        if (container == null) {

                query.setSession(null);
            }
        }
        Object result = referenceDataByKey.get(extractPrimaryKeyFromRow(databaseRow, session));

        // The source object might not have any target objects
        if (result == null) {




import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.descriptors.changetracking.AttributeChangeListener;
import org.eclipse.persistence.internal.descriptors.changetracking.ObjectChangeListener;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.indirection.*;

        ContainerPolicy cp = getContainerPolicy();
        for (Object iter = cp.iteratorFor(element); cp.hasNext(iter);) {
            Object wrappedObject = cp.nextEntry(iter, iterator.getSession());
            Object object = cp.unwrapIteratorResult(wrappedObject);
            cp.iterateOnMapKey(iterator, wrappedObject);
        }
    }

     */
    public Object extractResultFromBatchQuery(DatabaseQuery query, AbstractRecord databaseRow, AbstractSession session, AbstractRecord argumentRow) {
        //this can be null, because either one exists in the query or it will be created
        Map<Object, Object> referenceDataByKey = null;
        ContainerPolicy mappingContainerPolicy = getContainerPolicy();
        synchronized (query) {
            referenceDataByKey = (Map)query.getProperty("batched objects");
            mappingContainerPolicy = getContainerPolicy();
            if (referenceDataByKey == null) {
                
                List<AbstractRecord> rows = (List)session.executeQuery(query, argumentRow);
                referenceDataByKey = new Hashtable();

                for (AbstractRecord referenceRow : rows) {
                    AbstractRecord referenceRow = (AbstractRecord)rowsEnum.nextElement();
                    Object referenceKey = null;
                    if (query.isObjectBuildingQuery()){
                        referenceKey = getDirectMapUsableContainerPolicy().buildKey(databaseRow, (ObjectBuildingQuery)query, session);

                        referenceKey = getDirectMapUsableContainerPolicy().buildKey(databaseRow, null, session);
                    }
                    Object referenceValue = referenceRow.get(getDirectField());
                    Object eachCacheKey = extractKeyFromTargetRow(referenceRow, session);

                    Object container = referenceDataByKey.get(eachCacheKey);
                    if (container == null) {

                
            }
        }
        Object result = referenceDataByKey.get(extractPrimaryKeyFromRow(databaseRow, session));

        // The source object might not have any target objects
        if (result == null) {

        ObjectBuilder objectBuilder = getDescriptor().getObjectBuilder();
        // Extract the primary key of the source object, to filter only the joined rows for that object.
        Object sourceKey = objectBuilder.extractPrimaryKeyFromRow(row, executionSession);
        CacheKey sourceCacheKey = new CacheKey(sourceKey);
        // If the query was using joining, all of the result rows by primary key will have been computed.
        List<AbstractRecord> rows = joinManager.getDataResultsByPrimaryKey().get(sourceKey);
        
        // A set of direct values must be maintained to avoid duplicates from multiple 1-m joins.
        Set directValues = new HashSet();

        Converter keyConverter = getKeyConverter();
        Converter valueConverter = getValueConverter();
        // For each rows, extract the target row and build the target object and add to the collection.
        int size = rows.size();
        for (int index = 0; index < size; index++) {
            AbstractRecord sourceRow = rows.get(index);
            AbstractRecord targetRow = sourceRow;            
            // The field for many objects may be in the row,
            // so build the subpartion of the row through the computed values in the query,

            targetRow = trimRowForJoin(targetRow, joinManager, executionSession);
            // Partial object queries must select the primary key of the source and related objects.
            // If the target joined rows in null (outerjoin) means an empty collection.
            Object directKey = this.containerPolicy.buildKeyFromJoinedRow(targetRow, joinManager, sourceQuery, executionSession);
            if (directKey == null) {
                // A null direct value means an empty collection returned as nulls from an outerjoin.
                return getIndirectionPolicy().valueFromRow(value);

            // Only build/add the target object once, skip duplicates from multiple 1-m joins.
            if (!directValues.contains(directKey)) {
                directValues.add(directKey);
                Object directValue = targetRow.get(this.directField);
                // Allow for value conversion.
                if (valueConverter != null) {
                    directValue = valueConverter.convertDataValueToObjectValue(directValue, executionSession);




import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.indirection.*;
import org.eclipse.persistence.internal.queries.JoinedAttributeManager;
import org.eclipse.persistence.internal.sessions.remote.*;

     * When a UnitOfWork is in transaction, it executes the batch query
     * on the UnitOfWork and stores the clones on the UnitOfWork.
     */
    protected Map getBatchReadObjects(DatabaseQuery query, AbstractSession session) {
        if (session.isUnitOfWork()) {
            UnitOfWorkImpl unitOfWork = (UnitOfWorkImpl)session;
            return (Map)unitOfWork.getBatchReadObjects().get(query);
        } else {
            return (Map)query.getProperty("batched objects");
        }
    }

    /**
     * INTERNAL:
     * The map of batched objects resides in one of two places.
     * In the normal case it is stored in a query property.
     * When a UnitOfWork is in transaction, it executes the batch query
     * on the UnitOfWork and stores the clones on the UnitOfWork.
     */
    protected void setBatchReadObjects(Map referenceObjectsByKey, DatabaseQuery query, AbstractSession session) {
        if (session.isUnitOfWork()) {
            UnitOfWorkImpl unitOfWork = (UnitOfWorkImpl)session;
            unitOfWork.getBatchReadObjects().put(query, referenceObjectsByKey);

        if (isPrivateOwned){
            getDescriptor().addMappingsPostCalculateChanges(this);
            if (getDescriptor().hasInheritance()){
                for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
                    descriptor.addMappingsPostCalculateChanges(this);
                }
            }

            if (isPrivateOwned && !this.isPrivateOwned){
                this.descriptor.addMappingsPostCalculateChanges(this);
                if (getDescriptor().hasInheritance()){
                    for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
                        descriptor.addMappingsPostCalculateChanges(this);
                    }
                }
            }else if (!isPrivateOwned && this.isPrivateOwned){
                this.descriptor.getMappingsPostCalculateChanges().remove(this);
                if (getDescriptor().hasInheritance()){
                    for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
                        descriptor.getMappingsPostCalculateChanges().remove(this);
                    }
                }

            List nestedDataResults = dataResults;
            if (nestedDataResults == null) {
                // Extract the primary key of the source object, to filter only the joined rows for that object.
                Object sourceKey = this.descriptor.getObjectBuilder().extractPrimaryKeyFromRow(row, executionSession);
                nestedDataResults = joinManager.getDataResultsByPrimaryKey().get(sourceKey);
                nestedDataResults = joinManager.getDataResultsByPrimaryKey().get(sourceCacheKey);
            }
            nestedDataResults = new ArrayList(nestedDataResults);
            Object indexObject = joinManager.getJoinedMappingIndexes_().get(this);




import org.eclipse.persistence.history.*;
import org.eclipse.persistence.internal.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.queries.*;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.mappings.foundation.MapComponentMapping;

     * Extract the source primary key value from the relation row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
        int size = getSourceRelationKeyFields().size();
        Object[] key = new Object[size];

        for (int index = 0; index < size; index++) {
            DatabaseField relationField = getSourceRelationKeyFields().elementAt(index);
            DatabaseField sourceField = getSourceKeyFields().elementAt(index);
            Object value = row.get(relationField);

                throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
            }

            key[index] = value;
        }

        return new CacheId(key);
    }

    /**

     * Extract the primary key value from the source row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {
        int size = getSourceKeyFields().size();
        Object[] key = new Object[size];
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();

        for (int index = 0; index < size; index++) {
            DatabaseField field = getSourceKeyFields().get(index);
            Object value = row.get(field);

            // Must ensure the classification gets a cache hit.
            try {
                value = conversionManager.convertObject(value, this.descriptor.getObjectBuilder().getFieldClassification(field));
            } catch (ConversionException e) {
                throw ConversionException.couldNotBeConverted(this, this.descriptor, e);
            }

            key[index] = value;
        }
        
        return new CacheId(key);
    }

    /**




import org.eclipse.persistence.indirection.ValueHolderInterface;
import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.indirection.*;
import org.eclipse.persistence.internal.sessions.*;
import org.eclipse.persistence.queries.*;

        Object firstKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstReferencedObject, session);
        Object secondKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondReferencedObject, session);

        if (firstKey == null) {
            if (secondKey == null) {
                return true;

            if (!((firstValue == null) && (secondValue == null))) {
                if ((firstValue == null) || (secondValue == null)) {
                    return false;
                }
                if (!firstValue.equals(secondValue)) {
                    return false;
                }
            }
            return false;
        }

        return firstKey.equals(secondKey);
    }

    /**

    
            // delete the object in the database if it is no more a referenced object.						
            if (objectInDatabase != objectInMemory) {
                CacheKey cacheKeyForObjectInDatabase = null;
                CacheKey cacheKeyForObjectInMemory = new CacheKey(new Vector());
    
                Object keyForObjectInDatabase = getPrimaryKeyForObject(objectInDatabase, query.getSession());
                Object keyForObjectInMemory = null;
                if (objectInMemory != null) {
                    keyForObjectInMemory = getPrimaryKeyForObject(objectInMemory, query.getSession());
                }
    
                if ((keyForObjectInMemory != null) && keyForObjectInDatabase.equals(keyForObjectInMemory)) {
                    return;
                }
            } else {


        // If the value was changed, both values must be deleted (uow will have inserted the new one).
        if ((objectFromDatabase != null) && (objectFromDatabase != objectInMemory)) {
            // Also check pk as may not be maintaining identity.	
            Object keyForObjectInMemory = null;
            Object keyForObjectInDatabase = getPrimaryKeyForObject(objectFromDatabase, query.getSession());

            cacheKeyForObjectInDatabase = new CacheKey(getPrimaryKeyForObject(objectFromDatabase, query.getSession()));

            if (objectInMemory != null) {
                keyForObjectInMemory = getPrimaryKeyForObject(objectInMemory, query.getSession());
            }
            if ((keyForObjectInMemory == null) || !keyForObjectInDatabase.equals(keyForObjectInMemory)) {
                if (objectFromDatabase != null) {
                    DeleteObjectQuery deleteQuery = new DeleteObjectQuery();
                    deleteQuery.setIsExecutionClone(true);

            }
        }
    }

    /**
     * INTERNAL:
     */
    protected boolean cacheKeysAreEqual(CacheKey cacheKey1, CacheKey cacheKey2) {
        return cacheKey1.equals(cacheKey2);
    }
    
    /**
     * INTERNAL:


    /**
     * INTERNAL:
     * Return the primary key for the reference object (i.e. the object
     * object referenced by domainObject and specified by mapping).
     * This key will be used by a RemoteValueHolder.
     */
    public Object extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row) {
        return null;
    }

    /**

     */
    public Object extractPrimaryKeysFromRealReferenceObject(Object object, AbstractSession session) {
        if (object == null) {
            return null;
        } else {
            Object implementation = getReferenceDescriptor().getObjectBuilder().unwrapObject(object, session);
            return getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(implementation, session);

     * This list may be available if the relationship has been cached.
     */
    public Object valueFromPKList(Object[] pks, AbstractSession session) {
        Object pk = null;
        if (pks[0] == null) return null;
        if (getReferenceDescriptor().hasCMPPolicy()) {
            pk = getReferenceDescriptor().getCMPPolicy().createPrimaryKeyFromId(pks[0], session);
        } else {
            pk = pks[0];
        }
        ReadObjectQuery query = new ReadObjectQuery();
        query.setReferenceClass(getReferenceClass());




import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.sessions.DatabaseRecord;
import org.eclipse.persistence.internal.descriptors.CascadeLockingPolicy;
import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.expressions.SQLUpdateStatement;
import org.eclipse.persistence.mappings.foundation.MapComponentMapping;


     * results in a hash table keyed by the (primary) keys
     * of the source objects.
     */
    protected Map executeBatchQuery(DatabaseQuery query, AbstractSession session, AbstractRecord row) {
        ContainerPolicy mappingCP = getContainerPolicy();
        ContainerPolicy queryCP = ((ReadAllQuery)query).getContainerPolicy();
        Object queryResult = null;

        queryResult = session.executeQuery(query, row);

        Map batchedObjects = new Hashtable(queryCP.sizeFor(queryResult));

        for (Object iter = queryCP.iteratorFor(queryResult); queryCP.hasNext(iter);) {
            Object eachReferenceObject = queryCP.next(iter, session);
            Object eachForeignKey = extractForeignKeyFromReferenceObject(eachReferenceObject, session);

            Object container = batchedObjects.get(eachForeignKey);
            if (container == null) {

    /**
     * Extract the foreign key value from the reference object.
     * Used for batch reading. Keep the fields in the same order
     * as in the targetForeignKeysToSourceKeys map.
     */
    protected Object extractForeignKeyFromReferenceObject(Object object, AbstractSession session) {
        int size = this.sourceKeyFields.size();
        Object[] foreignKey = new Object[size];
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();
        ObjectBuilder builder = getReferenceDescriptor().getObjectBuilder();

        for (int index = 0; index < size; index++) {
            DatabaseField sourceField = this.sourceKeyFields.get(index);
            DatabaseField targetField = this.targetForeignKeyFields.get(index);
            DatabaseField targetField = (DatabaseField)entry.getKey();
            DatabaseField sourceField = (DatabaseField)entry.getValue();
            if (object == null) {
                foreignKey[index] = null;
            } else {
                Object value = builder.extractValueFromObjectForField(object, targetField, session);

                //CR:somenewsgroupbug need to ensure source and target types match.
                try {
                    value = conversionManager.convertObject(value, builder.getFieldClassification(sourceField));
                } catch (ConversionException e) {
                    throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
                }

                foreignKey[index] = value;
            }
        }
        return new CacheId(foreignKey);
    }

    /**

     * Extract the source primary key value from the target row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
        int size = this.sourceKeyFields.size();
        Object[] key = new Object[size];
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();

        for (int index = 0; index < size; index++) {
            DatabaseField targetField = this.targetForeignKeyFields.get(index);
            DatabaseField sourceField = this.sourceKeyFields.get(index);
            Object value = row.get(targetField);

            // Must ensure the classification gets a cache hit.

                throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
            }

            key[index] = value;
        }

        return new CacheId(key);
    }

    /**

     * Used for batch reading. Keep the fields in the same order
     * as in the targetForeignKeysToSourceKeys hashtable.
     */
    protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {
        int size = this.sourceKeyFields.size();
        Object[] key = new Object[size];
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();

        for (int index = 0; index < size; index++) {
            DatabaseField sourceField = this.sourceKeyFields.get(index);
            Object value = row.get(sourceField);
            Object value = row.get(field);

            // Must ensure the classification to get a cache hit.
            try {
                value = conversionManager.convertObject(value, sourceField.getType());
            } catch (ConversionException e) {
                throw ConversionException.couldNotBeConverted(this, this.descriptor, e);
            }

            key[index] = value;
        }
        
        return new CacheId(key);
    }

    /**
     * INTERNAL:
     * Extract the value from the batch optimized query.
     */
    @Override
    public Object extractResultFromBatchQuery(DatabaseQuery query, AbstractRecord row, AbstractSession session, AbstractRecord argumentRow) {
        if (((ReadAllQuery)query).shouldIncludeData()) {
            return super.extractResultFromBatchQuery(query, row, session, argumentRow);
        }
        //this can be null, because either one exists in the query or it will be created
        Map<Object, Object> batchedObjects = null;
        synchronized (query) {
            batchedObjects = getBatchReadObjects(query, session);
            if (batchedObjects == null) {

                query.setSession(null);
            }
        }
        Object result = batchedObjects.get(extractPrimaryKeyFromRow(row, session));

        // The source object might not have any target objects
        if (result == null) {





import java.util.*;

import org.eclipse.persistence.annotations.CacheKeyType;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;

import org.eclipse.persistence.queries.*;
import org.eclipse.persistence.internal.descriptors.CascadeLockingPolicy;
import org.eclipse.persistence.internal.descriptors.DescriptorIterator;
import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.expressions.ConstantExpression;
import org.eclipse.persistence.internal.expressions.ObjectExpression;
import org.eclipse.persistence.internal.expressions.SQLSelectStatement;

                    }
                }
    
                Iterator keyIterator = Arrays.asList(((CacheId)extractKeyFromReferenceObject(value, session)).getPrimaryKey()).iterator();
                for (DatabaseField field : getSourceToTargetKeyFields().keySet()) {
                         sourceFieldsEnum.hasNext();) {
                    DatabaseField field = (DatabaseField)sourceFieldsEnum.next();
                    Expression join = null;
                    join = base.getField(field).equal(keyIterator.next());
                    if (foreignKeyJoin == null) {
                        foreignKeyJoin = join;
                    } else {

            }
        } else {
            int size = this.mechanism.sourceKeyFields.size();
            Object key = null;
            if (value != null) {
                if (!getReferenceDescriptor().getJavaClass().isInstance(value)) {
                    // Bug 3894351 - ensure any proxys are triggered so we can do a proper class comparison
                    value = ProxyIndirectionPolicy.getValueFromProxy(value);

                        throw QueryException.incorrectClassForObjectComparison(base, value, this);
                    }
                }
                key = extractKeyFromReferenceObject(value, session);
                boolean allNulls = true;
                for (int i=0; i < size; i++) {
                    if (((CacheId)key).getPrimaryKey()[i] != null) {
                        allNulls = false;
                        break;
                    }
                }
                // the same case
                if (allNulls) {
                    value = null;
                }
            }
            if (value != null) {
                for(int i=0; i < size; i++) {
                    DatabaseField field = this.mechanism.sourceKeyFields.get(i);
                    Expression join = null;
                    join = base.getField(field).equal(((CacheId)key).getPrimaryKey()[i]);
                    if (foreignKeyJoin == null) {
                        foreignKeyJoin = join;
                    } else {

     * INTERNAL:
     * Extract the foreign key value from the source row.
     */
    protected Object extractForeignKeyFromRow(AbstractRecord row, AbstractSession session) {
        Object[] key;
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();
        ObjectBuilder builder = this.descriptor.getObjectBuilder();
        if (this.mechanism == null) {
            key = new Object[getSourceToTargetKeyFields().size()];
            int index = 0;
            for (DatabaseField field : getSourceToTargetKeyFields().keySet()) {
                Object value = row.get(field);    
    
                // Must ensure the classification gets a cache hit.
                try {
                    value = conversionManager.convertObject(value, builder.getFieldClassification(field));
                } catch (ConversionException e) {
                    throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
                }
    
                key[index] = value;
                index++;
            }
        } else {
            List<DatabaseField> sourceKeyFields = this.mechanism.sourceKeyFields;
            int size = sourceKeyFields.size();
            key = new Object[size];
            for (int i = 0; i < size; i++) {                
                DatabaseField field = sourceKeyFields.get(i);
                Object value = row.get(field);                
                // Must ensure the classification gets a cache hit.
                try {
                    value = conversionManager.convertObject(value, builder.getFieldClassification(field));
                } catch (ConversionException e) {
                    throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
                }
    
                key[i] = value;
            }            
        }

        return new CacheId(key);
    }

    

     * INTERNAL:
     * Extract the key value from the reference object.
     */
    protected Object extractKeyFromReferenceObject(Object object, AbstractSession session) {
        ObjectBuilder objectBuilder = getReferenceDescriptor().getObjectBuilder();
        Object[] key;
        if (this.mechanism == null) {
            key = new Object[getSourceToTargetKeyFields().size()];
            int index = 0;
            for (DatabaseField field : getSourceToTargetKeyFields().values()) {
                if (object == null) {
                    key[index] = null;
                } else {
                    key[index] = objectBuilder.extractValueFromObjectForField(object, field, session);
                    key.addElement(getReferenceDescriptor().getObjectBuilder().extractValueFromObjectForField(object, field, session));
                }
                index++;
            }
        } else {
            int size = this.mechanism.targetKeyFields.size();
            key = new Object[size];
            for (int i = 0; i < size; i++) {
                if (object == null) {
                    key[i] = null;
                } else {
                    DatabaseField field = this.mechanism.targetKeyFields.get(i);
                    key[i] = objectBuilder.extractValueFromObjectForField(object, field, session);
                }
            }            
        }

        return new CacheId(key);
    }

    /**
     * INTERNAL:
     * Return the primary key for the reference object (i.e. the object
     * object referenced by domainObject and specified by mapping).
     * This key will be used by a RemoteValueHolder.
     */
    @Override
    public Object extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row) {
        List primaryKeyFields = getReferenceDescriptor().getPrimaryKeyFields();
        Object[] result = new  Object[primaryKeyFields.size()];
        for (int index = 0; index < primaryKeyFields.size(); index++) {
            DatabaseField targetKeyField = (DatabaseField)primaryKeyFields.get(index);
            DatabaseField sourceKeyField = getTargetToSourceKeyFields().get(targetKeyField);
            if (sourceKeyField == null) {
                return null;
            }
            result[index] = row.get(sourceKeyField);
            if (getReferenceDescriptor().getCacheKeyType() == CacheKeyType.ID_VALUE) {
                return result[index];
            }
        }
        return new CacheId(result);
    }

    /**

     */
    public Object extractResultFromBatchQuery(DatabaseQuery query, AbstractRecord databaseRow, AbstractSession session, AbstractRecord argumentRow) {
        //this can be null, because either one exists in the query or it will be created
        Map<Object, Object> referenceObjectsByKey = null;
        synchronized (query) {
            referenceObjectsByKey = getBatchReadObjects(query, session);
            if (referenceObjectsByKey == null) {
                List results;
                referenceObjectsByKey = new Hashtable();
                if (this.mechanism == null) {
                    results = (List)session.executeQuery(query, argumentRow);
    
                    for (Object eachReferenceObject : results) {
                        Object eachReferenceKey = extractKeyFromReferenceObject(eachReferenceObject, session);    
                        CacheKey eachReferenceKey = new CacheKey(extractKeyFromReferenceObject(eachReferenceObject, session));
    
                        referenceObjectsByKey.put(eachReferenceKey, session.wrapObject(eachReferenceObject));
                    }
                } else {
                    ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();
                    ComplexQueryResult complexResult = (ComplexQueryResult)session.executeQuery(query, argumentRow);
                    results = (List)complexResult.getResult();
                    List<AbstractRecord> rows = (List)complexResult.getData();
                    int size = results.size();
                    List<DatabaseField> sourceKeyFields = this.mechanism.getSourceRelationKeyFields();
                    int sourceSize = sourceKeyFields.size();
                    for (int i=0; i < size; i++) {
                        AbstractRecord row = rows.get(i);
                        Object[] key = new Object[sourceSize];
                        for (int k = 0; k < sourceSize; k++) {
                            Object value = row.get(sourceKeyFields.get(k));
                            // must do the same conversion as extractForeignKeyFromRow does 
                            // so that CacheKey created here and in extractForeignKeyFromRow compare correctly. 
                            key[k] = conversionManager.convertObject(value, getDescriptor().getObjectBuilder().getFieldClassification(sourceKeyFields.get(k)));
                        }
                        referenceObjectsByKey.put(new CacheId(key), session.wrapObject(results.get(i)));
                        
                        referenceObjectsByKey.put(eachReferenceKey, session.wrapObject(results.get(i)));
                    }
                }
                setBatchReadObjects(referenceObjectsByKey, query, session);

            }
        }

        return referenceObjectsByKey.get(extractForeignKeyFromRow(databaseRow, session));
    }

    




package org.eclipse.persistence.mappings;

import java.util.Iterator;
import java.util.List;
import java.util.Vector;

import org.eclipse.persistence.descriptors.ClassDescriptor;

import org.eclipse.persistence.internal.descriptors.CascadeLockingPolicy;
import org.eclipse.persistence.internal.helper.ConversionManager;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.sessions.AbstractRecord;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.internal.sessions.ChangeRecord;

     * Extract the primary key value from the source row.
     * Used for batch reading, most following same order and fields as in the mapping.
     */
    protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {            
        int size = this.sourceKeyFields.size();
        Object[] key = new Object[size];
        ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();

        for (int index=0; index < size; index++) {

                throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
            }

            key[index] = value;
        }
        
        return new CacheId(key);
    }

    /**

            if(shouldIncrementTargetLockValueOnAddOrRemoveTarget) {
                descriptor.addMappingsPostCalculateChanges(this);
                if (getDescriptor().hasInheritance()){
                    for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
                        descriptor.addMappingsPostCalculateChanges(this);
                    }
                }

            if(shouldIncrementTargetLockValueOnDeleteSource && !isPrivateOwned) {
                descriptor.addMappingsPostCalculateChangesOnDeleted(this);
                if (getDescriptor().hasInheritance()){
                    for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
                        descriptor.addMappingsPostCalculateChangesOnDeleted(this);
                    }
                }




import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.*;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.queries.JoinedAttributeManager;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;

    /**
     * INTERNAL:
     */
    protected boolean cacheKeysAreEqual(CacheKey cacheKey1, CacheKey cacheKey2) {
        return (cacheKey1.equals(cacheKey2) && (cacheKey2.getClass().equals(cacheKey1.getClass())));
    }

    /**
     * INTERNAL:
     */
    @Override
    protected Object getPrimaryKeyForObject(Object object, AbstractSession session) {
        return session.getId(object);




import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.helper.NonSynchronizedVector;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.oxm.Reference;
import org.eclipse.persistence.internal.oxm.ReferenceResolver;
import org.eclipse.persistence.internal.oxm.XMLConversionManager;

        if (idx == -1) {
            return null;
        }
        return ((CacheId)pks).getPrimaryKey()[idx];
    }

    /**

        XMLField tgtFld = (XMLField) getSourceToTargetKeyFieldAssociations().get(xmlField);
        String tgtXPath = tgtFld.getXPath();        
        HashMap primaryKeyMap = reference.getPrimaryKeyMap();
        CacheId pks = (CacheId) primaryKeyMap.get(tgtXPath);
        ClassDescriptor descriptor = session.getClassDescriptor(getReferenceClass());
        if (pks == null){
            pks = new CacheId(new Object[0]);
            primaryKeyMap.put(tgtXPath, pks);
        }        

        ClassDescriptor descriptor = session.getClassDescriptor(getReferenceClass());
        DatabaseField typedField = descriptor.getTypedField(tgtFld);
        Class type = descriptor.getTypedField(tgtFld).getType();
        XMLConversionManager xmlConversionManager = (XMLConversionManager) session.getDatasourcePlatform().getConversionManager();
        for (StringTokenizer stok = new StringTokenizer((String) object); stok.hasMoreTokens();) {

     */
    public Object readFromRowIntoObject(AbstractRecord databaseRow, JoinedAttributeManager joinManager, Object targetObject, ObjectBuildingQuery sourceQuery, AbstractSession executionSession) throws DatabaseException {
        ClassDescriptor descriptor = sourceQuery.getSession().getClassDescriptor(getReferenceClass());
        ContainerPolicy cp = getContainerPolicy();
        Vector pkFieldNames = referenceDescriptor.getPrimaryKeyFieldNames();
        Vector primaryKeyValues = new Vector();
        primaryKeyValues.setSize(pkFieldNames.size());
        HashMap primaryKeyMap = new HashMap();
        // for each source xmlField, get the value from the row and store
        for (Iterator fieldIt = getFields().iterator(); fieldIt.hasNext();) {

            // need to get the actual type of the target (i.e. int, String, etc.) 
            // and use the converted value when checking the cache.
            XMLConversionManager xmlConversionManager = (XMLConversionManager) executionSession.getDatasourcePlatform().getConversionManager();
            CacheId newValues = new CacheId(new Object[0]);
            for (Iterator valIt = ((Vector) fieldValue).iterator(); valIt.hasNext();) {
                for (StringTokenizer stok = new StringTokenizer((String) valIt.next()); stok.hasMoreTokens();) {
                    Object value = xmlConversionManager.convertObject(stok.nextToken(), descriptor.getTypedField(tgtFld).getType());




import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.oxm.Reference;
import org.eclipse.persistence.internal.oxm.ReferenceListener;
import org.eclipse.persistence.internal.oxm.ReferenceResolver;

        if (idx == -1) {
            return null;
        }
        return ((CacheId)pks).getPrimaryKey()[idx];
    }

    /**

        // if reference is null, create a new instance and set it on the resolver
        Reference reference = resolver.getReference(this, srcObject);
        if (reference == null) {
            CacheId pks = new CacheId(new Object[pkFieldNames.size()]);
            pks.setSize(pkFieldNames.size());
            reference = new Reference(this, srcObject, getReferenceClass(), pks);
            resolver.addReference(reference);
            record.reference(reference);
        }
        XMLField tgtFld = (XMLField) getSourceToTargetKeyFieldAssociations().get(xmlField);
        int idx = pkFieldNames.indexOf(tgtFld.getXPath());
        Object primaryKeys = reference.getPrimaryKey();
        // fix for bug# 5687430
        // need to get the actual type of the target (i.e. int, String, etc.) 
        // and use the converted value when checking the cache.
        Object value = session.getDatasourcePlatform().getConversionManager().convertObject(object, clsDescriptor.getTypedField(tgtFld).getType());
        if (value != null) {
            ((CacheId)primaryKeys).set(idx, value);
        }
    }


        // reference descriptor's primary key entries
        ClassDescriptor descriptor = sourceQuery.getSession().getClassDescriptor(getReferenceClass());
        Vector pkFieldNames = descriptor.getPrimaryKeyFieldNames();
        CacheId primaryKeys = new CacheId(new Object[pkFieldNames.size()]);
        primaryKeys.setSize(pkFieldNames.size());
        Iterator keyIt = sourceToTargetKeys.iterator();
        while (keyIt.hasNext()) {
            XMLField keyFld = (XMLField) keyIt.next();

            // and use the converted value when checking the cache.
            Object value = executionSession.getDatasourcePlatform().getConversionManager().convertObject(databaseRow.get(keyFld), descriptor.getTypedField(tgtFld).getType());
            if (value != null) {
                primaryKeys.set(idx, value);
            }
        }
        // store the Reference instance on the resolver for use during mapping




import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import javax.xml.namespace.QName;


import org.eclipse.persistence.exceptions.XMLMarshalException;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.helper.Helper;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.identitymaps.CacheKey;
import org.eclipse.persistence.internal.oxm.ContainerValue;
import org.eclipse.persistence.internal.oxm.NodeValue;

                int primaryKeyFieldsSize = primaryKeyFields.size();
                if (primaryKeyFieldsSize > 0) {
                    Object pk = treeObjectBuilder.extractPrimaryKeyFromObject(currentObject, session);
                    for (int x=0; x<primaryKeyFieldsSize; x++) {
                        Object value = ((CacheId)pk).getPrimaryKey()[x];
                        if (null == value) {
                            XMLField pkField = (XMLField) xmlDescriptor.getPrimaryKeyFields().get(x);
                            ((CacheId)pk).set(x, getUnmarshaller().getXMLContext().getValueByXPath(currentObject, pkField.getXPath(), pkField.getNamespaceResolver(), Object.class));
                            }
                        }
                    }
                    CacheKey key = session.getIdentityMapAccessorInstance().acquireDeferredLock(pk, xmlDescriptor.getJavaClass(), xmlDescriptor);




        // Make sure that child is post initialized,
        // this initialize bottom up, unlike the two other phases that to top down.
        if (hasInheritance()) {
            for (ClassDescriptor child : getInheritancePolicy().getChildDescriptors()) {
                child.postInitialize(session);
            }
        }

        // Allow mapping to perform post initialization.
        for (DatabaseMapping mapping : getMappings()) {
            DatabaseMapping mapping = (DatabaseMapping) mappingsEnum.nextElement();

            // This causes post init to be called multiple times in inheritance.
            mapping.postInitialize(session);
        }

Lines 12-18 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/DoesExistQuery.java (-2 / +1 lines)
12	******************************************************************************/	12	******************************************************************************/
13	package org.eclipse.persistence.queries;	13	package org.eclipse.persistence.queries;
14		14
15	import java.util.*;
16	import org.eclipse.persistence.descriptors.ClassDescriptor;	15	import org.eclipse.persistence.descriptors.ClassDescriptor;
17	import org.eclipse.persistence.exceptions.*;	16	import org.eclipse.persistence.exceptions.*;
18	import org.eclipse.persistence.internal.helper.*;	17	import org.eclipse.persistence.internal.helper.*;
Lines 149-155 Link Here
149	}	148	}
150		149
151	}	150	}
152	if ((primaryKey == null) \|\| (((Vector)primaryKey).contains(null))) {	151	if (primaryKey == null) {
153	return Boolean.FALSE;	152	return Boolean.FALSE;
154	}	153	}
155		154




    /** INTERNAL: for bug 2612601 allow ability not to register results in UOW. */
    protected boolean shouldRegisterResultsInUnitOfWork = true;

    /** CMP only. Allow users to configure whether finder should be executed in a uow or not. */
    protected boolean shouldProcessResultsInUnitOfWork = true;

    /** Used for pessimistic locking. */
    protected ForUpdateClause lockingClause;
    public static final short NO_LOCK = 0;

        if (query.isObjectBuildingQuery()) {
            ObjectBuildingQuery readQuery = (ObjectBuildingQuery)query;
            this.shouldBuildNullForNullPk = readQuery.shouldBuildNullForNullPk;
            this.shouldProcessResultsInUnitOfWork = readQuery.shouldProcessResultsInUnitOfWork;
            this.shouldRefreshIdentityMapResult = readQuery.shouldRefreshIdentityMapResult;
            this.shouldRefreshRemoteIdentityMapResult = readQuery.shouldRefreshRemoteIdentityMapResult;
            this.shouldRegisterResultsInUnitOfWork = readQuery.shouldRegisterResultsInUnitOfWork;

    }

    /**
     * ADVANCED:
     * Used for CMP only.  This allows users to indicate whether cmp finders executed
     * at the beginning of a transaction should always be run against a UnitOfWork.
     * Defaults to true.
     * <p>
     * If set to false, then UnitOfWork allocation will be deferred until a business
     * method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
     * is invoked.  Any finder executed before such a time, will do so against the
     * underlying ServerSession.  Forcing finder execution to always go through a
     * UnitOfWork means the results will be cloned and cached in the UnitOfWork up
     * front.  This is desired when the results will be accessed in the same transaction.
     * <p>
     * Note that finders executed with an unspecified transaction context will never
     * be executed against a UnitOfWork, even if this setting is true.  This case may happen
     * with the NotSupported, Never, and Supports attributes.
     */
    public void setShouldProcessResultsInUnitOfWork(boolean processResultsInUnitOfWork) {
        this.shouldProcessResultsInUnitOfWork = processResultsInUnitOfWork;
    }

    /**
     * ADVANCED:
     * Used for CMP only.  Indicates whether cmp finders executed at the beginning
     * of a transaction should always be run against a UnitOfWork.
     * Defaults to true.
     * <p>
     * If set to false, then UnitOfWork allocation will be deferred until a business
     * method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
     * is invoked.  Any finder executed before such a time, will do so against the
     * underlying ServerSession.  Forcing finder execution to always go through a
     * UnitOfWork means the results will be cloned and cached in the UnitOfWork up
     * front.  This is desired when the results will be accessed in the same transaction.
     * <p>
     * Note that finders executed with an unspecified transaction context will never
     * be executed against a UnitOfWork, even if this setting is true.  This case may happen
     * with the NotSupported, Never, and Supports attributes.
     */
    public boolean shouldProcessResultsInUnitOfWork() {
        return this.shouldProcessResultsInUnitOfWork;
    }

    /**
     * INTERNAL:
     * Return if the attribute is specified for joining.
     */

Lines 212-218 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelModifyQuery.java (-1 / +1 lines)
212		212
213	if (this.primaryKey == null) {	213	if (this.primaryKey == null) {
214	if (this.objectChangeSet != null) {	214	if (this.objectChangeSet != null) {
215	this.primaryKey = this.objectChangeSet.getPrimaryKeys();	215	this.primaryKey = this.objectChangeSet.getId();
216	} else {	216	} else {
217	this.primaryKey = this.descriptor.getObjectBuilder().extractPrimaryKeyFromObject(this.object, this.session);	217	this.primaryKey = this.descriptor.getObjectBuilder().extractPrimaryKeyFromObject(this.object, this.session);
218	}	218	}





    /**
     * INTERNAL:
     * Answers if we are executing through a UnitOfWork and registering results.
     * This is only ever false if using the conforming without registering
     * feature.
     */
    public boolean isRegisteringResults() {
        return ((shouldRegisterResultsInUnitOfWork() && this.descriptor.shouldRegisterResultsInUnitOfWork()) || isLockQuery());
    }

    /**
     * INTERNAL:
     * If changes are made to the query that affect the derived SQL or Call
     * parameters the query needs to be prepared again.
     * <p>


    /**
     * PUBLIC:
     * Set if the attributes of the object(s) resulting from the query should be refreshed.
     * If cascading is used the private parts of the objects will also be refreshed.
     */
    public void setShouldRefreshIdentityMapResult(boolean shouldRefreshIdentityMapResult) {
        this.shouldRefreshIdentityMapResult = shouldRefreshIdentityMapResult;
        if (shouldRefreshIdentityMapResult) {
            setShouldRefreshRemoteIdentityMapResult(true);
        }
    }

    /**
     * PUBLIC:
     * Set if the attributes of the object(s) resulting from the query should be refreshed.
     * If cascading is used the private parts of the objects will also be refreshed.
     */
    public void setShouldRefreshRemoteIdentityMapResult(boolean shouldRefreshIdentityMapResult) {
        this.shouldRefreshRemoteIdentityMapResult = shouldRefreshIdentityMapResult;
    }

    /**
     * INTERNAL:
     * Set to false to have queries conform to a UnitOfWork without registering
     * any additional objects not already in that UnitOfWork.
     * @see #shouldRegisterResultsInUnitOfWork
     * @bug 2612601
     */
    public void setShouldRegisterResultsInUnitOfWork(boolean shouldRegisterResultsInUnitOfWork) {
        this.shouldRegisterResultsInUnitOfWork = shouldRegisterResultsInUnitOfWork;
    }

    /**
     * PUBLIC:
     * Return if cache should be checked.
     */
    public boolean shouldCheckCacheOnly() {

        this.shouldOuterJoinSubclasses = Boolean.valueOf(shouldOuterJoinSubclasses);
        setIsPrepared(false);
    }
    
    /**
     * INTERNAL:
     * Allows one to do conforming in a UnitOfWork without registering.
     * Queries executed on a UnitOfWork will only return working copies for objects
     * that have already been registered.
     * <p>Extreme care should be taken in using this feature, for a user will
     * get back a mix of registered and original (unregistered) objects.
     * <p>Best used with a WrapperPolicy where invoking on an object will trigger
     * its registration (CMP).  Without a WrapperPolicy {@link org.eclipse.persistence.sessions.UnitOfWork#registerExistingObject registerExistingObject}
     * should be called on any object that you intend to change.
     * @return true by default.
     * @see #setShouldRegisterResultsInUnitOfWork(boolean)
     * @see org.eclipse.persistence.descriptors.ClassDescriptor#shouldRegisterResultsInUnitOfWork()
     * @bug 2612601
     */
    public boolean shouldRegisterResultsInUnitOfWork() {
        return shouldRegisterResultsInUnitOfWork;
    }

    /**
     * INTERNAL:

    }

    /**
     * PUBLIC:
     * Set to a boolean. When set means refresh the instance
     * variables of referenceObject from the database.
     */
    public boolean shouldRefreshIdentityMapResult() {
        return shouldRefreshIdentityMapResult;
    }

    /**
     * PUBLIC:
     * Set to a boolean. When set means refresh the instance
     * variables of referenceObject from the database.
     */
    public boolean shouldRefreshRemoteIdentityMapResult() {
        return shouldRefreshRemoteIdentityMapResult;
    }

    /**
     * ADVANCED:
     * Used for CMP only.  This allows users to indicate whether cmp finders executed
     * at the beginning of a transaction should always be run against a UnitOfWork.
     * Defaults to true.
     * <p>
     * If set to false, then UnitOfWork allocation will be deferred until a business
     * method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
     * is invoked.  Any finder executed before such a time, will do so against the
     * underlying ServerSession.  Forcing finder execution to always go through a
     * UnitOfWork means the results will be cloned and cached in the UnitOfWork up
     * front.  This is desired when the results will be accessed in the same transaction.
     * <p>
     * Note that finders executed with an unspecified transaction context will never
     * be executed against a UnitOfWork, even if this setting is true.  This case may happen
     * with the NotSupported, Never, and Supports attributes.
     */
    public void setShouldProcessResultsInUnitOfWork(boolean processResultsInUnitOfWork) {
        this.shouldProcessResultsInUnitOfWork = processResultsInUnitOfWork;
    }

    /**
     * ADVANCED:
     * Used for CMP only.  Indicates whether cmp finders executed at the beginning
     * of a transaction should always be run against a UnitOfWork.
     * Defaults to true.
     * <p>
     * If set to false, then UnitOfWork allocation will be deferred until a business
     * method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
     * is invoked.  Any finder executed before such a time, will do so against the
     * underlying ServerSession.  Forcing finder execution to always go through a
     * UnitOfWork means the results will be cloned and cached in the UnitOfWork up
     * front.  This is desired when the results will be accessed in the same transaction.
     * <p>
     * Note that finders executed with an unspecified transaction context will never
     * be executed against a UnitOfWork, even if this setting is true.  This case may happen
     * with the NotSupported, Never, and Supports attributes.
     */
    public boolean shouldProcessResultsInUnitOfWork() {
        return this.shouldProcessResultsInUnitOfWork;
    }

    /**
     * ADVANCED:
     * If a distinct has been set the DISTINCT clause will be printed.
     * This is used internally by EclipseLink for batch reading but may also be
     * used directly for advanced queries or report queries.




import java.util.*;
import java.sql.*;
import org.eclipse.persistence.internal.databaseaccess.*;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.indirection.ProxyIndirectionPolicy;
import org.eclipse.persistence.internal.descriptors.*;
import org.eclipse.persistence.internal.queries.CallQueryMechanism;

    protected transient Object selectionObject;

    /** Key that can be used in place of a selection criteria. */
    protected Object selectionId;

    /** Can be used to refresh a specific non-cached instance from the database. */
    protected boolean shouldLoadResultIntoSelectionObject = false;    

                        // PERF: the read-object query should always be static to ensure no regeneration of SQL.
                        if ((!hasJoining() || !getJoinedAttributeManager().hasJoinedAttributeExpressions()) && (!hasPartialAttributeExpressions()) && (!hasAsOfClause()) && (!hasNonDefaultFetchGroup()) && (getHintString() == null)
                                && wasDefaultLockMode() && shouldIgnoreBindAllParameters() && (!hasFetchGroup()) && (getFetchGroupName() == null) && shouldUseDefaultFetchGroup()) {
                            if ((this.selectionId != null) || (this.selectionObject != null)) {// Must be primary key.
                                setIsCustomQueryUsed(true);
                            } else {            
                                if (getSelectionCriteria() != null) {

                    this.descriptor.getObjectBuilder().unwrapObject(result, unitOfWork.getParent()),
                    null, unitOfWork, null, null);
        }
        Expression selectionCriteria = getSelectionCriteria();
        if ((selectionCriteria != null) && (this.selectionId == null) && (this.selectionObject == null)) {
            ExpressionBuilder builder = selectionCriteria.getBuilder();
            builder.setSession(unitOfWork.getRootSession(null));
            builder.setQueryClass(getReferenceClass());
        }

        clone = conformIndividualResult(clone, unitOfWork, databaseRow, selectionCriteria, null);
        if (clone == null) {
            return clone;
        }

        }
        if ((result == null) && shouldRefreshIdentityMapResult()) {
            // bug5955326, should invalidate the shared cached if refreshed object no longer exists.
            if (getSelectionId() != null) {
                session.getParentIdentityMapSession(this, true, true).getIdentityMapAccessor().invalidateObject(getSelectionId(), getReferenceClass());
            } else if (getSelectionObject() != null) {
                session.getParentIdentityMapSession(this, true, true).getIdentityMapAccessor().invalidateObject(getSelectionObject());
            }

     */
    @Deprecated
    public Vector getSelectionKey() {
        if (this.selectionId instanceof CacheId) {
            return new Vector(Arrays.asList(((CacheId)this.selectionId).getPrimaryKey()));
        }
        Vector primaryKey = new Vector(1);
        primaryKey.add(this.selectionId);
        return (Vector)selectionId;

    }


     * Return if the query is by primary key.
     */
    public boolean isPrimaryKeyQuery() {
        return (this.selectionId != null) || (this.selectionObject != null);
    }

    /**

        super.copyFromQuery(query);
        if (query.isReadObjectQuery()) {
            ReadObjectQuery readQuery = (ReadObjectQuery)query;
            this.selectionId = readQuery.selectionId;
            this.selectionObject = readQuery.selectionObject;
            this.shouldLoadResultIntoSelectionObject = readQuery.shouldLoadResultIntoSelectionObject;
        }

        }
        super.prepare();
        
        if ((this.selectionId != null) || (this.selectionObject != null)) {
            // The expression is set in the prepare as params.
            setSelectionCriteria(this.descriptor.getObjectBuilder().getPrimaryKeyExpression());
            setExpressionBuilder(getSelectionCriteria().getBuilder());
            extendPessimisticLockScope();
            // For bug 2989998 the translation row is required to be set at this point.
            if (!shouldPrepare()) {
                if (this.selectionId != null) {
                    // Row must come from the key.
                    setTranslationRow(getDescriptor().getObjectBuilder().buildRowFromPrimaryKeyValues(this.selectionId, getSession()));
                } else {//(getSelectionObject() != null)
                    setTranslationRow(getDescriptor().getObjectBuilder().buildRowForTranslation(this.selectionObject, getSession()));
                }
            }
        }

        if (this.descriptor.isDescriptorForInterface()) {
            return;
        }
        

            // CR#... Must also set the selection object as may be loading into the object (refresh)
            customReadQuery.selectionObject = this.selectionObject;
            // The translation/primary key row will be set in prepareForExecution.
        } else if (this.selectionId != null) {
            customReadQuery.selectionId = this.selectionId;
        } else {
            // The primary key row must be used.
            primaryKeyRow = customQuery.getDescriptor().getObjectBuilder().extractPrimaryKeyRowFromExpression(getSelectionCriteria(), customQuery.getTranslationRow(), customReadQuery.getSession());


        // For bug 2989998 the translation row now sometimes set earlier in prepare.
        if (shouldPrepare()) {
            if (this.selectionId != null) {
                // Row must come from the key.
                this.translationRow = this.descriptor.getObjectBuilder().buildRowFromPrimaryKeyValues(this.selectionId, getSession());
            } else if (this.selectionObject != null) {
                // The expression is set in the prepare as params.
                this.translationRow = this.descriptor.getObjectBuilder().buildRowForTranslation(this.selectionObject, getSession());
            }
        }
    }

     * Return Id of the object to be selected by the query.
     */
    public Object getSelectionId() {
        return this.selectionId;
    }

    /**

     * This will generate a query by primary key.
     * This can be used instead of an Expression, SQL, or JPQL, or example object.
     * The Id is the Id value for a singleton primary key,
     * for a composite it is an instance of CacheId.
     * @see CacheId
     */
    public void setSelectionId(Object id) {
        this.selectionId = id;
    }

    /**
     * PUBLIC:
     * The primary key can be specified if used instead of an expression or selection object.
     * If composite the primary must be in the same order as defined in the descriptor.
     * @depreacted since EclipseLink 2.1, replaced by setSelectionId(Object)
     * @see #setSelectionId(Object)
     */
    @Deprecated
    public void setSelectionKey(List selectionKey) {
        if (selectionKey == null) {
            this.selectionId = null;
        } else if (selectionKey.size() == 1) {
            this.selectionId = selectionKey.get(0);            
        } else {
            this.selectionId = new CacheId(selectionKey.toArray());
        }
        // setIsPrepared(false); PERF: This cause the findByPrimaryKey query to unprepare,
        // Since this is an argument, and not a query modifier do not unprepare.
    }

    /**




import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.expressions.MapEntryExpression;
import org.eclipse.persistence.internal.helper.*;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.queries.*;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedInvokeConstructor;

                if (this.key != null) {
                    Object primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromRow(subRow, query.getSession());
                    if (primaryKey != null){//GF3233 NPE is caused by processing the null PK being extracted from referenced target with null values in database.
                        this.key.append(primaryKey);
                           this.key.append(iterator.next());
                           this.key.append("-");
                        }
                    }
                    this.key.append("_");
                }

        }

        // Compare PKs
        if (getId() != null) {
            if (result.getId() == null) {
                return false;
            }
            return getId().equals(getId());
        }

        return true;

     */
    @Deprecated
    public Vector<Object> getPrimaryKeyValues() {
        if (this.primaryKey instanceof CacheId) {
            return new Vector(Arrays.asList(((CacheId)this.primaryKey).getPrimaryKey()));
        }
        Vector primaryKey = new Vector(1);
        primaryKey.add(this.primaryKey);
        return primaryKey;
    }

    /**

     * If the PKs were retrieved with the attributes then this method can be used to read the real object from the database.
     */
    public Object readObject(Class javaClass, Session session) {
        if (getId() == null) {
            throw QueryException.reportQueryResultWithoutPKs(this);
        }

        ReadObjectQuery query = new ReadObjectQuery(javaClass);
        query.setSelectionId(getId());

        return session.executeQuery(query);
    }

Lines 25-31 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/changesets/ObjectChangeSet.java (-2 / +11 lines)
25	* <p>	25	* <p>
26	*/	26	*/
27	public interface ObjectChangeSet {	27	public interface ObjectChangeSet {
28	boolean equals(ObjectChangeSet objectChange);	28	boolean equals(Object objectChange);
29		29
30	/**	30	/**
31	* ADVANCED:	31	* ADVANCED:
Lines 67-78 Link Here
67		67
68	/**	68	/**
69	* ADVANCED:	69	* ADVANCED:
70	* This method returns the primary keys for the object that this change set represents.	70	* This method returns the primary key for the object that this change set represents.
		71	* @depreated since EclipseLink 2.1, replaced by getPrimaryKey()
		72	* @see getPrimaryKey()
71	*/	73	*/
		74	@Deprecated
72	Vector getPrimaryKeys();	75	Vector getPrimaryKeys();
73		76
74	/**	77	/**
75	* ADVANCED:	78	* ADVANCED:
		79	* This method returns the primary key for the object that this change set represents.
		80	*/
		81	Object getId();
		82
		83	/**
		84	* ADVANCED:
76	* This method is used to return the parent ChangeSet.	85	* This method is used to return the parent ChangeSet.
77	*/	86	*/
78	UnitOfWorkChangeSet getUOWChangeSet();	87	UnitOfWorkChangeSet getUOWChangeSet();

Lines 122-128 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/interceptors/CacheKeyInterceptor.java (-1 / +1 lines)
122	return wrappedKey.getLastUpdatedQueryId();	122	return wrappedKey.getLastUpdatedQueryId();
123	}	123	}
124		124
125	public Vector getKey() {	125	public Object getKey() {
126	return wrappedKey.getKey();	126	return wrappedKey.getKey();
127	}	127	}
128		128




    public void addAllObjectsForAbstractClass(Class objectsClass, AbstractSession session, Vector allObjects) {
        ClassDescriptor descriptor = session.getDescriptor(objectsClass);
        addAllObjectsForClass(objectsClass, allObjects);
        for (ClassDescriptor child : descriptor.getInheritancePolicy().getChildDescriptors()) {
            addAllObjectsForAbstractClass(child.getJavaClass(), session, allObjects);
            addAllObjectsForAbstractClass(((ClassDescriptor)enumeration.nextElement()).getJavaClass(), session, allObjects);
        }
    }


        Vector allObjects = new Vector();
        addAllObjectsForClass(objectsClass, allObjects);
        if (descriptor.hasInheritance()) {
            for (ClassDescriptor child : descriptor.getInheritancePolicy().getChildDescriptors()) {
                addAllObjectsForClass(child.getJavaClass(), allObjects);
                addAllObjectsForClass(((ClassDescriptor)enumeration.nextElement()).getJavaClass(), allObjects);
            }
        }





            PartnerLinkPK usedPk = new PartnerLinkPK(pLink3.getManId(), pLink3.getWomanId());
            assertTrue("PK's do not match.", usedPk.equals(createdPK));

        } finally {
            if (isTransactionActive(em)) {
                rollbackTransaction(em);
            }

            closeEntityManager(em);
            fail("An exception was caught: [" + e.getMessage() + "]");
        }

        closeEntityManager(em);
    }

    // GF1673, 2674 Java SE 6 classloading error for String[] field

Lines 169-175 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/sessionbean/SessionBeanTestsRCM.java (-1 / +1 lines)
169	empId = getEmployeeService(server1Url).insert(employee);	169	empId = getEmployeeService(server1Url).insert(employee);
170		170
171	/* read Employee from cache and/or DB */	171	/* read Employee from cache and/or DB */
172	Employee jane1 = (Employee) getEmployeeService(server1Url).findById(empId);	172	Employee jane1 = getEmployeeService(server1Url).findById(empId);
173	/* update employee on Server1 */	173	/* update employee on Server1 */
174	jane1.setLastName("LastNameUpdatedOnServer1");	174	jane1.setLastName("LastNameUpdatedOnServer1");
175	jane1.getAddress().setCity("newCity");	175	jane1.getAddress().setCity("newCity");




 ******************************************************************************/
package org.eclipse.persistence.internal.jpa;

import java.util.Vector;
import javax.persistence.Cache;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.identitymaps.CacheKey;


    public boolean contains(Class cls, Object primaryKey) {
        this.emf.verifyOpen();
        Object pk =  createPrimaryKeyFromId(cls, primaryKey);
        ClassDescriptor descriptor = this.serversession.getDescriptor(cls);
        CacheKey key = ((org.eclipse.persistence.internal.sessions.IdentityMapAccessor)this.accessor).getCacheKeyForObject(pk, cls, descriptor);

        return (key != null) && (key.getObject() != null) && (!descriptor.getCacheInvalidationPolicy().isInvalidated(key)); 
    }

    public void evict(Class cls, Object primaryKey) {
        this.emf.verifyOpen();
        this.accessor.invalidateObject(createPrimaryKeyFromId(cls, primaryKey), cls);
    }

    public void evict(Class cls) {

        this.accessor.invalidateAll();
    }

    private Object createPrimaryKeyFromId(Class cls, Object primaryKey){
        ClassDescriptor cdesc = this.serversession.getDescriptor(cls);
        CMP3Policy cmp = (CMP3Policy) (cdesc.getCMPPolicy());
        Object pk = cmp.createPrimaryKeyFromId(primaryKey, this.serversession);
        return pk;
    }
}




import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.*;

import org.eclipse.persistence.annotations.CacheKeyType;
import org.eclipse.persistence.descriptors.*;
import org.eclipse.persistence.internal.helper.ConversionManager;
import org.eclipse.persistence.internal.helper.NonSynchronizedVector;
import org.eclipse.persistence.internal.localization.ExceptionLocalization;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedGetField;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;

    
    /**
     * INTERNAL:
     * Use the key to create a EclipseLink primary key.
     * If the key is simple (direct mapped) then just add it to a vector,
     * otherwise must go through the inefficient process of copying the key into the bean
     * and extracting the key from the bean.
     *
     * @param key Object the primary key to use for creating the vector
     * @return Vector
     */
    @Override
    public Object createPrimaryKeyFromId(Object key, AbstractSession session) {
        // If the descriptor primary key is mapped through direct-to-field mappings,
        // then no elaborate conversion is required.
        // If key is compound, add each value to the vector.
        KeyElementAccessor[] pkElementArray = this.getKeyClassFields(key.getClass());
        Object[] primaryKey = null;
        if (getDescriptor().getCacheKeyType() != CacheKeyType.ID_VALUE) {
            primaryKey = new Object[pkElementArray.length];
        }
        for (int index = 0; index < pkElementArray.length; index++) {
            DatabaseMapping mapping = pkElementArray[index].getMapping();
            Object fieldValue = null;

                    }
                }
            }
            if (getDescriptor().getCacheKeyType() == CacheKeyType.ID_VALUE) {
                return fieldValue;
            }
            primaryKey[index] = fieldValue;
        }
        return new CacheId(primaryKey);
    }
    
    /**




import javax.persistence.metamodel.Metamodel;
import javax.sql.DataSource;

import org.eclipse.persistence.annotations.CacheKeyType;
import org.eclipse.persistence.config.*;
import org.eclipse.persistence.descriptors.*;
import org.eclipse.persistence.exceptions.*;
import org.eclipse.persistence.expressions.Expression;
import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;
import org.eclipse.persistence.internal.helper.BasicTypeHelperImpl;
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.jpa.querydef.CriteriaQueryImpl;
import org.eclipse.persistence.internal.jpa.transaction.*;
import org.eclipse.persistence.internal.localization.ExceptionLocalization;

     *             second argument is not a valid type for that entity's primary
     *             key.
     */
    protected Object findInternal(ClassDescriptor descriptor, AbstractSession session, Object id, LockModeType lockMode, Map<String, Object> properties) {
        if (id == null) { // gf721 - check for null PK
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage("null_pk"));
        }

        Object primaryKey;
        if (id instanceof List) {
            if (descriptor.getCacheKeyType() == CacheKeyType.ID_VALUE) {
                if (((List)id).isEmpty()) {
                    primaryKey = null;
                } else {
                    primaryKey = ((List)id).get(0);
                }
            } else {
                primaryKey = new CacheId(((List)id).toArray());
            }
        } else if (id instanceof CacheId) {
            primaryKey = id;
        } else {
            CMPPolicy policy = descriptor.getCMPPolicy();
            Class pkClass = policy.getPKClass();
            if ((pkClass != null) && (pkClass != id.getClass()) && (!BasicTypeHelperImpl.getInstance().isStrictlyAssignableFrom(pkClass, id.getClass()))) {
                throw new IllegalArgumentException(ExceptionLocalization.buildMessage("invalid_pk_class", new Object[] { descriptor.getCMPPolicy().getPKClass(), id.getClass() }));
            }
            primaryKey = policy.createPrimaryKeyFromId(id, session);
        }

        // Get the read object query and apply the properties to it.

        if (query == null) {
            // The properties/query hints and setIsExecutionClone etc. is set
            // in the getReadObjectQuery.
            query = getReadObjectQuery(descriptor.getJavaClass(), primaryKey, properties);
        } else {
            query.checkPrepare(session, null);
            query = (ReadObjectQuery) query.clone();

            QueryHintsHandler.apply(properties, query, session.getLoader(), session);

            query.setIsExecutionClone(true);
            query.setSelectionId(primaryKey);
        }

        // Apply any EclipseLink defaults if they haven't been set through

    /**
     * Build a selection query for the primary key values.
     */
    protected ReadObjectQuery getReadObjectQuery(Class referenceClass, Object primaryKey, Map properties) {
        ReadObjectQuery query = getReadObjectQuery(properties);
        query.setReferenceClass(referenceClass);
        query.setSelectionId(primaryKey);
        return query;
    }


Lines 15-20 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/PrimaryKeyMetadata.java (+5 lines)
15	import java.util.ArrayList;	15	import java.util.ArrayList;
16	import java.util.List;	16	import java.util.List;
17		17
		18	import org.eclipse.persistence.annotations.CacheKeyType;
18	import org.eclipse.persistence.annotations.IdValidation;	19	import org.eclipse.persistence.annotations.IdValidation;
19	import org.eclipse.persistence.annotations.PrimaryKey;	20	import org.eclipse.persistence.annotations.PrimaryKey;
20	import org.eclipse.persistence.exceptions.ValidationException;	21	import org.eclipse.persistence.exceptions.ValidationException;
Lines 33-38 Link Here
33	*/	34	*/
34	public class PrimaryKeyMetadata extends ORMetadata {	35	public class PrimaryKeyMetadata extends ORMetadata {
35	private String m_validation;	36	private String m_validation;
		37	private String m_cacheKeyType;
36	private List<ColumnMetadata> m_columns = new ArrayList<ColumnMetadata>();	38	private List<ColumnMetadata> m_columns = new ArrayList<ColumnMetadata>();
37		39
38	public PrimaryKeyMetadata() {	40	public PrimaryKeyMetadata() {
Lines 60-65 Link Here
60	if (m_validation != null) {	62	if (m_validation != null) {
61	descriptor.getClassDescriptor().setIdValidation(IdValidation.valueOf(m_validation));	63	descriptor.getClassDescriptor().setIdValidation(IdValidation.valueOf(m_validation));
62	}	64	}
		65	if (m_cacheKeyType != null) {
		66	descriptor.getClassDescriptor().setCacheKeyType(CacheKeyType.valueOf(m_cacheKeyType));
		67	}
63	if (hasColumns()) {	68	if (hasColumns()) {
64	List fields = new ArrayList(m_columns.size());	69	List fields = new ArrayList(m_columns.size());
65	for (ColumnMetadata column : m_columns) {	70	for (ColumnMetadata column : m_columns) {

Lines 1794-1799 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/xml/XMLEntityMappingsMappingProject.java (+5 lines)
1794	validationMapping.setXPath("@validation");	1794	validationMapping.setXPath("@validation");
1795	descriptor.addMapping(validationMapping);	1795	descriptor.addMapping(validationMapping);
1796		1796
		1797	XMLDirectMapping cacheKeyMapping = new XMLDirectMapping();
		1798	cacheKeyMapping.setAttributeName("m_cacheKeyType");
		1799	cacheKeyMapping.setXPath("@cache-key-type");
		1800	descriptor.addMapping(cacheKeyMapping);
		1801
1797	XMLCompositeCollectionMapping columnsMapping = new XMLCompositeCollectionMapping();	1802	XMLCompositeCollectionMapping columnsMapping = new XMLCompositeCollectionMapping();
1798	columnsMapping.setAttributeName("m_columns");	1803	columnsMapping.setAttributeName("m_columns");
1799	columnsMapping.setReferenceClass(ColumnMetadata.class);	1804	columnsMapping.setReferenceClass(ColumnMetadata.class);




    public static final String PERSISTENCE_OBJECT_SHORT_SIGNATURE = "org/eclipse/persistence/internal/descriptors/PersistenceObject";
    public static final String PERSISTENCE_OBJECT_SIGNATURE = "L" + PERSISTENCE_OBJECT_SHORT_SIGNATURE + ";";
    public static final String VECTOR_SIGNATURE = "Ljava/util/Vector;";
    public static final String OBJECT_SIGNATURE = "Ljava/lang/Object;";
    public static final String CACHEKEY_SIGNATURE = "Lorg/eclipse/persistence/internal/identitymaps/CacheKey;";
    
    // Fetch groups

    }
    
    /**
     * Add a variable of type Object to the class.
     * When this method has been run, the class will contain a variable declarations similar to the following:
     *  
     *  private Object _persistence_primaryKey;
     *  private Vector _persistence_cacheKey;
     */
    public void addPersistenceEntityVariables() {
        cv.visitField(ACC_PROTECTED + ACC_TRANSIENT, "_persistence_primaryKey", OBJECT_SIGNATURE, null, null);
        cv.visitField(ACC_PROTECTED + ACC_TRANSIENT, "_persistence_cacheKey", CACHEKEY_SIGNATURE, null, null);
    }
    
    /**

	        // clone._persistence_primaryKey = null;
	        cv_clone.visitVarInsn(ALOAD, 0);
	        cv_clone.visitInsn(ACONST_NULL);
	        cv_clone.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_primaryKey", OBJECT_SIGNATURE);
	        // clone._persistence_cacheKey = null;
	        cv_clone.visitVarInsn(ALOAD, 0);
	        cv_clone.visitInsn(ACONST_NULL);
	        cv_clone.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_cacheKey", CACHEKEY_SIGNATURE);
        }
        
        // return clone;

    /**
     * Adds get/set method for PersistenceEntity interface.
     * This adds the following methods:
     * 
     *  public CacheKey _persistence_getCacheKey() {
     *      return _persistence_cacheKey;
     *  }
     *  public void _persistence_setCacheKey(CacheKey key) {
     *      this._persistence_cacheKey = key;
     *  }
     *   
     *  public Object _persistence_getId() {
     *      return _persistence_primaryKey;
     *  }
     *  public void _persistence_setId(Object primaryKey) {
     *      this._persistence_primaryKey = primaryKey;
     *  }
     */
    public void addPersistenceEntityMethods(ClassDetails classDetails) {        
        CodeVisitor cv_getPKVector = cv.visitMethod(ACC_PUBLIC, "_persistence_getId", "()" + OBJECT_SIGNATURE, null, null);
        cv_getCacheKey.visitVarInsn(ALOAD, 0);
        cv_getCacheKey.visitFieldInsn(GETFIELD, classDetails.getClassName(), "_persistence_cacheKey", CACHEKEY_SIGNATURE);
        cv_getCacheKey.visitInsn(ARETURN);
        cv_getCacheKey.visitMaxs(0, 0);
        
        CodeVisitor cv_setCacheKey = cv.visitMethod(ACC_PUBLIC, "_persistence_setCacheKey", "(" + CACHEKEY_SIGNATURE + ")V", null, null);
        cv_setCacheKey.visitVarInsn(ALOAD, 0);
        cv_setCacheKey.visitVarInsn(ALOAD, 1);
        cv_setCacheKey.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_cacheKey", CACHEKEY_SIGNATURE);
        cv_setCacheKey.visitInsn(RETURN);
        cv_setCacheKey.visitMaxs(0 ,0);
        
        CodeVisitor cv_getPKVector = cv.visitMethod(ACC_PUBLIC, "_persistence_getPKVector", "()" + VECTOR_SIGNATURE, null, null);
        cv_getPKVector.visitVarInsn(ALOAD, 0);
        cv_getPKVector.visitFieldInsn(GETFIELD, classDetails.getClassName(), "_persistence_primaryKey", OBJECT_SIGNATURE);
        cv_getPKVector.visitInsn(ARETURN);
        cv_getPKVector.visitMaxs(0, 0);
        
        CodeVisitor cv_setPKVector = cv.visitMethod(ACC_PUBLIC, "_persistence_setId", "(" + OBJECT_SIGNATURE + ")V", null, null);
        cv_setPKVector.visitVarInsn(ALOAD, 0);
        cv_setPKVector.visitVarInsn(ALOAD, 1);
        cv_setPKVector.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_primaryKey", OBJECT_SIGNATURE);
        cv_setPKVector.visitInsn(RETURN);
        cv_setPKVector.visitMaxs(0 ,0);
    }




 ******************************************************************************/
package org.eclipse.persistence.jpa.dynamic;

//javase imports
import java.util.Vector;

//EclipseLink imports
import org.eclipse.persistence.internal.identitymaps.CacheId;
import org.eclipse.persistence.internal.jpa.CMP3Policy;
import org.eclipse.persistence.internal.sessions.AbstractSession;


public class DynamicIdentityPolicy extends CMP3Policy {

    @Override
    public Object createPrimaryKeyFromId(Object key, AbstractSession session) {
        if (key instanceof Object[]) {
            return new CacheId((Object[])key);
            Vector pk = new Vector(values.length);
            for (int index = 0; index < values.length; index++) {
                pk.add(values[index]);
            }
            return pk;
        }
        return super.createPrimaryKeyFromId(key, session);
    }

    @Override

Return to bug 298985

Lines 1943-1948 Link Here

(-)foundation/org.eclipse.persistence.core/resource/xsd/eclipselink_orm_2_0.xsd (-1 / +51 lines)
1943	</xsd:restriction>	1943	</xsd:restriction>
1944	</xsd:simpleType>	1944	</xsd:simpleType>
1945		1945
		1946	<xsd:simpleType name="cache-key-type">
		1947	<xsd:annotation>
		1948	<xsd:documentation>
		1949
		1950	/**
		1951	* Configures what type of Id value is used to store the object in the cache.
		1952	* This can either be the basic Id value for simple singleton Ids,
		1953	* or an optimized CacheKey type.
		1954	*
		1955	* @see PrimaryKey#cacheKeyType()
		1956	* @see ClassDescriptor#setCacheKeyType(CacheKeyType)
		1957	* @author James Sutherland
		1958	* @since EclipseLink 2.1
		1959	*/
		1960	public enum CacheKeyType {
		1961	/**
		1962	* This can only be used for simple singleton Ids, such as long/int/String.
		1963	* This is the default for simple singleton Ids.
		1964	*/
		1965	ID_VALUE,
		1966
		1967	/**
		1968	* Optimized cache key type that allows composite and complex values.
		1969	* This is the default for composite or complex Ids.
		1970	*/
		1971	CACHE_KEY,
		1972
		1973	/**
		1974	* The cache key type is automatically configured depending on what is optimal for the class.
		1975	*/
		1976	AUTO
		1977	}
		1978
		1979	</xsd:documentation>
		1980	</xsd:annotation>
		1981
		1982	<xsd:restriction base="xsd:token">
		1983	<xsd:enumeration value="ID_VALUE"/>
		1984	<xsd:enumeration value="CACHE_KEY"/>
		1985	<xsd:enumeration value="AUTO"/>
		1986	</xsd:restriction>
		1987	</xsd:simpleType>
		1988
1946	<!-- **************************************************** -->	1989	<!-- **************************************************** -->
1947		1990
1948	<xsd:complexType name="inheritance">	1991	<xsd:complexType name="inheritance">
Lines 3015-3020 Link Here
3015	IdValidation validation() default IdValidation.ZERO;	3058	IdValidation validation() default IdValidation.ZERO;
3016		3059
3017	/**	3060	/**
		3061	* (Optional) Configures what cache key type is used to store the object in the cache.
		3062	* By default the type is determined by what type is optimal for the class.
		3063	*/
		3064	CacheKeyType cacheKeyType() default CacheKeyType.AUTO;
		3065
		3066	/**
3018	* (Optional) Used to specify the primary key columns directly.	3067	* (Optional) Used to specify the primary key columns directly.
3019	* This can be used instead of @Id if the primary key includes a non basic field,	3068	* This can be used instead of @Id if the primary key includes a non basic field,
3020	* such as a foreign key, or a inheritance discriminator, embedded, or transformation mapped field.	3069	* such as a foreign key, or a inheritance discriminator, embedded, or transformation mapped field.
Lines 3025-3033 Link Here
3025	</xsd:documentation>	3074	</xsd:documentation>
3026	</xsd:annotation>	3075	</xsd:annotation>
3027	<xsd:sequence>	3076	<xsd:sequence>
3028	<xsd:element name="column" type="orm:column" minOccurs="0" maxOccurs="unbounded"/>	3077	<xsd:element name="column" type="orm:column" minOccurs="0" maxOccurs="unbounded"/>
3029	</xsd:sequence>	3078	</xsd:sequence>
3030	<xsd:attribute name="validation" type="orm:id-validation"/>	3079	<xsd:attribute name="validation" type="orm:id-validation"/>
		3080	<xsd:attribute name="cache-key-type" type="orm:cache-key-type"/>
3031	</xsd:complexType>	3081	</xsd:complexType>
3032		3082
3033	<!-- **************************************************** -->	3083	<!-- **************************************************** -->

Lines 14-23 Link Here

(-)dbws/org.eclipse.persistence.dbws/src/org/eclipse/persistence/internal/xr/XRDynamicEntity.java (-21 / +4 lines)
14		14
15	//javase imports	15	//javase imports
16	import java.beans.PropertyChangeListener;	16	import java.beans.PropertyChangeListener;
17	import java.util.Vector;
18		17
19	//java extension imports
20
21	//EclipseLink imports	18	//EclipseLink imports
22	import org.eclipse.persistence.descriptors.changetracking.ChangeTracker;	19	import org.eclipse.persistence.descriptors.changetracking.ChangeTracker;
23	import org.eclipse.persistence.dynamic.DynamicEntity;	20	import org.eclipse.persistence.dynamic.DynamicEntity;
Lines 112-130 Link Here
112	}	109	}
113		110
114	//PersistenceEntity API	111	//PersistenceEntity API
115	protected CacheKey __cacheKey;	112	protected Object __pk;
116	protected Vector __pk;	113	public Object _persistence_getId() {
117	// perf. optimization - cache the __cacheKey and pkVector
118	public CacheKey _persistence_getCacheKey() {
119	return __cacheKey;
120	}
121	public void _persistence_setCacheKey(CacheKey cacheKey) {
122	this.__cacheKey = cacheKey;
123	}
124	public Vector _persistence_getPKVector() {
125	return __pk;	114	return __pk;
126	}	115	}
127	public void _persistence_setPKVector(Vector pk) {	116	public void _persistence_setId(Object pk) {
128	this.__pk = pk;	117	this.__pk = pk;
129	}	118	}
130		119
Lines 195-207 Link Here
195	// this will print something like {Emp 10} or {Phone 234-5678 10}	184	// this will print something like {Emp 10} or {Phone 234-5678 10}
196	StringBuilder sb = new StringBuilder(20);	185	StringBuilder sb = new StringBuilder(20);
197	sb.append('{');	186	sb.append('{');
198	sb.append(getShortClassName(this.getClass()));	187	sb.append(__pk);
199	if (__pk != null) {
200	for (int i = 0; i < __pk.size(); i++) {
201	sb.append(' ');
202	sb.append(__pk.elementAt(i));
203	}
204	}
205	sb.append('}');	188	sb.append('}');
206	return sb.toString();	189	return sb.toString();
207	}	190	}

Lines 223-229 Link Here

(-)foundation/eclipselink.core.test/src/org/eclipse/persistence/testing/framework/JoinedAttributeTestHelper.java (-5 lines)
223	HashMap map1 = new HashMap(col1.size());	223	HashMap map1 = new HashMap(col1.size());
224	HashMap map2 = new HashMap(col2.size());	224	HashMap map2 = new HashMap(col2.size());
225		225
226	boolean simplePk = desc.getPrimaryKeyFields().size()==1;
227	ObjectBuilder builder = desc.getObjectBuilder();	226	ObjectBuilder builder = desc.getObjectBuilder();
228	Iterator it1 = col1.iterator();	227	Iterator it1 = col1.iterator();
229	Iterator it2 = col2.iterator();	228	Iterator it2 = col2.iterator();
Lines 232-241 Link Here
232	Object obj2 = it2.next();	231	Object obj2 = it2.next();
233	Object pk1 = builder.extractPrimaryKeyFromObject(obj1, session);	232	Object pk1 = builder.extractPrimaryKeyFromObject(obj1, session);
234	Object pk2 = builder.extractPrimaryKeyFromObject(obj2, session);	233	Object pk2 = builder.extractPrimaryKeyFromObject(obj2, session);
235	if(simplePk) {
236	pk1 = ((Vector)pk1).firstElement();
237	pk2 = ((Vector)pk2).firstElement();
238	}
239	map1.put(pk1, obj1);	234	map1.put(pk1, obj1);
240	map2.put(pk2, obj2);	235	map2.put(pk2, obj2);
241	}	236	}

Lines 94-110 Link Here

(-)foundation/eclipselink.core.test/src/org/eclipse/persistence/testing/tests/queries/inmemory/UnitOfWorkConformNewObjectTest.java (-5 / +5 lines)
94	queryReadObject_1_ByObject.setReferenceClass(Employee.class);	94	queryReadObject_1_ByObject.setReferenceClass(Employee.class);
95	queryReadObject_1_ByObject.conformResultsInUnitOfWork();	95	queryReadObject_1_ByObject.conformResultsInUnitOfWork();
96	queryReadObject_1_ByObject.setSelectionObject(emp1);	96	queryReadObject_1_ByObject.setSelectionObject(emp1);
97	if(emp1 != uow.executeQuery(queryReadObject_1_ByObject)) {	97	Employee result = (Employee)uow.executeQuery(queryReadObject_1_ByObject);
		98	if (emp1 != result) {
98	errorMsg += "queryReadObject_1_ByObject: emp1; ";	99	errorMsg += "queryReadObject_1_ByObject: emp1; ";
99	}	100	}
100		101
101	ReadObjectQuery queryReadObject_1_ByKey = new ReadObjectQuery();	102	ReadObjectQuery queryReadObject_1_ByKey = new ReadObjectQuery();
102	queryReadObject_1_ByKey.setReferenceClass(Employee.class);	103	queryReadObject_1_ByKey.setReferenceClass(Employee.class);
103	queryReadObject_1_ByKey.conformResultsInUnitOfWork();	104	queryReadObject_1_ByKey.conformResultsInUnitOfWork();
104	Vector key = new Vector(1);	105	queryReadObject_1_ByKey.setSelectionId(emp1.getId());
105	key.add(emp1.getId());	106	result = (Employee)uow.executeQuery(queryReadObject_1_ByKey);
106	queryReadObject_1_ByKey.setSelectionId(key);	107	if (emp1 != result) {
107	if(emp1 != uow.executeQuery(queryReadObject_1_ByKey)) {
108	errorMsg += "queryReadObject_1_ByKey: emp1; ";	108	errorMsg += "queryReadObject_1_ByKey: emp1; ";
109	}	109	}
110		110

Line 0 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/annotations/CacheKeyType.java (+44 lines)
	1	/*******************************************************************************
	2	* Copyright (c) 1998, 2010 Oracle. All rights reserved.
	3	* This program and the accompanying materials are made available under the
	4	* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
	5	* which accompanies this distribution.
	6	* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
	7	* and the Eclipse Distribution License is available at
	8	* http://www.eclipse.org/org/documents/edl-v10.php.
	9	*
	10	* Contributors:
	11	* James Sutherland - allow for zero ids
	12	******************************************************************************/
	13	package org.eclipse.persistence.annotations;
	14
	15	import org.eclipse.persistence.descriptors.ClassDescriptor;
	16
	17	/**
	18	* Configures what type of Id value is used to store the object in the cache.
	19	* This can either be the basic Id value for simple singleton Ids,
	20	* or an optimized CacheId type.
	21	*
	22	* @see PrimaryKey#cacheKeyType()
	23	* @see ClassDescriptor#setCacheKeyType(CacheKeyType)
	24	* @author James Sutherland
	25	* @since EclipseLink 2.1
	26	*/
	27	public enum CacheKeyType {
	28	/**
	29	* This can only be used for simple singleton Ids, such as long/int/String.
	30	* This is the default for simple singleton Ids.
	31	*/
	32	ID_VALUE,
	33
	34	/**
	35	* Optimized cache key type that allows composite and complex values.
	36	* This is the default for composite or complex Ids.
	37	*/
	38	CACHE_ID,
	39
	40	/**
	41	* The cache key type is automatically configured depending on what is optimal for the class.
	42	*/
	43	AUTO
	44	}

Lines 50-56 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/InheritancePolicy.java (-41 / +33 lines)
50	protected Class parentClass;	50	protected Class parentClass;
51	protected String parentClassName;	51	protected String parentClassName;
52	protected ClassDescriptor parentDescriptor;	52	protected ClassDescriptor parentDescriptor;
53	protected Vector childDescriptors;	53	protected List<ClassDescriptor> childDescriptors;
54	protected transient DatabaseField classIndicatorField;	54	protected transient DatabaseField classIndicatorField;
55	protected transient Map classIndicatorMapping;	55	protected transient Map classIndicatorMapping;
56	protected transient Map classNameIndicatorMapping;	56	protected transient Map classNameIndicatorMapping;
Lines 58-72 Link Here
58	protected transient Boolean shouldReadSubclasses;	58	protected transient Boolean shouldReadSubclasses;
59	protected transient boolean hasMultipleTableChild;	59	protected transient boolean hasMultipleTableChild;
60	protected transient DatabaseTable readAllSubclassesView;	60	protected transient DatabaseTable readAllSubclassesView;
61	protected transient Vector allChildClassIndicators;	61	protected transient List<Object> allChildClassIndicators;
62	protected transient Expression onlyInstancesExpression;	62	protected transient Expression onlyInstancesExpression;
63	protected transient Expression withAllSubclassesExpression;	63	protected transient Expression withAllSubclassesExpression;
64	// null if there are no childrenTables, otherwise all tables for reference class plus childrenTables	64	// null if there are no childrenTables, otherwise all tables for reference class plus childrenTables
65	protected transient Vector allTables;	65	protected transient Vector allTables;
66	// all tables for all subclasses (subclasses of subclasses included), should be in sync with childrenTablesJoinExpressions.	66	// all tables for all subclasses (subclasses of subclasses included), should be in sync with childrenTablesJoinExpressions.
67	protected transient List childrenTables;	67	protected transient List<DatabaseTable> childrenTables;
68	// join expression for each child table, keyed by the table, should be in sync with childrenTables.	68	// join expression for each child table, keyed by the table, should be in sync with childrenTables.
69	protected transient Map childrenTablesJoinExpressions;	69	protected transient Map<DatabaseTable, Expression> childrenTablesJoinExpressions;
70	// all expressions from childrenTablesJoinExpressions ANDed together	70	// all expressions from childrenTablesJoinExpressions ANDed together
71	protected transient Expression childrenJoinExpression;	71	protected transient Expression childrenJoinExpression;
72		72
Lines 100-107 Link Here
100	this.classIndicatorMapping = new HashMap(10);	100	this.classIndicatorMapping = new HashMap(10);
101	this.classNameIndicatorMapping = new HashMap(10);	101	this.classNameIndicatorMapping = new HashMap(10);
102	this.shouldUseClassNameAsIndicator = false;	102	this.shouldUseClassNameAsIndicator = false;
103	this.allChildClassIndicators = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance();	103	this.allChildClassIndicators = new ArrayList(4);
104	this.childDescriptors = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(5);	104	this.childDescriptors = new ArrayList(4);
105	this.setJoinedStrategy();	105	this.setJoinedStrategy();
106	}	106	}
107		107
Lines 120-126 Link Here
120	* Add child descriptor to the parent descriptor.	120	* Add child descriptor to the parent descriptor.
121	*/	121	*/
122	public void addChildDescriptor(ClassDescriptor childDescriptor) {	122	public void addChildDescriptor(ClassDescriptor childDescriptor) {
123	getChildDescriptors().addElement(childDescriptor);	123	getChildDescriptors().add(childDescriptor);
124	}	124	}
125		125
126	/**	126	/**
Lines 129-145 Link Here
129	* are created simultaneously and kept in sync.	129	* are created simultaneously and kept in sync.
130	*/	130	*/
131	protected void addChildTableJoinExpression(DatabaseTable table, Expression expression) {	131	protected void addChildTableJoinExpression(DatabaseTable table, Expression expression) {
132	if(childrenTablesJoinExpressions == null) {	132	if (this.childrenTablesJoinExpressions == null) {
133	childrenTablesJoinExpressions = new HashMap();	133	this.childrenTablesJoinExpressions = new HashMap();
134	// childrenTables should've been null, too	134	// childrenTables should've been null, too
135	childrenTables = new ArrayList();	135	this.childrenTables = new ArrayList();
136	// allTables should've been null, too	136	// allTables should've been null, too
137	allTables = new Vector(getDescriptor().getTables());	137	this.allTables = new Vector(getDescriptor().getTables());
138	}	138	}
139	childrenTables.add(table);	139	this.childrenTables.add(table);
140	allTables.add(table);	140	this.allTables.add(table);
141	childrenTablesJoinExpressions.put(table, expression);	141	this.childrenTablesJoinExpressions.put(table, expression);
142	childrenJoinExpression = expression.and(childrenJoinExpression);	142	this.childrenJoinExpression = expression.and(this.childrenJoinExpression);
143	}	143	}
144		144
145	/**	145	/**
Lines 221-227 Link Here
221		221
222	if (parentDescriptor.getInheritancePolicy().isChildDescriptor()) {	222	if (parentDescriptor.getInheritancePolicy().isChildDescriptor()) {
223	if (parentDescriptor.getInheritancePolicy().shouldReadSubclasses()) {	223	if (parentDescriptor.getInheritancePolicy().shouldReadSubclasses()) {
224	parentDescriptor.getInheritancePolicy().getAllChildClassIndicators().addElement(indicator);	224	parentDescriptor.getInheritancePolicy().getAllChildClassIndicators().add(indicator);
225	}	225	}
226	parentDescriptor.getInheritancePolicy().addClassIndicatorTypeToParent(indicator);	226	parentDescriptor.getInheritancePolicy().addClassIndicatorTypeToParent(indicator);
227	}	227	}
Lines 481-487 Link Here
481	* Stores class indicators for all child and children's children.	481	* Stores class indicators for all child and children's children.
482	* Used for queries on branch classes only.	482	* Used for queries on branch classes only.
483	*/	483	*/
484	protected Vector getAllChildClassIndicators() {	484	protected List<Object> getAllChildClassIndicators() {
485	return allChildClassIndicators;	485	return allChildClassIndicators;
486	}	486	}
487		487
Lines 491-499 Link Here
491	* subclasses.	491	* subclasses.
492	* Required for bug 3019934.	492	* Required for bug 3019934.
493	*/	493	*/
494	public Vector getAllChildDescriptors() {	494	public List<ClassDescriptor> getAllChildDescriptors() {
495	// Guess the number of child descriptors...	495	// Guess the number of child descriptors...
496	Vector allChildDescriptors = new Vector(this.getAllChildClassIndicators().size());	496	List<ClassDescriptor> allChildDescriptors = new ArrayList(this.getAllChildClassIndicators().size());
497	return getAllChildDescriptors(allChildDescriptors);	497	return getAllChildDescriptors(allChildDescriptors);
498	}	498	}
499		499
Lines 501-510 Link Here
501	* INTERNAL:	501	* INTERNAL:
502	* Recursive subroutine of getAllChildDescriptors.	502	* Recursive subroutine of getAllChildDescriptors.
503	*/	503	*/
504	protected Vector getAllChildDescriptors(Vector allChildDescriptors) {	504	protected List<ClassDescriptor> getAllChildDescriptors(List<ClassDescriptor> allChildDescriptors) {
505	for (Enumeration enumtr = getChildDescriptors().elements(); enumtr.hasMoreElements();) {	505	for (ClassDescriptor childDescriptor : getChildDescriptors()) {
506	ClassDescriptor childDescriptor = (ClassDescriptor)enumtr.nextElement();	506	allChildDescriptors.add(childDescriptor);
507	allChildDescriptors.addElement(childDescriptor);
508	childDescriptor.getInheritancePolicyOrNull().getAllChildDescriptors(allChildDescriptors);	507	childDescriptor.getInheritancePolicyOrNull().getAllChildDescriptors(allChildDescriptors);
509	}	508	}
510	return allChildDescriptors;	509	return allChildDescriptors;
Lines 514-520 Link Here
514	* INTERNAL:	513	* INTERNAL:
515	* if reads subclasses, all tables for all read subclasses (indirect included).	514	* if reads subclasses, all tables for all read subclasses (indirect included).
516	*/	515	*/
517	public List getChildrenTables() {	516	public List<DatabaseTable> getChildrenTables() {
518	return childrenTables;	517	return childrenTables;
519	}	518	}
520		519
Lines 522-528 Link Here
522	* INTERNAL:	521	* INTERNAL:
523	* join expression for each child table, keyed by the table	522	* join expression for each child table, keyed by the table
524	*/	523	*/
525	public Map getChildrenTablesJoinExpressions() {	524	public Map<DatabaseTable, Expression> getChildrenTablesJoinExpressions() {
526	return childrenTablesJoinExpressions;	525	return childrenTablesJoinExpressions;
527	}	526	}
528		527
Lines 539-545 Link Here
539	* all tables for reference class plus childrenTables	538	* all tables for reference class plus childrenTables
540	*/	539	*/
541	public Vector getAllTables() {	540	public Vector getAllTables() {
542	if(allTables == null) {	541	if (allTables == null) {
543	return this.getDescriptor().getTables();	542	return this.getDescriptor().getTables();
544	} else {	543	} else {
545	return allTables;	544	return allTables;
Lines 551-557 Link Here
551	* Return all the immediate child descriptors. Only descriptors from	550	* Return all the immediate child descriptors. Only descriptors from
552	* direct subclasses are returned.	551	* direct subclasses are returned.
553	*/	552	*/
554	public Vector getChildDescriptors() {	553	public List<ClassDescriptor> getChildDescriptors() {
555	return childDescriptors;	554	return childDescriptors;
556	}	555	}
557		556
Lines 943-949 Link Here
943		942
944	if (getClassIndicatorValue() != null) {	943	if (getClassIndicatorValue() != null) {
945	if (shouldReadSubclasses()) {	944	if (shouldReadSubclasses()) {
946	getAllChildClassIndicators().addElement(getClassIndicatorValue());	945	getAllChildClassIndicators().add(getClassIndicatorValue());
947	}	946	}
948	addClassIndicatorTypeToParent(getClassIndicatorValue());	947	addClassIndicatorTypeToParent(getClassIndicatorValue());
949	}	948	}
Lines 1209-1217 Link Here
1209	}	1208	}
1210		1209
1211	Vector tempChildren = new Vector(getChildDescriptors().size());	1210	Vector tempChildren = new Vector(getChildDescriptors().size());
1212	Enumeration childEnum = getChildDescriptors().elements();	1211	for (ClassDescriptor childDescriptor : getChildDescriptors()) {
1213	while (childEnum.hasMoreElements()) {
1214	ClassDescriptor childDescriptor = (ClassDescriptor)childEnum.nextElement();
1215	if (session.hasCorrespondingDescriptor(childDescriptor)) {	1212	if (session.hasCorrespondingDescriptor(childDescriptor)) {
1216	tempChildren.addElement(session.getDescriptor(childDescriptor.getJavaClass()));	1213	tempChildren.addElement(session.getDescriptor(childDescriptor.getJavaClass()));
1217	} else {	1214	} else {
Lines 1254-1262 Link Here
1254	}	1251	}
1255		1252
1256	// Recursively collect all rows from all concrete children and their children.	1253	// Recursively collect all rows from all concrete children and their children.
1257	for (Enumeration childrenEnum = getChildDescriptors().elements();	1254	for (ClassDescriptor concreteDescriptor : getChildDescriptors()) {
1258	childrenEnum.hasMoreElements();) {
1259	ClassDescriptor concreteDescriptor = (ClassDescriptor)childrenEnum.nextElement();
1260	Vector concreteRows = concreteDescriptor.getInheritancePolicy().selectAllRowUsingCustomMultipleTableSubclassRead(query);	1255	Vector concreteRows = concreteDescriptor.getInheritancePolicy().selectAllRowUsingCustomMultipleTableSubclassRead(query);
1261	rows = Helper.concatenateVectors(rows, concreteRows);	1256	rows = Helper.concatenateVectors(rows, concreteRows);
1262	}	1257	}
Lines 1281-1287 Link Here
1281	AbstractRecord row = (AbstractRecord)rowsEnum.nextElement();	1276	AbstractRecord row = (AbstractRecord)rowsEnum.nextElement();
1282	Class concreteClass = classFromRow(row, query.getSession());	1277	Class concreteClass = classFromRow(row, query.getSession());
1283	if (!classes.contains(concreteClass)) {//Ensure unique ** we should do a distinct.. we do	1278	if (!classes.contains(concreteClass)) {//Ensure unique ** we should do a distinct.. we do
1284	classes.addElement(concreteClass);	1279	classes.add(concreteClass);
1285	}	1280	}
1286	}	1281	}
1287		1282
Lines 1369-1379 Link Here
1369	}	1364	}
1370		1365
1371	// Recursively collect all rows from all concrete children and their children.	1366	// Recursively collect all rows from all concrete children and their children.
1372	for (Enumeration childrenEnum = getChildDescriptors().elements();	1367	for (ClassDescriptor concreteDescriptor : getChildDescriptors()) {
1373	childrenEnum.hasMoreElements();) {
1374	ClassDescriptor concreteDescriptor = (ClassDescriptor)childrenEnum.nextElement();
1375	AbstractRecord row = concreteDescriptor.getInheritancePolicy().selectOneRowUsingCustomMultipleTableSubclassRead(query);	1368	AbstractRecord row = concreteDescriptor.getInheritancePolicy().selectOneRowUsingCustomMultipleTableSubclassRead(query);
1376
1377	if (row != null) {	1369	if (row != null) {
1378	return row;	1370	return row;
1379	}	1371	}
Lines 1434-1441 Link Here
1434	/**	1426	/**
1435	* INTERNAL:	1427	* INTERNAL:
1436	*/	1428	*/
1437	public void setChildDescriptors(Vector theChildDescriptors) {	1429	public void setChildDescriptors(List<ClassDescriptor> childDescriptors) {
1438	childDescriptors = theChildDescriptors;	1430	this.childDescriptors = childDescriptors;
1439	}	1431	}
1440		1432
1441	/**	1433	/**

Lines 28-34 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/eis/mappings/EISOneToManyMapping.java (-5 / +1 lines)
28	import org.eclipse.persistence.expressions.Expression;	28	import org.eclipse.persistence.expressions.Expression;
29	import org.eclipse.persistence.internal.descriptors.ObjectBuilder;	29	import org.eclipse.persistence.internal.descriptors.ObjectBuilder;
30	import org.eclipse.persistence.internal.helper.DatabaseField;	30	import org.eclipse.persistence.internal.helper.DatabaseField;
31	import org.eclipse.persistence.internal.identitymaps.CacheKey;
32	import org.eclipse.persistence.internal.indirection.EISOneToManyQueryBasedValueHolder;	31	import org.eclipse.persistence.internal.indirection.EISOneToManyQueryBasedValueHolder;
33	import org.eclipse.persistence.oxm.XMLField;	32	import org.eclipse.persistence.oxm.XMLField;
34	import org.eclipse.persistence.internal.oxm.XPathEngine;	33	import org.eclipse.persistence.internal.oxm.XPathEngine;
Lines 709-718 Link Here
709	Object primaryKey1 = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(element1, session);	708	Object primaryKey1 = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(element1, session);
710	Object primaryKey2 = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(element2, session);	709	Object primaryKey2 = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(element2, session);
711		710
712	CacheKey cacheKey1 = new CacheKey(primaryKey1);	711	if (!primaryKey1.equals(primaryKey2)) {
713	CacheKey cacheKey2 = new CacheKey(primaryKey2);
714
715	if (!cacheKey1.equals(cacheKey2)) {
716	return false;	712	return false;
717	}	713	}
718		714

Lines 17-29 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/eis/mappings/EISOneToOneMapping.java (-104 / +46 lines)
17	import java.util.Iterator;	17	import java.util.Iterator;
18	import java.util.List;	18	import java.util.List;
19	import java.util.Map;	19	import java.util.Map;
20	import java.util.Vector;	20
21	import org.eclipse.persistence.exceptions.ConversionException;	21	import org.eclipse.persistence.annotations.CacheKeyType;
22	import org.eclipse.persistence.exceptions.DatabaseException;	22	import org.eclipse.persistence.exceptions.DatabaseException;
23	import org.eclipse.persistence.exceptions.DescriptorException;	23	import org.eclipse.persistence.exceptions.DescriptorException;
24	import org.eclipse.persistence.expressions.Expression;	24	import org.eclipse.persistence.expressions.Expression;
25	import org.eclipse.persistence.expressions.ExpressionBuilder;	25	import org.eclipse.persistence.expressions.ExpressionBuilder;
26	import org.eclipse.persistence.internal.helper.DatabaseField;	26	import org.eclipse.persistence.internal.helper.DatabaseField;
		27	import org.eclipse.persistence.internal.identitymaps.CacheId;
27	import org.eclipse.persistence.internal.queries.JoinedAttributeManager;	28	import org.eclipse.persistence.internal.queries.JoinedAttributeManager;
28	import org.eclipse.persistence.internal.sessions.AbstractRecord;	29	import org.eclipse.persistence.internal.sessions.AbstractRecord;
29	import org.eclipse.persistence.internal.sessions.AbstractSession;	30	import org.eclipse.persistence.internal.sessions.AbstractSession;
Lines 35-41 Link Here
35	* <p>An EIS one-to-one mapping is a reference mapping that represents the relationship between	36	* <p>An EIS one-to-one mapping is a reference mapping that represents the relationship between
36	* a single source object and a single mapped persistent Java object. The source object usually	37	* a single source object and a single mapped persistent Java object. The source object usually
37	* contains a foreign key (pointer) to the target object (key on source); alternatively, the target	38	* contains a foreign key (pointer) to the target object (key on source); alternatively, the target
38	* object may contiain a foreign key to the source object (key on target). Because both the source	39	* object may contain a foreign key to the source object (key on target). Because both the source
39	* and target objects use interactions, they must both be configured as root object types.	40	* and target objects use interactions, they must both be configured as root object types.
40	*	41	*
41	* <p><table border="1">	42	* <p><table border="1">
Lines 72-78 Link Here
72	protected Map sourceToTargetKeyFields;	73	protected Map sourceToTargetKeyFields;
73		74
74	/** Maps the target primary/foreign key fields to the source foreign/primary key fields. */	75	/** Maps the target primary/foreign key fields to the source foreign/primary key fields. */
75	protected Map targetToSourceKeyFields;	76	protected Map<DatabaseField, DatabaseField> targetToSourceKeyFields;
76		77
77	/** These are used for non-unit of work modification to check if the value of the 1-1 was changed and a deletion is required. */	78	/** These are used for non-unit of work modification to check if the value of the 1-1 was changed and a deletion is required. */
78	protected boolean shouldVerifyDelete;	79	protected boolean shouldVerifyDelete;
Lines 90-95 Link Here
90	/**	91	/**
91	* INTERNAL:	92	* INTERNAL:
92	*/	93	*/
		94	@Override
93	public boolean isEISMapping() {	95	public boolean isEISMapping() {
94	return true;	96	return true;
95	}	97	}
Lines 97-119 Link Here
97	/**	99	/**
98	* INTERNAL:	100	* INTERNAL:
99	*/	101	*/
		102	@Override
100	public boolean isOneToOneMapping() {	103	public boolean isOneToOneMapping() {
101	return true;	104	return true;
102	}	105	}
103		106
104	/**	107	/**
105	* PUBLIC:	108	* PUBLIC:
106	* Define the source foreign key relationship in the one-to-one mapping.	109	* Define the source foreign key relationship in the one-to-one mapping.
107	* This method is used to add foreign key relationships to the mapping.	110	* This method is used to add foreign key relationships to the mapping.
108	* Both the source foreign key field name and the corresponding	111	* Both the source foreign key field name and the corresponding
109	* target primary key field name must be specified.	112	* target primary key field name must be specified.
110	*/	113	*/
111	public void addForeignKeyField(DatabaseField sourceForeignKeyField, DatabaseField targetKeyField) {	114	public void addForeignKeyField(DatabaseField sourceForeignKeyField, DatabaseField targetKeyField) {
112	this.getSourceToTargetKeyFields().put(sourceForeignKeyField, targetKeyField);	115	getSourceToTargetKeyFields().put(sourceForeignKeyField, targetKeyField);
113	this.getTargetToSourceKeyFields().put(targetKeyField, sourceForeignKeyField);	116	getTargetToSourceKeyFields().put(targetKeyField, sourceForeignKeyField);
114		117
115	this.getForeignKeyFields().add(sourceForeignKeyField);	118	getForeignKeyFields().add(sourceForeignKeyField);
116	this.setIsForeignKeyRelationship(true);	119	setIsForeignKeyRelationship(true);
117	}	120	}
118		121
119	/**	122	/**
Lines 132-137 Link Here
132	* This methods clones all the fields and ensures that each collection refers to	135	* This methods clones all the fields and ensures that each collection refers to
133	* the same clones.	136	* the same clones.
134	*/	137	*/
		138	@Override
135	public Object clone() {	139	public Object clone() {
136	EISOneToOneMapping clone = (EISOneToOneMapping)super.clone();	140	EISOneToOneMapping clone = (EISOneToOneMapping)super.clone();
137	clone.setForeignKeyFields(org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(getForeignKeyFields().size()));	141	clone.setForeignKeyFields(org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance(getForeignKeyFields().size()));
Lines 151-157 Link Here
151	Iterator sourceKeyIterator = getSourceToTargetKeyFields().keySet().iterator();	155	Iterator sourceKeyIterator = getSourceToTargetKeyFields().keySet().iterator();
152	while (sourceKeyIterator.hasNext()) {	156	while (sourceKeyIterator.hasNext()) {
153	DatabaseField sourceField = (DatabaseField)sourceKeyIterator.next();	157	DatabaseField sourceField = (DatabaseField)sourceKeyIterator.next();
154	DatabaseField targetField = (DatabaseField)getSourceToTargetKeyFields().get(sourceField);	158	DatabaseField targetField = getSourceToTargetKeyFields().get(sourceField);
155		159
156	DatabaseField targetClone = (DatabaseField)setOfFields.get(targetField);	160	DatabaseField targetClone = (DatabaseField)setOfFields.get(targetField);
157	if (targetClone == null) {	161	if (targetClone == null) {
Lines 171-177 Link Here
171	Iterator targetKeyIterator = getTargetToSourceKeyFields().keySet().iterator();	175	Iterator targetKeyIterator = getTargetToSourceKeyFields().keySet().iterator();
172	while (targetKeyIterator.hasNext()) {	176	while (targetKeyIterator.hasNext()) {
173	DatabaseField targetField = (DatabaseField)targetKeyIterator.next();	177	DatabaseField targetField = (DatabaseField)targetKeyIterator.next();
174	DatabaseField sourceField = (DatabaseField)getTargetToSourceKeyFields().get(targetField);	178	DatabaseField sourceField = getTargetToSourceKeyFields().get(targetField);
175		179
176	DatabaseField targetClone = (DatabaseField)setOfFields.get(targetField);	180	DatabaseField targetClone = (DatabaseField)setOfFields.get(targetField);
177	if (targetClone == null) {	181	if (targetClone == null) {
Lines 192-263 Link Here
192		196
193	/**	197	/**
194	* INTERNAL:	198	* INTERNAL:
195	* Extract the foreign key value from the source row.
196	*/
197	protected Vector extractForeignKeyFromRow(AbstractRecord row, AbstractSession session) {
198	Vector key = new Vector();
199
200	Iterator sourceKeyIterator = getSourceToTargetKeyFields().keySet().iterator();
201	while (sourceKeyIterator.hasNext()) {
202	DatabaseField field = (DatabaseField)sourceKeyIterator.next();
203	Object value = row.get(field);
204
205	// Must ensure the classification gets a cache hit.
206	try {
207	value = session.getDatasourcePlatform().getConversionManager().convertObject(value, getDescriptor().getObjectBuilder().getFieldClassification(field));
208	} catch (ConversionException e) {
209	throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
210	}
211
212	key.addElement(value);
213	}
214
215	return key;
216	}
217
218	/**
219	* INTERNAL:
220	* Extract the key value from the reference object.
221	*/
222	protected Vector extractKeyFromReferenceObject(Object object, AbstractSession session) {
223	Vector key = new Vector();
224
225	Iterator sourceKeyIterator = getSourceToTargetKeyFields().keySet().iterator();
226	while (sourceKeyIterator.hasNext()) {
227	DatabaseField field = (DatabaseField)sourceKeyIterator.next();
228	if (object == null) {
229	key.addElement(null);
230	} else {
231	key.addElement(getReferenceDescriptor().getObjectBuilder().extractValueFromObjectForField(object, field, session));
232	}
233	}
234	return key;
235	}
236
237	/**
238	* INTERNAL:
239	* Return the primary key for the reference object (i.e. the object	199	* Return the primary key for the reference object (i.e. the object
240	* object referenced by domainObject and specified by mapping).	200	* object referenced by domainObject and specified by mapping).
241	* This key will be used by a RemoteValueHolder.	201	* This key will be used by a RemoteValueHolder.
242	*/	202	*/
243	public Vector extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row) {	203	@Override
		204	public Object extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row) {
244	List primaryKeyFields = getReferenceDescriptor().getPrimaryKeyFields();	205	List primaryKeyFields = getReferenceDescriptor().getPrimaryKeyFields();
245	Vector result = new Vector(primaryKeyFields.size());	206	Object[] result = new Object[primaryKeyFields.size()];
246	for (int index = 0; index < primaryKeyFields.size(); index++) {	207	for (int index = 0; index < primaryKeyFields.size(); index++) {
247	DatabaseField targetKeyField = (DatabaseField)primaryKeyFields.get(index);	208	DatabaseField targetKeyField = (DatabaseField)primaryKeyFields.get(index);
248	DatabaseField sourceKeyField = (DatabaseField)getTargetToSourceKeyFields().get(targetKeyField);	209	DatabaseField sourceKeyField = getTargetToSourceKeyFields().get(targetKeyField);
249	if (sourceKeyField == null) {	210	if (sourceKeyField == null) {
250	return new Vector(1);	211	return null;
251	}	212	}
252	result.addElement(row.get(sourceKeyField));	213	result[index] = row.get(sourceKeyField);
		214	if (getReferenceDescriptor().getCacheKeyType() == CacheKeyType.ID_VALUE) {
		215	return result[index];
		216	}
253	}	217	}
254	return result;	218	return new CacheId(result);
255	}	219	}
256		220
257	/**	221	/**
258	* INTERNAL:	222	* INTERNAL:
259	* Initialize the mapping.	223	* Initialize the mapping.
260	*/	224	*/
		225	@Override
261	public void initialize(AbstractSession session) throws DescriptorException {	226	public void initialize(AbstractSession session) throws DescriptorException {
262	super.initialize(session);	227	super.initialize(session);
263		228
Lines 320-326 Link Here
320	Iterator keyIterator = getSourceToTargetKeyFields().keySet().iterator();	285	Iterator keyIterator = getSourceToTargetKeyFields().keySet().iterator();
321	while (keyIterator.hasNext()) {	286	while (keyIterator.hasNext()) {
322	DatabaseField foreignKey = (DatabaseField)keyIterator.next();	287	DatabaseField foreignKey = (DatabaseField)keyIterator.next();
323	DatabaseField targetKey = (DatabaseField)getSourceToTargetKeyFields().get(foreignKey);	288	DatabaseField targetKey = getSourceToTargetKeyFields().get(foreignKey);
324		289
325	Expression expression = builder.getField(targetKey).equal(builder.getParameter(foreignKey));	290	Expression expression = builder.getField(targetKey).equal(builder.getParameter(foreignKey));
326	criteria = expression.and(getSelectionCriteria());	291	criteria = expression.and(getSelectionCriteria());
Lines 332-337 Link Here
332	* INTERNAL:	297	* INTERNAL:
333	* Reads the private owned object.	298	* Reads the private owned object.
334	*/	299	*/
		300	@Override
335	protected Object readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery) throws DatabaseException {	301	protected Object readPrivateOwnedForObject(ObjectLevelModifyQuery modifyQuery) throws DatabaseException {
336	if (modifyQuery.getSession().isUnitOfWork()) {	302	if (modifyQuery.getSession().isUnitOfWork()) {
337	return getRealAttributeValueFromObject(modifyQuery.getBackupClone(), modifyQuery.getSession());	303	return getRealAttributeValueFromObject(modifyQuery.getBackupClone(), modifyQuery.getSession());
Lines 378-383 Link Here
378	* Return the value of the field from the row or a value holder on the query to obtain the object.	344	* Return the value of the field from the row or a value holder on the query to obtain the object.
379	* Check for batch + aggregation reading.	345	* Check for batch + aggregation reading.
380	*/	346	*/
		347	@Override
381	public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery query, AbstractSession session) throws DatabaseException {	348	public Object valueFromRow(AbstractRecord row, JoinedAttributeManager joinManager, ObjectBuildingQuery query, AbstractSession session) throws DatabaseException {
382	// If any field in the foreign key is null then it means there are no referenced objects	349	// If any field in the foreign key is null then it means there are no referenced objects
383	// Skip for partial objects as fk may not be present.	350	// Skip for partial objects as fk may not be present.
Lines 415-420 Link Here
415	* INTERNAL:	382	* INTERNAL:
416	* Get a value from the object and set that in the respective field of the row.	383	* Get a value from the object and set that in the respective field of the row.
417	*/	384	*/
		385	@Override
418	public void writeFromObjectIntoRow(Object object, AbstractRecord Record, AbstractSession session) {	386	public void writeFromObjectIntoRow(Object object, AbstractRecord Record, AbstractSession session) {
419	if (isReadOnly() \|\| (!isForeignKeyRelationship())) {	387	if (isReadOnly() \|\| (!isForeignKeyRelationship())) {
420	return;	388	return;
Lines 427-433 Link Here
427		395
428	for (int i = 0; i < getForeignKeyFields().size(); i++) {	396	for (int i = 0; i < getForeignKeyFields().size(); i++) {
429	DatabaseField sourceKey = getForeignKeyFields().get(i);	397	DatabaseField sourceKey = getForeignKeyFields().get(i);
430	DatabaseField targetKey = (DatabaseField)getSourceToTargetKeyFields().get(sourceKey);	398	DatabaseField targetKey = getSourceToTargetKeyFields().get(sourceKey);
431		399
432	Object referenceValue = null;	400	Object referenceValue = null;
433		401
Lines 450-457 Link Here
450	* Return the classifiction for the field contained in the mapping.	418	* Return the classifiction for the field contained in the mapping.
451	* This is used to convert the row value to a consistent java value.	419	* This is used to convert the row value to a consistent java value.
452	*/	420	*/
		421	@Override
453	public Class getFieldClassification(DatabaseField fieldToClassify) throws DescriptorException {	422	public Class getFieldClassification(DatabaseField fieldToClassify) throws DescriptorException {
454	DatabaseField fieldInTarget = (DatabaseField)getSourceToTargetKeyFields().get(fieldToClassify);	423	DatabaseField fieldInTarget = getSourceToTargetKeyFields().get(fieldToClassify);
455	if (fieldInTarget == null) {	424	if (fieldInTarget == null) {
456	return null;// Can be registered as multiple table secondary field mapping	425	return null;// Can be registered as multiple table secondary field mapping
457	}	426	}
Lines 507-513 Link Here
507	* INTERNAL:	476	* INTERNAL:
508	* Gets the foreign key fields.	477	* Gets the foreign key fields.
509	*/	478	*/
510	public Map getSourceToTargetKeyFields() {	479	public Map<DatabaseField, DatabaseField> getSourceToTargetKeyFields() {
511	return sourceToTargetKeyFields;	480	return sourceToTargetKeyFields;
512	}	481	}
513		482
Lines 515-521 Link Here
515	* INTERNAL:	484	* INTERNAL:
516	* Gets the target foreign key fields.	485	* Gets the target foreign key fields.
517	*/	486	*/
518	public Map getTargetToSourceKeyFields() {	487	public Map<DatabaseField, DatabaseField> getTargetToSourceKeyFields() {
519	return targetToSourceKeyFields;	488	return targetToSourceKeyFields;
520	}	489	}
521		490
Lines 539-544 Link Here
539	* INTERNAL:	508	* INTERNAL:
540	* This method is not supported in an EIS environment.	509	* This method is not supported in an EIS environment.
541	*/	510	*/
		511	@Override
542	public void setSelectionSQLString(String sqlString) {	512	public void setSelectionSQLString(String sqlString) {
543	throw DescriptorException.invalidMappingOperation(this, "setSelectionSQLString");	513	throw DescriptorException.invalidMappingOperation(this, "setSelectionSQLString");
544	}	514	}
Lines 547-593 Link Here
547	* INTERNAL:	517	* INTERNAL:
548	* This method is not supported in an EIS environment.	518	* This method is not supported in an EIS environment.
549	*/	519	*/
		520	@Override
550	public void setUsesBatchReading(boolean usesBatchReading) {	521	public void setUsesBatchReading(boolean usesBatchReading) {
551	throw DescriptorException.invalidMappingOperation(this, "setUsesBatchReading");	522	if (usesBatchReading) {
		523	throw DescriptorException.invalidMappingOperation(this, "setUsesBatchReading");
		524	}
552	}	525	}
553		526
554	/**	527	/**
555	* INTERNAL:	528	* INTERNAL:
556	* This method is not supported in an EIS environment.	529	* This method is not supported in an EIS environment.
557	*/	530	*/
558	public boolean shouldUseBatchReading() {	531	@Override
559	throw DescriptorException.invalidMappingOperation(this, "shouldUseBatchReading");
560	}
561
562	/**
563	* INTERNAL:
564	* This method is not supported in an EIS environment.
565	*/
566	public void useBatchReading() {	532	public void useBatchReading() {
567	throw DescriptorException.invalidMappingOperation(this, "useBatchReading");	533	throw DescriptorException.invalidMappingOperation(this, "useBatchReading");
568	}	534	}
569
570	/**
571	* INTERNAL:
572	* This method is not supported in an EIS environment.
573	*/
574	public void dontUseBatchReading() {
575	throw DescriptorException.invalidMappingOperation(this, "dontUseBatchReading");
576	}
577
578	/**
579	* INTERNAL:
580	* This method is not supported in an EIS environment.
581	*/
582	public void addAscendingOrdering(String queryKeyName) {
583	throw DescriptorException.invalidMappingOperation(this, "addAscendingOrdering");
584	}
585
586	/**
587	* INTERNAL:
588	* This method is not supported in an EIS environment.
589	*/
590	public void addDescendingOrdering(String queryKeyName) {
591	throw DescriptorException.invalidMappingOperation(this, "addDescendingOrdering");
592	}
593	}	535	}

Lines 158-177 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/expressions/QueryKeyExpression.java (-5 / +5 lines)
158	Vector tables = getDescriptor().getTables();	158	Vector tables = getDescriptor().getTables();
159	// skip the main table - start with i=1	159	// skip the main table - start with i=1
160	int tablesSize = tables.size();	160	int tablesSize = tables.size();
161	if(shouldUseOuterJoin()) {	161	if (shouldUseOuterJoin()) {
162	for( int i=1; i < tablesSize; i++) {	162	for (int i=1; i < tablesSize; i++) {
163	DatabaseTable table = (DatabaseTable)tables.elementAt(i);	163	DatabaseTable table = (DatabaseTable)tables.elementAt(i);
164	Expression joinExpression = (Expression)getDescriptor().getQueryManager().getTablesJoinExpressions().get(table);	164	Expression joinExpression = (Expression)getDescriptor().getQueryManager().getTablesJoinExpressions().get(table);
165	joinExpression = getBaseExpression().twist(joinExpression, this);	165	joinExpression = getBaseExpression().twist(joinExpression, this);
166	tablesJoinExpressions.put(table, joinExpression);	166	tablesJoinExpressions.put(table, joinExpression);
167	}	167	}
168	}	168	}
169	if(isUsingOuterJoinForMultitableInheritance()) {	169	if (isUsingOuterJoinForMultitableInheritance()) {
170	List childrenTables = getDescriptor().getInheritancePolicy().getChildrenTables();	170	List childrenTables = getDescriptor().getInheritancePolicy().getChildrenTables();
171	tablesSize = childrenTables.size();	171	tablesSize = childrenTables.size();
172	for( int i=0; i < tablesSize; i++) {	172	for (int i=0; i < tablesSize; i++) {
173	DatabaseTable table = (DatabaseTable)childrenTables.get(i);	173	DatabaseTable table = (DatabaseTable)childrenTables.get(i);
174	Expression joinExpression = (Expression)getDescriptor().getInheritancePolicy().getChildrenTablesJoinExpressions().get(table);	174	Expression joinExpression = getDescriptor().getInheritancePolicy().getChildrenTablesJoinExpressions().get(table);
175	joinExpression = getBaseExpression().twist(joinExpression, this);	175	joinExpression = getBaseExpression().twist(joinExpression, this);
176	tablesJoinExpressions.put(table, joinExpression);	176	tablesJoinExpressions.put(table, joinExpression);
177	}	177	}

Lines 265-271 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/helper/WriteLockManager.java (-13 / +13 lines)
265	for (Map<ObjectChangeSet, ObjectChangeSet> changeSets : changeSet.getObjectChanges().values()) {	265	for (Map<ObjectChangeSet, ObjectChangeSet> changeSets : changeSet.getObjectChanges().values()) {
266	ClassDescriptor descriptor = null;	266	ClassDescriptor descriptor = null;
267	for (ObjectChangeSet objectChangeSet : changeSets.values()) {	267	for (ObjectChangeSet objectChangeSet : changeSets.values()) {
268	if (objectChangeSet.getCacheKey() == null) {	268	if (objectChangeSet.getId() == null) {
269	//skip this process as we will be unable to acquire the correct cachekey anyway	269	//skip this process as we will be unable to acquire the correct cachekey anyway
270	//this is a new object with identity after write sequencing	270	//this is a new object with identity after write sequencing
271	continue;	271	continue;
Lines 281-305 Link Here
281	if (descriptor.shouldIsolateObjectsInUnitOfWork()) {	281	if (descriptor.shouldIsolateObjectsInUnitOfWork()) {
282	break;	282	break;
283	}	283	}
284	CacheKey activeCacheKey = attemptToAcquireLock(descriptor, objectChangeSet.getCacheKey(), session);	284	CacheKey activeCacheKey = attemptToAcquireLock(descriptor, objectChangeSet.getId(), session);
285	if (activeCacheKey == null) {	285	if (activeCacheKey == null) {
286	// if cacheKey is null then the lock was not available no need to synchronize this block,because if the	286	// if cacheKey is null then the lock was not available no need to synchronize this block,because if the
287	// check fails then this thread will just return to the queue until it gets woken up.	287	// check fails then this thread will just return to the queue until it gets woken up.
288	if (this.prevailingQueue.getFirst() == mergeManager) {	288	if (this.prevailingQueue.getFirst() == mergeManager) {
289	// wait on this object until it is free, or until wait time expires because	289	// wait on this object until it is free, or until wait time expires because
290	// this thread is the prevailing thread	290	// this thread is the prevailing thread
291	activeCacheKey = waitOnObjectLock(descriptor, objectChangeSet.getCacheKey(), session, (int)Math.round((Math.random()*500)));	291	activeCacheKey = waitOnObjectLock(descriptor, objectChangeSet.getId(), session, (int)Math.round((Math.random()*500)));
292	}	292	}
293	if (activeCacheKey == null) {	293	if (activeCacheKey == null) {
294	// failed to acquire lock, release all acquired	294	// failed to acquire lock, release all acquired
295	// locks and place thread on waiting list	295	// locks and place thread on waiting list
296	releaseAllAcquiredLocks(mergeManager);	296	releaseAllAcquiredLocks(mergeManager);
297	// get cacheKey	297	// get cacheKey
298	activeCacheKey = session.getIdentityMapAccessorInstance().getCacheKeyForObjectForLock(objectChangeSet.getCacheKey().getKey(), descriptor.getJavaClass(), descriptor);	298	activeCacheKey = session.getIdentityMapAccessorInstance().getCacheKeyForObjectForLock(objectChangeSet.getId(), descriptor.getJavaClass(), descriptor);
299	if (session.shouldLog(SessionLog.FINER, SessionLog.CACHE)) {	299	if (session.shouldLog(SessionLog.FINER, SessionLog.CACHE)) {
300	Object[] params = new Object[3];	300	Object[] params = new Object[3];
301	params[0] = descriptor.getJavaClass();	301	params[0] = descriptor.getJavaClass();
302	params[1] = objectChangeSet.getCacheKey() != null ? objectChangeSet.getCacheKey().getKey() : new Vector();	302	params[1] = objectChangeSet.getId();
303	params[2] = Thread.currentThread().getName();	303	params[2] = Thread.currentThread().getName();
304	session.log(SessionLog.FINER, SessionLog.CACHE, "dead_lock_encountered_on_write_no_cachekey", params, null, true);	304	session.log(SessionLog.FINER, SessionLog.CACHE, "dead_lock_encountered_on_write_no_cachekey", params, null, true);
305	}	305	}
Lines 316-322 Link Here
316		316
317	// set the cache key on the merge manager for	317	// set the cache key on the merge manager for
318	// the object that could not be acquired	318	// the object that could not be acquired
319	mergeManager.setWriteLockQueued(objectChangeSet.getCacheKey());	319	mergeManager.setWriteLockQueued(objectChangeSet.getId());
320	try {	320	try {
321	if (activeCacheKey != null){	321	if (activeCacheKey != null){
322	//wait on the lock of the object that we couldn't get.	322	//wait on the lock of the object that we couldn't get.
Lines 373-383 Link Here
373	* a new object that was not locked previously. Unlike the other methods	373	* a new object that was not locked previously. Unlike the other methods
374	* within this class this method will lock only this object.	374	* within this class this method will lock only this object.
375	*/	375	*/
376	public Object appendLock(Vector primaryKeys, Object objectToLock, ClassDescriptor descriptor, MergeManager mergeManager, AbstractSession session) {	376	public Object appendLock(Object primaryKey, Object objectToLock, ClassDescriptor descriptor, MergeManager mergeManager, AbstractSession session) {
377	CacheKey lockedCacheKey = session.getIdentityMapAccessorInstance().acquireLockNoWait(primaryKeys, descriptor.getJavaClass(), true, descriptor);	377	CacheKey lockedCacheKey = session.getIdentityMapAccessorInstance().acquireLockNoWait(primaryKey, descriptor.getJavaClass(), true, descriptor);
378	if (lockedCacheKey == null) {	378	if (lockedCacheKey == null) {
379	session.getIdentityMapAccessorInstance().getWriteLockManager().transitionToDeferredLocks(mergeManager);	379	session.getIdentityMapAccessorInstance().getWriteLockManager().transitionToDeferredLocks(mergeManager);
380	lockedCacheKey = session.getIdentityMapAccessorInstance().acquireDeferredLock(primaryKeys, descriptor.getJavaClass(), descriptor);	380	lockedCacheKey = session.getIdentityMapAccessorInstance().acquireDeferredLock(primaryKey, descriptor.getJavaClass(), descriptor);
381	Object cachedObject = lockedCacheKey.getObject();	381	Object cachedObject = lockedCacheKey.getObject();
382	if (cachedObject == null) {	382	if (cachedObject == null) {
383	cachedObject = lockedCacheKey.waitForObject();	383	cachedObject = lockedCacheKey.waitForObject();
Lines 400-407 Link Here
400	* This method performs the operations of finding the cacheKey and locking it if possible.	400	* This method performs the operations of finding the cacheKey and locking it if possible.
401	* Returns True if the lock was acquired, false otherwise	401	* Returns True if the lock was acquired, false otherwise
402	*/	402	*/
403	protected CacheKey attemptToAcquireLock(ClassDescriptor descriptor, CacheKey cacheKey, AbstractSession session) {	403	protected CacheKey attemptToAcquireLock(ClassDescriptor descriptor, Object primaryKey, AbstractSession session) {
404	return session.getIdentityMapAccessorInstance().acquireLockNoWait(cacheKey.getKey(), descriptor.getJavaClass(), true, descriptor);	404	return session.getIdentityMapAccessorInstance().acquireLockNoWait(primaryKey, descriptor.getJavaClass(), true, descriptor);
405	}	405	}
406		406
407	/**	407	/**
Lines 477-483 Link Here
477	* This method performs the operations of finding the cacheKey and locking it if possible.	477	* This method performs the operations of finding the cacheKey and locking it if possible.
478	* Waits until the lock can be acquired	478	* Waits until the lock can be acquired
479	*/	479	*/
480	protected CacheKey waitOnObjectLock(ClassDescriptor descriptor, CacheKey cacheKey, AbstractSession session, int waitTime) {	480	protected CacheKey waitOnObjectLock(ClassDescriptor descriptor, Object primaryKey, AbstractSession session, int waitTime) {
481	return session.getIdentityMapAccessorInstance().acquireLockWithWait(cacheKey.getKey(), descriptor.getJavaClass(), true, descriptor, waitTime);	481	return session.getIdentityMapAccessorInstance().acquireLockWithWait(primaryKey, descriptor.getJavaClass(), true, descriptor, waitTime);
482	}	482	}
483	}	483	}

Lines 65-80 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/identitymaps/AbstractIdentityMap.java (-50 / +54 lines)
65	* Other threads will get deferred locks, all threads will wait until all other threads are complete before releasing their locks.	65	* Other threads will get deferred locks, all threads will wait until all other threads are complete before releasing their locks.
66	*/	66	*/
67	public CacheKey acquireDeferredLock(Object primaryKey) {	67	public CacheKey acquireDeferredLock(Object primaryKey) {
68	// Create and lock a new cacheKey.	68	CacheKey cacheKey = getCacheKey(primaryKey);
69	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
70	newCacheKey.acquireDeferredLock();
71	// PERF: To avoid synchronization, getIfAbsentPut is used.
72	CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
73	// Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
74	if (cacheKey == null) {	69	if (cacheKey == null) {
75	return newCacheKey;	70	// Create and lock a new cacheKey.
76	} else {	71	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
77	newCacheKey.releaseDeferredLock();	72	newCacheKey.acquireDeferredLock();
		73	// PERF: To avoid synchronization, getIfAbsentPut is used.
		74	cacheKey = putCacheKeyIfAbsent(newCacheKey);
		75	// Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
		76	if (cacheKey == null) {
		77	return newCacheKey;
		78	} else {
		79	newCacheKey.releaseDeferredLock();
		80	}
78	}	81	}
79	// Acquire a lock on the cache key.	82	// Acquire a lock on the cache key.
80	cacheKey.acquireDeferredLock();	83	cacheKey.acquireDeferredLock();
Lines 86-101 Link Here
86	* This is used by reading (when using indirection or no relationships) and by merge.	89	* This is used by reading (when using indirection or no relationships) and by merge.
87	*/	90	*/
88	public CacheKey acquireLock(Object primaryKey, boolean forMerge) {	91	public CacheKey acquireLock(Object primaryKey, boolean forMerge) {
89	// Create and lock a new cacheKey.	92	CacheKey cacheKey = getCacheKey(primaryKey);
90	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
91	newCacheKey.acquire(forMerge);
92	// PERF: To avoid synchronization, getIfAbsentPut is used.
93	CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
94	// Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
95	if (cacheKey == null) {	93	if (cacheKey == null) {
96	return newCacheKey;	94	// Create and lock a new cacheKey.
97	} else {	95	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
98	newCacheKey.release();	96	newCacheKey.acquire(forMerge);
		97	// PERF: To avoid synchronization, getIfAbsentPut is used.
		98	cacheKey = putCacheKeyIfAbsent(newCacheKey);
		99	// Return if the newCacheKey was put as it was already locked, otherwise must still lock it.
		100	if (cacheKey == null) {
		101	return newCacheKey;
		102	} else {
		103	newCacheKey.release();
		104	}
99	}	105	}
100	// Acquire a lock on the cache key.	106	// Acquire a lock on the cache key.
101	cacheKey.acquire();	107	cacheKey.acquire();
Lines 107-122 Link Here
107	* This is used by merge for missing existing objects.	113	* This is used by merge for missing existing objects.
108	*/	114	*/
109	public CacheKey acquireLockNoWait(Object primaryKey, boolean forMerge) {	115	public CacheKey acquireLockNoWait(Object primaryKey, boolean forMerge) {
110	// Create and lock a new cacheKey.	116	CacheKey cacheKey = getCacheKey(primaryKey);
111	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
112	newCacheKey.acquire(forMerge);
113	// PERF: To avoid synchronization, getIfAbsentPut is used.
114	CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
115	// Return if the newCacheKey was put as already lock, otherwise must still lock.
116	if (cacheKey == null) {	117	if (cacheKey == null) {
117	return newCacheKey;	118	// Create and lock a new cacheKey.
118	} else {	119	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
119	newCacheKey.release();	120	newCacheKey.acquire(forMerge);
		121	// PERF: To avoid synchronization, getIfAbsentPut is used.
		122	cacheKey = putCacheKeyIfAbsent(newCacheKey);
		123	// Return if the newCacheKey was put as already lock, otherwise must still lock.
		124	if (cacheKey == null) {
		125	return newCacheKey;
		126	} else {
		127	newCacheKey.release();
		128	}
120	}	129	}
121	// Acquire a lock on the cache key.	130	// Acquire a lock on the cache key.
122	// Return null if already locked.	131	// Return null if already locked.
Lines 131-146 Link Here
131	* This is used by merge for missing existing objects.	140	* This is used by merge for missing existing objects.
132	*/	141	*/
133	public CacheKey acquireLockWithWait(Object primaryKey, boolean forMerge, int wait) {	142	public CacheKey acquireLockWithWait(Object primaryKey, boolean forMerge, int wait) {
134	// Create and lock a new cacheKey.	143	CacheKey cacheKey = getCacheKey(primaryKey);
135	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
136	newCacheKey.acquire(forMerge);
137	// PERF: To avoid synchronization, getIfAbsentPut is used.
138	CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);
139	// Return if the newCacheKey was put as already lock, otherwise must still lock.
140	if (cacheKey == null) {	144	if (cacheKey == null) {
141	return newCacheKey;	145	// Create and lock a new cacheKey.
142	} else {	146	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
143	newCacheKey.release();	147	newCacheKey.acquire(forMerge);
		148	// PERF: To avoid synchronization, getIfAbsentPut is used.
		149	cacheKey = putCacheKeyIfAbsent(newCacheKey);
		150	// Return if the newCacheKey was put as already lock, otherwise must still lock.
		151	if (cacheKey == null) {
		152	return newCacheKey;
		153	} else {
		154	newCacheKey.release();
		155	}
144	}	156	}
145	// Acquire a lock on the cache key.	157	// Acquire a lock on the cache key.
146	// Return null if already locked.	158	// Return null if already locked.
Lines 156-164 Link Here
156	* This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.	168	* This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.
157	*/	169	*/
158	public CacheKey acquireReadLockOnCacheKey(Object primaryKey) {	170	public CacheKey acquireReadLockOnCacheKey(Object primaryKey) {
159	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);	171	CacheKey cacheKey = getCacheKey(primaryKey);
160	CacheKey cacheKey = getCacheKey(newCacheKey);
161	if (cacheKey == null) {	172	if (cacheKey == null) {
		173	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
162	// Lock new cacheKey.	174	// Lock new cacheKey.
163	newCacheKey.acquireReadLock();	175	newCacheKey.acquireReadLock();
164	// Create one but not put it in the cache, as we are only reading	176	// Create one but not put it in the cache, as we are only reading
Lines 177-185 Link Here
177	* This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.	189	* This will allow multiple users to read the same object but prevent writes to the object while the read lock is held.
178	*/	190	*/
179	public CacheKey acquireReadLockOnCacheKeyNoWait(Object primaryKey) {	191	public CacheKey acquireReadLockOnCacheKeyNoWait(Object primaryKey) {
180	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);	192	CacheKey cacheKey = getCacheKey(primaryKey);
181	CacheKey cacheKey = getCacheKey(newCacheKey);
182	if (cacheKey == null) {	193	if (cacheKey == null) {
		194	CacheKey newCacheKey = createCacheKey(primaryKey, null, null);
183	// Lock new cacheKey.	195	// Lock new cacheKey.
184	newCacheKey.acquireReadLock();	196	newCacheKey.acquireReadLock();
185	// Create one but not put it in the cache, as we are only reading	197	// Create one but not put it in the cache, as we are only reading
Lines 255-264 Link Here
255	/**	267	/**
256	* Get the cache key (with object) for the primary key.	268	* Get the cache key (with object) for the primary key.
257	*/	269	*/
258	public CacheKey getCacheKey(Object primaryKey) {	270	public abstract CacheKey getCacheKey(Object primaryKey);
259	CacheKey searchKey = new CacheKey(primaryKey);
260	return getCacheKey(searchKey);
261	}
262		271
263	/**	272	/**
264	* Get the cache key (with object) for the primary key.	273	* Get the cache key (with object) for the primary key.
Lines 266-283 Link Here
266	public CacheKey getCacheKeyForLock(Object primaryKey) {	275	public CacheKey getCacheKeyForLock(Object primaryKey) {
267	return getCacheKey(primaryKey);	276	return getCacheKey(primaryKey);
268	}	277	}
269
270	/**
271	* Return the cache key (with object) matching the searchKey.
272	*/
273	protected abstract CacheKey getCacheKey(CacheKey searchKey);
274		278
275	/**	279	/**
276	* Return the CacheKey (with object) matching the searchKey.	280	* Return the CacheKey (with object) matching the searchKey.
277	* If the CacheKey is missing then put the searchKey in the map.	281	* If the CacheKey is missing then put the searchKey in the map.
278	* The searchKey should have already been locked.	282	* The searchKey should have already been locked.
279	*/	283	*/
280	protected abstract CacheKey getCacheKeyIfAbsentPut(CacheKey cacheKey);	284	protected abstract CacheKey putCacheKeyIfAbsent(CacheKey cacheKey);
281		285
282	/**	286	/**
283	* Get the cache key (with object) for the primary key with read lock.	287	* Get the cache key (with object) for the primary key with read lock.

Lines 28-34 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/identitymaps/FullIdentityMap.java (-20 / +15 lines)
28	public class FullIdentityMap extends AbstractIdentityMap {	28	public class FullIdentityMap extends AbstractIdentityMap {
29		29
30	/** Map of CacheKeys stored using their key. */	30	/** Map of CacheKeys stored using their key. */
31	protected Map<CacheKey, CacheKey> cacheKeys;	31	protected Map<Object, CacheKey> cacheKeys;
32		32
33	public FullIdentityMap() {}	33	public FullIdentityMap() {}
34		34
Lines 49-59 Link Here
49	@Override	49	@Override
50	public Object clone() {	50	public Object clone() {
51	FullIdentityMap clone = (FullIdentityMap)super.clone();	51	FullIdentityMap clone = (FullIdentityMap)super.clone();
52	clone.setCacheKeys(new ConcurrentHashMap(getCacheKeys().size()));	52	clone.setCacheKeys(new ConcurrentHashMap(this.cacheKeys.size()));
53		53
54	for (Iterator cacheKeysIterator = getCacheKeys().values().iterator(); cacheKeysIterator.hasNext();) {	54	for (Iterator cacheKeysIterator = this.cacheKeys.values().iterator(); cacheKeysIterator.hasNext();) {
55	CacheKey key = (CacheKey)((CacheKey)cacheKeysIterator.next()).clone();	55	CacheKey key = (CacheKey)((CacheKey)cacheKeysIterator.next()).clone();
56	clone.getCacheKeys().put(key, key);	56	clone.getCacheKeys().put(key.getKey(), key);
57	}	57	}
58		58
59	return clone;	59	return clone;
Lines 65-71 Link Here
65	*/	65	*/
66	@Override	66	@Override
67	public void collectLocks(HashMap threadList) {	67	public void collectLocks(HashMap threadList) {
68	Iterator cacheKeyIterator = getCacheKeys().values().iterator();	68	Iterator cacheKeyIterator = this.cacheKeys.values().iterator();
69	while (cacheKeyIterator.hasNext()) {	69	while (cacheKeyIterator.hasNext()) {
70	CacheKey cacheKey = (CacheKey)cacheKeyIterator.next();	70	CacheKey cacheKey = (CacheKey)cacheKeyIterator.next();
71	if (cacheKey.isAcquired()) {	71	if (cacheKey.isAcquired()) {
Lines 93-100 Link Here
93	* If no object for the key exists, return null.	93	* If no object for the key exists, return null.
94	*/	94	*/
95	@Override	95	@Override
96	protected CacheKey getCacheKey(CacheKey searchKey) {	96	public CacheKey getCacheKey(Object searchKey) {
97	return getCacheKeys().get(searchKey);	97	return this.cacheKeys.get(searchKey);
98	}	98	}
99		99
100	/**	100	/**
Lines 103-122 Link Here
103	* The searchKey should have already been locked.	103	* The searchKey should have already been locked.
104	*/	104	*/
105	@Override	105	@Override
106	protected CacheKey getCacheKeyIfAbsentPut(CacheKey searchKey) {	106	protected CacheKey putCacheKeyIfAbsent(CacheKey searchKey) {
107	// PERF: First to a get, and get is non-locking, putIfAbsent locks.	107	searchKey.setOwningMap(this);
108	CacheKey cacheKey = getCacheKeys().get(searchKey);	108	return (CacheKey)((ConcurrentMap)this.cacheKeys).putIfAbsent(searchKey.getKey(), searchKey);
109	if (cacheKey == null) {
110	searchKey.setOwningMap(this);
111	cacheKey = (CacheKey)((ConcurrentMap)getCacheKeys()).putIfAbsent(searchKey, searchKey);
112	}
113	return cacheKey;
114	}	109	}
115		110
116	/**	111	/**
117	* Return the cache keys.	112	* Return the cache keys.
118	*/	113	*/
119	public Map<CacheKey, CacheKey> getCacheKeys() {	114	public Map<Object, CacheKey> getCacheKeys() {
120	return cacheKeys;	115	return cacheKeys;
121	}	116	}
122		117
Lines 136-142 Link Here
136	@Override	131	@Override
137	public int getSize(Class myClass, boolean recurse) {	132	public int getSize(Class myClass, boolean recurse) {
138	int count = 0;	133	int count = 0;
139	Iterator keys = getCacheKeys().values().iterator();	134	Iterator keys = this.cacheKeys.values().iterator();
140		135
141	while (keys.hasNext()) {	136	while (keys.hasNext()) {
142	CacheKey key = (CacheKey)keys.next();	137	CacheKey key = (CacheKey)keys.next();
Lines 184-190 Link Here
184	public CacheKey put(Object primaryKey, Object object, Object writeLockValue, long readTime) {	179	public CacheKey put(Object primaryKey, Object object, Object writeLockValue, long readTime) {
185	CacheKey newCacheKey = createCacheKey(primaryKey, object, writeLockValue, readTime);	180	CacheKey newCacheKey = createCacheKey(primaryKey, object, writeLockValue, readTime);
186	// Find the cache key in the map, reset it, or put the new one.	181	// Find the cache key in the map, reset it, or put the new one.
187	CacheKey cacheKey = getCacheKeyIfAbsentPut(newCacheKey);	182	CacheKey cacheKey = putCacheKeyIfAbsent(newCacheKey);
188	if (cacheKey != null) {	183	if (cacheKey != null) {
189	// The cache key is locked inside resetCacheKey() to keep other threads from accessing the object.	184	// The cache key is locked inside resetCacheKey() to keep other threads from accessing the object.
190	resetCacheKey(cacheKey, object, writeLockValue, readTime);	185	resetCacheKey(cacheKey, object, writeLockValue, readTime);
Lines 204-210 Link Here
204	if (cacheKey != null) {	199	if (cacheKey != null) {
205	// Cache key needs to be locked when removing from the map.	200	// Cache key needs to be locked when removing from the map.
206	cacheKey.acquire();	201	cacheKey.acquire();
207	getCacheKeys().remove(cacheKey);	202	this.cacheKeys.remove(cacheKey.getKey());
208	// Cache key needs to be released after removing from the map.	203	// Cache key needs to be released after removing from the map.
209	cacheKey.release();	204	cacheKey.release();
210	return cacheKey.getObject();	205	return cacheKey.getObject();
Lines 224-230 Link Here
224	key.release();	219	key.release();
225	}	220	}
226		221
227	protected void setCacheKeys(Map<CacheKey, CacheKey> cacheKeys) {	222	protected void setCacheKeys(Map<Object, CacheKey> cacheKeys) {
228	this.cacheKeys = cacheKeys;	223	this.cacheKeys = cacheKeys;
229	}	224	}
230	}	225	}

Lines 455-477 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/queries/OrderedListContainerPolicy.java (-7 / +7 lines)
455		455
456	//if objectToRemove is null, we can't look it up in the collection.	456	//if objectToRemove is null, we can't look it up in the collection.
457	// This should not happen unless identity is lost.	457	// This should not happen unless identity is lost.
458	if (objectToRemove!=null){	458	if (objectToRemove != null) {
459	Integer index = changeObject.getIndex();	459	Integer index = changeObject.getIndex();
460	if (index!=null){	460	if (index!=null){
461	if (objectToRemove.equals(get(index, valueOfTarget, mergeManager.getSession()))) {	461	if (objectToRemove.equals(get(index, valueOfTarget, mergeManager.getSession()))) {
462	removeFromAtIndex(index, valueOfTarget);	462	removeFromAtIndex(index, valueOfTarget);
463	} else {	463	} else {
464	//Object is in the cache, but the collection doesn't have it at the location we expect	464	// Object is in the cache, but the collection doesn't have it at the location we expect
465	// Collection is invalid with respect to these changes, so invalidate the parent and abort	465	// Collection is invalid with respect to these changes, so invalidate the parent and abort
466	Vector key = ((org.eclipse.persistence.internal.sessions.ObjectChangeSet)changeRecord.getOwner()).getPrimaryKeys();	466	Object key = changeRecord.getOwner().getId();
467	parentSession.getIdentityMapAccessor().invalidateObject(key, changeRecord.getOwner().getClassType(parentSession));	467	parentSession.getIdentityMapAccessor().invalidateObject(key, changeRecord.getOwner().getClassType(parentSession));
468	return;	468	return;
469	}	469	}
470	} else{	470	} else {
471	removeFrom(objectToRemove, valueOfTarget, parentSession);	471	removeFrom(objectToRemove, valueOfTarget, parentSession);
472	}	472	}
473		473
474	if ( (! mergeManager.shouldMergeChangesIntoDistributedCache()) && changeRecord.getMapping().isPrivateOwned()) {	474	if ((! mergeManager.shouldMergeChangesIntoDistributedCache()) && changeRecord.getMapping().isPrivateOwned()) {
475	// Check that the object was actually removed and not moved.	475	// Check that the object was actually removed and not moved.
476	if (objectRemoved) {	476	if (objectRemoved) {
477	mergeManager.registerRemovedNewObjectIfRequired(objectChanges.getUnitOfWorkClone());	477	mergeManager.registerRemovedNewObjectIfRequired(objectChanges.getUnitOfWorkClone());
Lines 480-486 Link Here
480	}	480	}
481		481
482		482
483	} else {//getChangeType == add	483	} else { //getChangeType == add
484	boolean objectAdded = changeRecord.getAddObjectList().containsKey(objectChanges);	484	boolean objectAdded = changeRecord.getAddObjectList().containsKey(objectChanges);
485	Object object = null;	485	Object object = null;
486	// The object was actually added and not moved.	486	// The object was actually added and not moved.
Lines 538-544 Link Here
538		538
539	//Object is either not in the cache, or not at the location we expect	539	//Object is either not in the cache, or not at the location we expect
540	// Collection is invalid with respect to these changes, so invalidate the parent and abort	540	// Collection is invalid with respect to these changes, so invalidate the parent and abort
541	Vector key = ((org.eclipse.persistence.internal.sessions.ObjectChangeSet)changeRecord.getOwner()).getPrimaryKeys();	541	Object key = changeRecord.getOwner().getId();
542	parentSession.getIdentityMapAccessor().invalidateObject(key, changeRecord.getOwner().getClassType(parentSession));	542	parentSession.getIdentityMapAccessor().invalidateObject(key, changeRecord.getOwner().getClassType(parentSession));
543	return;	543	return;
544	}	544	}

Lines 178-190 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/IdentityMapAccessor.java (-15 / +29 lines)
178	}	178	}
179		179
180	/**	180	/**
		181	* Convert the primary key Vector into a primary key object.
		182	* This is used to support the old deprecated Vector API.
		183	*/
		184	public Object primaryKeyFromVector(Vector primaryKeyVector) {
		185	if (primaryKeyVector == null) {
		186	return null;
		187	} else if (primaryKeyVector.size() == 1) {
		188	return primaryKeyVector.get(0);
		189	} else {
		190	return new CacheId(primaryKeyVector.toArray());
		191	}
		192	}
		193
		194	/**
181	* ADVANCED:	195	* ADVANCED:
182	* Return if their is an object for the primary key.	196	* Return if their is an object for the primary key.
183	*/	197	*/
184	@Deprecated	198	@Deprecated
185	public boolean containsObjectInIdentityMap(Vector primaryKey, Class theClass) {	199	public boolean containsObjectInIdentityMap(Vector primaryKey, Class theClass) {
186	ClassDescriptor descriptor = getSession().getDescriptor(theClass);	200	return containsObjectInIdentityMap(primaryKeyFromVector(primaryKey), theClass);
187	return containsObjectInIdentityMap(primaryKey, theClass, descriptor);
188	}	201	}
189		202
190	/**	203	/**
Lines 331-337 Link Here
331	*/	344	*/
332	@Deprecated	345	@Deprecated
333	public Object getFromIdentityMap(Vector primaryKey, Class theClass) {	346	public Object getFromIdentityMap(Vector primaryKey, Class theClass) {
334	return getFromIdentityMap(primaryKey, theClass, true);	347	return getFromIdentityMap(primaryKeyFromVector(primaryKey), theClass);
335	}	348	}
336		349
337	/**	350	/**
Lines 357-363 Link Here
357	*/	370	*/
358	@Deprecated	371	@Deprecated
359	public Object getFromIdentityMap(Vector primaryKey, Class theClass, boolean shouldReturnInvalidatedObjects) {	372	public Object getFromIdentityMap(Vector primaryKey, Class theClass, boolean shouldReturnInvalidatedObjects) {
360	return getFromIdentityMap(primaryKey, theClass, shouldReturnInvalidatedObjects, getSession().getDescriptor(theClass));	373	return getFromIdentityMap(primaryKeyFromVector(primaryKey), theClass, shouldReturnInvalidatedObjects);
361	}	374	}
362		375
363	/**	376	/**
Lines 574-580 Link Here
574	*/	587	*/
575	@Deprecated	588	@Deprecated
576	public Object getWriteLockValue(Vector primaryKey, Class theClass) {	589	public Object getWriteLockValue(Vector primaryKey, Class theClass) {
577	return getWriteLockValue(primaryKey, theClass, getSession().getDescriptor(theClass));	590	return getWriteLockValue(primaryKeyFromVector(primaryKey), theClass);
578	}	591	}
579		592
580	/**	593	/**
Lines 662-668 Link Here
662	*/	675	*/
663	@Deprecated	676	@Deprecated
664	public void invalidateObject(Vector primaryKey, Class theClass, boolean invalidateCluster) {	677	public void invalidateObject(Vector primaryKey, Class theClass, boolean invalidateCluster) {
665	invalidateObject((Object)primaryKey, theClass, invalidateCluster);	678	invalidateObject(primaryKeyFromVector(primaryKey), theClass, invalidateCluster);
666	}	679	}
667		680
668	/**	681	/**
Lines 673-679 Link Here
673	*/	686	*/
674	@Deprecated	687	@Deprecated
675	public void invalidateObject(Vector primaryKey, Class theClass) {	688	public void invalidateObject(Vector primaryKey, Class theClass) {
676	invalidateObject(primaryKey, theClass, false);	689	invalidateObject(primaryKeyFromVector(primaryKey), theClass);
677	}	690	}
678		691
679	/**	692	/**
Lines 692-700 Link Here
692	* @param invalidateCluster if true the invalidation will be broadcast to each server in the cluster.	705	* @param invalidateCluster if true the invalidation will be broadcast to each server in the cluster.
693	*/	706	*/
694	public void invalidateObject(Object primaryKey, Class theClass, boolean invalidateCluster) {	707	public void invalidateObject(Object primaryKey, Class theClass, boolean invalidateCluster) {
		708	if (primaryKey == null) {
		709	return;
		710	}
695	ClassDescriptor descriptor = getSession().getDescriptor(theClass);	711	ClassDescriptor descriptor = getSession().getDescriptor(theClass);
696	//forward the call to getCacheKeyForObject locally in case subclasses overload	712	//forward the call to getCacheKeyForObject locally in case subclasses overload
697	CacheKey key = this.getCacheKeyForObjectForLock(primaryKey, theClass, descriptor);	713	CacheKey key = getCacheKeyForObjectForLock(primaryKey, theClass, descriptor);
698	if (key != null) {	714	if (key != null) {
699	key.setInvalidationState(CacheKey.CACHE_KEY_INVALID);	715	key.setInvalidationState(CacheKey.CACHE_KEY_INVALID);
700	}	716	}
Lines 840-846 Link Here
840	*/	856	*/
841	@Deprecated	857	@Deprecated
842	public boolean isValid(Vector primaryKey, Class theClass) {	858	public boolean isValid(Vector primaryKey, Class theClass) {
843	return isValid((Object)primaryKey, theClass);	859	return isValid(primaryKeyFromVector(primaryKey), theClass);
844	}	860	}
845		861
846	/**	862	/**
Lines 914-920 Link Here
914	*/	930	*/
915	@Deprecated	931	@Deprecated
916	public Object putInIdentityMap(Object object, Vector key) {	932	public Object putInIdentityMap(Object object, Vector key) {
917	return putInIdentityMap(object, key, null);	933	return putInIdentityMap(object, primaryKeyFromVector(key));
918	}	934	}
919		935
920	/**	936	/**
Lines 953-960 Link Here
953	*/	969	*/
954	@Deprecated	970	@Deprecated
955	public Object putInIdentityMap(Object object, Vector key, Object writeLockValue, long readTime) {	971	public Object putInIdentityMap(Object object, Vector key, Object writeLockValue, long readTime) {
956	ClassDescriptor descriptor = getSession().getDescriptor(object);	972	return putInIdentityMap(object, primaryKeyFromVector(key), writeLockValue, readTime);
957	return putInIdentityMap(object, key, writeLockValue, readTime, descriptor);
958	}	973	}
959		974
960	/**	975	/**
Lines 1030-1037 Link Here
1030	*/	1045	*/
1031	@Deprecated	1046	@Deprecated
1032	public Object removeFromIdentityMap(Vector key, Class theClass) {	1047	public Object removeFromIdentityMap(Vector key, Class theClass) {
1033	ClassDescriptor descriptor = getSession().getDescriptor(theClass);	1048	return removeFromIdentityMap(primaryKeyFromVector(key), theClass);
1034	return removeFromIdentityMap(key, theClass, descriptor, null);
1035	}	1049	}
1036		1050
1037	/**	1051	/**
Lines 1082-1088 Link Here
1082	*/	1096	*/
1083	@Deprecated	1097	@Deprecated
1084	public void updateWriteLockValue(Vector primaryKey, Class theClass, Object writeLockValue) {	1098	public void updateWriteLockValue(Vector primaryKey, Class theClass, Object writeLockValue) {
1085	updateWriteLockValue((Object)primaryKey, theClass, writeLockValue);	1099	updateWriteLockValue(primaryKeyFromVector(primaryKey), theClass, writeLockValue);
1086	}	1100	}
1087		1101
1088	/**	1102	/**

Lines 583-594 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/AggregateObjectMapping.java (-11 / +7 lines)
583	AbstractRecord result = getReferenceDescriptor().getObjectBuilder().buildTemplateInsertRow(session);	583	AbstractRecord result = getReferenceDescriptor().getObjectBuilder().buildTemplateInsertRow(session);
584	List processedMappings = (List)getReferenceDescriptor().getMappings().clone();	584	List processedMappings = (List)getReferenceDescriptor().getMappings().clone();
585	if (getReferenceDescriptor().hasInheritance()) {	585	if (getReferenceDescriptor().hasInheritance()) {
586	Enumeration children = getReferenceDescriptor().getInheritancePolicy().getChildDescriptors().elements();	586	for (ClassDescriptor child : getReferenceDescriptor().getInheritancePolicy().getChildDescriptors()) {
587	while (children.hasMoreElements()) {	587	for (DatabaseMapping mapping : child.getMappings()) {
588	Enumeration mappings = ((ClassDescriptor)children.nextElement()).getMappings().elements();
589	while (mappings.hasMoreElements()) {
590	DatabaseMapping mapping = (DatabaseMapping)mappings.nextElement();
591
592	// Only write mappings once.	588	// Only write mappings once.
593	if (!processedMappings.contains(mapping)) {	589	if (!processedMappings.contains(mapping)) {
594	mapping.writeInsertFieldsIntoRow(result, session);	590	mapping.writeInsertFieldsIntoRow(result, session);
Lines 1067-1082 Link Here
1067	//recursive call to the further children descriptors	1063	//recursive call to the further children descriptors
1068	if (parentDescriptor.getInheritancePolicy().hasChildren()) {	1064	if (parentDescriptor.getInheritancePolicy().hasChildren()) {
1069	//setFields(clonedChildDescriptor.getFields());	1065	//setFields(clonedChildDescriptor.getFields());
1070	Vector childDescriptors = parentDescriptor.getInheritancePolicy().getChildDescriptors();	1066	List<ClassDescriptor> childDescriptors = parentDescriptor.getInheritancePolicy().getChildDescriptors();
1071	Vector cloneChildDescriptors = org.eclipse.persistence.internal.helper.NonSynchronizedVector.newInstance();	1067	List<ClassDescriptor> cloneChildDescriptors = new ArrayList();
1072	for (Enumeration enumtr = childDescriptors.elements(); enumtr.hasMoreElements();) {	1068	for (ClassDescriptor child : childDescriptors) {
1073	ClassDescriptor clonedChildDescriptor = (ClassDescriptor)((ClassDescriptor)enumtr.nextElement()).clone();	1069	ClassDescriptor clonedChildDescriptor = (ClassDescriptor)child.clone();
1074	clonedChildDescriptor.getInheritancePolicy().setParentDescriptor(parentDescriptor);	1070	clonedChildDescriptor.getInheritancePolicy().setParentDescriptor(parentDescriptor);
1075	initializeReferenceDescriptor(clonedChildDescriptor);	1071	initializeReferenceDescriptor(clonedChildDescriptor);
1076	clonedChildDescriptor.preInitialize(session);	1072	clonedChildDescriptor.preInitialize(session);
1077	clonedChildDescriptor.initialize(session);	1073	clonedChildDescriptor.initialize(session);
1078	translateFields(clonedChildDescriptor, session);	1074	translateFields(clonedChildDescriptor, session);
1079	cloneChildDescriptors.addElement(clonedChildDescriptor);	1075	cloneChildDescriptors.add(clonedChildDescriptor);
1080	initializeChildInheritance(clonedChildDescriptor, session);	1076	initializeChildInheritance(clonedChildDescriptor, session);
1081	}	1077	}
1082	parentDescriptor.getInheritancePolicy().setChildDescriptors(cloneChildDescriptors);	1078	parentDescriptor.getInheritancePolicy().setChildDescriptors(cloneChildDescriptors);

Lines 19-24 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/ManyToManyMapping.java (-14 / +18 lines)
19	import org.eclipse.persistence.history.*;	19	import org.eclipse.persistence.history.*;
20	import org.eclipse.persistence.internal.expressions.*;	20	import org.eclipse.persistence.internal.expressions.*;
21	import org.eclipse.persistence.internal.helper.*;	21	import org.eclipse.persistence.internal.helper.*;
		22	import org.eclipse.persistence.internal.identitymaps.CacheId;
22	import org.eclipse.persistence.internal.queries.*;	23	import org.eclipse.persistence.internal.queries.*;
23	import org.eclipse.persistence.internal.sessions.*;	24	import org.eclipse.persistence.internal.sessions.*;
24	import org.eclipse.persistence.mappings.foundation.MapComponentMapping;	25	import org.eclipse.persistence.mappings.foundation.MapComponentMapping;
Lines 176-185 Link Here
176	* Extract the source primary key value from the relation row.	177	* Extract the source primary key value from the relation row.
177	* Used for batch reading, most following same order and fields as in the mapping.	178	* Used for batch reading, most following same order and fields as in the mapping.
178	*/	179	*/
179	protected Vector extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {	180	protected Object extractKeyFromTargetRow(AbstractRecord row, AbstractSession session) {
180	Vector key = new Vector(getSourceRelationKeyFields().size());	181	int size = getSourceRelationKeyFields().size();
		182	Object[] key = new Object[size];
181		183
182	for (int index = 0; index < getSourceRelationKeyFields().size(); index++) {	184	for (int index = 0; index < size; index++) {
183	DatabaseField relationField = getSourceRelationKeyFields().elementAt(index);	185	DatabaseField relationField = getSourceRelationKeyFields().elementAt(index);
184	DatabaseField sourceField = getSourceKeyFields().elementAt(index);	186	DatabaseField sourceField = getSourceKeyFields().elementAt(index);
185	Object value = row.get(relationField);	187	Object value = row.get(relationField);
Lines 191-200 Link Here
191	throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);	193	throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
192	}	194	}
193		195
194	key.addElement(value);	196	key[index] = value;
195	}	197	}
196		198
197	return key;	199	return new CacheId(key);
198	}	200	}
199		201
200	/**	202	/**
Lines 202-225 Link Here
202	* Extract the primary key value from the source row.	204	* Extract the primary key value from the source row.
203	* Used for batch reading, most following same order and fields as in the mapping.	205	* Used for batch reading, most following same order and fields as in the mapping.
204	*/	206	*/
205	protected Vector extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {	207	protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {
206	Vector key = new Vector(getSourceKeyFields().size());	208	int size = getSourceKeyFields().size();
		209	Object[] key = new Object[size];
		210	ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();
207		211
208	for (Enumeration fieldEnum = getSourceKeyFields().elements(); fieldEnum.hasMoreElements();) {	212	for (int index = 0; index < size; index++) {
209	DatabaseField field = (DatabaseField)fieldEnum.nextElement();	213	DatabaseField field = getSourceKeyFields().get(index);
210	Object value = row.get(field);	214	Object value = row.get(field);
211		215
212	// Must ensure the classification gets a cache hit.	216	// Must ensure the classification gets a cache hit.
213	try {	217	try {
214	value = session.getDatasourcePlatform().getConversionManager().convertObject(value, getDescriptor().getObjectBuilder().getFieldClassification(field));	218	value = conversionManager.convertObject(value, this.descriptor.getObjectBuilder().getFieldClassification(field));
215	} catch (ConversionException e) {	219	} catch (ConversionException e) {
216	throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);	220	throw ConversionException.couldNotBeConverted(this, this.descriptor, e);
217	}	221	}
218		222
219	key.addElement(value);	223	key[index] = value;
220	}	224	}
221		225
222	return key;	226	return new CacheId(key);
223	}	227	}
224		228
225	/**	229	/**

Lines 21-27 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/ObjectReferenceMapping.java (-40 / +21 lines)
21	import org.eclipse.persistence.indirection.ValueHolderInterface;	21	import org.eclipse.persistence.indirection.ValueHolderInterface;
22	import org.eclipse.persistence.internal.descriptors.*;	22	import org.eclipse.persistence.internal.descriptors.*;
23	import org.eclipse.persistence.internal.helper.*;	23	import org.eclipse.persistence.internal.helper.*;
24	import org.eclipse.persistence.internal.identitymaps.CacheKey;
25	import org.eclipse.persistence.internal.indirection.*;	24	import org.eclipse.persistence.internal.indirection.*;
26	import org.eclipse.persistence.internal.sessions.*;	25	import org.eclipse.persistence.internal.sessions.*;
27	import org.eclipse.persistence.queries.*;	26	import org.eclipse.persistence.queries.*;
Lines 211-231 Link Here
211	Object firstKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstReferencedObject, session);	210	Object firstKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(firstReferencedObject, session);
212	Object secondKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondReferencedObject, session);	211	Object secondKey = getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(secondReferencedObject, session);
213		212
214	for (int index = 0; index < ((Vector)firstKey).size(); index++) {	213	if (firstKey == null) {
215	Object firstValue = ((Vector)firstKey).get(index);	214	if (secondKey == null) {
216	Object secondValue = ((Vector)secondKey).get(index);	215	return true;
217
218	if (!((firstValue == null) && (secondValue == null))) {
219	if ((firstValue == null) \|\| (secondValue == null)) {
220	return false;
221	}
222	if (!firstValue.equals(secondValue)) {
223	return false;
224	}
225	}	216	}
		217	return false;
226	}	218	}
227		219
228	return true;	220	return firstKey.equals(secondKey);
229	}	221	}
230		222
231	/**	223	/**
Lines 643-658 Link Here
643		635
644	// delete the object in the database if it is no more a referenced object.	636	// delete the object in the database if it is no more a referenced object.
645	if (objectInDatabase != objectInMemory) {	637	if (objectInDatabase != objectInMemory) {
646	CacheKey cacheKeyForObjectInDatabase = null;
647	CacheKey cacheKeyForObjectInMemory = new CacheKey(new Vector());
648		638
649	cacheKeyForObjectInDatabase = new CacheKey(getPrimaryKeyForObject(objectInDatabase, query.getSession()));	639	Object keyForObjectInDatabase = getPrimaryKeyForObject(objectInDatabase, query.getSession());
650		640	Object keyForObjectInMemory = null;
651	if (objectInMemory != null) {	641	if (objectInMemory != null) {
652	cacheKeyForObjectInMemory = new CacheKey(getPrimaryKeyForObject(objectInMemory, query.getSession()));	642	keyForObjectInMemory = getPrimaryKeyForObject(objectInMemory, query.getSession());
653	}	643	}
654		644
655	if (cacheKeysAreEqual(cacheKeyForObjectInDatabase, cacheKeyForObjectInMemory)) {	645	if ((keyForObjectInMemory != null) && keyForObjectInDatabase.equals(keyForObjectInMemory)) {
656	return;	646	return;
657	}	647	}
658	} else {	648	} else {
Lines 684-699 Link Here
684		674
685	// If the value was changed, both values must be deleted (uow will have inserted the new one).	675	// If the value was changed, both values must be deleted (uow will have inserted the new one).
686	if ((objectFromDatabase != null) && (objectFromDatabase != objectInMemory)) {	676	if ((objectFromDatabase != null) && (objectFromDatabase != objectInMemory)) {
687	// Also check pk as may not be maintaining identity.	677	// Also check pk as may not be maintaining identity.
688	CacheKey cacheKeyForObjectInDatabase = null;	678	Object keyForObjectInMemory = null;
689	CacheKey cacheKeyForObjectInMemory = new CacheKey(new Vector());	679	Object keyForObjectInDatabase = getPrimaryKeyForObject(objectFromDatabase, query.getSession());
690		680
691	cacheKeyForObjectInDatabase = new CacheKey(getPrimaryKeyForObject(objectFromDatabase, query.getSession()));
692
693	if (objectInMemory != null) {	681	if (objectInMemory != null) {
694	cacheKeyForObjectInMemory = new CacheKey(getPrimaryKeyForObject(objectInMemory, query.getSession()));	682	keyForObjectInMemory = getPrimaryKeyForObject(objectInMemory, query.getSession());
695	}	683	}
696	if (!cacheKeysAreEqual(cacheKeyForObjectInMemory, cacheKeyForObjectInDatabase)) {	684	if ((keyForObjectInMemory == null) \|\| !keyForObjectInDatabase.equals(keyForObjectInMemory)) {
697	if (objectFromDatabase != null) {	685	if (objectFromDatabase != null) {
698	DeleteObjectQuery deleteQuery = new DeleteObjectQuery();	686	DeleteObjectQuery deleteQuery = new DeleteObjectQuery();
699	deleteQuery.setIsExecutionClone(true);	687	deleteQuery.setIsExecutionClone(true);
Lines 836-848 Link Here
836	}	824	}
837	}	825	}
838	}	826	}
839
840	/**
841	* INTERNAL:
842	*/
843	protected boolean cacheKeysAreEqual(CacheKey cacheKey1, CacheKey cacheKey2) {
844	return cacheKey1.equals(cacheKey2);
845	}
846		827
847	/**	828	/**
848	* INTERNAL:	829	* INTERNAL:
Lines 911-922 Link Here
911		892
912	/**	893	/**
913	* INTERNAL:	894	* INTERNAL:
914	* Return the primary key for the reference object (i.e. the object	895	* Return the primary key for the reference object (i.e. the object
915	* object referenced by domainObject and specified by mapping).	896	* object referenced by domainObject and specified by mapping).
916	* This key will be used by a RemoteValueHolder.	897	* This key will be used by a RemoteValueHolder.
917	*/	898	*/
918	public Vector extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row) {	899	public Object extractPrimaryKeysForReferenceObjectFromRow(AbstractRecord row) {
919	return new Vector(1);	900	return null;
920	}	901	}
921		902
922	/**	903	/**
Lines 925-931 Link Here
925	*/	906	*/
926	public Object extractPrimaryKeysFromRealReferenceObject(Object object, AbstractSession session) {	907	public Object extractPrimaryKeysFromRealReferenceObject(Object object, AbstractSession session) {
927	if (object == null) {	908	if (object == null) {
928	return new Vector(1);	909	return null;
929	} else {	910	} else {
930	Object implementation = getReferenceDescriptor().getObjectBuilder().unwrapObject(object, session);	911	Object implementation = getReferenceDescriptor().getObjectBuilder().unwrapObject(object, session);
931	return getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(implementation, session);	912	return getReferenceDescriptor().getObjectBuilder().extractPrimaryKeyFromObject(implementation, session);
Lines 1176-1187 Link Here
1176	* This list may be available if the relationship has been cached.	1157	* This list may be available if the relationship has been cached.
1177	*/	1158	*/
1178	public Object valueFromPKList(Object[] pks, AbstractSession session) {	1159	public Object valueFromPKList(Object[] pks, AbstractSession session) {
1179	Vector pk = null;	1160	Object pk = null;
1180	if (pks[0] == null) return null;	1161	if (pks[0] == null) return null;
1181	if (getReferenceDescriptor().hasCMPPolicy()) {	1162	if (getReferenceDescriptor().hasCMPPolicy()) {
1182	pk = getReferenceDescriptor().getCMPPolicy().createPkVectorFromKey(pks[0], session);	1163	pk = getReferenceDescriptor().getCMPPolicy().createPrimaryKeyFromId(pks[0], session);
1183	} else {	1164	} else {
1184	pk = (Vector) pks[0];	1165	pk = pks[0];
1185	}	1166	}
1186	ReadObjectQuery query = new ReadObjectQuery();	1167	ReadObjectQuery query = new ReadObjectQuery();
1187	query.setReferenceClass(getReferenceClass());	1168	query.setReferenceClass(getReferenceClass());

Lines 13-19 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/mappings/UnidirectionalOneToManyMapping.java (-9 / +9 lines)
13	package org.eclipse.persistence.mappings;	13	package org.eclipse.persistence.mappings;
14		14
15	import java.util.Iterator;	15	import java.util.Iterator;
16	import java.util.List;
17	import java.util.Vector;	16	import java.util.Vector;
18		17
19	import org.eclipse.persistence.descriptors.ClassDescriptor;	18	import org.eclipse.persistence.descriptors.ClassDescriptor;
Lines 24-29 Link Here
24	import org.eclipse.persistence.internal.descriptors.CascadeLockingPolicy;	23	import org.eclipse.persistence.internal.descriptors.CascadeLockingPolicy;
25	import org.eclipse.persistence.internal.helper.ConversionManager;	24	import org.eclipse.persistence.internal.helper.ConversionManager;
26	import org.eclipse.persistence.internal.helper.DatabaseField;	25	import org.eclipse.persistence.internal.helper.DatabaseField;
		26	import org.eclipse.persistence.internal.identitymaps.CacheId;
27	import org.eclipse.persistence.internal.sessions.AbstractRecord;	27	import org.eclipse.persistence.internal.sessions.AbstractRecord;
28	import org.eclipse.persistence.internal.sessions.AbstractSession;	28	import org.eclipse.persistence.internal.sessions.AbstractSession;
29	import org.eclipse.persistence.internal.sessions.ChangeRecord;	29	import org.eclipse.persistence.internal.sessions.ChangeRecord;
Lines 106-114 Link Here
106	* Extract the primary key value from the source row.	106	* Extract the primary key value from the source row.
107	* Used for batch reading, most following same order and fields as in the mapping.	107	* Used for batch reading, most following same order and fields as in the mapping.
108	*/	108	*/
109	protected Vector extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {	109	protected Object extractPrimaryKeyFromRow(AbstractRecord row, AbstractSession session) {
110	int size = sourceKeyFields.size();	110	int size = this.sourceKeyFields.size();
111	Vector key = new Vector(size);	111	Object[] key = new Object[size];
112	ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();	112	ConversionManager conversionManager = session.getDatasourcePlatform().getConversionManager();
113		113
114	for (int index=0; index < size; index++) {	114	for (int index=0; index < size; index++) {
Lines 122-131 Link Here
122	throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);	122	throw ConversionException.couldNotBeConverted(this, getDescriptor(), e);
123	}	123	}
124		124
125	key.addElement(value);	125	key[index] = value;
126	}	126	}
127		127
128	return key;	128	return new CacheId(key);
129	}	129	}
130		130
131	/**	131	/**
Lines 180-186 Link Here
180	if(shouldIncrementTargetLockValueOnAddOrRemoveTarget) {	180	if(shouldIncrementTargetLockValueOnAddOrRemoveTarget) {
181	descriptor.addMappingsPostCalculateChanges(this);	181	descriptor.addMappingsPostCalculateChanges(this);
182	if (getDescriptor().hasInheritance()){	182	if (getDescriptor().hasInheritance()){
183	for (ClassDescriptor descriptor: (List<ClassDescriptor>)getDescriptor().getInheritancePolicy().getAllChildDescriptors()){	183	for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
184	descriptor.addMappingsPostCalculateChanges(this);	184	descriptor.addMappingsPostCalculateChanges(this);
185	}	185	}
186	}	186	}
Lines 188-194 Link Here
188	if(shouldIncrementTargetLockValueOnDeleteSource && !isPrivateOwned) {	188	if(shouldIncrementTargetLockValueOnDeleteSource && !isPrivateOwned) {
189	descriptor.addMappingsPostCalculateChangesOnDeleted(this);	189	descriptor.addMappingsPostCalculateChangesOnDeleted(this);
190	if (getDescriptor().hasInheritance()){	190	if (getDescriptor().hasInheritance()){
191	for (ClassDescriptor descriptor: (List<ClassDescriptor>)getDescriptor().getInheritancePolicy().getAllChildDescriptors()){	191	for (ClassDescriptor descriptor: getDescriptor().getInheritancePolicy().getAllChildDescriptors()) {
192	descriptor.addMappingsPostCalculateChangesOnDeleted(this);	192	descriptor.addMappingsPostCalculateChangesOnDeleted(this);
193	}	193	}
194	}	194	}

Lines 17-23 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/oxm/record/UnmarshalRecord.java (-7 / +6 lines)
17	import java.util.HashMap;	17	import java.util.HashMap;
18	import java.util.List;	18	import java.util.List;
19	import java.util.Map;	19	import java.util.Map;
20	import java.util.Vector;
21		20
22	import javax.xml.namespace.QName;	21	import javax.xml.namespace.QName;
23		22
Lines 28-33 Link Here
28	import org.eclipse.persistence.exceptions.XMLMarshalException;	27	import org.eclipse.persistence.exceptions.XMLMarshalException;
29	import org.eclipse.persistence.internal.helper.DatabaseField;	28	import org.eclipse.persistence.internal.helper.DatabaseField;
30	import org.eclipse.persistence.internal.helper.Helper;	29	import org.eclipse.persistence.internal.helper.Helper;
		30	import org.eclipse.persistence.internal.identitymaps.CacheId;
31	import org.eclipse.persistence.internal.identitymaps.CacheKey;	31	import org.eclipse.persistence.internal.identitymaps.CacheKey;
32	import org.eclipse.persistence.internal.oxm.ContainerValue;	32	import org.eclipse.persistence.internal.oxm.ContainerValue;
33	import org.eclipse.persistence.internal.oxm.NodeValue;	33	import org.eclipse.persistence.internal.oxm.NodeValue;
Lines 520-531 Link Here
520	int primaryKeyFieldsSize = primaryKeyFields.size();	520	int primaryKeyFieldsSize = primaryKeyFields.size();
521	if (primaryKeyFieldsSize > 0) {	521	if (primaryKeyFieldsSize > 0) {
522	Object pk = treeObjectBuilder.extractPrimaryKeyFromObject(currentObject, session);	522	Object pk = treeObjectBuilder.extractPrimaryKeyFromObject(currentObject, session);
523	if (((Vector)pk).contains(null)) {	523	for (int x=0; x<primaryKeyFieldsSize; x++) {
524	for (int x=0; x<primaryKeyFieldsSize; x++) {	524	Object value = ((CacheId)pk).getPrimaryKey()[x];
525	if (null == ((Vector)pk).get(x)) {	525	if (null == value) {
526	XMLField pkField = (XMLField) xmlDescriptor.getPrimaryKeyFields().get(x);	526	XMLField pkField = (XMLField) xmlDescriptor.getPrimaryKeyFields().get(x);
527	((Vector)pk).set(x, getUnmarshaller().getXMLContext().getValueByXPath(currentObject, pkField.getXPath(), pkField.getNamespaceResolver(), Object.class));	527	((CacheId)pk).set(x, getUnmarshaller().getXMLContext().getValueByXPath(currentObject, pkField.getXPath(), pkField.getNamespaceResolver(), Object.class));
528	}
529	}	528	}
530	}	529	}
531	CacheKey key = session.getIdentityMapAccessorInstance().acquireDeferredLock(pk, xmlDescriptor.getJavaClass(), xmlDescriptor);	530	CacheKey key = session.getIdentityMapAccessorInstance().acquireDeferredLock(pk, xmlDescriptor.getJavaClass(), xmlDescriptor);

Lines 53-61 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectBuildingQuery.java (-46 lines)
53	/** INTERNAL: for bug 2612601 allow ability not to register results in UOW. */	53	/** INTERNAL: for bug 2612601 allow ability not to register results in UOW. */
54	protected boolean shouldRegisterResultsInUnitOfWork = true;	54	protected boolean shouldRegisterResultsInUnitOfWork = true;
55		55
56	/** CMP only. Allow users to configure whether finder should be executed in a uow or not. */
57	protected boolean shouldProcessResultsInUnitOfWork = true;
58
59	/** Used for pessimistic locking. */	56	/** Used for pessimistic locking. */
60	protected ForUpdateClause lockingClause;	57	protected ForUpdateClause lockingClause;
61	public static final short NO_LOCK = 0;	58	public static final short NO_LOCK = 0;
Lines 163-169 Link Here
163	if (query.isObjectBuildingQuery()) {	160	if (query.isObjectBuildingQuery()) {
164	ObjectBuildingQuery readQuery = (ObjectBuildingQuery)query;	161	ObjectBuildingQuery readQuery = (ObjectBuildingQuery)query;
165	this.shouldBuildNullForNullPk = readQuery.shouldBuildNullForNullPk;	162	this.shouldBuildNullForNullPk = readQuery.shouldBuildNullForNullPk;
166	this.shouldProcessResultsInUnitOfWork = readQuery.shouldProcessResultsInUnitOfWork;
167	this.shouldRefreshIdentityMapResult = readQuery.shouldRefreshIdentityMapResult;	163	this.shouldRefreshIdentityMapResult = readQuery.shouldRefreshIdentityMapResult;
168	this.shouldRefreshRemoteIdentityMapResult = readQuery.shouldRefreshRemoteIdentityMapResult;	164	this.shouldRefreshRemoteIdentityMapResult = readQuery.shouldRefreshRemoteIdentityMapResult;
169	this.shouldRegisterResultsInUnitOfWork = readQuery.shouldRegisterResultsInUnitOfWork;	165	this.shouldRegisterResultsInUnitOfWork = readQuery.shouldRegisterResultsInUnitOfWork;
Lines 625-672 Link Here
625	}	621	}
626		622
627	/**	623	/**
628	* ADVANCED:
629	* Used for CMP only. This allows users to indicate whether cmp finders executed
630	* at the beginning of a transaction should always be run against a UnitOfWork.
631	* Defaults to true.
632	* <p>
633	* If set to false, then UnitOfWork allocation will be deferred until a business
634	* method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
635	* is invoked. Any finder executed before such a time, will do so against the
636	* underlying ServerSession. Forcing finder execution to always go through a
637	* UnitOfWork means the results will be cloned and cached in the UnitOfWork up
638	* front. This is desired when the results will be accessed in the same transaction.
639	* <p>
640	* Note that finders executed with an unspecified transaction context will never
641	* be executed against a UnitOfWork, even if this setting is true. This case may happen
642	* with the NotSupported, Never, and Supports attributes.
643	*/
644	public void setShouldProcessResultsInUnitOfWork(boolean processResultsInUnitOfWork) {
645	this.shouldProcessResultsInUnitOfWork = processResultsInUnitOfWork;
646	}
647
648	/**
649	* ADVANCED:
650	* Used for CMP only. Indicates whether cmp finders executed at the beginning
651	* of a transaction should always be run against a UnitOfWork.
652	* Defaults to true.
653	* <p>
654	* If set to false, then UnitOfWork allocation will be deferred until a business
655	* method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
656	* is invoked. Any finder executed before such a time, will do so against the
657	* underlying ServerSession. Forcing finder execution to always go through a
658	* UnitOfWork means the results will be cloned and cached in the UnitOfWork up
659	* front. This is desired when the results will be accessed in the same transaction.
660	* <p>
661	* Note that finders executed with an unspecified transaction context will never
662	* be executed against a UnitOfWork, even if this setting is true. This case may happen
663	* with the NotSupported, Never, and Supports attributes.
664	*/
665	public boolean shouldProcessResultsInUnitOfWork() {
666	return this.shouldProcessResultsInUnitOfWork;
667	}
668
669	/**
670	* INTERNAL:	624	* INTERNAL:
671	* Return if the attribute is specified for joining.	625	* Return if the attribute is specified for joining.
672	*/	626	*/

Lines 1731-1746 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelReadQuery.java (-121 lines)
1731		1731
1732	/**	1732	/**
1733	* INTERNAL:	1733	* INTERNAL:
1734	* Answers if we are executing through a UnitOfWork and registering results.
1735	* This is only ever false if using the conforming without registering
1736	* feature.
1737	*/
1738	public boolean isRegisteringResults() {
1739	return ((shouldRegisterResultsInUnitOfWork() && this.descriptor.shouldRegisterResultsInUnitOfWork()) \|\| isLockQuery());
1740	}
1741
1742	/**
1743	* INTERNAL:
1744	* If changes are made to the query that affect the derived SQL or Call	1734	* If changes are made to the query that affect the derived SQL or Call
1745	* parameters the query needs to be prepared again.	1735	* parameters the query needs to be prepared again.
1746	* <p>	1736	* <p>
Lines 2384-2421 Link Here
2384		2374
2385	/**	2375	/**
2386	* PUBLIC:	2376	* PUBLIC:
2387	* Set if the attributes of the object(s) resulting from the query should be refreshed.
2388	* If cascading is used the private parts of the objects will also be refreshed.
2389	*/
2390	public void setShouldRefreshIdentityMapResult(boolean shouldRefreshIdentityMapResult) {
2391	this.shouldRefreshIdentityMapResult = shouldRefreshIdentityMapResult;
2392	if (shouldRefreshIdentityMapResult) {
2393	setShouldRefreshRemoteIdentityMapResult(true);
2394	}
2395	}
2396
2397	/**
2398	* PUBLIC:
2399	* Set if the attributes of the object(s) resulting from the query should be refreshed.
2400	* If cascading is used the private parts of the objects will also be refreshed.
2401	*/
2402	public void setShouldRefreshRemoteIdentityMapResult(boolean shouldRefreshIdentityMapResult) {
2403	this.shouldRefreshRemoteIdentityMapResult = shouldRefreshIdentityMapResult;
2404	}
2405
2406	/**
2407	* INTERNAL:
2408	* Set to false to have queries conform to a UnitOfWork without registering
2409	* any additional objects not already in that UnitOfWork.
2410	* @see #shouldRegisterResultsInUnitOfWork
2411	* @bug 2612601
2412	*/
2413	public void setShouldRegisterResultsInUnitOfWork(boolean shouldRegisterResultsInUnitOfWork) {
2414	this.shouldRegisterResultsInUnitOfWork = shouldRegisterResultsInUnitOfWork;
2415	}
2416
2417	/**
2418	* PUBLIC:
2419	* Return if cache should be checked.	2377	* Return if cache should be checked.
2420	*/	2378	*/
2421	public boolean shouldCheckCacheOnly() {	2379	public boolean shouldCheckCacheOnly() {
Lines 2479-2503 Link Here
2479	this.shouldOuterJoinSubclasses = Boolean.valueOf(shouldOuterJoinSubclasses);	2437	this.shouldOuterJoinSubclasses = Boolean.valueOf(shouldOuterJoinSubclasses);
2480	setIsPrepared(false);	2438	setIsPrepared(false);
2481	}	2439	}
2482
2483	/**
2484	* INTERNAL:
2485	* Allows one to do conforming in a UnitOfWork without registering.
2486	* Queries executed on a UnitOfWork will only return working copies for objects
2487	* that have already been registered.
2488	* <p>Extreme care should be taken in using this feature, for a user will
2489	* get back a mix of registered and original (unregistered) objects.
2490	* <p>Best used with a WrapperPolicy where invoking on an object will trigger
2491	* its registration (CMP). Without a WrapperPolicy {@link org.eclipse.persistence.sessions.UnitOfWork#registerExistingObject registerExistingObject}
2492	* should be called on any object that you intend to change.
2493	* @return true by default.
2494	* @see #setShouldRegisterResultsInUnitOfWork(boolean)
2495	* @see org.eclipse.persistence.descriptors.ClassDescriptor#shouldRegisterResultsInUnitOfWork()
2496	* @bug 2612601
2497	*/
2498	public boolean shouldRegisterResultsInUnitOfWork() {
2499	return shouldRegisterResultsInUnitOfWork;
2500	}
2501		2440
2502	/**	2441	/**
2503	* INTERNAL:	2442	* INTERNAL:
Lines 2527-2593 Link Here
2527	}	2466	}
2528		2467
2529	/**	2468	/**
2530	* PUBLIC:
2531	* Set to a boolean. When set means refresh the instance
2532	* variables of referenceObject from the database.
2533	*/
2534	public boolean shouldRefreshIdentityMapResult() {
2535	return shouldRefreshIdentityMapResult;
2536	}
2537
2538	/**
2539	* PUBLIC:
2540	* Set to a boolean. When set means refresh the instance
2541	* variables of referenceObject from the database.
2542	*/
2543	public boolean shouldRefreshRemoteIdentityMapResult() {
2544	return shouldRefreshRemoteIdentityMapResult;
2545	}
2546
2547	/**
2548	* ADVANCED:	2469	* ADVANCED:
2549	* Used for CMP only. This allows users to indicate whether cmp finders executed
2550	* at the beginning of a transaction should always be run against a UnitOfWork.
2551	* Defaults to true.
2552	* <p>
2553	* If set to false, then UnitOfWork allocation will be deferred until a business
2554	* method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
2555	* is invoked. Any finder executed before such a time, will do so against the
2556	* underlying ServerSession. Forcing finder execution to always go through a
2557	* UnitOfWork means the results will be cloned and cached in the UnitOfWork up
2558	* front. This is desired when the results will be accessed in the same transaction.
2559	* <p>
2560	* Note that finders executed with an unspecified transaction context will never
2561	* be executed against a UnitOfWork, even if this setting is true. This case may happen
2562	* with the NotSupported, Never, and Supports attributes.
2563	*/
2564	public void setShouldProcessResultsInUnitOfWork(boolean processResultsInUnitOfWork) {
2565	this.shouldProcessResultsInUnitOfWork = processResultsInUnitOfWork;
2566	}
2567
2568	/**
2569	* ADVANCED:
2570	* Used for CMP only. Indicates whether cmp finders executed at the beginning
2571	* of a transaction should always be run against a UnitOfWork.
2572	* Defaults to true.
2573	* <p>
2574	* If set to false, then UnitOfWork allocation will be deferred until a business
2575	* method (including creates/removes) or finder with shouldProcessResultsInUnitOfWork == true
2576	* is invoked. Any finder executed before such a time, will do so against the
2577	* underlying ServerSession. Forcing finder execution to always go through a
2578	* UnitOfWork means the results will be cloned and cached in the UnitOfWork up
2579	* front. This is desired when the results will be accessed in the same transaction.
2580	* <p>
2581	* Note that finders executed with an unspecified transaction context will never
2582	* be executed against a UnitOfWork, even if this setting is true. This case may happen
2583	* with the NotSupported, Never, and Supports attributes.
2584	*/
2585	public boolean shouldProcessResultsInUnitOfWork() {
2586	return this.shouldProcessResultsInUnitOfWork;
2587	}
2588
2589	/**
2590	* ADVANCED:
2591	* If a distinct has been set the DISTINCT clause will be printed.	2470	* If a distinct has been set the DISTINCT clause will be printed.
2592	* This is used internally by EclipseLink for batch reading but may also be	2471	* This is used internally by EclipseLink for batch reading but may also be
2593	* used directly for advanced queries or report queries.	2472	* used directly for advanced queries or report queries.

Lines 46-54 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/tools/schemaframework/PopulationManager.java (-6 / +4 lines)
46	public void addAllObjectsForAbstractClass(Class objectsClass, AbstractSession session, Vector allObjects) {	46	public void addAllObjectsForAbstractClass(Class objectsClass, AbstractSession session, Vector allObjects) {
47	ClassDescriptor descriptor = session.getDescriptor(objectsClass);	47	ClassDescriptor descriptor = session.getDescriptor(objectsClass);
48	addAllObjectsForClass(objectsClass, allObjects);	48	addAllObjectsForClass(objectsClass, allObjects);
49	for (Enumeration enumeration = descriptor.getInheritancePolicy().getChildDescriptors().elements();	49	for (ClassDescriptor child : descriptor.getInheritancePolicy().getChildDescriptors()) {
50	enumeration.hasMoreElements();) {	50	addAllObjectsForAbstractClass(child.getJavaClass(), session, allObjects);
51	addAllObjectsForAbstractClass(((ClassDescriptor)enumeration.nextElement()).getJavaClass(), session, allObjects);
52	}	51	}
53	}	52	}
54		53
Lines 136-144 Link Here
136	Vector allObjects = new Vector();	135	Vector allObjects = new Vector();
137	addAllObjectsForClass(objectsClass, allObjects);	136	addAllObjectsForClass(objectsClass, allObjects);
138	if (descriptor.hasInheritance()) {	137	if (descriptor.hasInheritance()) {
139	for (Enumeration enumeration = descriptor.getInheritancePolicy().getChildDescriptors().elements();	138	for (ClassDescriptor child : descriptor.getInheritancePolicy().getChildDescriptors()) {
140	enumeration.hasMoreElements();) {	139	addAllObjectsForClass(child.getJavaClass(), allObjects);
141	addAllObjectsForClass(((ClassDescriptor)enumeration.nextElement()).getJavaClass(), allObjects);
142	}	140	}
143	}	141	}
144		142

Lines 231-246 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/advanced/AdvancedJunitTest.java (-5 / +1 lines)
231	PartnerLinkPK usedPk = new PartnerLinkPK(pLink3.getManId(), pLink3.getWomanId());	231	PartnerLinkPK usedPk = new PartnerLinkPK(pLink3.getManId(), pLink3.getWomanId());
232	assertTrue("PK's do not match.", usedPk.equals(createdPK));	232	assertTrue("PK's do not match.", usedPk.equals(createdPK));
233		233
234	} catch (RuntimeException e) {	234	} finally {
235	if (isTransactionActive(em)) {	235	if (isTransactionActive(em)) {
236	rollbackTransaction(em);	236	rollbackTransaction(em);
237	}	237	}
238
239	closeEntityManager(em);	238	closeEntityManager(em);
240	fail("An exception was caught: [" + e.getMessage() + "]");
241	}	239	}
242
243	closeEntityManager(em);
244	}	240	}
245		241
246	// GF1673, 2674 Java SE 6 classloading error for String[] field	242	// GF1673, 2674 Java SE 6 classloading error for String[] field

Lines 23-37 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/CMP3Policy.java (-9 / +15 lines)
23	import java.security.AccessController;	23	import java.security.AccessController;
24	import java.security.PrivilegedActionException;	24	import java.security.PrivilegedActionException;
25	import java.util.*;	25	import java.util.*;
		26
		27	import org.eclipse.persistence.annotations.CacheKeyType;
26	import org.eclipse.persistence.descriptors.*;	28	import org.eclipse.persistence.descriptors.*;
27	import org.eclipse.persistence.internal.helper.ConversionManager;	29	import org.eclipse.persistence.internal.helper.ConversionManager;
28	import org.eclipse.persistence.internal.helper.NonSynchronizedVector;
29	import org.eclipse.persistence.internal.localization.ExceptionLocalization;	30	import org.eclipse.persistence.internal.localization.ExceptionLocalization;
30	import org.eclipse.persistence.internal.sessions.AbstractSession;	31	import org.eclipse.persistence.internal.sessions.AbstractSession;
31	import org.eclipse.persistence.mappings.DatabaseMapping;	32	import org.eclipse.persistence.mappings.DatabaseMapping;
32	import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;	33	import org.eclipse.persistence.mappings.foundation.AbstractDirectMapping;
33	import org.eclipse.persistence.exceptions.*;	34	import org.eclipse.persistence.exceptions.*;
34	import org.eclipse.persistence.internal.helper.DatabaseField;	35	import org.eclipse.persistence.internal.helper.DatabaseField;
		36	import org.eclipse.persistence.internal.identitymaps.CacheId;
35	import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;	37	import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
36	import org.eclipse.persistence.internal.security.PrivilegedGetField;	38	import org.eclipse.persistence.internal.security.PrivilegedGetField;
37	import org.eclipse.persistence.internal.security.PrivilegedClassForName;	39	import org.eclipse.persistence.internal.security.PrivilegedClassForName;
Lines 182-201 Link Here
182		184
183	/**	185	/**
184	* INTERNAL:	186	* INTERNAL:
185	* Use the key to create a EclipseLink primary key Vector.	187	* Use the key to create a EclipseLink primary key.
186	* If the key is simple (direct mapped) then just add it to a vector,	188	* If the key is simple (direct mapped) then just add it to a vector,
187	* otherwise must go through the inefficient process of copying the key into the bean	189	* otherwise must go through the inefficient process of copying the key into the bean
188	* and extracting the key from the bean.	190	* and extracting the key from the bean.
189	*
190	* @param key Object the primary key to use for creating the vector
191	* @return Vector
192	*/	191	*/
193	public Vector createPkVectorFromKey(Object key, AbstractSession session) {	192	@Override
		193	public Object createPrimaryKeyFromId(Object key, AbstractSession session) {
194	// If the descriptor primary key is mapped through direct-to-field mappings,	194	// If the descriptor primary key is mapped through direct-to-field mappings,
195	// then no elaborate conversion is required.	195	// then no elaborate conversion is required.
196	// If key is compound, add each value to the vector.	196	// If key is compound, add each value to the vector.
197	KeyElementAccessor[] pkElementArray = this.getKeyClassFields(key.getClass());	197	KeyElementAccessor[] pkElementArray = this.getKeyClassFields(key.getClass());
198	Vector pkVector = new NonSynchronizedVector(pkElementArray.length);	198	Object[] primaryKey = null;
		199	if (getDescriptor().getCacheKeyType() != CacheKeyType.ID_VALUE) {
		200	primaryKey = new Object[pkElementArray.length];
		201	}
199	for (int index = 0; index < pkElementArray.length; index++) {	202	for (int index = 0; index < pkElementArray.length; index++) {
200	DatabaseMapping mapping = pkElementArray[index].getMapping();	203	DatabaseMapping mapping = pkElementArray[index].getMapping();
201	Object fieldValue = null;	204	Object fieldValue = null;
Lines 216-224 Link Here
216	}	219	}
217	}	220	}
218	}	221	}
219	pkVector.add(fieldValue);	222	if (getDescriptor().getCacheKeyType() == CacheKeyType.ID_VALUE) {
		223	return fieldValue;
		224	}
		225	primaryKey[index] = fieldValue;
220	}	226	}
221	return pkVector;	227	return new CacheId(primaryKey);
222	}	228	}
223		229
224	/**	230	/**

Lines 33-45 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerImpl.java (-15 / +24 lines)
33	import javax.persistence.metamodel.Metamodel;	33	import javax.persistence.metamodel.Metamodel;
34	import javax.sql.DataSource;	34	import javax.sql.DataSource;
35		35
		36	import org.eclipse.persistence.annotations.CacheKeyType;
36	import org.eclipse.persistence.config.*;	37	import org.eclipse.persistence.config.*;
37	import org.eclipse.persistence.descriptors.*;	38	import org.eclipse.persistence.descriptors.*;
38	import org.eclipse.persistence.exceptions.*;	39	import org.eclipse.persistence.exceptions.*;
39	import org.eclipse.persistence.expressions.Expression;	40	import org.eclipse.persistence.expressions.Expression;
40	import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;	41	import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;
41	import org.eclipse.persistence.internal.helper.BasicTypeHelperImpl;	42	import org.eclipse.persistence.internal.helper.BasicTypeHelperImpl;
42	import org.eclipse.persistence.internal.helper.NonSynchronizedVector;	43	import org.eclipse.persistence.internal.identitymaps.CacheId;
43	import org.eclipse.persistence.internal.jpa.querydef.CriteriaQueryImpl;	44	import org.eclipse.persistence.internal.jpa.querydef.CriteriaQueryImpl;
44	import org.eclipse.persistence.internal.jpa.transaction.*;	45	import org.eclipse.persistence.internal.jpa.transaction.*;
45	import org.eclipse.persistence.internal.localization.ExceptionLocalization;	46	import org.eclipse.persistence.internal.localization.ExceptionLocalization;
Lines 633-655 Link Here
633	* second argument is not a valid type for that entity's primary	634	* second argument is not a valid type for that entity's primary
634	* key.	635	* key.
635	*/	636	*/
636	protected Object findInternal(ClassDescriptor descriptor, AbstractSession session, Object primaryKey, LockModeType lockMode, Map<String, Object> properties) {	637	protected Object findInternal(ClassDescriptor descriptor, AbstractSession session, Object id, LockModeType lockMode, Map<String, Object> properties) {
637	if (primaryKey == null) { // gf721 - check for null PK	638	if (id == null) { // gf721 - check for null PK
638	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("null_pk"));	639	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("null_pk"));
639	}	640	}
640		641
641	List primaryKeyValues;	642	Object primaryKey;
642	if (primaryKey instanceof Vector) {	643	if (id instanceof List) {
643	primaryKeyValues = (Vector)primaryKey;	644	if (descriptor.getCacheKeyType() == CacheKeyType.ID_VALUE) {
644	} else if (primaryKey instanceof List) {	645	if (((List)id).isEmpty()) {
645	primaryKeyValues = new NonSynchronizedVector((List)primaryKey);	646	primaryKey = null;
		647	} else {
		648	primaryKey = ((List)id).get(0);
		649	}
		650	} else {
		651	primaryKey = new CacheId(((List)id).toArray());
		652	}
		653	} else if (id instanceof CacheId) {
		654	primaryKey = id;
646	} else {	655	} else {
647	CMPPolicy policy = descriptor.getCMPPolicy();	656	CMPPolicy policy = descriptor.getCMPPolicy();
648	Class pkClass = policy.getPKClass();	657	Class pkClass = policy.getPKClass();
649	if ((pkClass != null) && (! BasicTypeHelperImpl.getInstance().isStrictlyAssignableFrom(pkClass, primaryKey.getClass())) ) {	658	if ((pkClass != null) && (pkClass != id.getClass()) && (!BasicTypeHelperImpl.getInstance().isStrictlyAssignableFrom(pkClass, id.getClass()))) {
650	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("invalid_pk_class", new Object[] { descriptor.getCMPPolicy().getPKClass(), primaryKey.getClass() }));	659	throw new IllegalArgumentException(ExceptionLocalization.buildMessage("invalid_pk_class", new Object[] { descriptor.getCMPPolicy().getPKClass(), id.getClass() }));
651	}	660	}
652	primaryKeyValues = policy.createPkVectorFromKey(primaryKey, session);	661	primaryKey = policy.createPrimaryKeyFromId(id, session);
653	}	662	}
654		663
655	// Get the read object query and apply the properties to it.	664	// Get the read object query and apply the properties to it.
Lines 659-665 Link Here
659	if (query == null) {	668	if (query == null) {
660	// The properties/query hints and setIsExecutionClone etc. is set	669	// The properties/query hints and setIsExecutionClone etc. is set
661	// in the getReadObjectQuery.	670	// in the getReadObjectQuery.
662	query = getReadObjectQuery(descriptor.getJavaClass(), primaryKeyValues, properties);	671	query = getReadObjectQuery(descriptor.getJavaClass(), primaryKey, properties);
663	} else {	672	} else {
664	query.checkPrepare(session, null);	673	query.checkPrepare(session, null);
665	query = (ReadObjectQuery) query.clone();	674	query = (ReadObjectQuery) query.clone();
Lines 668-674 Link Here
668	QueryHintsHandler.apply(properties, query, session.getLoader(), session);	677	QueryHintsHandler.apply(properties, query, session.getLoader(), session);
669		678
670	query.setIsExecutionClone(true);	679	query.setIsExecutionClone(true);
671	query.setSelectionId(primaryKeyValues);	680	query.setSelectionId(primaryKey);
672	}	681	}
673		682
674	// Apply any EclipseLink defaults if they haven't been set through	683	// Apply any EclipseLink defaults if they haven't been set through
Lines 1135-1144 Link Here
1135	/**	1144	/**
1136	* Build a selection query for the primary key values.	1145	* Build a selection query for the primary key values.
1137	*/	1146	*/
1138	protected ReadObjectQuery getReadObjectQuery(Class referenceClass, List primaryKeyValues, Map properties) {	1147	protected ReadObjectQuery getReadObjectQuery(Class referenceClass, Object primaryKey, Map properties) {
1139	ReadObjectQuery query = getReadObjectQuery(properties);	1148	ReadObjectQuery query = getReadObjectQuery(properties);
1140	query.setReferenceClass(referenceClass);	1149	query.setReferenceClass(referenceClass);
1141	query.setSelectionId(primaryKeyValues);	1150	query.setSelectionId(primaryKey);
1142	return query;	1151	return query;
1143	}	1152	}
1144		1153

Lines 54-59 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/weaving/ClassWeaver.java (-38 / +13 lines)
54	public static final String PERSISTENCE_OBJECT_SHORT_SIGNATURE = "org/eclipse/persistence/internal/descriptors/PersistenceObject";	54	public static final String PERSISTENCE_OBJECT_SHORT_SIGNATURE = "org/eclipse/persistence/internal/descriptors/PersistenceObject";
55	public static final String PERSISTENCE_OBJECT_SIGNATURE = "L" + PERSISTENCE_OBJECT_SHORT_SIGNATURE + ";";	55	public static final String PERSISTENCE_OBJECT_SIGNATURE = "L" + PERSISTENCE_OBJECT_SHORT_SIGNATURE + ";";
56	public static final String VECTOR_SIGNATURE = "Ljava/util/Vector;";	56	public static final String VECTOR_SIGNATURE = "Ljava/util/Vector;";
		57	public static final String OBJECT_SIGNATURE = "Ljava/lang/Object;";
57	public static final String CACHEKEY_SIGNATURE = "Lorg/eclipse/persistence/internal/identitymaps/CacheKey;";	58	public static final String CACHEKEY_SIGNATURE = "Lorg/eclipse/persistence/internal/identitymaps/CacheKey;";
58		59
59	// Fetch groups	60	// Fetch groups
Lines 608-622 Link Here
608	}	609	}
609		610
610	/**	611	/**
611	* Add a variable of type Vector, CacheKey to the class.	612	* Add a variable of type Object to the class.
612	* When this method has been run, the class will contain a variable declarations similar to the following:	613	* When this method has been run, the class will contain a variable declarations similar to the following:
613	*	614	*
614	* private Vector _persistence_primaryKey;	615	* private Object _persistence_primaryKey;
615	* private Vector _persistence_cacheKey;
616	*/	616	*/
617	public void addPersistenceEntityVariables() {	617	public void addPersistenceEntityVariables() {
618	cv.visitField(ACC_PROTECTED + ACC_TRANSIENT, "_persistence_primaryKey", VECTOR_SIGNATURE, null, null);	618	cv.visitField(ACC_PROTECTED + ACC_TRANSIENT, "_persistence_primaryKey", OBJECT_SIGNATURE, null, null);
619	cv.visitField(ACC_PROTECTED + ACC_TRANSIENT, "_persistence_cacheKey", CACHEKEY_SIGNATURE, null, null);
620	}	619	}
621		620
622	/**	621	/**
Lines 681-691 Link Here
681	// clone._persistence_primaryKey = null;	680	// clone._persistence_primaryKey = null;
682	cv_clone.visitVarInsn(ALOAD, 0);	681	cv_clone.visitVarInsn(ALOAD, 0);
683	cv_clone.visitInsn(ACONST_NULL);	682	cv_clone.visitInsn(ACONST_NULL);
684	cv_clone.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_primaryKey", VECTOR_SIGNATURE);	683	cv_clone.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_primaryKey", OBJECT_SIGNATURE);
685	// clone._persistence_cacheKey = null;
686	cv_clone.visitVarInsn(ALOAD, 0);
687	cv_clone.visitInsn(ACONST_NULL);
688	cv_clone.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_cacheKey", CACHEKEY_SIGNATURE);
689	}	684	}
690		685
691	// return clone;	686	// return clone;
Lines 874-918 Link Here
874	/**	869	/**
875	* Adds get/set method for PersistenceEntity interface.	870	* Adds get/set method for PersistenceEntity interface.
876	* This adds the following methods:	871	* This adds the following methods:
877	*
878	* public CacheKey _persistence_getCacheKey() {
879	* return _persistence_cacheKey;
880	* }
881	* public void _persistence_setCacheKey(CacheKey key) {
882	* this._persistence_cacheKey = key;
883	* }
884	*	872	*
885	* public Vector _persistence_getPKVector() {	873	* public Object _persistence_getId() {
886	* return _persistence_primaryKey;	874	* return _persistence_primaryKey;
887	* }	875	* }
888	* public void _persistence_setPKVector(Vector pk) {	876	* public void _persistence_setId(Object primaryKey) {
889	* this._persistence_primaryKey = pk;	877	* this._persistence_primaryKey = primaryKey;
890	* }	878	* }
891	*/	879	*/
892	public void addPersistenceEntityMethods(ClassDetails classDetails) {	880	public void addPersistenceEntityMethods(ClassDetails classDetails) {
893	CodeVisitor cv_getCacheKey = cv.visitMethod(ACC_PUBLIC, "_persistence_getCacheKey", "()" + CACHEKEY_SIGNATURE, null, null);	881	CodeVisitor cv_getPKVector = cv.visitMethod(ACC_PUBLIC, "_persistence_getId", "()" + OBJECT_SIGNATURE, null, null);
894	cv_getCacheKey.visitVarInsn(ALOAD, 0);
895	cv_getCacheKey.visitFieldInsn(GETFIELD, classDetails.getClassName(), "_persistence_cacheKey", CACHEKEY_SIGNATURE);
896	cv_getCacheKey.visitInsn(ARETURN);
897	cv_getCacheKey.visitMaxs(0, 0);
898
899	CodeVisitor cv_setCacheKey = cv.visitMethod(ACC_PUBLIC, "_persistence_setCacheKey", "(" + CACHEKEY_SIGNATURE + ")V", null, null);
900	cv_setCacheKey.visitVarInsn(ALOAD, 0);
901	cv_setCacheKey.visitVarInsn(ALOAD, 1);
902	cv_setCacheKey.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_cacheKey", CACHEKEY_SIGNATURE);
903	cv_setCacheKey.visitInsn(RETURN);
904	cv_setCacheKey.visitMaxs(0 ,0);
905
906	CodeVisitor cv_getPKVector = cv.visitMethod(ACC_PUBLIC, "_persistence_getPKVector", "()" + VECTOR_SIGNATURE, null, null);
907	cv_getPKVector.visitVarInsn(ALOAD, 0);	882	cv_getPKVector.visitVarInsn(ALOAD, 0);
908	cv_getPKVector.visitFieldInsn(GETFIELD, classDetails.getClassName(), "_persistence_primaryKey", VECTOR_SIGNATURE);	883	cv_getPKVector.visitFieldInsn(GETFIELD, classDetails.getClassName(), "_persistence_primaryKey", OBJECT_SIGNATURE);
909	cv_getPKVector.visitInsn(ARETURN);	884	cv_getPKVector.visitInsn(ARETURN);
910	cv_getPKVector.visitMaxs(0, 0);	885	cv_getPKVector.visitMaxs(0, 0);
911		886
912	CodeVisitor cv_setPKVector = cv.visitMethod(ACC_PUBLIC, "_persistence_setPKVector", "(" + VECTOR_SIGNATURE + ")V", null, null);	887	CodeVisitor cv_setPKVector = cv.visitMethod(ACC_PUBLIC, "_persistence_setId", "(" + OBJECT_SIGNATURE + ")V", null, null);
913	cv_setPKVector.visitVarInsn(ALOAD, 0);	888	cv_setPKVector.visitVarInsn(ALOAD, 0);
914	cv_setPKVector.visitVarInsn(ALOAD, 1);	889	cv_setPKVector.visitVarInsn(ALOAD, 1);
915	cv_setPKVector.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_primaryKey", VECTOR_SIGNATURE);	890	cv_setPKVector.visitFieldInsn(PUTFIELD, classDetails.getClassName(), "_persistence_primaryKey", OBJECT_SIGNATURE);
916	cv_setPKVector.visitInsn(RETURN);	891	cv_setPKVector.visitInsn(RETURN);
917	cv_setPKVector.visitMaxs(0 ,0);	892	cv_setPKVector.visitMaxs(0 ,0);
918	}	893	}