/**
 * Try to initialize a collection from the cache
 *
 * @param id The id of the collection to initialize
 * @param persister The collection persister
 * @param collection The collection to initialize
 * @param source The originating session
 *
 * @return true if we were able to initialize the collection from the cache;
 *         false otherwise.
 */
private boolean initializeCollectionFromCache(
		Serializable id,
		CollectionPersister persister,
		PersistentCollection collection,
		SessionImplementor source) {

	if ( source.getLoadQueryInfluencers().hasEnabledFilters() && persister.isAffectedByEnabledFilters( source ) ) {
		LOG.trace( "Disregarding cached version (if any) of collection due to enabled filters" );
		return false;
	}

	final boolean useCache = persister.hasCache() && source.getCacheMode().isGetEnabled();

	if ( !useCache ) {
		return false;
	}

	final SessionFactoryImplementor factory = source.getFactory();
	final CollectionDataAccess cacheAccessStrategy = persister.getCacheAccessStrategy();
	final Object ck = cacheAccessStrategy.generateCacheKey( id, persister, factory, source.getTenantIdentifier() );
	final Object ce = CacheHelper.fromSharedCache( source, ck, cacheAccessStrategy );

	final StatisticsImplementor statistics = factory.getStatistics();
	if ( statistics.isStatisticsEnabled() ) {
		if ( ce == null ) {
			statistics.collectionCacheMiss( persister.getNavigableRole(), cacheAccessStrategy.getRegion().getName() );
		}
		else {
			statistics.collectionCacheHit( persister.getNavigableRole(), cacheAccessStrategy.getRegion().getName() );
		}
	}

	if ( ce == null ) {
		return false;
	}

	CollectionCacheEntry cacheEntry = (CollectionCacheEntry) persister.getCacheEntryStructure().destructure( ce, factory );

	final PersistenceContext persistenceContext = source.getPersistenceContextInternal();
	cacheEntry.assemble( collection, persister, persistenceContext.getCollectionOwner( id, persister ) );
	persistenceContext.getCollectionEntry( collection ).postInitialize( collection );
	return true;
}
 

/**
 * Add the collection to the second-level cache
 *
 * @param lce The entry representing the collection to add
 * @param persister The persister
 */
