clean up some obsolete code in EntityBinder

Author: gavinking

hibernate-core/src/main/java/org/hibernate/boot/model/internal/EntityBinder.java

@@ -89,6 +89,7 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 
 import static jakarta.persistence.InheritanceType.SINGLE_TABLE;
@@ -118,7 +119,6 @@
 import static org.hibernate.internal.CoreLogging.messageLogger;
 import static org.hibernate.internal.util.ReflectHelper.getDefaultSupplier;
 import static org.hibernate.internal.util.StringHelper.isBlank;
-import static org.hibernate.internal.util.StringHelper.isEmpty;
 import static org.hibernate.internal.util.StringHelper.isNotBlank;
 import static org.hibernate.internal.util.StringHelper.nullIfEmpty;
 import static org.hibernate.internal.util.StringHelper.unqualify;
@@ -143,8 +143,6 @@ public class EntityBinder {
 	private String name;
 	private ClassDetails annotatedClass;
 	private PersistentClass persistentClass;
-	private boolean lazy;
-	private ClassDetails proxyClass;
 	private String where;
 	// todo : we should defer to InFlightMetadataCollector.EntityTableXref for secondary table tracking;
 	//		atm we use both from here; HBM binding solely uses InFlightMetadataCollector.EntityTableXref
@@ -1259,9 +1257,8 @@ private void bindEntity() {
 		bindEntityAnnotation();
 		bindRowManagement();
 		bindOptimisticLocking();
-		bindProxy();
 		bindConcreteProxy();
-		bindWhere();
+		bindSqlRestriction();
 		bindCache();
 		bindNaturalIdCache();
 		bindFiltersInHierarchy();
@@ -1271,11 +1268,9 @@ private void bindEntity() {
 		persistentClass.setJpaEntityName( name );
 		persistentClass.setEntityName( annotatedClass.getName() );
 		persistentClass.setCached( isCached );
-		persistentClass.setLazy( lazy );
+		persistentClass.setLazy( true );
 		persistentClass.setQueryCacheLayout( queryCacheLayout );
-		if ( proxyClass != null && proxyClass != ClassDetails.VOID_CLASS_DETAILS ) {
-			persistentClass.setProxyInterfaceName( proxyClass.getName() );
-		}
+		persistentClass.setProxyInterfaceName( annotatedClass.getName() );
 
 		if ( persistentClass instanceof RootClass ) {
 			bindRootEntity();
@@ -1435,21 +1430,16 @@ private <A extends Annotation> A resolveCustomSqlAnnotation(
 				annotatedClass.getRepeatedAnnotationUsages( overrideAnnotation, modelsContext() );
 		if ( isNotEmpty( dialectOverrides ) ) {
 			final Dialect dialect = getMetadataCollector().getDatabase().getDialect();
-			for ( int i = 0; i < dialectOverrides.length; i++ ) {
+			for ( Annotation annotation : dialectOverrides ) {
 				//noinspection unchecked
-				final DialectOverrider<A> dialectOverride = (DialectOverrider<A>) dialectOverrides[i];
-				if ( !dialectOverride.matches( dialect ) ) {
-					continue;
-				}
-
-				final A override = dialectOverride.override();
-				if ( isBlank( tableName )
-						&& isEmpty( ( (CustomSqlDetails) override ).table() ) ) {
-					return override;
-				}
-				else if ( isNotBlank( tableName )
-						&& tableName.equals( ( (CustomSqlDetails) override ).table() ) ) {
-					return override;
+				final DialectOverrider<A> dialectOverride = (DialectOverrider<A>) annotation;
+				if ( dialectOverride.matches( dialect ) ) {
+					final A override = dialectOverride.override();
+					final String table = ((CustomSqlDetails) override).table();
+					if ( isBlank( tableName ) && isBlank( table )
+							|| Objects.equals( tableName, table ) ) {
+						return override;
+					}
 				}
 			}
 		}
@@ -1568,12 +1558,6 @@ private void bindDiscriminatorValue() {
 		}
 	}
 
-	private void bindProxy() {
-		//needed to allow association lazy loading.
-		lazy = true;
-		proxyClass = annotatedClass;
-	}
-
 	private void bindConcreteProxy() {
 		final ConcreteProxy annotationUsage =
 				annotatedClass.getAnnotationUsage( ConcreteProxy.class, modelsContext() );
@@ -1586,19 +1570,20 @@ private void bindConcreteProxy() {
 		}
 	}
 
-	private void bindWhere() {
-		final SQLRestriction restriction = extractSQLRestriction( annotatedClass, context );
+	private void bindSqlRestriction() {
+		final SQLRestriction restriction = extractSQLRestriction( annotatedClass );
 		if ( restriction != null ) {
-			this.where = restriction.value();
+			where = restriction.value();
 		}
 	}
 
-	private static SQLRestriction extractSQLRestriction(ClassDetails classDetails, MetadataBuildingContext context) {
-		final SourceModelBuildingContext modelsContext = context.getBootstrapContext().getModelsContext();
+	private SQLRestriction extractSQLRestriction(ClassDetails classDetails) {
+		final SourceModelBuildingContext modelsContext = modelsContext();
 		final SQLRestriction fromClass = getOverridableAnnotation( classDetails, SQLRestriction.class, context );
 		if ( fromClass != null ) {
 			return fromClass;
 		}
+		// as a special favor to users, we allow @SQLRestriction to be declared on a @MappedSuperclass
 		ClassDetails classToCheck = classDetails.getSuperClass();
 		while ( classToCheck != null
 				&& classToCheck.hasAnnotationUsage( jakarta.persistence.MappedSuperclass.class, modelsContext ) ) {

hibernate-core/src/main/java/org/hibernate/mapping/PersistentClass.java

@@ -220,10 +220,11 @@ public void addSubclass(Subclass subclass) throws MappingException {
 		while ( superclass != null ) {
 			if ( subclass.getEntityName().equals( superclass.getEntityName() ) ) {
 				throw new MappingException(
-						"Circular inheritance mapping detected: " +
-								subclass.getEntityName() +
-								" will have itself as superclass when extending " +
-								getEntityName()
+						"Circular inheritance mapping: '"
+							+ subclass.getEntityName()
+							+ "' will have itself as superclass when extending '"
+							+ getEntityName()
+							+ "'"
 				);
 			}
 			superclass = superclass.getSuperclass();