/** * INTERNAL: Check if existence can be determined without going to the database. Note that custom * query check is not require for does exist as the custom is always used. Used by unit of work, * and will return null if checkDatabaseIfInvalid is set and the cachekey is invalidated */ public Object checkEarlyReturn( Object object, Vector primaryKey, AbstractSession session, AbstractRecord translationRow) { // For bug 3136413/2610803 building the selection criteria from an EJBQL string or // an example object is done just in time. buildSelectionCriteria(session); // Return false on null since it can't exist. Little more done in case PK not set in the query if (object == null) { return Boolean.FALSE; } ClassDescriptor descriptor = session.getDescriptor(object.getClass()); if (primaryKey == null) { primaryKey = getPrimaryKey(); if (primaryKey == null) { primaryKey = descriptor.getObjectBuilder().extractPrimaryKeyFromObject(object, session, true); } } if ((primaryKey == null) || (primaryKey.contains(null))) { return Boolean.FALSE; } // Need to do the cache check first if flag set or if we should check the cache only for // existence. if ((shouldCheckCacheForDoesExist() || this.checkCacheFirst) && !descriptor.isDescriptorForInterface()) { // If this is a UOW and modification queries have been executed, the cache cannot be trusted. if (this.checkDatabaseIfInvalid && (session.isUnitOfWork() && ((UnitOfWorkImpl) session).shouldReadFromDB())) { return null; } CacheKey cacheKey; Class objectClass = object.getClass(); AbstractSession tempSession = session; while (tempSession.isUnitOfWork()) { // could be nested lets check all UOWs cacheKey = tempSession .getIdentityMapAccessorInstance() .getCacheKeyForObjectForLock(primaryKey, objectClass, descriptor); if (cacheKey != null) { // If in the UOW cache it can't be invalid. return Boolean.TRUE; } tempSession = ((UnitOfWorkImpl) tempSession).getParent(); } // Did not find it registered in UOW so check main cache and check for invalidation. cacheKey = tempSession .getIdentityMapAccessorInstance() .getCacheKeyForObject(primaryKey, objectClass, descriptor); if ((cacheKey != null)) { // Assume that if there is a cachekey, object exists. if (this.checkDatabaseIfInvalid) { checkDescriptor(object, session); if (this.descriptor .getCacheInvalidationPolicy() .isInvalidated(cacheKey, System.currentTimeMillis())) { return null; } } Object objectFromCache = cacheKey.getObject(); if ((session.isUnitOfWork()) && ((UnitOfWorkImpl) session).wasDeleted(objectFromCache)) { if (shouldCheckCacheForDoesExist()) { return Boolean.FALSE; } } else { return Boolean.TRUE; } } else if (shouldCheckCacheForDoesExist()) { // We know its not in cache, and a checkcache policy so return false. return Boolean.FALSE; } } // Check if we have to assume that the object does not exist. if (shouldAssumeNonExistenceForDoesExist()) { return Boolean.FALSE; } // Check to see if we only need to check that the object contains a primary key. if (shouldAssumeExistenceForDoesExist()) { return Boolean.TRUE; } return null; }