Attachment #157784 for bug #301063

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

View | Details | Raw Unified | Return to bug 301063
Collapse All | Expand All

Lines 116-122 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/config/QueryHints.java (-2 / +2 lines)
116	* <p>Configures a randomization on the expiry invalidation time.	116	* <p>Configures a randomization on the expiry invalidation time.
117	* This can be used to avoid bottlenecks from the cached values expiring at the same time.	117	* This can be used to avoid bottlenecks from the cached values expiring at the same time.
118	* By default expiry is not randomized.	118	* By default expiry is not randomized.
119	* Valid values are number of milliseconds, Integer or Strings that can be parsed to int values.	119	* Valid values are "true" and "false", false is the default.
120	* @see org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy#setInvalidationRandomized(boolean)	120	* @see org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy#setInvalidationRandomized(boolean)
121	*/	121	*/
122	public static final String QUERY_RESULTS_CACHE_RANDOMIZE_EXPIRY = "eclipselink.query-results-cache.randomize-expiry";	122	public static final String QUERY_RESULTS_CACHE_RANDOMIZE_EXPIRY = "eclipselink.query-results-cache.randomize-expiry";
Lines 126-132 Link Here
126	* <p>Configures null results to not be cached.	126	* <p>Configures null results to not be cached.
127	* This can be used to use the query cache as a secondary key index, and allow inserts of new objects.	127	* This can be used to use the query cache as a secondary key index, and allow inserts of new objects.
128	* By default null results are cached.	128	* By default null results are cached.
129	* Valid values are number of milliseconds, Integer or Strings that can be parsed to int values.	129	* Valid values are "true" and "false", false is the default.
130	* @see org.eclipse.persistence.queries.QueryResultsCachePolicy#setIsNullIgnored(boolean)	130	* @see org.eclipse.persistence.queries.QueryResultsCachePolicy#setIsNullIgnored(boolean)
131	*/	131	*/
132	public static final String QUERY_RESULTS_CACHE_IGNORE_NULL = "eclipselink.query-results-cache.ignore-null";	132	public static final String QUERY_RESULTS_CACHE_IGNORE_NULL = "eclipselink.query-results-cache.ignore-null";




            Vector mappings = getMappings();
            Object[] mappingsArray = new Object[mappings.size()];
            for (int index = 0; index < mappings.size(); index++) {
                mappingsArray[index] = mappings.get(index);
            }
            Arrays.sort(mappingsArray, new MappingCompare());
            mappings = NonSynchronizedVector.newInstance(mappingsArray.length);
            for (int index = 0; index < mappingsArray.length; index++) {
                mappings.add(mappingsArray[index]);
            }
            setMappings(mappings);
        }

        for (DatabaseMapping mapping : getMappings()) {
            DatabaseMapping mapping = (DatabaseMapping)mappingsEnum.nextElement();
            validateMappingType(mapping);
            mapping.initialize(session);
            if (mapping.isLockableMapping()){


            // JPA 2.0 Derived identities - build a map of derived id mappings.
            if (mapping.derivesId()) {
                this.derivesIdMappings.put(mapping.getAttributeName(), mapping);
            }
            
            // Add all the fields in the mapping to myself.
            Helper.addAllUniqueToVector(getFields(), mapping.getFields());
        }
        
        if (hasMappingsPostCalculateChangesOnDeleted()) {
            session.getProject().setHasMappingsPostCalculateChangesOnDeleted(true);
        }


        if (hasInheritance()) {
            getInheritancePolicy().initialize(session);
            if (getInheritancePolicy().isChildDescriptor()) {
                for (DatabaseMapping mapping : getInheritancePolicy().getParentDescriptor().getMappings()) {
                         iterator.hasNext();) {
                    DatabaseMapping mapping = (DatabaseMapping)iterator.next();
                    if (mapping.isAggregateObjectMapping() || ((mapping.isForeignReferenceMapping() && (!mapping.isDirectCollectionMapping())) && (!((ForeignReferenceMapping)mapping).usesIndirection()))) {
                        getLockableMappings().add(mapping);// add those mappings from the parent.
                    }
                    // JPA 2.0 Derived identities - build a map of derived id mappings.
                    if (mapping.derivesId()) {
                        this.derivesIdMappings.put(mapping.getAttributeName(), mapping);
                    }
                }
            }

            Vector mappings = getMappings();
            Object[] mappingsArray = new Object[mappings.size()];
            for (int index = 0; index < mappings.size(); index++) {
                mappingsArray[index] = mappings.get(index);
            }
            Arrays.sort(mappingsArray, new MappingCompare());
            mappings = NonSynchronizedVector.newInstance(mappingsArray.length);
            for (int index = 0; index < mappingsArray.length; index++) {
                mappings.add(mappingsArray[index]);
            }
            setMappings(mappings);
        }

            field.setIndex(index);
        }        
        // Set cache key type.
        if (getCacheKeyType() == null || (getCacheKeyType() == CacheKeyType.AUTO)) {
            if ((getPrimaryKeyFields().size() > 1) || getObjectBuilder().isXMLObjectBuilder()) {
                setCacheKeyType(CacheKeyType.CACHE_ID);
            } else if (getPrimaryKeyFields().size() == 1) {

            } else {
                setCacheKeyType(CacheKeyType.CACHE_ID);                
            }
        } else if ((getCacheKeyType() == CacheKeyType.ID_VALUE) && (getPrimaryKeyFields().size() > 1)) {
            session.getIntegrityChecker().handleError(DescriptorException.cannotUseIdValueForCompositeId(this));
        }
        getObjectBuilder().postInitialize(session);


     */
    protected void validateAfterInitialization(AbstractSession session) {
        selfValidationAfterInitialization(session);
        for (DatabaseMapping mapping : getMappings()) {
            mapping.validateAfterInitialization(session);
        }
    }


     */
    protected void validateBeforeInitialization(AbstractSession session) {
        selfValidationBeforeInitialization(session);
        for (DatabaseMapping mapping : getMappings()) {
            mapping.validateBeforeInitialization(session);
        }
    }


     * Check that the qualifier on the table names are properly set.
     */
    protected void verifyTableQualifiers(Platform platform) {
        DatabaseTable table;
        Enumeration tableEnumeration;
        String tableQualifier = platform.getTableQualifier();

        if (tableQualifier.length() == 0) {
            return;
        }

        for (DatabaseTable table : getTables()) {
        while (tableEnumeration.hasMoreElements()) {
            table = (DatabaseTable)tableEnumeration.nextElement();
            if (table.getTableQualifier().length() == 0) {
                table.setTableQualifier(tableQualifier);
            }





    /**
     * INTERNAL:
     * Create an instance of the Id class or value from the object.
     */
    public Object createPrimaryKeyInstance(Object object, AbstractSession session) {
        KeyElementAccessor[] pkElementArray = this.getKeyClassFields(getPKClass());
        ObjectBuilder builder = getDescriptor().getObjectBuilder();
        if (pkElementArray.length == 1 && pkElementArray[0] instanceof KeyIsElementAccessor){
            DatabaseMapping mapping = builder.getMappingForAttributeName(pkElementArray[0].getAttributeName());
            Object fieldValue = mapping.getRealAttributeValueFromObject(object, session);
            if (mapping.isObjectReferenceMapping()){
                fieldValue = mapping.getReferenceDescriptor().getCMPPolicy().createPrimaryKeyInstance(fieldValue, session);
            }

        Object keyInstance = getPKClassInstance();
        Set<ObjectReferenceMapping> usedObjectReferenceMappings = new HashSet<ObjectReferenceMapping>();
        for (int index = 0; index < pkElementArray.length; index++) {
            Object keyObj = object;
            KeyElementAccessor accessor = pkElementArray[index];
            DatabaseField field = accessor.getDatabaseField();
            DatabaseMapping mapping = builder.getMappingForField(field);




    public final static int MULTIPLE_TARGET_FOREIGN_KEY_TABLES = 213;
    public final static int ONE_TO_ONE_MAPPING_CONFLICT = 214;
    public final static int NO_RELATION_TABLE_MECHANISM = 215;
    public final static int CANNOT_USE_ID_VALUE_FOR_COMPOSITE_ID = 216;

    /**
     * INTERNAL:

    }

    public static DescriptorException noRelationTableMechanism(DatabaseMapping mapping) {
        Object[] args = { mapping };

        DescriptorException descriptorException = new DescriptorException(ExceptionMessageGenerator.buildMessage(DescriptorException.class, NO_RELATION_TABLE_MECHANISM, args), mapping);
        descriptorException.setErrorCode(NO_RELATION_TABLE_MECHANISM);
        return descriptorException;
    }


    public static DescriptorException cannotUseIdValueForCompositeId(ClassDescriptor descriptor) {
        Object[] args = {  };

        DescriptorException descriptorException = new DescriptorException(ExceptionMessageGenerator.buildMessage(DescriptorException.class, CANNOT_USE_ID_VALUE_FOR_COMPOSITE_ID, args), descriptor);
        descriptorException.setErrorCode(CANNOT_USE_ID_VALUE_FOR_COMPOSITE_ID);
        return descriptorException;
    }    

}

Lines 224-229 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/exceptions/i18n/DescriptorExceptionResource.java (+1 lines)
224	{ "213", "{0} requires all target foreign key fields to belong to the same table, but several were found: {1}." },	224	{ "213", "{0} requires all target foreign key fields to belong to the same table, but several were found: {1}." },
225	{ "214", "{0} specifies relation table, that is not compatible with addForeignKey(Name) method, or use addSourceRelationKeyField(Name) and addTargetRelationKeyFieldName methods instead."},	225	{ "214", "{0} specifies relation table, that is not compatible with addForeignKey(Name) method, or use addSourceRelationKeyField(Name) and addTargetRelationKeyFieldName methods instead."},
226	{ "215", "{0} must have non-null RelationTableMechanism."},	226	{ "215", "{0} must have non-null RelationTableMechanism."},
		227	{ "216", "CacheKeyType cannot be ID_VALUE for a composite primary key.."},
227		228
228	};	229	};
229		230

Lines 570-579 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/descriptors/ObjectBuilder.java (-1 / +2 lines)
570	CacheKey unitOfWorkCacheKey = unitOfWork.getIdentityMapAccessorInstance().acquireLock(primaryKey, concreteDescriptor.getJavaClass(), concreteDescriptor);	570	CacheKey unitOfWorkCacheKey = unitOfWork.getIdentityMapAccessorInstance().acquireLock(primaryKey, concreteDescriptor.getJavaClass(), concreteDescriptor);
571	Object clone = unitOfWorkCacheKey.getObject();	571	Object clone = unitOfWorkCacheKey.getObject();
572	boolean found = clone != null;	572	boolean found = clone != null;
573	Object original = null;	573	Object original = null;
574	try {	574	try {
575	// Only check parent cache if not in unit of work, or if a refresh is required.	575	// Only check parent cache if not in unit of work, or if a refresh is required.
576	if (!found \|\| query.shouldRefreshIdentityMapResult()	576	if (!found \|\| query.shouldRefreshIdentityMapResult()
		577	\|\| query.shouldCacheQueryResults() // Need to build original to cache it.
577	\|\| query.shouldRetrieveBypassCache()	578	\|\| query.shouldRetrieveBypassCache()
578	\|\| (concreteDescriptor.hasFetchGroupManager() && concreteDescriptor.getFetchGroupManager().isPartialObject(clone))) {	579	\|\| (concreteDescriptor.hasFetchGroupManager() && concreteDescriptor.getFetchGroupManager().isPartialObject(clone))) {
579	// This is normal case when we are not in transaction.	580	// This is normal case when we are not in transaction.

Lines 927-933 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/identitymaps/IdentityMapManager.java (-5 / +7 lines)
927	* values of the parameters to the query so different parameters will have	927	* values of the parameters to the query so different parameters will have
928	* different cached results.	928	* different cached results.
929	*/	929	*/
930	public Object getQueryResult(ReadQuery query, Vector parameters, boolean shouldCheckExpiry) {	930	public Object getQueryResult(ReadQuery query, List parameters, boolean shouldCheckExpiry) {
931	if (query.getQueryResultsCachePolicy() == null) {	931	if (query.getQueryResultsCachePolicy() == null) {
932	return null;	932	return null;
933	}	933	}
Lines 1226-1232 Link Here
1226	* Query results are cached based on the parameter values provided to the query	1226	* Query results are cached based on the parameter values provided to the query
1227	* different parameter values access different caches.	1227	* different parameter values access different caches.
1228	*/	1228	*/
1229	public void putQueryResult(ReadQuery query, Vector parameters, Object results) {	1229	public void putQueryResult(ReadQuery query, List parameters, Object results) {
		1230	if ((results == null) \|\| (results == InvalidObject.instance())) {
		1231	if (query.getQueryResultsCachePolicy().isNullIgnored()) {
		1232	return;
		1233	}
		1234	}
1230	// PERF: use query name, unless no name.	1235	// PERF: use query name, unless no name.
1231	Object queryKey = query.getName();	1236	Object queryKey = query.getName();
1232	if ((queryKey == null) \|\| ((String)queryKey).length() == 0) {	1237	if ((queryKey == null) \|\| ((String)queryKey).length() == 0) {
Lines 1257-1265 Link Here
1257	}	1262	}
1258	// Bug 6138532 - store InvalidObject for "no results", do not store null	1263	// Bug 6138532 - store InvalidObject for "no results", do not store null
1259	if (results == null) {	1264	if (results == null) {
1260	if (query.getQueryResultsCachePolicy().isNullIgnored()) {
1261	return;
1262	}
1263	results = InvalidObject.instance();	1265	results = InvalidObject.instance();
1264	}	1266	}
1265	map.put(lookupParameters, results, null, queryTime);	1267	map.put(lookupParameters, results, null, queryTime);




        if (descriptor == null) {
            throw ValidationException.missingDescriptor(theClass.toString());
        }
        return getIdentityMap(descriptor);
    }

    /**

     * Get the identity map for the given class from the IdentityMapManager
     */
    public IdentityMap getIdentityMap(ClassDescriptor descriptor) {
        return getIdentityMap(descriptor, false);
    }

    /**
     * INTERNAL:
     * Get the identity map for the given class from the IdentityMapManager
     */
    public IdentityMap getIdentityMap(ClassDescriptor descriptor, boolean returnNullIfMissing) {
        return getIdentityMapManager().getIdentityMap(descriptor, returnNullIfMissing);
    }

    /**
     * INTERNAL:
     * Get the cached results associated with a query.  Results are cached by the
     * values of the parameters to the query so different parameters will have
     * different cached results.
     */
    public Object getQueryResult(ReadQuery query, List parameters, boolean checkExpiry) {
        return getIdentityMapManager().getQueryResult(query, parameters, checkExpiry);
    }


     * Query results are cached based on the parameter values provided to the query
     * different parameter values access different caches.
     */
    public void putQueryResult(ReadQuery query, List parameters, Object results) {
        getIdentityMapManager().putQueryResult(query, parameters, results);
    }


        Iterator descriptors = getSession().getDescriptors().values().iterator();
        while (descriptors.hasNext()) {
            ClassDescriptor descriptor = (ClassDescriptor)descriptors.next();
            IdentityMap cache = getIdentityMap(descriptor, true);
            if (cache != null) {
                for (Enumeration mapEnum = cache.elements(); mapEnum.hasMoreElements();) {
                    iterator.startIterationOn(mapEnum.nextElement());
                }
            }
        }
    }




     * Get the identity map for the given class from the IdentityMapManager
     */
    @Override
    public IdentityMap getIdentityMap(ClassDescriptor descriptor, boolean returnNullIfMissing) {
        if (descriptor.isIsolated()) {
            return getIdentityMapManager().getIdentityMap(descriptor, returnNullIfMissing);
        } else {
            return ((IsolatedClientSession)session).getParent().getIdentityMapAccessorInstance().getIdentityMap(descriptor, returnNullIfMissing);
        }
    }


     * different cached results.
     */
    @Override
    public Object getQueryResult(ReadQuery query, List parameters, boolean checkExpiry) {
        if (((IsolatedClientSession)session).isIsolatedQuery(query)) {
            return getIdentityMapManager().getQueryResult(query, parameters, checkExpiry);
        } else {

     * different parameter values access different caches.
     */
    @Override
    public void putQueryResult(ReadQuery query, List parameters, Object results) {
        if (((IsolatedClientSession)session).isIsolatedQuery(query)) {
            getIdentityMapManager().putQueryResult(query, parameters, results);
        } else {

Lines 190-196 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/UnitOfWorkIdentityMapAccessor.java (-2 / +2 lines)
190	* results are only cached in the parent session for UnitOfWorks	190	* results are only cached in the parent session for UnitOfWorks
191	*/	191	*/
192	@Override	192	@Override
193	public Object getQueryResult(ReadQuery query, Vector parameters, boolean checkExpiry) {	193	public Object getQueryResult(ReadQuery query, List parameters, boolean checkExpiry) {
194	return ((UnitOfWorkImpl)this.session).getParent().getIdentityMapAccessorInstance().getQueryResult(query, parameters, checkExpiry);	194	return ((UnitOfWorkImpl)this.session).getParent().getIdentityMapAccessorInstance().getQueryResult(query, parameters, checkExpiry);
195	}	195	}
196		196
Lines 203-209 Link Here
203	* Results are only cached in the parent session for UnitOfWorks	203	* Results are only cached in the parent session for UnitOfWorks
204	*/	204	*/
205	@Override	205	@Override
206	public void putQueryResult(ReadQuery query, Vector parameters, Object results) {	206	public void putQueryResult(ReadQuery query, List parameters, Object results) {
207	((UnitOfWorkImpl)this.session).getParent().getIdentityMapAccessorInstance().putQueryResult(query, parameters, results);	207	((UnitOfWorkImpl)this.session).getParent().getIdentityMapAccessorInstance().putQueryResult(query, parameters, results);
208	}	208	}
209		209

Lines 120-126 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/DataReadQuery.java (-1 / +1 lines)
120	Object results = getQueryResults(session, row, true);	120	Object results = getQueryResults(session, row, true);
121	// Bug6138532 - if results are "cached no results", return null immediately	121	// Bug6138532 - if results are "cached no results", return null immediately
122	if (results == InvalidObject.instance) {	122	if (results == InvalidObject.instance) {
123	return null;	123	return getContainerPolicy().containerInstance(0);
124	}	124	}
125	if (results != null) {	125	if (results != null) {
126	return results;	126	return results;




     */
    protected int inMemoryQueryIndirectionPolicy;

    /**
     * Used to set the read time on objects that use this query.
     * Should be set to the time the query returned from the database.
     */
    protected long executionTime = 0;

    /** Allow for a query level fetch group to be set. */
    protected FetchGroup fetchGroup;


    }

    /**
     * INTERNAL:
     * Set the the time this query went to the database.
     */
    public void setExecutionTime(long executionTime) {
        this.executionTime = executionTime;
    }

    /**
     * PUBLIC:
     * Set the example object of the query to be the newExampleObject.
     * The example object is used for Query By Example.




    protected Object executeObjectLevelReadQuery() throws DatabaseException {
        Object result = null;
        
        if (this.containerPolicy.overridesRead()) {
            return this.containerPolicy.execute();
        }

        if (this.descriptor.isDescriptorForInterface()) {
            Object returnValue = this.descriptor.getInterfacePolicy().selectAllObjectsUsingMultipleTableSubclassRead(this);
            this.executionTime = System.currentTimeMillis();
            return returnValue;
        }

        List rows = getQueryMechanism().selectAllRows();
        this.executionTime = System.currentTimeMillis();
        
        // If using 1-m joins, must set all rows.
        if (hasJoining() && this.joinedAttributeManager.isToManyJoin()) {

        if (this.session.isUnitOfWork()) {
            result = registerResultInUnitOfWork(rows, (UnitOfWorkImpl)this.session, this.translationRow, true);// 
        } else {
            result = this.containerPolicy.containerInstance(rows.size());
            this.descriptor.getObjectBuilder().buildObjectsInto(this, rows, result);
        }


            ComplexQueryResult complexResult = new ComplexQueryResult();
            complexResult.setResult(result);
            complexResult.setData(rows);
            result = complexResult;
        }

        // Add the other (already registered) results and return them.
        if (this.descriptor.hasTablePerClassPolicy()) {
            result = this.containerPolicy.concatenateContainers(result, this.descriptor.getTablePerClassPolicy().selectAllObjectsUsingMultipleTableSubclassRead(this));
        }

        // If the results were empty, then ensure they get cached still.
        if (shouldCacheQueryResults() && this.containerPolicy.isEmpty(result)) {
            this.temporaryCachedQueryResults = InvalidObject.instance();
        }
        
        return result;
    }




     * It will cause the original to be cached in the query results if the query
     * is set to do so.
     */
    public void cacheResult(Object object) {
        Object cachableObject = object;
        if (object == null) {
            this.temporaryCachedQueryResults = InvalidObject.instance();
        } else {
            if (this.shouldUseWrapperPolicy) {
                cachableObject = this.session.wrapObject(object);
            }
            this.temporaryCachedQueryResults = cachableObject;
        }
        setTemporaryCachedQueryResults(cachableObject);
    }



Lines 12-17 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadQuery.java (-6 / +9 lines)
12	******************************************************************************/	12	******************************************************************************/
13	package org.eclipse.persistence.queries;	13	package org.eclipse.persistence.queries;
14		14
		15	import java.util.List;
15	import java.util.Vector;	16	import java.util.Vector;
16	import org.eclipse.persistence.internal.helper.NonSynchronizedVector;	17	import org.eclipse.persistence.internal.helper.NonSynchronizedVector;
17	import org.eclipse.persistence.internal.sessions.AbstractRecord;	18	import org.eclipse.persistence.internal.sessions.AbstractRecord;
Lines 107-114 Link Here
107	*/	108	*/
108	protected void clonedQueryExecutionComplete(DatabaseQuery query, AbstractSession session) {	109	protected void clonedQueryExecutionComplete(DatabaseQuery query, AbstractSession session) {
109	if (shouldCacheQueryResults()) {	110	if (shouldCacheQueryResults()) {
110	// Cached query results must exist on the original query rather than the cloned one	111	Object result = ((ReadQuery)query).getTemporaryCachedQueryResults();
111	setQueryResults(((ReadQuery)query).getTemporaryCachedQueryResults(), query.getTranslationRow(), query.getSession());	112	// If the temporary results were never set, then don't cache null.
		113	if (result != null) {
		114	// Cached query results must exist on the original query rather than the cloned one.
		115	setQueryResults(result, query.getTranslationRow(), query.getSession());
		116	}
112	}	117	}
113	}	118	}
114		119
Lines 216-225 Link Here
216	*/	221	*/
217	protected Object getQueryResults(AbstractSession session, AbstractRecord row, boolean checkExpiry) {	222	protected Object getQueryResults(AbstractSession session, AbstractRecord row, boolean checkExpiry) {
218	// Check for null translation row.	223	// Check for null translation row.
219	Vector arguments = null;	224	List arguments = null;
220	if (row == null) {	225	if (row != null) {
221	arguments = new NonSynchronizedVector(1);
222	} else {
223	arguments = row.getValues();	226	arguments = row.getValues();
224	}	227	}
225	return session.getIdentityMapAccessorInstance().getQueryResult(this, arguments, checkExpiry);	228	return session.getIdentityMapAccessorInstance().getQueryResult(this, arguments, checkExpiry);

Lines 273-279 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/sessions/IdentityMapAccessor.java (-1 / +1 lines)
273	/**	273	/**
274	* ADVANCED:	274	* ADVANCED:
275	* Returns the remaining life of the given Object. This method is associated with use of	275	* Returns the remaining life of the given Object. This method is associated with use of
276	* TopLink's cache invalidation feature and returns the difference between the next expiry	276	* cache invalidation feature and returns the difference between the next expiry
277	* time of the Object and its read time. The method will return 0 for invalidated Objects.	277	* time of the Object and its read time. The method will return 0 for invalidated Objects.
278	* @param object Object under consideration	278	* @param object Object under consideration
279	* @return long time in milliseconds	279	* @return long time in milliseconds




        query="SELECT e FROM Employee e",
        hints={
                @QueryHint(name=QueryHints.QUERY_RESULTS_CACHE, value="true"),
                @QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_TYPE, value="FULL"),
                @QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_IGNORE_NULL, value="false"),
                @QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_RANDOMIZE_EXPIRY, value="true"),
                @QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_SIZE, value="200"),
                @QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_EXPIRY, value="50000")
        }
),
@NamedQuery(
        name="CachedNoEmployees",
        query="SELECT e FROM Employee e where 1 <> 1",
        hints={
                @QueryHint(name=QueryHints.QUERY_RESULTS_CACHE, value="true")
        }
),
@NamedQuery(
        name="CachedTimeOfDayAllEmployees",
        query="SELECT e FROM Employee e",
        hints={




import junit.framework.TestSuite;
import org.eclipse.persistence.testing.models.jpa.advanced.*;
import org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl;
import org.eclipse.persistence.jpa.JpaCache;
import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;

/**

        super(name);
    }

    public static void setUpClass() throws Exception {
    }

    public static void tearDownClass() throws Exception {
    }

    public void setUp() {

        super.setUp();
        clearCache();
    }

        suite.addTest(new CacheImplJUnitTest("testEvictClass"));
        suite.addTest(new CacheImplJUnitTest("testEvictAll"));
        suite.addTest(new CacheImplJUnitTest("testEvictContains"));
        suite.addTest(new CacheImplJUnitTest("testCacheAPI"));
        
        return suite;
    }

        em1.persist(e1);
        commitTransaction(em1);
        closeEntityManager(em1);
        boolean result = getEntityManagerFactory("default1").getCache().contains(Employee.class, 101);
        assertTrue("Employee not found in cache", result);
            assertTrue("Assertion Error",result);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    /**
     * Test cache API.
     */
    public void testCacheAPI() {
        EntityManager em = createEntityManager("default1");
        beginTransaction(em);
        Employee employee = new Employee();
        employee.setFirstName("testCacheAPI");
        em.persist(employee);
        commitTransaction(em);
        closeEntityManager(em);
        JpaCache cache = (JpaCache)getEntityManagerFactory("default1").getCache();
        assertTrue("Employee not valid in cache", cache.isValid(employee));
        assertTrue("Employee not valid in cache", cache.isValid(Employee.class, employee.getId()));
        cache.timeToLive(employee);
        assertTrue("Employee not found in cache", cache.getObject(Employee.class, employee.getId()) != null);
        assertTrue("Employee not found in cache", cache.contains(employee));
        cache.evict(employee);
        cache.putObject(employee);
        cache.removeObject(employee);
        cache.removeObject(Employee.class, employee.getId());
        cache.clear();
        cache.clear(Employee.class);
        cache.clearQueryCache();
        cache.clearQueryCache("findAllEmployeesByIdAndFirstName");
        assertTrue("Employee id not correct", employee.getId().equals(cache.getId(employee)));
        cache.print();
        cache.print(Employee.class);
        cache.printLocks();
        cache.validate();
    }

    /**
     * Test of evict method, of class CacheImpl.

            Employee e3 = em4.find(Employee.class, 121);
            afterCache = e3.getFirstName();
            assertNotSame("Assertion Error", beforeCache, afterCache);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeEntityManager(em3);
            closeEntityManager(em4);

            Employee e5 = em7.find(Employee.class, 131);
            String actual = e5.getFirstName();
            assertNotSame("Assertion Error", expected, actual);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeEntityManager(em6);
            closeEntityManager(em7);

            String actualDept = d2.getName();
            assertEquals("Assertion Error", expectedEmp, actualEmp);
            assertEquals("Assertion Error", expectedDept, actualDept);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            closeEntityManager(em9);
        }

        em.persist(emp);
        commitTransaction(em);

        try {
            assertTrue(em.getEntityManagerFactory().getCache().contains(Employee.class, emp.getId()));
    
            em.clear();

            em.getEntityManagerFactory().getCache().evict(Employee.class, emp.getId());
            assertFalse(em.getEntityManagerFactory().getCache().contains(Employee.class, emp.getId()));
        } finally {
            closeEntityManager(em);
        }

    }




import javax.persistence.EntityManager;
import javax.persistence.RollbackException;

import junit.framework.Assert;
import junit.framework.Test;
import junit.framework.TestSuite;


import org.eclipse.persistence.descriptors.invalidation.DailyCacheInvalidationPolicy;
import org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy;
import org.eclipse.persistence.internal.sessions.AbstractSession;
import org.eclipse.persistence.jpa.JpaCache;
import org.eclipse.persistence.jpa.JpaQuery;
import org.eclipse.persistence.queries.Cursor;
import org.eclipse.persistence.queries.ReadQuery;

import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
import org.eclipse.persistence.testing.framework.QuerySQLTracker;
import org.eclipse.persistence.testing.models.jpa.advanced.Employee;
import org.eclipse.persistence.testing.models.jpa.advanced.Address;
import org.eclipse.persistence.testing.models.jpa.advanced.EmployeePopulator;
import org.eclipse.persistence.testing.models.jpa.advanced.AdvancedTableCreator;


            if (!(readQuery.getQueryResultsCachePolicy().getCacheInvalidationPolicy() instanceof TimeToLiveCacheInvalidationPolicy)) {
                fail("Query cache invalidation not set.");
            }
            if (((TimeToLiveCacheInvalidationPolicy)readQuery.getQueryResultsCachePolicy().getCacheInvalidationPolicy()).getTimeToLive() != 50000) {
                fail("Query cache invalidation time not set.");
            }
            

            // Query by primary key.
            Query query = em.createNamedQuery("CachedAllEmployees");
            if (result.size() != query.getResultList().size()) {
                fail("List result size is not correct on 2nd cached query.");
            }
            if (counter.getSqlStatements().size() > 0) {
                fail("Query cache was not used: " + counter.getSqlStatements());
            }
            ((JpaCache)getEntityManagerFactory().getCache()).clearQueryCache();
            // Preload uow to test query cache in uow.
            em.createQuery("Select e from Employee e").getResultList();
            query.getResultList();
            if (result.size() != query.getResultList().size()) {
                fail("List result size is not correct on cached query in unit of work.");
            }
            ((JpaCache)getEntityManagerFactory().getCache()).clearQueryCache();
            // Also test query cache in early transaction.
            em.persist(new Address());
            em.flush();
            query.getResultList();
            if (result.size() != query.getResultList().size()) {
                fail("List result size is not correct on cached query in transaction.");
            }
            // Query by primary key.
            query = em.createNamedQuery("CachedNoEmployees");
            if (!query.getResultList().isEmpty()) {
                fail("List result size is not correct.");
            }
            // Also test empty query cache.
            counter.remove();
            counter = new QuerySQLTracker(getServerSession());
            if (!query.getResultList().isEmpty()) {
                fail("List result size is not correct.");
            }
            if (counter.getSqlStatements().size() > 0) {
                fail("Query cache was not used: " + counter.getSqlStatements());
            }

    }

    public void testLockWithSecondaryTable() {
        ServerSession session = JUnitTestCase.getServerSession();

        // Cannot create parallel entity managers in the server.
        if (! isOnServer() && isSelectForUpateSupported()) {
            EntityManager em = createEntityManager();

    }

    public void testVersionChangeWithReadLock() {
        ServerSession session = JUnitTestCase.getServerSession();

        // It's a JPA2.0 feature.
        if (! isJPA10() && isSelectForUpateNoWaitSupported()){
            Employee employee = null;

    }

    public void testVersionChangeWithWriteLock() {
        ServerSession session = JUnitTestCase.getServerSession();

        // It's a JPA2.0 feature
        if (! isJPA10() && isSelectForUpateNoWaitSupported()) {
            Employee employee = null;

Lines 12-20 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/CacheImpl.java (-11 / +201 lines)
12	******************************************************************************/	12	******************************************************************************/
13	package org.eclipse.persistence.internal.jpa;	13	package org.eclipse.persistence.internal.jpa;
14		14
15	import javax.persistence.Cache;
16	import org.eclipse.persistence.descriptors.ClassDescriptor;	15	import org.eclipse.persistence.descriptors.ClassDescriptor;
17	import org.eclipse.persistence.internal.identitymaps.CacheKey;	16	import org.eclipse.persistence.internal.identitymaps.CacheKey;
		17	import org.eclipse.persistence.jpa.JpaCache;
18	import org.eclipse.persistence.sessions.IdentityMapAccessor;	18	import org.eclipse.persistence.sessions.IdentityMapAccessor;
19	import org.eclipse.persistence.sessions.server.ServerSession;	19	import org.eclipse.persistence.sessions.server.ServerSession;
20		20
Lines 22-28 Link Here
22	* Implements the JPA Cache interface using the EclipseLink cache API through IdentityMapAccessor.	22	* Implements the JPA Cache interface using the EclipseLink cache API through IdentityMapAccessor.
23	* @author DaraniY	23	* @author DaraniY
24	*/	24	*/
25	public class CacheImpl implements Cache {	25	public class CacheImpl implements JpaCache {
26		26
27	private IdentityMapAccessor accessor;	27	private IdentityMapAccessor accessor;
28	private EntityManagerFactoryImpl emf;	28	private EntityManagerFactoryImpl emf;
Lines 34-67 Link Here
34	this.serversession = emf.getServerSession();	34	this.serversession = emf.getServerSession();
35	}	35	}
36		36
37	public boolean contains(Class cls, Object primaryKey) {	37	/**
		38	* Returns true if the cache contains an Object with the id and Class type, and is valid.
		39	*/
		40	public boolean contains(Class cls, Object id) {
38	this.emf.verifyOpen();	41	this.emf.verifyOpen();
39	Object pk = createPrimaryKeyFromId(cls, primaryKey);	42	Object pk = createPrimaryKeyFromId(cls, id);
40	ClassDescriptor descriptor = this.serversession.getDescriptor(cls);	43	ClassDescriptor descriptor = this.serversession.getDescriptor(cls);
41	CacheKey key = ((org.eclipse.persistence.internal.sessions.IdentityMapAccessor)this.accessor).getCacheKeyForObject(pk, cls, descriptor);	44	CacheKey key = ((org.eclipse.persistence.internal.sessions.IdentityMapAccessor)this.accessor).getCacheKeyForObject(pk, cls, descriptor);
42		45
43	return (key != null) && (key.getObject() != null) && (!descriptor.getCacheInvalidationPolicy().isInvalidated(key));	46	return (key != null) && (key.getObject() != null) && (!descriptor.getCacheInvalidationPolicy().isInvalidated(key));
44	}	47	}
45		48
46	public void evict(Class cls, Object primaryKey) {	49	/**
		50	* Sets an Object with the id and Class type to be invalid in the cache.
		51	*/
		52	public void evict(Class cls, Object id) {
47	this.emf.verifyOpen();	53	this.emf.verifyOpen();
48	this.accessor.invalidateObject(createPrimaryKeyFromId(cls, primaryKey), cls);	54	this.accessor.invalidateObject(createPrimaryKeyFromId(cls, id), cls);
49	}	55	}
50		56
		57	/**
		58	* Sets all instances of the class to be invalid.
		59	*/
51	public void evict(Class cls) {	60	public void evict(Class cls) {
52	this.emf.verifyOpen();	61	this.emf.verifyOpen();
53	this.accessor.invalidateClass(cls);	62	this.accessor.invalidateClass(cls);
54	}	63	}
55		64
		65	/**
		66	* Sets all instances in the cache to be invalid.
		67	*/
56	public void evictAll() {	68	public void evictAll() {
57	this.emf.verifyOpen();	69	this.emf.verifyOpen();
58	this.accessor.invalidateAll();	70	this.accessor.invalidateAll();
59	}	71	}
60		72
61	private Object createPrimaryKeyFromId(Class cls, Object primaryKey){	73	/**
62	ClassDescriptor cdesc = this.serversession.getDescriptor(cls);	74	* Return the EclipseLink cache key object from the JPA Id object.
63	CMP3Policy cmp = (CMP3Policy) (cdesc.getCMPPolicy());	75	*/
64	Object pk = cmp.createPrimaryKeyFromId(primaryKey, this.serversession);	76	private Object createPrimaryKeyFromId(Class cls, Object id) {
65	return pk;	77	CMP3Policy policy = (CMP3Policy)this.serversession.getDescriptor(cls).getCMPPolicy();
		78	Object primaryKey = policy.createPrimaryKeyFromId(id, this.serversession);
		79	return primaryKey;
66	}	80	}
		81
		82	/**
		83	* ADVANCED:
		84	* Resets the entire Object cache, and the Query cache.
		85	* <p> NOTE: Be careful using this method. This method blows away both this session's and its parent's caches.
		86	* This includes the server cache or any other cache. This throws away any Objects that have been read in.
		87	* Extreme caution should be used before doing this because Object identity will no longer
		88	* be maintained for any Objects currently read in. This should only be called
		89	* if the application knows that it no longer has references to Objects held in the cache.
		90	*/
		91	public void clear() {
		92	this.emf.verifyOpen();
		93	this.accessor.initializeAllIdentityMaps();
		94	}
		95
		96	/**
		97	* ADVANCED:
		98	* Resets the cache for only the instances of the given Class type.
		99	* For inheritance the user must make sure that they only use the root class,
		100	* clearing a subclass cache is not allowed (as they share their parents cache).
		101	* <p> NOTE: Caution must be used in doing this to ensure that the Objects within the cache
		102	* are not referenced from other Objects of other classes or from the application.
		103	*/
		104	public void clear(Class cls) {
		105	this.emf.verifyOpen();
		106	this.accessor.initializeIdentityMap(cls);
		107	}
		108
		109	/**
		110	* Clear all the query caches.
		111	*/
		112	public void clearQueryCache() {
		113	this.emf.verifyOpen();
		114	this.accessor.clearQueryCache();
		115	}
		116
		117	/**
		118	* Clear the named query cache associated with the query name.
		119	*/
		120	public void clearQueryCache(String queryName) {
		121	this.emf.verifyOpen();
		122	this.accessor.clearQueryCache(queryName);
		123	}
		124
		125	/**
		126	* Returns the remaining life of the given Object (in milliseconds). This method is associated with use of
		127	* cache invalidation feature and returns the difference between the next expiry
		128	* time of the Object and its read time. The method will return 0 for invalidated Objects.
		129	*/
		130	public long timeToLive(Object object) {
		131	this.emf.verifyOpen();
		132	return this.accessor.getRemainingValidTime(object);
		133	}
		134
		135	/**
		136	* Returns true if the Object with the same id and Class type of the
		137	* the given Object is valid in the cache.
		138	*/
		139	public boolean isValid(Object object) {
		140	this.emf.verifyOpen();
		141	return this.accessor.isValid(object);
		142	}
		143
		144	/**
145	* Returns true if the Object with the id and Class type is valid in the cache.
146	*/
147	public boolean isValid(Class cls, Object id) {
148	this.emf.verifyOpen();
149	return this.accessor.isValid(createPrimaryKeyFromId(cls, id), cls);
150	}
151
152	/**
153	* Used to print all the Objects in the cache.
154	* The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
155	*/
156	public void print() {
157	this.emf.verifyOpen();
158	this.accessor.printIdentityMaps();
159	}
160
161	/**
162	* Used to print all the Objects in the cache of the Class type.
163	* The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
164	*/
165	public void print(Class cls) {
166	this.emf.verifyOpen();
167	this.accessor.printIdentityMap(cls);
168	}
169
170	/**
171	* Used to print all the currently locked cache keys in the cache.
172	* The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
173	*/
174	public void printLocks() {
175	this.emf.verifyOpen();
176	this.accessor.printIdentityMapLocks();
177	}
178
179	/**
180	* This can be used to help debugging an Object identity problem.
181	* An Object identity problem is when an Object in the cache references an
182	* Object that is not in the cache. This method will validate that all cached
183	* Objects are in a correct state.
184	*/
185	public void validate() {
186	this.emf.verifyOpen();
187	this.accessor.validateCache();
188	}
189
190	/**
191	* Returns the Object from the cache map with the id
192	* and Class type.
193	*/
194	public Object getObject(Class cls, Object id) {
195	this.emf.verifyOpen();
196	return this.accessor.getFromIdentityMap(createPrimaryKeyFromId(cls, id), cls);
197	}
198
199	/**
200	* ADVANCED:
201	* Puts the given Object into the cache.
202	* This is a very advanced method, and caution should be used in adding objects to the cache
203	* as other objects may have relationships to previous object, or this object may have
204	* relationships to other objects.
205	*/
206	public Object putObject(Object object) {
207	this.emf.verifyOpen();
208	return this.accessor.putInIdentityMap(object);
209	}
210
211	/**
212	* ADVANCED:
213	* Removes the Object from the cache.
214	* <p> NOTE: Caution should be used when calling to avoid violating Object identity.
215	* The application should only call this if its known that no references to the Object exist.
216	*/
217	public Object removeObject(Object object) {
218	this.emf.verifyOpen();
219	return this.accessor.removeFromIdentityMap(object);
220	}
221
222	/**
223	* ADVANCED:
224	* Removes the Object with the id and Class type from the cache.
225	* <p> NOTE: Caution should be used when calling to avoid violating Object identity.
226	* The application should only call this if its known that no references to the Object exist.
227	*/
228	public Object removeObject(Class cls, Object id) {
229	this.emf.verifyOpen();
230	return this.accessor.removeFromIdentityMap(createPrimaryKeyFromId(cls, id), cls);
231	}
232
233	/**
234	* Returns true if the cache contains an Object with the same id and Class type of the given object.
235	*/
236	public boolean contains(Object object) {
237	return contains(object.getClass(), getId(object));
238	}
239
240	/**
241	* Sets the object to be invalid in the cache.
242	*/
243	public void evict(Object object) {
244	this.emf.verifyOpen();
245	this.accessor.invalidateObject(object);
246	}
247
248	/**
249	* Returns the object's Id.
250	*/
251	public Object getId(Object object) {
252	this.emf.verifyOpen();
253	ClassDescriptor cdesc = this.serversession.getDescriptor(object.getClass());
254	CMP3Policy policy = (CMP3Policy) (cdesc.getCMPPolicy());
255	return policy.createPrimaryKeyInstance(object, this.serversession);
256	}
67	}	257	}




 * 
 * @author gyorke
 * @since TopLink Essentials - JPA 1.0
 * 
 *        03/19/2009-2.0 Michael O'Brien - 266912: JPA 2.0 Metamodel API (part
 *        of the JSR-317 EJB 3.1 Criteria API)
 */
public class EntityManagerFactoryImpl implements EntityManagerFactory, PersistenceUnitUtil {
    /** Reference to Cache Interface. */
    protected Cache myCache;
    /** Reference to the ServerSession for this deployment. */
    protected volatile ServerSession serverSession;
    /** EntityManagerSetupImpl that deployed this factory. */
    protected EntityManagerSetupImpl setupImpl;
    /** Stores if closed has been called. */
    protected boolean isOpen = true;
    /** Persistence unit properties from create factory. */
    protected Map properties;

    /**
     * INTERNAL: The following properties passed to createEMF cached and
     * processed on the emf directly. None of these properties processed during
     * predeploy or deploy.
     **/
    protected static final Set<String> supportedNonServerSessionProperties = PersistenceUnitProperties.getSupportedNonServerSessionProperties();
    
	/**
	 * Default join existing transaction property, allows reading through write
	 * connection.
	 */
	protected boolean beginEarlyTransaction;

    /**
     * Default join existing transaction property, allows reading through write
     * connection.
     */
    protected boolean beginEarlyTransaction;

    /** Default property, allows flush before query to be avoided. */
    protected FlushModeType flushMode = FlushModeType.AUTO;

    /** Default property, allows weak unit of work references. */
    protected ReferenceMode referenceMode = ReferenceMode.HARD;
	 * commit anyway.
	 */
	protected boolean closeOnCommit;

    /**
     * Default property to avoid resuming unit of work if going to be closed on
     * commit anyway.
     */
    protected boolean closeOnCommit;

    /**
     * Default property to avoid discover new objects in unit of work if
     * application always uses persist.
     */
    protected boolean persistOnCommit = true;
	 */
	protected String flushClearCache = FlushClearCache.DEFAULT;

    /**
     * Default FlashClearCache mode to be used. Relevant only in case call to
     * flush method followed by call to clear method.
     * 
     * @see org.eclipse.persistence.config.FlushClearCache
     */
    protected String flushClearCache = FlushClearCache.DEFAULT;

    /** Default to determine if does-exist should be performed on persist. */
    protected boolean shouldValidateExistence;
    protected boolean commitWithoutPersistRules;
	 * 
	 * @param serverSession
	 */
	public EntityManagerFactoryImpl(ServerSession serverSession) {
		this.serverSession = serverSession;
		processProperties(serverSession.getProperties());
	}

    /**
     * Will return an instance of the Factory. Should only be called by
     * EclipseLink.
     * 
     * @param serverSession
     */
    public EntityManagerFactoryImpl(ServerSession serverSession) {
        this.serverSession = serverSession;
        processProperties(serverSession.getProperties());
    }

    public EntityManagerFactoryImpl(EntityManagerSetupImpl setupImpl, Map properties) {
        this.setupImpl = setupImpl;
        this.properties = properties;
    }
	 * construction
	 */
	public ServerSession getServerSession() {
		if (this.serverSession == null) {
			// PERF: Avoid synchronization.
			synchronized (this) {
				// DCL ok as isLoggedIn is volatile boolean, set after login is
				// complete.
				if (this.serverSession == null) {
					ClassLoader realLoader = setupImpl.getPersistenceUnitInfo().getClassLoader();
					// splitProperties[0] contains supportedNonServerSessionProperties; [1] - all the rest.
					Map[] splitProperties = EntityManagerFactoryProvider.splitSpecifiedProperties(properties, supportedNonServerSessionProperties);
					// keep only non server session properties - the rest will be either cached in the server session or ignored
					properties = splitProperties[0];
					Map serverSessionProperties = splitProperties[1];
					// the call top setupImpl.deploy() finishes the session
					// creation
					ServerSession tempServerSession = setupImpl.deploy(realLoader, serverSessionProperties);
					// discard all but non server session properties from server session properties.
					Map tempProperties = EntityManagerFactoryProvider.keepSpecifiedProperties(tempServerSession.getProperties(), supportedNonServerSessionProperties);
					// properties override server session properties 
					Map propertiesToProcess = EntityManagerFactoryProvider.mergeMaps(properties, tempProperties);
					processProperties(propertiesToProcess);
					this.serverSession = tempServerSession;
				}
			}
		}
		return this.serverSession;
	}

    /**
     * INTERNAL: Returns the ServerSession that the Factory will be using and
     * initializes it if it is not available. This method makes use of the
     * partially constructed session stored in our setupImpl and completes its
     * construction
     */
    public ServerSession getServerSession() {
        if (this.serverSession == null) {
            // PERF: Avoid synchronization.
            synchronized (this) {
                // DCL ok as isLoggedIn is volatile boolean, set after login is
                // complete.
                if (this.serverSession == null) {
                    ClassLoader realLoader = setupImpl.getPersistenceUnitInfo().getClassLoader();
                    // splitProperties[0] contains
                    // supportedNonServerSessionProperties; [1] - all the rest.
                    Map[] splitProperties = EntityManagerFactoryProvider.splitSpecifiedProperties(properties, supportedNonServerSessionProperties);
                    // keep only non server session properties - the rest will
                    // be either cached in the server session or ignored
                    properties = splitProperties[0];
                    Map serverSessionProperties = splitProperties[1];
                    // the call top setupImpl.deploy() finishes the session
                    // creation
                    ServerSession tempServerSession = setupImpl.deploy(realLoader, serverSessionProperties);
                    // discard all but non server session properties from server
                    // session properties.
                    Map tempProperties = EntityManagerFactoryProvider.keepSpecifiedProperties(tempServerSession.getProperties(), supportedNonServerSessionProperties);
                    // properties override server session properties
                    Map propertiesToProcess = EntityManagerFactoryProvider.mergeMaps(properties, tempProperties);
                    processProperties(propertiesToProcess);
                    this.serverSession = tempServerSession;
                }
            }
        }
        return this.serverSession;
    }

    /**
     * Closes this factory, releasing any resources that might be held by this
     * factory. After invoking this method, all methods on the instance will
     * throw an {@link IllegalStateException}, except for {@link #isOpen}, which
     * will return <code>false</code>.
     */
    public synchronized void close() {
        verifyOpen();
        isOpen = false;
        // Do not invalidate the metaModel field
        // (a reopened emf will re-populate the same metaModel)
        // (a new persistence unit will generate a new metaModel)
        if (setupImpl != null) {
            // 260511 null check so that closing a EM
            // created from the constructor no longer throws a NPE
            setupImpl.undeploy();
        }
    }

    /**
     * Indicates whether or not this factory is open. Returns <code>true</code>
     * until a call to {@link #close} is made.
     */
    public boolean isOpen() {
        return isOpen;
    }

    /**
     * PUBLIC: Returns an EntityManager for this deployment.
     */
    public EntityManager createEntityManager() {
        return createEntityManagerImpl(null);
    }

    /**
     * PUBLIC: Returns an EntityManager for this deployment.
     */
    public EntityManager createEntityManager(Map properties) {
        return createEntityManagerImpl(properties);
    }

    protected EntityManagerImpl createEntityManagerImpl(Map properties) {
        verifyOpen();
        ServerSession session = getServerSession();
        if (!session.isLoggedIn()) {
            // PERF: Avoid synchronization.
            synchronized (session) {
                // DCL ok as isLoggedIn is volatile boolean, set after login is
                // complete.
                if (!session.isLoggedIn()) {
                    session.login();
                }
            }
        }
        return new EntityManagerImpl(this, properties);
    }

    protected void verifyOpen() {
        if (!this.isOpen) {
            throw new IllegalStateException(ExceptionLocalization.buildMessage("operation_on_closed_entity_manager_factory"));
        }
    }

    protected void finalize() throws Throwable {
        if (isOpen()) {
            close();
        }
    }

    /**
     * The method return user defined property passed in from
     * EntityManagerFactory.
     */
    public Object getProperty(String name) {
        if (name == null) {
            return null;
        }
        if (properties != null) {
            Object value = properties.get(name);
            if (value != null) {
                return value;
            }
        }
        return getServerSession().getProperty(name);
    }

    /**
     * Process all EntityManager properties. This allows all EntityManager
     * properties specified in the persistence.xml, factory properties, or
     * System properties to be preprocessed. This save the cost of processing
     * these properties each time an EntityManager is created, which can add
     * considerable overhead to both performance and concurrency as System
     * properties are a Hashtable and synchronized. ATTENTION: If you add a new
     * property to be processed in this method please also add the property's
     * name to PersistenceUnitProperties.supportedNonServerSessionProperties
     */
    protected void processProperties(Map properties) {
        String beginEarlyTransactionProperty = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.JOIN_EXISTING_TRANSACTION, properties, this.serverSession, true);
        if (beginEarlyTransactionProperty != null) {
            this.beginEarlyTransaction = "true".equalsIgnoreCase(beginEarlyTransactionProperty);
        }
        String referenceMode = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.PERSISTENCE_CONTEXT_REFERENCE_MODE, properties, this.serverSession, true);
        if (referenceMode != null) {
            this.referenceMode = ReferenceMode.valueOf(referenceMode);
        }
        String flushMode = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.PERSISTENCE_CONTEXT_FLUSH_MODE, properties, this.serverSession, true);
        if (flushMode != null) {
            this.flushMode = FlushModeType.valueOf(flushMode);
        }
        String closeOnCommit = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.PERSISTENCE_CONTEXT_CLOSE_ON_COMMIT, properties, this.serverSession, true);
        if (closeOnCommit != null) {
            this.closeOnCommit = "true".equalsIgnoreCase(closeOnCommit);
        }
        String persistOnCommit = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.PERSISTENCE_CONTEXT_PERSIST_ON_COMMIT, properties, this.serverSession, true);
        if (persistOnCommit != null) {
            this.persistOnCommit = "true".equalsIgnoreCase(persistOnCommit);
        }
		}
        String commitWithoutPersist = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.PERSISTENCE_CONTEXT_COMMIT_WITHOUT_PERSIST_RULES, properties, this.serverSession, true);
        if (commitWithoutPersist != null) {
            this.commitWithoutPersistRules = "true".equalsIgnoreCase(commitWithoutPersist);
        }
        String shouldValidateExistence = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.VALIDATE_EXISTENCE, properties, this.serverSession, true);
        if (shouldValidateExistence != null) {
            this.shouldValidateExistence = "true".equalsIgnoreCase(shouldValidateExistence);
        }
        String flushClearCache = PropertiesHandler.getPropertyValueLogDebug(EntityManagerProperties.FLUSH_CLEAR_CACHE, properties, this.serverSession, true);
        if (flushClearCache != null) {
            this.flushClearCache = flushClearCache;
        }
    }

    /**
     * Return default join existing transaction property, allows reading through
     * write connection.
     */
    public boolean getBeginEarlyTransaction() {
        return beginEarlyTransaction;
    }

    /**
     * Set default join existing transaction property, allows reading through
     * write connection.
     */
    public void setBeginEarlyTransaction(boolean beginEarlyTransaction) {
        this.beginEarlyTransaction = beginEarlyTransaction;
    }

    /**
     * Return default property, allows flush before query to be avoided.
     */
    public FlushModeType getFlushMode() {
        return flushMode;
    }

    /**
     * Set default property, allows flush before query to be avoided.
     */
    public void setFlushMode(FlushModeType flushMode) {
        this.flushMode = flushMode;
    }

    /**
     * Return default property, allows weak unit of work references.
     */
    public ReferenceMode getReferenceMode() {
        return referenceMode;
    }

    /**
     * Set default property, allows weak unit of work references.
     */
    public void setReferenceMode(ReferenceMode referenceMode) {
        this.referenceMode = referenceMode;
    }

    /**
     * Return default property to avoid resuming unit of work if going to be
     * closed on commit anyway.
     */
    public boolean getCloseOnCommit() {
        return closeOnCommit;
    }

    /**
     * Set default property to avoid resuming unit of work if going to be closed
     * on commit anyway.
     */
    public void setCloseOnCommit(boolean closeOnCommit) {
        this.closeOnCommit = closeOnCommit;
    }

    /**
     * Return default property to avoid discover new objects in unit of work if
     * application always uses persist.
     */
    public boolean getPersistOnCommit() {
        return persistOnCommit;
    }

    /**
     * Return interface providing access to utility methods for the persistence
     * unit.
     * 
     * @return PersistenceUnitUtil interface
     * @throws IllegalStateException
     *             if the entity manager factory has been closed.
     */
    public PersistenceUnitUtil getPersistenceUnitUtil() {
        return this;
    }

    /**
     * Set default property to avoid discover new objects in unit of work if
     * application always uses persist.
     */
    public void setPersistOnCommit(boolean persistOnCommit) {
        this.persistOnCommit = persistOnCommit;
    }

    /**
     * Return default property to avoid discover new objects in unit of work if
     * application always uses persist.
     */
    public boolean getCommitWithoutPersistRules() {
        return commitWithoutPersistRules;
    }

    /**
     * Set default property to avoid discover new objects in unit of work if
     * application always uses persist.
     */
    public void setCommitWithoutPersistRules(boolean commitWithoutPersistRules) {
        this.commitWithoutPersistRules = commitWithoutPersistRules;
    }

    /**
     * Return the default FlashClearCache mode to be used. Relevant only in case
     * call to flush method followed by call to clear method.
     * 
     * @see org.eclipse.persistence.config.FlushClearCache
     */
    public String getFlushClearCache() {
        return flushClearCache;
    }

    /**
     * Set the default FlashClearCache mode to be used. Relevant only in case
     * call to flush method followed by call to clear method.
     * 
     * @see org.eclipse.persistence.config.FlushClearCache
     */
    public void setFlushClearCache(String flushClearCache) {
        this.flushClearCache = flushClearCache;
    }

    /**
     * Return the default to determine if does-exist should be performed on
     * persist.
     */
    public boolean shouldValidateExistence() {
        return shouldValidateExistence;
    }

    /**
     * Set the default to determine if does-exist should be performed on
     * persist.
     */
    public void setShouldValidateExistence(boolean shouldValidateExistence) {
        this.shouldValidateExistence = shouldValidateExistence;
    }

    public Cache getCache() {
        verifyOpen();
        if (myCache == null) {
            ServerSession session = this.getServerSession();
            myCache = new CacheImpl(this, session.getIdentityMapAccessor());
        }
        return myCache;
    }

    /**
     * @see javax.persistence.EntityManagerFactory#getProperties()
     * @since Java Persistence API 2.0
     */
    public Map<String, Object> getProperties() {
        if (!this.isOpen()) {
            throw new IllegalStateException(ExceptionLocalization.buildMessage("operation_on_closed_entity_manager_factory"));
        }
        return Collections.unmodifiableMap(EntityManagerFactoryProvider.mergeMaps(properties, this.getServerSession().getProperties()));
    }

    /**
     * @see javax.persistence.EntityManagerFactory#getCriteriaBuilder()
     * @since Java Persistence 2.0
     */
    public CriteriaBuilder getCriteriaBuilder() {
        return new CriteriaBuilderImpl(this.getMetamodel());
    }

    /**
     * Return an instance of Metamodel interface for access to the metamodel of
     * the persistence unit.
     * 
     * @return Metamodel instance
     * @throws IllegalStateException
     *             if the entity manager factory has been closed.
     * @see javax.persistence.EntityManagerFactory#getMetamodel()
     * @since Java Persistence 2.0
     */
    public Metamodel getMetamodel() {
        if (!this.isOpen()) {
            throw new IllegalStateException(ExceptionLocalization.buildMessage("operation_on_closed_entity_manager_factory"));
        }
        return this.setupImpl.getMetamodel();
    }

    /**
     * INTERNAL: Convenience function to allow us to reset the Metamodel in the
     * possible case that we want to regenerate it. This function is outside of
     * the JPA 2.0 specification.
     * 
     * @param aMetamodel
     * @since Java Persistence 2.0
     */
    public void setMetamodel(Metamodel aMetamodel) {
        if (!this.isOpen()) {
            throw new IllegalStateException(ExceptionLocalization.buildMessage("operation_on_closed_entity_manager_factory"));
        }
        this.setupImpl.setMetamodel(aMetamodel);
    }

    /**
     * Determine the load state of a given persistent attribute of an entity
     * belonging to the persistence unit.
     * 
     * @param entity
     *            containing the attribute
     * @param attributeName
     *            name of attribute whose load state is to be determined
     * @return false if entity's state has not been loaded or if the attribute
     *         state has not been loaded, otherwise true
     */
    public boolean isLoaded(Object entity, String attributeName) {
        if (EntityManagerFactoryImpl.isLoaded(entity, attributeName, serverSession).equals(Boolean.valueOf(true))) {
            return true;
        }
        return false;
    }

    /**
     * Determine the load state of an entity belonging to the persistence unit.
     * This method can be used to determine the load state of an entity passed
     * as a reference. An entity is considered loaded if all attributes for
     * which FetchType EAGER has been specified have been loaded. The
     * isLoaded(Object, String) method should be used to determine the load
     * state of an attribute. Not doing so might lead to unintended loading of
     * state.
     * 
     * @param entity
     *            whose load state is to be determined
     * @return false if the entity has not been loaded, else true.
     */
    public boolean isLoaded(Object entity) {
        if (EntityManagerFactoryImpl.isLoaded(entity, serverSession).equals(Boolean.valueOf(true))) {
            return true;
        }
        return false;
    }

    /**
     * Returns the id of the entity. A generated id is not guaranteed to be
     * available until after the database insert has occurred. Returns null if
     * the entity does not yet have an id
     * 
     * @param entity
     * @return id of the entity
     * @throws IllegalStateException
     *             if the entity is found not to be an entity.
     */
    public Object getIdentifier(Object entity) {
        return EntityManagerFactoryImpl.getIdentifier(entity, serverSession);
    }

    /**
     * Determine the load state of a given persistent attribute of an entity
     * belonging to the persistence unit.
     * 
     * @param entity
     *            containing the attribute
     * @param attributeName
     *            name of attribute whose load state is to be determined
     * @return false if entity's state has not been loaded or if the attribute
     *         state has not been loaded, otherwise true
     */
    public static Boolean isLoaded(Object entity, String attributeName, AbstractSession session) {
        ClassDescriptor descriptor = session.getDescriptor(entity);
        if (descriptor == null) {
            return null;
        }
        DatabaseMapping mapping = descriptor.getMappingForAttributeName(attributeName);
        if (mapping == null) {
            return null;
        }
        return isLoaded(entity, attributeName, mapping);
    }

    /**
     * Check whether a named attribute on a given entity with a given mapping
     * has been loaded.
     * 
     * This method will check the valueholder or indirect collection for LAZY
     * ForeignReferenceMappings to see if has been instantiated and otherwise
     * check the fetch group.
     * 
     * @param entity
     * @param attributeName
     * @param mapping
     * @return
     */
    public static boolean isLoaded(Object entity, String attributeName, DatabaseMapping mapping) {
        if (mapping.isForeignReferenceMapping()) {
            if (((ForeignReferenceMapping) mapping).isLazy()) {
                Object value = mapping.getAttributeValueFromObject(entity);
                IndirectionPolicy policy = ((ForeignReferenceMapping) mapping).getIndirectionPolicy();
                return policy.objectIsInstantiated(value);
            }
        }

        if (entity instanceof FetchGroupTracker) {
            return ((FetchGroupTracker) entity)._persistence_isAttributeFetched(attributeName);
        } else {
            return true;
        }
    }

    /**
     * Determine the load state of an entity belonging to the persistence unit.
     * This method can be used to determine the load state of an entity passed
     * as a reference. An entity is considered loaded if all attributes for
     * which FetchType EAGER has been specified have been loaded. The
     * isLoaded(Object, String) method should be used to determine the load
     * state of an attribute. Not doing so might lead to unintended loading of
     * state.
     * 
     * @param entity
     *            whose load state is to be determined
     * @return false if the entity has not been loaded, else true.
     */
    public static Boolean isLoaded(Object entity, AbstractSession session) {
        ClassDescriptor descriptor = session.getDescriptor(entity);
        if (descriptor == null) {
            return null;
        }
        List<DatabaseMapping> mappings = descriptor.getMappings();
        Iterator<DatabaseMapping> i = mappings.iterator();
        while (i.hasNext()) {
            DatabaseMapping mapping = i.next();
            if (!mapping.isLazy() && !isLoaded(entity, mapping.getAttributeName(), mapping)) {
                return false;
            }
        }
        return true;
    }

    /**
     * Returns the id of the entity. A generated id is not guaranteed to be
     * available until after the database insert has occurred. Returns null if
     * the entity does not yet have an id
     * 
     * @param entity
     * @return id of the entity
     * @throws IllegalStateException
     *             if the entity is found not to be an entity.
     */
    public static Object getIdentifier(Object entity, AbstractSession session) {
        ClassDescriptor descriptor = session.getDescriptor(entity);
        if (descriptor == null) {
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage("jpa_persistence_util_non_persistent_class ", new Object[] { entity }));
        }
        if (descriptor.getCMPPolicy() != null) {
            return descriptor.getCMPPolicy().createPrimaryKeyInstance(entity, session);
        } else {
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage("jpa_persistence_util_non_persistent_class ", new Object[] { entity }));
        }
    }





/*******************************************************************************
 * 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  = 1.0 - Initial contribution
 ******************************************************************************/
package org.eclipse.persistence.jpa;

import javax.persistence.Cache;

/**
 * Extends JPA Cache interface with additional EclipseLink API.
 * @author James Sutherland
 */
public interface JpaCache extends Cache {
    
    /**
     * ADVANCED:
     * Resets the entire Object cache, and the Query cache.
     * <p> NOTE: Be careful using this method. This method blows away both this session's and its parent's caches.
     * This includes the server cache or any other cache. This throws away any Objects that have been read in.
     * Extreme caution should be used before doing this because Object identity will no longer
     * be maintained for any Objects currently read in.  This should only be called
     * if the application knows that it no longer has references to Objects held in the cache.
     */
    void clear();
    
    /**
     * ADVANCED:
     * Resets the cache for only the instances of the given Class type.
     * For inheritance the user must make sure that they only use the root class,
     * clearing a subclass cache is not allowed (as they share their parents cache).
     * <p> NOTE: Caution must be used in doing this to ensure that the Objects within the cache
     * are not referenced from other Objects of other classes or from the application.
     */
    void clear(Class cls);

    /**
     * Clear all the query caches.
     */
    void clearQueryCache();

    /**
     * Clear the named query cache associated with the query name.
     */
    void clearQueryCache(String queryName);

    /**
     * Returns the remaining life of the given Object (in milliseconds).  This method is associated with use of
     * cache invalidation feature and returns the difference between the next expiry
     * time of the Object and its read time.  The method will return 0 for invalidated Objects.
     */
    long timeToLive(Object object);

    /**
     * Returns true if the Object with the same id and Class type of the
     * the given Object is valid in the cache.
     */
    boolean isValid(Object object);

    /**
     * Returns true if the Object with the id and Class type is valid in the cache.
     */
    boolean isValid(Class cls, Object id);

    /**
     * Used to print all the Objects in the cache.
     * The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
     */
    void print();

    /**
     * Used to print all the Objects in the cache of the Class type.
     * The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
     */
    void print(Class cls);

    /**
     * Used to print all the currently locked cache keys in the cache.
     * The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
     */
    void printLocks();

    /**
     * This can be used to help debugging an Object identity problem.
     * An Object identity problem is when an Object in the cache references an 
     * Object that is not in the cache. This method will validate that all cached 
     * Objects are in a correct state.
     */
    void validate();

    /**
     * Returns the Object from the cache map with the id 
     * and Class type.
     */
    Object getObject(Class cls, Object id);

    /**
     * ADVANCED:
     * Puts the given Object into the cache.
     * This is a very advanced method, and caution should be used in adding objects to the cache
     * as other objects may have relationships to previous object, or this object may have
     * relationships to other objects.
     */
    Object putObject(Object object);

    /**
     * ADVANCED:
     * Removes the Object from the cache.
     * <p> NOTE: Caution should be used when calling to avoid violating Object identity.
     * The application should only call this if its known that no references to the Object exist.
     */
    Object removeObject(Object object);

    /**
     * ADVANCED:
     * Removes the Object with the id and Class type from the cache.
     * <p> NOTE: Caution should be used when calling to avoid violating Object identity.
     * The application should only call this if its known that no references to the Object exist.
     */
    Object removeObject(Class cls, Object id);

    /**
     * Returns true if the cache contains an Object with the same id and Class type of the given object.
     */
    boolean contains(Object object);

    /**
     * Sets an Object to be invalid in the cache.
     */
    void evict(Object object);

    /**
     * Returns the object's Id.
     */
    Object getId(Object object);

}

Return to bug 301063

Lines 2619-2636 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/descriptors/ClassDescriptor.java (-23 / +17 lines)
2619	Vector mappings = getMappings();	2619	Vector mappings = getMappings();
2620	Object[] mappingsArray = new Object[mappings.size()];	2620	Object[] mappingsArray = new Object[mappings.size()];
2621	for (int index = 0; index < mappings.size(); index++) {	2621	for (int index = 0; index < mappings.size(); index++) {
2622	mappingsArray[index] = mappings.elementAt(index);	2622	mappingsArray[index] = mappings.get(index);
2623	}	2623	}
2624	Arrays.sort(mappingsArray, new MappingCompare());	2624	Arrays.sort(mappingsArray, new MappingCompare());
2625	mappings = NonSynchronizedVector.newInstance(mappingsArray.length);	2625	mappings = NonSynchronizedVector.newInstance(mappingsArray.length);
2626	for (int index = 0; index < mappingsArray.length; index++) {	2626	for (int index = 0; index < mappingsArray.length; index++) {
2627	mappings.addElement(mappingsArray[index]);	2627	mappings.add(mappingsArray[index]);
2628	}	2628	}
2629	setMappings(mappings);	2629	setMappings(mappings);
2630	}	2630	}
2631		2631
2632	for (Enumeration mappingsEnum = getMappings().elements(); mappingsEnum.hasMoreElements();) {	2632	for (DatabaseMapping mapping : getMappings()) {
2633	DatabaseMapping mapping = (DatabaseMapping)mappingsEnum.nextElement();
2634	validateMappingType(mapping);	2633	validateMappingType(mapping);
2635	mapping.initialize(session);	2634	mapping.initialize(session);
2636	if (mapping.isLockableMapping()){	2635	if (mapping.isLockableMapping()){
Lines 2650-2663 Link Here
2650		2649
2651	// JPA 2.0 Derived identities - build a map of derived id mappings.	2650	// JPA 2.0 Derived identities - build a map of derived id mappings.
2652	if (mapping.derivesId()) {	2651	if (mapping.derivesId()) {
2653	derivesIdMappings.put(mapping.getAttributeName(), mapping);	2652	this.derivesIdMappings.put(mapping.getAttributeName(), mapping);
2654	}	2653	}
2655		2654
2656	// Add all the fields in the mapping to myself.	2655	// Add all the fields in the mapping to myself.
2657	Helper.addAllUniqueToVector(getFields(), mapping.getFields());	2656	Helper.addAllUniqueToVector(getFields(), mapping.getFields());
2658	}	2657	}
2659		2658
2660	if(hasMappingsPostCalculateChangesOnDeleted()) {	2659	if (hasMappingsPostCalculateChangesOnDeleted()) {
2661	session.getProject().setHasMappingsPostCalculateChangesOnDeleted(true);	2660	session.getProject().setHasMappingsPostCalculateChangesOnDeleted(true);
2662	}	2661	}
2663		2662
Lines 2682-2696 Link Here
2682	if (hasInheritance()) {	2681	if (hasInheritance()) {
2683	getInheritancePolicy().initialize(session);	2682	getInheritancePolicy().initialize(session);
2684	if (getInheritancePolicy().isChildDescriptor()) {	2683	if (getInheritancePolicy().isChildDescriptor()) {
2685	for (Iterator iterator = getInheritancePolicy().getParentDescriptor().getMappings().iterator();	2684	for (DatabaseMapping mapping : getInheritancePolicy().getParentDescriptor().getMappings()) {
2686	iterator.hasNext();) {
2687	DatabaseMapping mapping = (DatabaseMapping)iterator.next();
2688	if (mapping.isAggregateObjectMapping() \|\| ((mapping.isForeignReferenceMapping() && (!mapping.isDirectCollectionMapping())) && (!((ForeignReferenceMapping)mapping).usesIndirection()))) {	2685	if (mapping.isAggregateObjectMapping() \|\| ((mapping.isForeignReferenceMapping() && (!mapping.isDirectCollectionMapping())) && (!((ForeignReferenceMapping)mapping).usesIndirection()))) {
2689	getLockableMappings().add(mapping);// add those mappings from the parent.	2686	getLockableMappings().add(mapping);// add those mappings from the parent.
2690	}	2687	}
2691	// JPA 2.0 Derived identities - build a map of derived id mappings.	2688	// JPA 2.0 Derived identities - build a map of derived id mappings.
2692	if (mapping.derivesId()) {	2689	if (mapping.derivesId()) {
2693	derivesIdMappings.put(mapping.getAttributeName(), mapping);	2690	this.derivesIdMappings.put(mapping.getAttributeName(), mapping);
2694	}	2691	}
2695	}	2692	}
2696	}	2693	}
Lines 2705-2716 Link Here
2705	Vector mappings = getMappings();	2702	Vector mappings = getMappings();
2706	Object[] mappingsArray = new Object[mappings.size()];	2703	Object[] mappingsArray = new Object[mappings.size()];
2707	for (int index = 0; index < mappings.size(); index++) {	2704	for (int index = 0; index < mappings.size(); index++) {
2708	mappingsArray[index] = mappings.elementAt(index);	2705	mappingsArray[index] = mappings.get(index);
2709	}	2706	}
2710	Arrays.sort(mappingsArray, new MappingCompare());	2707	Arrays.sort(mappingsArray, new MappingCompare());
2711	mappings = NonSynchronizedVector.newInstance(mappingsArray.length);	2708	mappings = NonSynchronizedVector.newInstance(mappingsArray.length);
2712	for (int index = 0; index < mappingsArray.length; index++) {	2709	for (int index = 0; index < mappingsArray.length; index++) {
2713	mappings.addElement(mappingsArray[index]);	2710	mappings.add(mappingsArray[index]);
2714	}	2711	}
2715	setMappings(mappings);	2712	setMappings(mappings);
2716	}	2713	}
Lines 3238-3244 Link Here
3238	field.setIndex(index);	3235	field.setIndex(index);
3239	}	3236	}
3240	// Set cache key type.	3237	// Set cache key type.
3241	if (getCacheKeyType() == null) {	3238	if (getCacheKeyType() == null \|\| (getCacheKeyType() == CacheKeyType.AUTO)) {
3242	if ((getPrimaryKeyFields().size() > 1) \|\| getObjectBuilder().isXMLObjectBuilder()) {	3239	if ((getPrimaryKeyFields().size() > 1) \|\| getObjectBuilder().isXMLObjectBuilder()) {
3243	setCacheKeyType(CacheKeyType.CACHE_ID);	3240	setCacheKeyType(CacheKeyType.CACHE_ID);
3244	} else if (getPrimaryKeyFields().size() == 1) {	3241	} else if (getPrimaryKeyFields().size() == 1) {
Lines 3251-3256 Link Here
3251	} else {	3248	} else {
3252	setCacheKeyType(CacheKeyType.CACHE_ID);	3249	setCacheKeyType(CacheKeyType.CACHE_ID);
3253	}	3250	}
		3251	} else if ((getCacheKeyType() == CacheKeyType.ID_VALUE) && (getPrimaryKeyFields().size() > 1)) {
		3252	session.getIntegrityChecker().handleError(DescriptorException.cannotUseIdValueForCompositeId(this));
3254	}	3253	}
3255	getObjectBuilder().postInitialize(session);	3254	getObjectBuilder().postInitialize(session);
3256		3255
Lines 5255-5262 Link Here
5255	*/	5254	*/
5256	protected void validateAfterInitialization(AbstractSession session) {	5255	protected void validateAfterInitialization(AbstractSession session) {
5257	selfValidationAfterInitialization(session);	5256	selfValidationAfterInitialization(session);
5258	for (Enumeration mappings = getMappings().elements(); mappings.hasMoreElements();) {	5257	for (DatabaseMapping mapping : getMappings()) {
5259	((DatabaseMapping)mappings.nextElement()).validateAfterInitialization(session);	5258	mapping.validateAfterInitialization(session);
5260	}	5259	}
5261	}	5260	}
5262		5261
Lines 5266-5273 Link Here
5266	*/	5265	*/
5267	protected void validateBeforeInitialization(AbstractSession session) {	5266	protected void validateBeforeInitialization(AbstractSession session) {
5268	selfValidationBeforeInitialization(session);	5267	selfValidationBeforeInitialization(session);
5269	for (Enumeration mappings = getMappings().elements(); mappings.hasMoreElements();) {	5268	for (DatabaseMapping mapping : getMappings()) {
5270	((DatabaseMapping)mappings.nextElement()).validateBeforeInitialization(session);	5269	mapping.validateBeforeInitialization(session);
5271	}	5270	}
5272	}	5271	}
5273		5272
Lines 5276-5292 Link Here
5276	* Check that the qualifier on the table names are properly set.	5275	* Check that the qualifier on the table names are properly set.
5277	*/	5276	*/
5278	protected void verifyTableQualifiers(Platform platform) {	5277	protected void verifyTableQualifiers(Platform platform) {
5279	DatabaseTable table;
5280	Enumeration tableEnumeration;
5281	String tableQualifier = platform.getTableQualifier();	5278	String tableQualifier = platform.getTableQualifier();
5282
5283	if (tableQualifier.length() == 0) {	5279	if (tableQualifier.length() == 0) {
5284	return;	5280	return;
5285	}	5281	}
5286		5282
5287	tableEnumeration = getTables().elements();	5283	for (DatabaseTable table : getTables()) {
5288	while (tableEnumeration.hasMoreElements()) {
5289	table = (DatabaseTable)tableEnumeration.nextElement();
5290	if (table.getTableQualifier().length() == 0) {	5284	if (table.getTableQualifier().length() == 0) {
5291	table.setTableQualifier(tableQualifier);	5285	table.setTableQualifier(tableQualifier);
5292	}	5286	}

Lines 511-517 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/IdentityMapAccessor.java (-7 / +17 lines)
511	if (descriptor == null) {	511	if (descriptor == null) {
512	throw ValidationException.missingDescriptor(theClass.toString());	512	throw ValidationException.missingDescriptor(theClass.toString());
513	}	513	}
514	return this.getIdentityMap(descriptor);	514	return getIdentityMap(descriptor);
515	}	515	}
516		516
517	/**	517	/**
Lines 519-534 Link Here
519	* Get the identity map for the given class from the IdentityMapManager	519	* Get the identity map for the given class from the IdentityMapManager
520	*/	520	*/
521	public IdentityMap getIdentityMap(ClassDescriptor descriptor) {	521	public IdentityMap getIdentityMap(ClassDescriptor descriptor) {
522	return getIdentityMapManager().getIdentityMap(descriptor);	522	return getIdentityMap(descriptor, false);
523	}	523	}
524		524
525	/**	525	/**
526	* INTERNAL:	526	* INTERNAL:
		527	* Get the identity map for the given class from the IdentityMapManager
		528	*/
		529	public IdentityMap getIdentityMap(ClassDescriptor descriptor, boolean returnNullIfMissing) {
		530	return getIdentityMapManager().getIdentityMap(descriptor, returnNullIfMissing);
		531	}
		532
		533	/**
		534	* INTERNAL:
527	* Get the cached results associated with a query. Results are cached by the	535	* Get the cached results associated with a query. Results are cached by the
528	* values of the parameters to the query so different parameters will have	536	* values of the parameters to the query so different parameters will have
529	* different cached results.	537	* different cached results.
530	*/	538	*/
531	public Object getQueryResult(ReadQuery query, Vector parameters, boolean checkExpiry) {	539	public Object getQueryResult(ReadQuery query, List parameters, boolean checkExpiry) {
532	return getIdentityMapManager().getQueryResult(query, parameters, checkExpiry);	540	return getIdentityMapManager().getQueryResult(query, parameters, checkExpiry);
533	}	541	}
534		542
Lines 1003-1009 Link Here
1003	* Query results are cached based on the parameter values provided to the query	1011	* Query results are cached based on the parameter values provided to the query
1004	* different parameter values access different caches.	1012	* different parameter values access different caches.
1005	*/	1013	*/
1006	public void putQueryResult(ReadQuery query, Vector parameters, Object results) {	1014	public void putQueryResult(ReadQuery query, List parameters, Object results) {
1007	getIdentityMapManager().putQueryResult(query, parameters, results);	1015	getIdentityMapManager().putQueryResult(query, parameters, results);
1008	}	1016	}
1009		1017
Lines 1131-1139 Link Here
1131	Iterator descriptors = getSession().getDescriptors().values().iterator();	1139	Iterator descriptors = getSession().getDescriptors().values().iterator();
1132	while (descriptors.hasNext()) {	1140	while (descriptors.hasNext()) {
1133	ClassDescriptor descriptor = (ClassDescriptor)descriptors.next();	1141	ClassDescriptor descriptor = (ClassDescriptor)descriptors.next();
1134	for (Enumeration mapEnum = getIdentityMap(descriptor).elements();	1142	IdentityMap cache = getIdentityMap(descriptor, true);
1135	mapEnum.hasMoreElements();) {	1143	if (cache != null) {
1136	iterator.startIterationOn(mapEnum.nextElement());	1144	for (Enumeration mapEnum = cache.elements(); mapEnum.hasMoreElements();) {
		1145	iterator.startIterationOn(mapEnum.nextElement());
		1146	}
1137	}	1147	}
1138	}	1148	}
1139	}	1149	}

Lines 289-299 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/sessions/IsolatedClientSessionIdentityMapAccessor.java (-5 / +5 lines)
289	* Get the identity map for the given class from the IdentityMapManager	289	* Get the identity map for the given class from the IdentityMapManager
290	*/	290	*/
291	@Override	291	@Override
292	public IdentityMap getIdentityMap(ClassDescriptor descriptor) {	292	public IdentityMap getIdentityMap(ClassDescriptor descriptor, boolean returnNullIfMissing) {
293	if (descriptor.isIsolated()) {	293	if (descriptor.isIsolated()) {
294	return getIdentityMapManager().getIdentityMap(descriptor);	294	return getIdentityMapManager().getIdentityMap(descriptor, returnNullIfMissing);
295	} else {	295	} else {
296	return ((IsolatedClientSession)session).getParent().getIdentityMapAccessorInstance().getIdentityMap(descriptor);	296	return ((IsolatedClientSession)session).getParent().getIdentityMapAccessorInstance().getIdentityMap(descriptor, returnNullIfMissing);
297	}	297	}
298	}	298	}
299		299
Lines 304-310 Link Here
304	* different cached results.	304	* different cached results.
305	*/	305	*/
306	@Override	306	@Override
307	public Object getQueryResult(ReadQuery query, Vector parameters, boolean checkExpiry) {	307	public Object getQueryResult(ReadQuery query, List parameters, boolean checkExpiry) {
308	if (((IsolatedClientSession)session).isIsolatedQuery(query)) {	308	if (((IsolatedClientSession)session).isIsolatedQuery(query)) {
309	return getIdentityMapManager().getQueryResult(query, parameters, checkExpiry);	309	return getIdentityMapManager().getQueryResult(query, parameters, checkExpiry);
310	} else {	310	} else {
Lines 412-418 Link Here
412	* different parameter values access different caches.	412	* different parameter values access different caches.
413	*/	413	*/
414	@Override	414	@Override
415	public void putQueryResult(ReadQuery query, Vector parameters, Object results) {	415	public void putQueryResult(ReadQuery query, List parameters, Object results) {
416	if (((IsolatedClientSession)session).isIsolatedQuery(query)) {	416	if (((IsolatedClientSession)session).isIsolatedQuery(query)) {
417	getIdentityMapManager().putQueryResult(query, parameters, results);	417	getIdentityMapManager().putQueryResult(query, parameters, results);
418	} else {	418	} else {

Lines 444-461 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadAllQuery.java (-8 / +13 lines)
444	protected Object executeObjectLevelReadQuery() throws DatabaseException {	444	protected Object executeObjectLevelReadQuery() throws DatabaseException {
445	Object result = null;	445	Object result = null;
446		446
447	if (getContainerPolicy().overridesRead()) {	447	if (this.containerPolicy.overridesRead()) {
448	return getContainerPolicy().execute();	448	return this.containerPolicy.execute();
449	}	449	}
450		450
451	if (this.descriptor.isDescriptorForInterface()) {	451	if (this.descriptor.isDescriptorForInterface()) {
452	Object returnValue = this.descriptor.getInterfacePolicy().selectAllObjectsUsingMultipleTableSubclassRead(this);	452	Object returnValue = this.descriptor.getInterfacePolicy().selectAllObjectsUsingMultipleTableSubclassRead(this);
453	setExecutionTime(System.currentTimeMillis());	453	this.executionTime = System.currentTimeMillis();
454	return returnValue;	454	return returnValue;
455	}	455	}
456		456
457	List rows = getQueryMechanism().selectAllRows();	457	List rows = getQueryMechanism().selectAllRows();
458	setExecutionTime(System.currentTimeMillis());	458	this.executionTime = System.currentTimeMillis();
459		459
460	// If using 1-m joins, must set all rows.	460	// If using 1-m joins, must set all rows.
461	if (hasJoining() && this.joinedAttributeManager.isToManyJoin()) {	461	if (hasJoining() && this.joinedAttributeManager.isToManyJoin()) {
Lines 465-471 Link Here
465	if (this.session.isUnitOfWork()) {	465	if (this.session.isUnitOfWork()) {
466	result = registerResultInUnitOfWork(rows, (UnitOfWorkImpl)this.session, this.translationRow, true);//	466	result = registerResultInUnitOfWork(rows, (UnitOfWorkImpl)this.session, this.translationRow, true);//
467	} else {	467	} else {
468	result = getContainerPolicy().containerInstance(rows.size());	468	result = this.containerPolicy.containerInstance(rows.size());
469	this.descriptor.getObjectBuilder().buildObjectsInto(this, rows, result);	469	this.descriptor.getObjectBuilder().buildObjectsInto(this, rows, result);
470	}	470	}
471		471
Lines 473-485 Link Here
473	ComplexQueryResult complexResult = new ComplexQueryResult();	473	ComplexQueryResult complexResult = new ComplexQueryResult();
474	complexResult.setResult(result);	474	complexResult.setResult(result);
475	complexResult.setData(rows);	475	complexResult.setData(rows);
476	return complexResult;	476	result = complexResult;
477	}	477	}
478		478
479	// Add the other (already registered) results and return them.	479	// Add the other (already registered) results and return them.
480	if (getDescriptor().hasTablePerClassPolicy()) {	480	if (this.descriptor.hasTablePerClassPolicy()) {
481	result = containerPolicy.concatenateContainers(result, getDescriptor().getTablePerClassPolicy().selectAllObjectsUsingMultipleTableSubclassRead(this));	481	result = this.containerPolicy.concatenateContainers(result, this.descriptor.getTablePerClassPolicy().selectAllObjectsUsingMultipleTableSubclassRead(this));
482	}	482	}
		483
		484	// If the results were empty, then ensure they get cached still.
		485	if (shouldCacheQueryResults() && this.containerPolicy.isEmpty(result)) {
		486	this.temporaryCachedQueryResults = InvalidObject.instance();
		487	}
483		488
484	return result;	489	return result;
485	}	490	}

Lines 230-235 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/exceptions/DescriptorException.java (-1 / +11 lines)
230	public final static int MULTIPLE_TARGET_FOREIGN_KEY_TABLES = 213;	230	public final static int MULTIPLE_TARGET_FOREIGN_KEY_TABLES = 213;
231	public final static int ONE_TO_ONE_MAPPING_CONFLICT = 214;	231	public final static int ONE_TO_ONE_MAPPING_CONFLICT = 214;
232	public final static int NO_RELATION_TABLE_MECHANISM = 215;	232	public final static int NO_RELATION_TABLE_MECHANISM = 215;
		233	public final static int CANNOT_USE_ID_VALUE_FOR_COMPOSITE_ID = 216;
233		234
234	/**	235	/**
235	* INTERNAL:	236	* INTERNAL:
Lines 1993-2003 Link Here
1993	}	1994	}
1994		1995
1995	public static DescriptorException noRelationTableMechanism(DatabaseMapping mapping) {	1996	public static DescriptorException noRelationTableMechanism(DatabaseMapping mapping) {
1996	Object[] args = { };	1997	Object[] args = { mapping };
1997		1998
1998	DescriptorException descriptorException = new DescriptorException(ExceptionMessageGenerator.buildMessage(DescriptorException.class, NO_RELATION_TABLE_MECHANISM, args), mapping);	1999	DescriptorException descriptorException = new DescriptorException(ExceptionMessageGenerator.buildMessage(DescriptorException.class, NO_RELATION_TABLE_MECHANISM, args), mapping);
1999	descriptorException.setErrorCode(NO_RELATION_TABLE_MECHANISM);	2000	descriptorException.setErrorCode(NO_RELATION_TABLE_MECHANISM);
2000	return descriptorException;	2001	return descriptorException;
2001	}	2002	}
2002		2003
		2004
		2005	public static DescriptorException cannotUseIdValueForCompositeId(ClassDescriptor descriptor) {
		2006	Object[] args = { };
		2007
		2008	DescriptorException descriptorException = new DescriptorException(ExceptionMessageGenerator.buildMessage(DescriptorException.class, CANNOT_USE_ID_VALUE_FOR_COMPOSITE_ID, args), descriptor);
		2009	descriptorException.setErrorCode(CANNOT_USE_ID_VALUE_FOR_COMPOSITE_ID);
		2010	return descriptorException;
		2011	}
		2012
2003	}	2013	}

Lines 105-116 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ObjectLevelReadQuery.java (-14 lines)
105	*/	105	*/
106	protected int inMemoryQueryIndirectionPolicy;	106	protected int inMemoryQueryIndirectionPolicy;
107		107
108	/**
109	* Used to set the read time on objects that use this query.
110	* Should be set to the time the query returned from the database.
111	*/
112	protected long executionTime = 0;
113
114	/** Allow for a query level fetch group to be set. */	108	/** Allow for a query level fetch group to be set. */
115	protected FetchGroup fetchGroup;	109	protected FetchGroup fetchGroup;
116		110
Lines 2118-2131 Link Here
2118	}	2112	}
2119		2113
2120	/**	2114	/**
2121	* INTERNAL:
2122	* Set the the time this query went to the database.
2123	*/
2124	public void setExecutionTime(long executionTime) {
2125	this.executionTime = executionTime;
2126	}
2127
2128	/**
2129	* PUBLIC:	2115	* PUBLIC:
2130	* Set the example object of the query to be the newExampleObject.	2116	* Set the example object of the query to be the newExampleObject.
2131	* The example object is used for Query By Example.	2117	* The example object is used for Query By Example.

Lines 156-167 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/queries/ReadObjectQuery.java (-5 / +9 lines)
156	* It will cause the original to be cached in the query results if the query	156	* It will cause the original to be cached in the query results if the query
157	* is set to do so.	157	* is set to do so.
158	*/	158	*/
159	public void cacheResult(Object unwrappedOriginal) {	159	public void cacheResult(Object object) {
160	Object cachableObject = unwrappedOriginal;	160	Object cachableObject = object;
161	if (shouldUseWrapperPolicy()){	161	if (object == null) {
162	cachableObject = getSession().wrapObject(unwrappedOriginal);	162	this.temporaryCachedQueryResults = InvalidObject.instance();
		163	} else {
		164	if (this.shouldUseWrapperPolicy) {
		165	cachableObject = this.session.wrapObject(object);
		166	}
		167	this.temporaryCachedQueryResults = cachableObject;
163	}	168	}
164	setTemporaryCachedQueryResults(cachableObject);
165	}	169	}
166		170
167		171

Lines 115-128 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/advanced/Employee.java (-3 / +10 lines)
115	query="SELECT e FROM Employee e",	115	query="SELECT e FROM Employee e",
116	hints={	116	hints={
117	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE, value="true"),	117	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE, value="true"),
118	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_TYPE, value="SOFT"),	118	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_TYPE, value="FULL"),
119	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_IGNORE_NULL, value="true"),	119	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_IGNORE_NULL, value="false"),
120	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_RANDOMIZE_EXPIRY, value="true"),	120	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_RANDOMIZE_EXPIRY, value="true"),
121	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_SIZE, value="200"),	121	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_SIZE, value="200"),
122	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_EXPIRY, value="5000")	122	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE_EXPIRY, value="50000")
123	}	123	}
124	),	124	),
125	@NamedQuery(	125	@NamedQuery(
		126	name="CachedNoEmployees",
		127	query="SELECT e FROM Employee e where 1 <> 1",
		128	hints={
		129	@QueryHint(name=QueryHints.QUERY_RESULTS_CACHE, value="true")
		130	}
		131	),
		132	@NamedQuery(
126	name="CachedTimeOfDayAllEmployees",	133	name="CachedTimeOfDayAllEmployees",
127	query="SELECT e FROM Employee e",	134	query="SELECT e FROM Employee e",
128	hints={	135	hints={

Lines 17-22 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/advanced/CacheImplJUnitTest.java (-21 / +38 lines)
17	import junit.framework.TestSuite;	17	import junit.framework.TestSuite;
18	import org.eclipse.persistence.testing.models.jpa.advanced.*;	18	import org.eclipse.persistence.testing.models.jpa.advanced.*;
19	import org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl;	19	import org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl;
		20	import org.eclipse.persistence.jpa.JpaCache;
20	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;	21	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
21		22
22	/**	23	/**
Lines 33-46 Link Here
33	super(name);	34	super(name);
34	}	35	}
35		36
36	public static void setUpClass() throws Exception {
37	}
38
39	public static void tearDownClass() throws Exception {
40	}
41
42	public void setUp() {	37	public void setUp() {
43
44	super.setUp();	38	super.setUp();
45	clearCache();	39	clearCache();
46	}	40	}
Lines 55-60 Link Here
55	suite.addTest(new CacheImplJUnitTest("testEvictClass"));	49	suite.addTest(new CacheImplJUnitTest("testEvictClass"));
56	suite.addTest(new CacheImplJUnitTest("testEvictAll"));	50	suite.addTest(new CacheImplJUnitTest("testEvictAll"));
57	suite.addTest(new CacheImplJUnitTest("testEvictContains"));	51	suite.addTest(new CacheImplJUnitTest("testEvictContains"));
		52	suite.addTest(new CacheImplJUnitTest("testCacheAPI"));
58		53
59	return suite;	54	return suite;
60	}	55	}
Lines 79-91 Link Here
79	em1.persist(e1);	74	em1.persist(e1);
80	commitTransaction(em1);	75	commitTransaction(em1);
81	closeEntityManager(em1);	76	closeEntityManager(em1);
82	try {	77	boolean result = getEntityManagerFactory("default1").getCache().contains(Employee.class, 101);
83	boolean result = getEntityManagerFactory("default1").getCache().contains(Employee.class, 101);	78	assertTrue("Employee not found in cache", result);
84	assertTrue("Assertion Error",result);
85	} catch (Exception e) {
86	e.printStackTrace();
87	}
88	}	79	}
		80
		81	/**
		82	* Test cache API.
		83	*/
		84	public void testCacheAPI() {
		85	EntityManager em = createEntityManager("default1");
		86	beginTransaction(em);
		87	Employee employee = new Employee();
		88	employee.setFirstName("testCacheAPI");
		89	em.persist(employee);
		90	commitTransaction(em);
		91	closeEntityManager(em);
		92	JpaCache cache = (JpaCache)getEntityManagerFactory("default1").getCache();
		93	assertTrue("Employee not valid in cache", cache.isValid(employee));
		94	assertTrue("Employee not valid in cache", cache.isValid(Employee.class, employee.getId()));
		95	cache.timeToLive(employee);
		96	assertTrue("Employee not found in cache", cache.getObject(Employee.class, employee.getId()) != null);
		97	assertTrue("Employee not found in cache", cache.contains(employee));
		98	cache.evict(employee);
		99	cache.putObject(employee);
		100	cache.removeObject(employee);
		101	cache.removeObject(Employee.class, employee.getId());
		102	cache.clear();
		103	cache.clear(Employee.class);
		104	cache.clearQueryCache();
		105	cache.clearQueryCache("findAllEmployeesByIdAndFirstName");
		106	assertTrue("Employee id not correct", employee.getId().equals(cache.getId(employee)));
		107	cache.print();
		108	cache.print(Employee.class);
		109	cache.printLocks();
		110	cache.validate();
		111	}
89		112
90	/**	113	/**
91	* Test of evict method, of class CacheImpl.	114	* Test of evict method, of class CacheImpl.
Lines 111-118 Link Here
111	Employee e3 = em4.find(Employee.class, 121);	134	Employee e3 = em4.find(Employee.class, 121);
112	afterCache = e3.getFirstName();	135	afterCache = e3.getFirstName();
113	assertNotSame("Assertion Error", beforeCache, afterCache);	136	assertNotSame("Assertion Error", beforeCache, afterCache);
114	} catch (Exception e) {
115	e.printStackTrace();
116	} finally {	137	} finally {
117	closeEntityManager(em3);	138	closeEntityManager(em3);
118	closeEntityManager(em4);	139	closeEntityManager(em4);
Lines 141-148 Link Here
141	Employee e5 = em7.find(Employee.class, 131);	162	Employee e5 = em7.find(Employee.class, 131);
142	String actual = e5.getFirstName();	163	String actual = e5.getFirstName();
143	assertNotSame("Assertion Error", expected, actual);	164	assertNotSame("Assertion Error", expected, actual);
144	} catch (Exception e) {
145	e.printStackTrace();
146	} finally {	165	} finally {
147	closeEntityManager(em6);	166	closeEntityManager(em6);
148	closeEntityManager(em7);	167	closeEntityManager(em7);
Lines 180-187 Link Here
180	String actualDept = d2.getName();	199	String actualDept = d2.getName();
181	assertEquals("Assertion Error", expectedEmp, actualEmp);	200	assertEquals("Assertion Error", expectedEmp, actualEmp);
182	assertEquals("Assertion Error", expectedDept, actualDept);	201	assertEquals("Assertion Error", expectedDept, actualDept);
183	} catch (Exception e) {
184	e.printStackTrace();
185	} finally {	202	} finally {
186	closeEntityManager(em9);	203	closeEntityManager(em9);
187	}	204	}
Lines 196-202 Link Here
196	em.persist(emp);	213	em.persist(emp);
197	commitTransaction(em);	214	commitTransaction(em);
198		215
199	try{	216	try {
200	assertTrue(em.getEntityManagerFactory().getCache().contains(Employee.class, emp.getId()));	217	assertTrue(em.getEntityManagerFactory().getCache().contains(Employee.class, emp.getId()));
201		218
202	em.clear();	219	em.clear();
Lines 206-212 Link Here
206	em.getEntityManagerFactory().getCache().evict(Employee.class, emp.getId());	223	em.getEntityManagerFactory().getCache().evict(Employee.class, emp.getId());
207	assertFalse(em.getEntityManagerFactory().getCache().contains(Employee.class, emp.getId()));	224	assertFalse(em.getEntityManagerFactory().getCache().contains(Employee.class, emp.getId()));
208	} finally {	225	} finally {
209	this.closeEntityManager(em);	226	closeEntityManager(em);
210	}	227	}
211		228
212	}	229	}

Lines 26-32 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/jpql/AdvancedQueryTestSuite.java (-8 / +32 lines)
26	import javax.persistence.EntityManager;	26	import javax.persistence.EntityManager;
27	import javax.persistence.RollbackException;	27	import javax.persistence.RollbackException;
28		28
29	import junit.framework.Assert;
30	import junit.framework.Test;	29	import junit.framework.Test;
31	import junit.framework.TestSuite;	30	import junit.framework.TestSuite;
32		31
Lines 39-44 Link Here
39	import org.eclipse.persistence.descriptors.invalidation.DailyCacheInvalidationPolicy;	38	import org.eclipse.persistence.descriptors.invalidation.DailyCacheInvalidationPolicy;
40	import org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy;	39	import org.eclipse.persistence.descriptors.invalidation.TimeToLiveCacheInvalidationPolicy;
41	import org.eclipse.persistence.internal.sessions.AbstractSession;	40	import org.eclipse.persistence.internal.sessions.AbstractSession;
		41	import org.eclipse.persistence.jpa.JpaCache;
42	import org.eclipse.persistence.jpa.JpaQuery;	42	import org.eclipse.persistence.jpa.JpaQuery;
43	import org.eclipse.persistence.queries.Cursor;	43	import org.eclipse.persistence.queries.Cursor;
44	import org.eclipse.persistence.queries.ReadQuery;	44	import org.eclipse.persistence.queries.ReadQuery;
Lines 49-54 Link Here
49	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;	49	import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
50	import org.eclipse.persistence.testing.framework.QuerySQLTracker;	50	import org.eclipse.persistence.testing.framework.QuerySQLTracker;
51	import org.eclipse.persistence.testing.models.jpa.advanced.Employee;	51	import org.eclipse.persistence.testing.models.jpa.advanced.Employee;
		52	import org.eclipse.persistence.testing.models.jpa.advanced.Address;
52	import org.eclipse.persistence.testing.models.jpa.advanced.EmployeePopulator;	53	import org.eclipse.persistence.testing.models.jpa.advanced.EmployeePopulator;
53	import org.eclipse.persistence.testing.models.jpa.advanced.AdvancedTableCreator;	54	import org.eclipse.persistence.testing.models.jpa.advanced.AdvancedTableCreator;
54		55
Lines 745-751 Link Here
745	if (!(readQuery.getQueryResultsCachePolicy().getCacheInvalidationPolicy() instanceof TimeToLiveCacheInvalidationPolicy)) {	746	if (!(readQuery.getQueryResultsCachePolicy().getCacheInvalidationPolicy() instanceof TimeToLiveCacheInvalidationPolicy)) {
746	fail("Query cache invalidation not set.");	747	fail("Query cache invalidation not set.");
747	}	748	}
748	if (((TimeToLiveCacheInvalidationPolicy)readQuery.getQueryResultsCachePolicy().getCacheInvalidationPolicy()).getTimeToLive() != 5000) {	749	if (((TimeToLiveCacheInvalidationPolicy)readQuery.getQueryResultsCachePolicy().getCacheInvalidationPolicy()).getTimeToLive() != 50000) {
749	fail("Query cache invalidation time not set.");	750	fail("Query cache invalidation time not set.");
750	}	751	}
751		752
Lines 772-779 Link Here
772	// Query by primary key.	773	// Query by primary key.
773	Query query = em.createNamedQuery("CachedAllEmployees");	774	Query query = em.createNamedQuery("CachedAllEmployees");
774	if (result.size() != query.getResultList().size()) {	775	if (result.size() != query.getResultList().size()) {
		776	fail("List result size is not correct on 2nd cached query.");
		777	}
		778	if (counter.getSqlStatements().size() > 0) {
		779	fail("Query cache was not used: " + counter.getSqlStatements());
		780	}
		781	((JpaCache)getEntityManagerFactory().getCache()).clearQueryCache();
		782	// Preload uow to test query cache in uow.
		783	em.createQuery("Select e from Employee e").getResultList();
		784	query.getResultList();
		785	if (result.size() != query.getResultList().size()) {
		786	fail("List result size is not correct on cached query in unit of work.");
		787	}
		788	((JpaCache)getEntityManagerFactory().getCache()).clearQueryCache();
		789	// Also test query cache in early transaction.
		790	em.persist(new Address());
		791	em.flush();
		792	query.getResultList();
		793	if (result.size() != query.getResultList().size()) {
		794	fail("List result size is not correct on cached query in transaction.");
		795	}
		796	// Query by primary key.
		797	query = em.createNamedQuery("CachedNoEmployees");
		798	if (!query.getResultList().isEmpty()) {
775	fail("List result size is not correct.");	799	fail("List result size is not correct.");
776	}	800	}
		801	// Also test empty query cache.
		802	counter.remove();
		803	counter = new QuerySQLTracker(getServerSession());
		804	if (!query.getResultList().isEmpty()) {
		805	fail("List result size is not correct.");
		806	}
777	if (counter.getSqlStatements().size() > 0) {	807	if (counter.getSqlStatements().size() > 0) {
778	fail("Query cache was not used: " + counter.getSqlStatements());	808	fail("Query cache was not used: " + counter.getSqlStatements());
779	}	809	}
Lines 1310-1317 Link Here
1310	}	1340	}
1311		1341
1312	public void testLockWithSecondaryTable() {	1342	public void testLockWithSecondaryTable() {
1313	ServerSession session = JUnitTestCase.getServerSession();
1314
1315	// Cannot create parallel entity managers in the server.	1343	// Cannot create parallel entity managers in the server.
1316	if (! isOnServer() && isSelectForUpateSupported()) {	1344	if (! isOnServer() && isSelectForUpateSupported()) {
1317	EntityManager em = createEntityManager();	1345	EntityManager em = createEntityManager();
Lines 1361-1368 Link Here
1361	}	1389	}
1362		1390
1363	public void testVersionChangeWithReadLock() {	1391	public void testVersionChangeWithReadLock() {
1364	ServerSession session = JUnitTestCase.getServerSession();
1365
1366	// It's a JPA2.0 feature.	1392	// It's a JPA2.0 feature.
1367	if (! isJPA10() && isSelectForUpateNoWaitSupported()){	1393	if (! isJPA10() && isSelectForUpateNoWaitSupported()){
1368	Employee employee = null;	1394	Employee employee = null;
Lines 1440-1447 Link Here
1440	}	1466	}
1441		1467
1442	public void testVersionChangeWithWriteLock() {	1468	public void testVersionChangeWithWriteLock() {
1443	ServerSession session = JUnitTestCase.getServerSession();
1444
1445	// It's a JPA2.0 feature	1469	// It's a JPA2.0 feature
1446	if (! isJPA10() && isSelectForUpateNoWaitSupported()) {	1470	if (! isJPA10() && isSelectForUpateNoWaitSupported()) {
1447	Employee employee = null;	1471	Employee employee = null;

Line 0 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/jpa/JpaCache.java (+144 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 = 1.0 - Initial contribution
		12	******************************************************************************/
		13	package org.eclipse.persistence.jpa;
		14
		15	import javax.persistence.Cache;
		16
		17	/**
		18	* Extends JPA Cache interface with additional EclipseLink API.
		19	* @author James Sutherland
		20	*/
		21	public interface JpaCache extends Cache {
		22
		23	/**
		24	* ADVANCED:
		25	* Resets the entire Object cache, and the Query cache.
		26	* <p> NOTE: Be careful using this method. This method blows away both this session's and its parent's caches.
		27	* This includes the server cache or any other cache. This throws away any Objects that have been read in.
		28	* Extreme caution should be used before doing this because Object identity will no longer
		29	* be maintained for any Objects currently read in. This should only be called
		30	* if the application knows that it no longer has references to Objects held in the cache.
		31	*/
		32	void clear();
		33
		34	/**
		35	* ADVANCED:
		36	* Resets the cache for only the instances of the given Class type.
		37	* For inheritance the user must make sure that they only use the root class,
		38	* clearing a subclass cache is not allowed (as they share their parents cache).
		39	* <p> NOTE: Caution must be used in doing this to ensure that the Objects within the cache
		40	* are not referenced from other Objects of other classes or from the application.
		41	*/
		42	void clear(Class cls);
		43
		44	/**
		45	* Clear all the query caches.
		46	*/
		47	void clearQueryCache();
		48
		49	/**
		50	* Clear the named query cache associated with the query name.
		51	*/
		52	void clearQueryCache(String queryName);
		53
		54	/**
		55	* Returns the remaining life of the given Object (in milliseconds). This method is associated with use of
		56	* cache invalidation feature and returns the difference between the next expiry
		57	* time of the Object and its read time. The method will return 0 for invalidated Objects.
		58	*/
		59	long timeToLive(Object object);
		60
		61	/**
		62	* Returns true if the Object with the same id and Class type of the
		63	* the given Object is valid in the cache.
		64	*/
65	boolean isValid(Object object);
66
67	/**
68	* Returns true if the Object with the id and Class type is valid in the cache.
69	*/
70	boolean isValid(Class cls, Object id);
71
72	/**
73	* Used to print all the Objects in the cache.
74	* The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
75	*/
76	void print();
77
78	/**
79	* Used to print all the Objects in the cache of the Class type.
80	* The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
81	*/
82	void print(Class cls);
83
84	/**
85	* Used to print all the currently locked cache keys in the cache.
86	* The output of this method will be logged to this persistence unit's SessionLog at SEVERE level.
87	*/
88	void printLocks();
89
90	/**
91	* This can be used to help debugging an Object identity problem.
92	* An Object identity problem is when an Object in the cache references an
93	* Object that is not in the cache. This method will validate that all cached
94	* Objects are in a correct state.
95	*/
96	void validate();
97
98	/**
99	* Returns the Object from the cache map with the id
100	* and Class type.
101	*/
102	Object getObject(Class cls, Object id);
103
104	/**
105	* ADVANCED:
106	* Puts the given Object into the cache.
107	* This is a very advanced method, and caution should be used in adding objects to the cache
108	* as other objects may have relationships to previous object, or this object may have
109	* relationships to other objects.
110	*/
111	Object putObject(Object object);
112
113	/**
114	* ADVANCED:
115	* Removes the Object from the cache.
116	* <p> NOTE: Caution should be used when calling to avoid violating Object identity.
117	* The application should only call this if its known that no references to the Object exist.
118	*/
119	Object removeObject(Object object);
120
121	/**
122	* ADVANCED:
123	* Removes the Object with the id and Class type from the cache.
124	* <p> NOTE: Caution should be used when calling to avoid violating Object identity.
125	* The application should only call this if its known that no references to the Object exist.
126	*/
127	Object removeObject(Class cls, Object id);
128
129	/**
130	* Returns true if the cache contains an Object with the same id and Class type of the given object.
131	*/
132	boolean contains(Object object);
133
134	/**
135	* Sets an Object to be invalid in the cache.
136	*/
137	void evict(Object object);
138
139	/**
140	* Returns the object's Id.
141	*/
142	Object getId(Object object);
143
144	}