HHH-12282 - Allow disabling of invalidation of second-level cache ent…

…ries for multi-table entities

hibernate-core/src/main/java/org/hibernate/boot/internal/SessionFactoryOptionsBuilder.java

@@ -1212,6 +1212,14 @@ public void enableJpaClosedCompliance(boolean enabled) {
 		this.jpaCompliance.setClosedCompliance( enabled );
 	}
 
+	public void enableJpaProxyCompliance(boolean enabled) {
+		this.jpaCompliance.setProxyCompliance( enabled );
+	}
+
+	public void enableJpaCachingCompliance(boolean enabled) {
+		this.jpaCompliance.setCachingCompliance( enabled );
+	}
+
 	public void markAsJpaBootstrap() {
 		this.jpaBootstrap = true;
 	}

hibernate-core/src/main/java/org/hibernate/cfg/AvailableSettings.java

@@ -1834,6 +1834,12 @@ public interface AvailableSettings extends org.hibernate.jpa.AvailableSettings {
 	 */
 	String JPA_PROXY_COMPLIANCE = "hibernate.jpa.compliance.proxy";
 
+	/**
+	 * @see JpaCompliance#isJpaCacheComplianceEnabled()
+	 * @since 5.3
+	 */
+	String JPA_CACHING_COMPLIANCE = "hibernate.jpa.compliance.caching";
+
 	/**
 	 * True/False setting indicating if the value stored in the table used by the {@link javax.persistence.TableGenerator}
 	 * is the last value generated or the next value to be used.

hibernate-core/src/main/java/org/hibernate/jpa/JpaCompliance.java

@@ -77,4 +77,16 @@ public interface JpaCompliance {
 	 * @return {@code true} indicates to behave in the spec-defined way
 	 */
 	boolean isJpaProxyComplianceEnabled();
+
+	/**
+	 * Should Hibernate comply with all aspects of caching as defined by JPA?  Or can
+	 * it deviate to perform things it believes will be "better"?
+	 *
+	 * @implNote Effects include marking all secondary tables as non-optional.  The reason
+	 * being that optional secondary tables can lead to entity cache being invalidated rather
+	 * than updated.
+	 *
+	 * @return {@code true} says to act the spec-defined way.
+	 */
+	boolean isJpaCacheComplianceEnabled();
 }

hibernate-core/src/main/java/org/hibernate/jpa/spi/JpaComplianceImpl.java

@@ -21,6 +21,7 @@ public class JpaComplianceImpl implements JpaCompliance {
 	private boolean listCompliance;
 	private boolean closedCompliance;
 	private boolean proxyCompliance;
+	private boolean cachingCompliance;
 
 
 	@SuppressWarnings("ConstantConditions")
@@ -52,6 +53,11 @@ public JpaComplianceImpl(Map configurationSettings, boolean jpaByDefault) {
 				configurationSettings,
 				jpaByDefault
 		);
+		cachingCompliance = ConfigurationHelper.getBoolean(
+				AvailableSettings.JPA_CACHING_COMPLIANCE,
+				configurationSettings,
+				jpaByDefault
+		);
 	}
 
 	@Override
@@ -79,6 +85,11 @@ public boolean isJpaProxyComplianceEnabled() {
 		return proxyCompliance;
 	}
 
+	@Override
+	public boolean isJpaCacheComplianceEnabled() {
+		return cachingCompliance;
+	}
+
 	// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 	// Mutators
 
@@ -97,4 +108,12 @@ public void setListCompliance(boolean listCompliance) {
 	public void setClosedCompliance(boolean closedCompliance) {
 		this.closedCompliance = closedCompliance;
 	}
+
+	public void setProxyCompliance(boolean proxyCompliance) {
+		this.proxyCompliance = proxyCompliance;
+	}
+
+	public void setCachingCompliance(boolean cachingCompliance) {
+		this.cachingCompliance = cachingCompliance;
+	}
 }

hibernate-core/src/main/java/org/hibernate/persister/entity/AbstractEntityPersister.java

@@ -95,6 +95,7 @@
 import org.hibernate.mapping.Column;
 import org.hibernate.mapping.Component;
 import org.hibernate.mapping.Formula;
+import org.hibernate.mapping.Join;
 import org.hibernate.mapping.PersistentClass;
 import org.hibernate.mapping.Property;
 import org.hibernate.mapping.Selectable;
@@ -152,6 +153,7 @@ public abstract class AbstractEntityPersister
 	private final SessionFactoryImplementor factory;
 	private final boolean canReadFromCache;
 	private final boolean canWriteToCache;
+	private final boolean invalidateCache;
 	private final EntityRegionAccessStrategy cacheAccessStrategy;
 	private final NaturalIdRegionAccessStrategy naturalIdRegionAccessStrategy;
 	private final boolean isLazyPropertiesCacheable;