private void addCollectionToCache(LoadingCollectionEntry lce, CollectionPersister persister) {
	final SharedSessionContractImplementor session = getLoadContext().getPersistenceContext().getSession();
	final SessionFactoryImplementor factory = session.getFactory();

	final boolean debugEnabled = LOG.isDebugEnabled();
	if ( debugEnabled ) {
		LOG.debugf( "Caching collection: %s", MessageHelper.collectionInfoString( persister, lce.getCollection(), lce.getKey(), session ) );
	}

	if ( !session.getLoadQueryInfluencers().getEnabledFilters().isEmpty() && persister.isAffectedByEnabledFilters( session ) ) {
		// some filters affecting the collection are enabled on the session, so do not do the put into the cache.
		if ( debugEnabled ) {
			LOG.debug( "Refusing to add to cache due to enabled filters" );
		}
		// todo : add the notion of enabled filters to the cache key to differentiate filtered collections from non-filtered;
		//      DefaultInitializeCollectionEventHandler.initializeCollectionFromCache() (which makes sure to not read from
		//      cache with enabled filters).
		// EARLY EXIT!!!!!
		return;
	}

	final Object version;
	if ( persister.isVersioned() ) {
		Object collectionOwner = getLoadContext().getPersistenceContext().getCollectionOwner( lce.getKey(), persister );
		if ( collectionOwner == null ) {
			// generally speaking this would be caused by the collection key being defined by a property-ref, thus
			// the collection key and the owner key would not match up.  In this case, try to use the key of the
			// owner instance associated with the collection itself, if one.  If the collection does already know
			// about its owner, that owner should be the same instance as associated with the PC, but we do the
			// resolution against the PC anyway just to be safe since the lookup should not be costly.
			if ( lce.getCollection() != null ) {
				final Object linkedOwner = lce.getCollection().getOwner();
				if ( linkedOwner != null ) {
					final Serializable ownerKey = persister.getOwnerEntityPersister().getIdentifier( linkedOwner, session );
					collectionOwner = getLoadContext().getPersistenceContext().getCollectionOwner( ownerKey, persister );
				}
			}
			if ( collectionOwner == null ) {
				throw new HibernateException(
						"Unable to resolve owner of loading collection [" +
								MessageHelper.collectionInfoString( persister, lce.getCollection(), lce.getKey(), session ) +
								"] for second level caching"
				);
			}
		}
		version = getLoadContext().getPersistenceContext().getEntry( collectionOwner ).getVersion();
	}
	else {
		version = null;
	}

	final CollectionCacheEntry entry = new CollectionCacheEntry( lce.getCollection(), persister );
	final CollectionDataAccess cacheAccess = persister.getCacheAccessStrategy();
	final Object cacheKey = cacheAccess.generateCacheKey(
			lce.getKey(),
			persister,
			session.getFactory(),
			session.getTenantIdentifier()
	);

	boolean isPutFromLoad = true;
	if ( persister.getElementType().isAssociationType() ) {
		for ( Serializable id : entry.getState() ) {
			EntityPersister entityPersister = ( (QueryableCollection) persister ).getElementPersister();
			if ( session.getPersistenceContext().wasInsertedDuringTransaction( entityPersister, id ) ) {
				isPutFromLoad = false;
				break;
			}
		}
	}

	// CollectionRegionAccessStrategy has no update, so avoid putting uncommitted data via putFromLoad
	if (isPutFromLoad) {
		try {
			session.getEventListenerManager().cachePutStart();
			final boolean put = cacheAccess.putFromLoad(
					session,
					cacheKey,
					persister.getCacheEntryStructure().structure( entry ),
					version,
					factory.getSessionFactoryOptions().isMinimalPutsEnabled() && session.getCacheMode()!= CacheMode.REFRESH
			);

			if ( put && factory.getStatistics().isStatisticsEnabled() ) {
				factory.getStatistics().collectionCachePut(
						persister.getNavigableRole(),
						persister.getCacheAccessStrategy().getRegion().getName()
				);
			}
		}
		finally {
			session.getEventListenerManager().cachePutEnd();
		}
	}
}
 

/**
 * Try to initialize a collection from the cache
 *
 * @param id The id of the collection of initialize
 * @param persister The collection persister
 * @param collection The collection to initialize
 * @param source The originating session
 *
 * @return true if we were able to initialize the collection from the cache;
 *         false otherwise.
 */
private boolean initializeCollectionFromCache(
		Serializable id,
		CollectionPersister persister,
		PersistentCollection collection,
		SessionImplementor source) {

	if ( !source.getLoadQueryInfluencers().getEnabledFilters().isEmpty()
			&& persister.isAffectedByEnabledFilters( source ) ) {
		LOG.trace( "Disregarding cached version (if any) of collection due to enabled filters" );
		return false;
	}

	final boolean useCache = persister.hasCache() && source.getCacheMode().isGetEnabled();

	if ( !useCache ) {
		return false;
	}

	final SessionFactoryImplementor factory = source.getFactory();
	final CollectionDataAccess cacheAccessStrategy = persister.getCacheAccessStrategy();
	final Object ck = cacheAccessStrategy.generateCacheKey( id, persister, factory, source.getTenantIdentifier() );
	final Object ce = CacheHelper.fromSharedCache( source, ck, persister.getCacheAccessStrategy() );

	if ( factory.getStatistics().isStatisticsEnabled() ) {
		if ( ce == null ) {
			factory.getStatistics().collectionCacheMiss(
					persister.getNavigableRole(),
					cacheAccessStrategy.getRegion().getName()
			);
		}
		else {
			factory.getStatistics().collectionCacheHit(
					persister.getNavigableRole(),
					cacheAccessStrategy.getRegion().getName()
			);
		}
	}

	if ( ce == null ) {
		return false;
	}

	CollectionCacheEntry cacheEntry = (CollectionCacheEntry) persister.getCacheEntryStructure().destructure(
			ce,
			factory
	);

	final PersistenceContext persistenceContext = source.getPersistenceContext();
	cacheEntry.assemble( collection, persister, persistenceContext.getCollectionOwner( id, persister ) );
	persistenceContext.getCollectionEntry( collection ).postInitialize( collection );
	// addInitializedCollection(collection, persister, id);
	return true;
}