@@ -845,6 +847,50 @@ public AbstractEntityPersister(
 
 		this.cacheEntryHelper = buildCacheEntryHelper();
 
+		if ( creationContext.getSessionFactory().getSessionFactoryOptions().isSecondLevelCacheEnabled() ) {
+			this.invalidateCache = canWriteToCache && determineWhetherToInvalidateCache( persistentClass, creationContext );
+		}
+		else {
+			this.invalidateCache = false;
+		}
+
+	}
+
+	@SuppressWarnings("RedundantIfStatement")
+	private boolean determineWhetherToInvalidateCache(
+			PersistentClass persistentClass,
+			PersisterCreationContext creationContext) {
+		if ( hasFormulaProperties() ) {
+			return true;
+		}
+
+		if ( isVersioned() ) {
+			return false;
+		}
+
+		if ( entityMetamodel.isDynamicUpdate() ) {
+			return false;
+		}
+
+		// We need to check whether the user may have circumvented this logic (JPA TCK)
+		final boolean complianceEnabled = creationContext.getSessionFactory()
+				.getSessionFactoryOptions()
+				.getJpaCompliance()
+				.isJpaCacheComplianceEnabled();
+		if ( complianceEnabled ) {
+			// The JPA TCK (inadvertently, but still...) requires that we cache
+			// entities with secondary tables even though Hibernate historically
+			// invalidated them
+			return false;
+		}
+
+		if ( persistentClass.getJoinClosureSpan() >= 1 ) {
+			// todo : this should really consider optionality of the secondary tables in count
+			//		non-optional tables do not cause this bypass
+			return true;
+		}
+
+		return false;
 	}
 
 	@SuppressWarnings("unchecked")
@@ -1273,8 +1319,7 @@ protected boolean[] getSubclassFormulaLazyiness() {
 	 * item.
 	 */
 	public boolean isCacheInvalidationRequired() {
-		return hasFormulaProperties() ||
-				( !isVersioned() && ( entityMetamodel.isDynamicUpdate() || getTableSpan() > 1 ) );
+		return invalidateCache;
 	}
 
 	public boolean isLazyPropertiesCacheable() {

hibernate-core/src/main/java/org/hibernate/persister/entity/JoinedSubclassEntityPersister.java

@@ -243,7 +243,12 @@ else if ( persistentClass.isDiscriminatorValueNotNull() ) {
 		while ( joinItr.hasNext() ) {
 			Join join = (Join) joinItr.next();
 
-			isNullableTable[tableIndex++] = join.isOptional();
+			isNullableTable[tableIndex++] = join.isOptional() ||
+					creationContext.getSessionFactory()
+							.getSessionFactoryOptions()
+							.getJpaCompliance()
+							.isJpaCacheComplianceEnabled();
+
 
 			Table table = join.getTable();
 			final String tableName = determineTableName( table, jdbcEnvironment );

hibernate-core/src/main/java/org/hibernate/persister/entity/SingleTableEntityPersister.java

@@ -178,7 +178,11 @@ public SingleTableEntityPersister(
 			Join join = (Join) joinIter.next();
 			qualifiedTableNames[j] = determineTableName( join.getTable(), jdbcEnvironment );
 			isInverseTable[j] = join.isInverse();
-			isNullableTable[j] = join.isOptional();
+			isNullableTable[j] = join.isOptional()
+					|| creationContext.getSessionFactory()
+							.getSessionFactoryOptions()
+							.getJpaCompliance()
+							.isJpaCacheComplianceEnabled();
 			cascadeDeleteEnabled[j] = join.getKey().isCascadeDeleteEnabled() &&
 					factory.getDialect().supportsCascadeDelete();
 
@@ -244,7 +248,12 @@ public SingleTableEntityPersister(
 			isConcretes.add( persistentClass.isClassOrSuperclassJoin( join ) );
 			isDeferreds.add( join.isSequentialSelect() );
 			isInverses.add( join.isInverse() );
-			isNullables.add( join.isOptional() );
+			isNullables.add(
+					join.isOptional() || creationContext.getSessionFactory()
+							.getSessionFactoryOptions()
+							.getJpaCompliance()
+							.isJpaCacheComplianceEnabled()
+			);
 			isLazies.add( lazyAvailable && join.isLazy() );
 			if ( join.isSequentialSelect() && !persistentClass.isClassOrSuperclassJoin( join ) ) {
 				hasDeferred = true;

hibernate-core/src/test/java/org/hibernate/jpa/JpaComplianceTestingImpl.java

@@ -43,6 +43,7 @@ public static JpaCompliance withClosedCompliance() {
 	private boolean listCompliance;
 	private boolean closedCompliance;
 	private boolean proxyCompliance;
+	private boolean cacheCompliance;
 
 	@Override
 	public boolean isJpaQueryComplianceEnabled() {
@@ -68,4 +69,9 @@ public boolean isJpaClosedComplianceEnabled() {
 	public boolean isJpaProxyComplianceEnabled() {
 		return proxyCompliance;
 	}
+
+	@Override
+	public boolean isJpaCacheComplianceEnabled() {
+		return cacheCompliance;
+	}
 }