HHH-17504 Fixed IllegalArgumentException caused by setting AnnotationUsage attributes values to null (#219)

HHH-17504 - Ongoing JPA 32 work

hibernate-core/src/main/java/org/hibernate/boot/model/IdentifierGeneratorDefinition.java

@@ -27,6 +27,7 @@ import jakarta.persistence.TableGenerator;
 import static java.util.Collections.emptyMap;
 import static java.util.Collections.unmodifiableMap;
 import static org.hibernate.boot.models.JpaAnnotations.TABLE_GENERATOR;
+import static org.hibernate.boot.models.internal.AnnotationUsageHelper.applyStringAttributeIfSpecified;
 import static org.hibernate.internal.util.collections.CollectionHelper.isEmpty;
 
 /**
@@ -161,7 +162,7 @@ public class IdentifierGeneratorDefinition implements Serializable {
 				null,
 				null
 		);
-		sequenceGeneratorUsage.setAttributeValue( "name", name );
+		applyStringAttributeIfSpecified( "name", name, sequenceGeneratorUsage );
 		GenerationStrategyInterpreter.STRATEGY_INTERPRETER.interpretSequenceGenerator( sequenceGeneratorUsage, builder );
 		return builder.build();
 	}

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

@@ -22,6 +22,7 @@ import org.hibernate.boot.model.naming.Identifier;
 import org.hibernate.boot.model.naming.ImplicitBasicColumnNameSource;
 import org.hibernate.boot.model.source.spi.AttributePath;
 import org.hibernate.boot.models.JpaAnnotations;
+import org.hibernate.boot.models.internal.AnnotationUsageHelper;
 import org.hibernate.boot.spi.MetadataBuildingContext;
 import org.hibernate.internal.CoreLogging;
 import org.hibernate.internal.util.StringHelper;
@@ -490,18 +491,27 @@ public abstract class AbstractPropertyHolder implements PropertyHolder {
 					final String columnName = timeZoneColumn != null
 							? timeZoneColumn.getString( "name" )
 							: column.getString( "name" ) + "_tz";
-					created.setAttributeValue( "name", columnName );
+					AnnotationUsageHelper.applyStringAttributeIfSpecified( "name", columnName, created );
-					created.setAttributeValue( "nullable", column.getBoolean( "nullable" ) );
+					AnnotationUsageHelper.applyAttributeIfSpecified(
+							"nullable",
+							column.getBoolean( "nullable" ),
+							created
+					);
 
 					final AnnotationUsage<?> source = timeZoneColumn != null
 							? timeZoneColumn
 							: column;
-					created.setAttributeValue( "table", source.getAttributeValue( "table" ) );
+					AnnotationUsageHelper.applyStringAttributeIfSpecified( "table", source.getAttributeValue( "table" ), created );
-					created.setAttributeValue( "insertable", source.getAttributeValue( "insertable" ) );
+					AnnotationUsageHelper.applyAttributeIfSpecified( "insertable", source.getAttributeValue( "insertable" ), created );
-					created.setAttributeValue( "updatable", source.getAttributeValue( "updatable" ) );
+					AnnotationUsageHelper.applyAttributeIfSpecified( "updatable", source.getAttributeValue( "updatable" ), created );
 
 					if ( timeZoneColumn != null ) {
-						created.setAttributeValue( "columnDefinition", timeZoneColumn.getAttributeValue( "columnDefinition" ) );
+						AnnotationUsageHelper
+								.applyStringAttributeIfSpecified(
+										"columnDefinition",
+										timeZoneColumn.getAttributeValue( "columnDefinition" ),
+										created
+								);
 					}
 				},
 				context.getMetadataCollector().getSourceModelBuildingContext()
@@ -551,7 +561,7 @@ public abstract class AbstractPropertyHolder implements PropertyHolder {
 		return JpaAnnotations.COLUMN.createUsage(
 				element,
 				(created) -> {
-					created.setAttributeValue( "name", implicitName.getText() );
+					AnnotationUsageHelper.applyStringAttributeIfSpecified( "name", implicitName.getText(), created );
 					created.setAttributeValue( "precision", precision );
 				},
 				context.getMetadataCollector().getSourceModelBuildingContext()

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

@@ -23,7 +23,6 @@ import org.hibernate.models.spi.AnnotationDescriptor;
 import org.hibernate.models.spi.AnnotationDescriptorRegistry;
 import org.hibernate.models.spi.AnnotationUsage;
 import org.hibernate.models.spi.MemberDetails;
-import org.hibernate.models.spi.MutableAnnotationUsage;
 import org.hibernate.models.spi.SourceModelBuildingContext;
 
 import jakarta.persistence.CheckConstraint;
@@ -48,6 +47,7 @@ import static org.hibernate.boot.model.internal.AnnotatedColumn.buildFormulaFrom
 import static org.hibernate.boot.model.internal.BinderHelper.getOverridableAnnotation;
 import static org.hibernate.boot.model.internal.BinderHelper.getPath;
 import static org.hibernate.boot.model.internal.BinderHelper.getPropertyOverriddenByMapperOrMapsId;
+import static org.hibernate.boot.models.internal.AnnotationUsageHelper.applyAttributeIfSpecified;
 import static org.hibernate.internal.util.StringHelper.nullIfEmpty;
 
 /**
@@ -320,24 +320,36 @@ class ColumnsBuilder {
 		return joinColumnDescriptor.createUsage(
 				property,
 				(usage) -> {
-					transferAttribute( "name", pkJoinColumnAnn, usage );
+					applyAttributeIfSpecified(
-					transferAttribute( "referencedColumnName", pkJoinColumnAnn, usage );
+							"name",
-					transferAttribute( "columnDefinition", pkJoinColumnAnn, usage );
+							pkJoinColumnAnn.getAttributeValue( "name" ),
-					transferAttribute( "options", pkJoinColumnAnn, usage );
+							usage
-					transferAttribute( "foreignKey", pkJoinColumnAnn, usage );
+					);
+					applyAttributeIfSpecified(
+							"referencedColumnName",
+							pkJoinColumnAnn.getAttributeValue( "referencedColumnName" ),
+							usage
+					);
+					applyAttributeIfSpecified(
+							"columnDefinition",
+							pkJoinColumnAnn.getAttributeValue( "columnDefinition" ),
+							usage
+					);
+					applyAttributeIfSpecified(
+							"options",
+							pkJoinColumnAnn.getAttributeValue( "options" ),
+							usage
+					);
+					applyAttributeIfSpecified(
+							"foreignKey",
+							pkJoinColumnAnn.getAttributeValue( "foreignKey" ),
+							usage
+					);
 				},
 				hibernateModelsContext
 		);
 	}
 
-	@SuppressWarnings({ "rawtypes", "unchecked" })
-	private void transferAttribute(
-			String attributeName,
-			AnnotationUsage source,
-			MutableAnnotationUsage target) {
-		target.setAttributeValue( attributeName, source.getAttributeValue( attributeName ) );
-	}
-
 	/**
 	 * Useful to override a column either by {@code @MapsId} or by {@code @IdClass}
 	 */

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

@@ -159,6 +159,7 @@ import static org.hibernate.boot.model.internal.PropertyBinder.processElementAnn
 import static org.hibernate.boot.model.internal.PropertyHolderBuilder.buildPropertyHolder;
 import static org.hibernate.boot.model.internal.TableBinder.bindForeignKey;
 import static org.hibernate.boot.model.naming.Identifier.toIdentifier;
+import static org.hibernate.boot.models.internal.AnnotationUsageHelper.applyAttributeIfSpecified;
 import static org.hibernate.engine.OptimisticLockStyle.fromLockType;
 import static org.hibernate.engine.spi.ExecuteUpdateResultCheckStyle.fromResultCheckStyle;
 import static org.hibernate.internal.util.ReflectHelper.getDefaultSupplier;
@@ -1770,8 +1771,12 @@ public class EntityBinder {
 				classDetails,
 				context.getMetadataCollector().getSourceModelBuildingContext()
 		);
-		cacheUsage.setAttributeValue( "region", classDetails.getName() );
+		applyAttributeIfSpecified( "region", classDetails.getName(), cacheUsage );
-		cacheUsage.setAttributeValue( "usage", determineCacheConcurrencyStrategy( context ) );
+		applyAttributeIfSpecified(
+				"usage",
+				determineCacheConcurrencyStrategy( context ),
+				cacheUsage
+		);
 		return cacheUsage;
 	}
 

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

@@ -20,6 +20,10 @@ import jakarta.persistence.ForeignKey;
 import jakarta.persistence.JoinColumn;
 import jakarta.persistence.MapKeyJoinColumn;
 
+import static org.hibernate.boot.models.internal.AnnotationUsageHelper.applyAttributeIfSpecified;
+import static org.hibernate.boot.models.internal.AnnotationUsageHelper.applyStringAttributeIfSpecified;
+
+
 /**
  * @author Emmanuel Bernard
  */
@@ -44,16 +48,52 @@ public class MapKeyJoinColumnDelegator implements JoinColumn {
 				context.getMetadataCollector().getSourceModelBuildingContext()
 		);
 
-		joinColumn.setAttributeValue( "name", mapKeyJoinColumn.getAttributeValue( "name" ) );
+		applyStringAttributeIfSpecified(
-		joinColumn.setAttributeValue( "table", mapKeyJoinColumn.getAttributeValue( "table" ) );
+				"name",
-		joinColumn.setAttributeValue( "unique", mapKeyJoinColumn.getAttributeValue( "unique" ) );
+				mapKeyJoinColumn.getAttributeValue( "name" ),
-		joinColumn.setAttributeValue( "nullable", mapKeyJoinColumn.getAttributeValue( "nullable" ) );
+				joinColumn
-		joinColumn.setAttributeValue( "insertable", mapKeyJoinColumn.getAttributeValue( "insertable" ) );
+		);
-		joinColumn.setAttributeValue( "referencedColumnName", mapKeyJoinColumn.getAttributeValue( "referencedColumnName" ) );
+		applyStringAttributeIfSpecified(
-		joinColumn.setAttributeValue( "columnDefinition", mapKeyJoinColumn.getAttributeValue( "columnDefinition" ) );
+				"table",
-		joinColumn.setAttributeValue( "options", mapKeyJoinColumn.getAttributeValue( "options" ) );
+				mapKeyJoinColumn.getAttributeValue( "table" ),
+				joinColumn
+		);
+		applyAttributeIfSpecified(
+				"unique",
+				mapKeyJoinColumn.getAttributeValue( "unique" ),
+				joinColumn
+		);
+		applyAttributeIfSpecified(
+				"nullable",
+				mapKeyJoinColumn.getAttributeValue( "nullable" ),
+				joinColumn
+		);
+		applyAttributeIfSpecified(
+				"insertable",
+				mapKeyJoinColumn.getAttributeValue( "insertable" ),
+				joinColumn
+		);
+		applyStringAttributeIfSpecified(
+				"referencedColumnName",
+				mapKeyJoinColumn.getAttributeValue( "referencedColumnName" ),
+				joinColumn
+		);
+		applyStringAttributeIfSpecified(
+				"columnDefinition",
+				mapKeyJoinColumn.getAttributeValue( "columnDefinition" ),
+				joinColumn
+		);
+		applyStringAttributeIfSpecified(
+				"options",
+				mapKeyJoinColumn.getAttributeValue( "options" ),
+				joinColumn
+		);
 //		joinColumn.setAttributeValue( "comment", mapKeyJoinColumn.getAttributeValue( "comment" ) );
-		joinColumn.setAttributeValue( "foreignKey", mapKeyJoinColumn.getAttributeValue( "foreignKey" ) );
+		applyAttributeIfSpecified(
+				"foreignKey",
+				mapKeyJoinColumn.getAttributeValue( "foreignKey" ),
+				joinColumn
+		);
 
 		return joinColumn;
 	}

hibernate-core/src/main/java/org/hibernate/boot/models/categorize/internal/GlobalRegistrationsImpl.java

@@ -107,6 +107,8 @@ import static org.hibernate.boot.models.HibernateAnnotations.FILTER_DEF;
 import static org.hibernate.boot.models.HibernateAnnotations.JAVA_TYPE_REG;
 import static org.hibernate.boot.models.HibernateAnnotations.JDBC_TYPE_REG;
 import static org.hibernate.boot.models.HibernateAnnotations.TYPE_REG;
+import static org.hibernate.boot.models.internal.AnnotationUsageHelper.applyAttributeIfSpecified;
+import static org.hibernate.boot.models.internal.AnnotationUsageHelper.applyStringAttributeIfSpecified;
 import static org.hibernate.internal.util.collections.CollectionHelper.arrayList;
 import static org.hibernate.internal.util.collections.CollectionHelper.isEmpty;
 
@@ -638,12 +640,13 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 
 		sequenceGenerators.forEach( (generator) -> {
 			final MutableAnnotationUsage<SequenceGenerator> annotationUsage = makeAnnotation( JpaAnnotations.SEQUENCE_GENERATOR );
-			annotationUsage.setAttributeValue( "name", generator.getName() );
+			applyStringAttributeIfSpecified( "name", generator.getName(), annotationUsage );
-			annotationUsage.setAttributeValue( "sequenceName", generator.getSequenceName() );
+			applyStringAttributeIfSpecified( "sequenceName", generator.getSequenceName(), annotationUsage );
-			annotationUsage.setAttributeValue( "catalog", generator.getCatalog() );
+			applyStringAttributeIfSpecified( "catalog", generator.getCatalog(), annotationUsage );
-			annotationUsage.setAttributeValue( "schema", generator.getSchema() );
+			applyStringAttributeIfSpecified( "schema", generator.getSchema(), annotationUsage );
-			annotationUsage.setAttributeValue( "initialValue", generator.getInitialValue() );
+			applyAttributeIfSpecified( "initialValue", generator.getInitialValue(), annotationUsage );
-			annotationUsage.setAttributeValue( "allocationSize", generator.getAllocationSize() );
+			applyAttributeIfSpecified( "allocationSize", generator.getAllocationSize(), annotationUsage );
+			applyStringAttributeIfSpecified( "options", generator.getOptions(), annotationUsage );
 
 			collectSequenceGenerator( new SequenceGeneratorRegistration( generator.getName(), annotationUsage ) );
 		} );
@@ -676,15 +679,18 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 
 		tableGenerators.forEach( (generator) -> {
 			final MutableAnnotationUsage<TableGenerator> annotationUsage = makeAnnotation( JpaAnnotations.TABLE_GENERATOR );
-			annotationUsage.setAttributeValue( "name", generator.getName() );
+			applyStringAttributeIfSpecified( "name", generator.getName(), annotationUsage );
-			annotationUsage.setAttributeValue( "table", generator.getTable() );
+			applyStringAttributeIfSpecified( "table", generator.getTable(), annotationUsage );
-			annotationUsage.setAttributeValue( "catalog", generator.getCatalog() );
+			applyStringAttributeIfSpecified( "catalog", generator.getCatalog(), annotationUsage );
-			annotationUsage.setAttributeValue( "schema", generator.getSchema() );
+			applyStringAttributeIfSpecified( "schema", generator.getSchema(), annotationUsage );
-			annotationUsage.setAttributeValue( "pkColumnName", generator.getPkColumnName() );
+			applyStringAttributeIfSpecified( "pkColumnName", generator.getPkColumnName(), annotationUsage );
-			annotationUsage.setAttributeValue( "valueColumnName", generator.getValueColumnName() );
+			applyStringAttributeIfSpecified( "valueColumnName", generator.getValueColumnName(), annotationUsage );
-			annotationUsage.setAttributeValue( "pkColumnValue", generator.getPkColumnValue() );
+			applyStringAttributeIfSpecified( "pkColumnValue", generator.getPkColumnValue(), annotationUsage );
-			annotationUsage.setAttributeValue( "initialValue", generator.getInitialValue() );
+			applyAttributeIfSpecified( "initialValue", generator.getInitialValue(), annotationUsage );
-			annotationUsage.setAttributeValue( "allocationSize", generator.getAllocationSize() );
+			applyAttributeIfSpecified( "allocationSize", generator.getAllocationSize(), annotationUsage );
+			applyAttributeIfSpecified( "uniqueConstraints", generator.getUniqueConstraint(), annotationUsage );
+			applyAttributeIfSpecified( "indexes", generator.getIndex(), annotationUsage );
+			applyStringAttributeIfSpecified( "options", generator.getOptions(), annotationUsage );
 
 			collectTableGenerator( new TableGeneratorRegistration( generator.getName(), annotationUsage ) );
 		} );
@@ -713,11 +719,13 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 
 		genericGenerators.forEach( (generator) -> {
 			final MutableAnnotationUsage<GenericGenerator> annotationUsage = makeAnnotation( HibernateAnnotations.GENERIC_GENERATOR );
-			annotationUsage.setAttributeValue( "name", generator.getName() );
+			applyStringAttributeIfSpecified( "name", generator.getName(), annotationUsage );
-			annotationUsage.setAttributeValue( "strategy", generator.getClazz() );
+
+			applyStringAttributeIfSpecified( "strategy", generator.getClazz(), annotationUsage );
 
 			// todo : update the mapping.xsd to account for new @GenericGenerator definition
-
+			applyAttributeIfSpecified( "parameters", generator.getParameters(), annotationUsage );
+//			setValueIfNotNull( "type", generator.getType(), annotationUsage );
 			collectGenericGenerator( new GenericGeneratorRegistration( generator.getName(), annotationUsage ) );
 		} );
 	}
@@ -783,7 +791,7 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 
 		jaxbSqlResultSetMappings.forEach( (jaxbMapping) -> {
 			final MutableAnnotationUsage<SqlResultSetMapping> mappingAnnotation = JpaAnnotations.SQL_RESULT_SET_MAPPING.createUsage( null, null );
-			mappingAnnotation.setAttributeValue( "name", jaxbMapping.getName() );
+			applyStringAttributeIfSpecified( "name", jaxbMapping.getName(), mappingAnnotation );
 
 			sqlResultSetMappingRegistrations.put(
 					jaxbMapping.getName(),
@@ -792,17 +800,17 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 
 			applyEntityResults(
 					jaxbMapping.getEntityResult(),
-					(results) -> mappingAnnotation.setAttributeValue( "entities", results )
+					(results) -> applyAttributeIfSpecified( "entities", results, mappingAnnotation )
 			);
 
 			applyConstructorResults(
 					jaxbMapping.getConstructorResult(),
-					(results) -> mappingAnnotation.setAttributeValue( "classes", results )
+					(results) -> applyAttributeIfSpecified( "classes", results, mappingAnnotation )
 			);
 
 			applyColumnResults(
 					jaxbMapping.getColumnResult(),
-					(columnResults) -> mappingAnnotation.setAttributeValue( "columns", columnResults )
+					(columnResults) -> applyAttributeIfSpecified( "columns", columnResults, mappingAnnotation )
 			);
 		} );
 	}
@@ -820,18 +828,18 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 			final MutableAnnotationUsage<EntityResult> entityResultAnnotation = makeAnnotation( JpaAnnotations.ENTITY_RESULT );
 			entityResults.add( entityResultAnnotation );
 
-			entityResultAnnotation.setAttributeValue( "entityClass", classDetailsRegistry.resolveClassDetails( jaxbEntityResult.getEntityClass() ) );
+			applyAttributeIfSpecified( "entityClass", classDetailsRegistry.resolveClassDetails( jaxbEntityResult.getEntityClass() ), entityResultAnnotation );
-			entityResultAnnotation.setAttributeValue( "lockMode", jaxbEntityResult.getLockMode() );
+			applyAttributeIfSpecified( "lockMode", jaxbEntityResult.getLockMode(), entityResultAnnotation );
-			entityResultAnnotation.setAttributeValue( "discriminatorColumn", jaxbEntityResult.getDiscriminatorColumn() );
+			applyStringAttributeIfSpecified( "discriminatorColumn", jaxbEntityResult.getDiscriminatorColumn(), entityResultAnnotation );
 
 			if ( !jaxbEntityResult.getFieldResult().isEmpty() ) {
 				final List<AnnotationUsage<FieldResult>> fieldResults = arrayList( jaxbEntityResult.getFieldResult().size() );
-				entityResultAnnotation.setAttributeValue( "fields", fieldResults );
+				applyAttributeIfSpecified( "fields", fieldResults, entityResultAnnotation );
 
 				for ( JaxbFieldResultImpl jaxbFieldResult : jaxbEntityResult.getFieldResult() ) {
 					final MutableAnnotationUsage<FieldResult> fieldResultAnnotation = makeAnnotation( JpaAnnotations.FIELD_RESULT );
-					fieldResultAnnotation.setAttributeValue( "name", jaxbFieldResult.getName() );
+					applyStringAttributeIfSpecified( "name", jaxbFieldResult.getName(), fieldResultAnnotation );
-					fieldResultAnnotation.setAttributeValue( "column", jaxbFieldResult.getColumn() );
+					applyStringAttributeIfSpecified( "column", jaxbFieldResult.getColumn(), fieldResultAnnotation );
 				}
 			}
 		}
@@ -877,7 +885,7 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 			columnResults.add( columnResultAnnotation );
 
 			columnResultAnnotation.setAttributeValue( "name", jaxbColumn.getName() );
-			columnResultAnnotation.setAttributeValue( "type", classDetailsRegistry.resolveClassDetails( jaxbColumn.getClazz() ) );
+			applyAttributeIfSpecified( "type", classDetailsRegistry.resolveClassDetails( jaxbColumn.getClazz() ), columnResultAnnotation );
 		}
 		annotationListConsumer.accept( columnResults );
 	}
@@ -898,12 +906,12 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 					new NamedQueryRegistration( jaxbNamedQuery.getName(), queryAnnotation )
 			);
 
-			queryAnnotation.setAttributeValue( "name", jaxbNamedQuery.getName() );
+			applyStringAttributeIfSpecified( "name", jaxbNamedQuery.getName(), queryAnnotation );
-			queryAnnotation.setAttributeValue( "query", jaxbNamedQuery.getQuery() );
+			applyStringAttributeIfSpecified( "query", jaxbNamedQuery.getQuery(), queryAnnotation );
-			queryAnnotation.setAttributeValue( "lockMode", jaxbNamedQuery.getLockMode() );
+			applyAttributeIfSpecified( "lockMode", jaxbNamedQuery.getLockMode(), queryAnnotation );
 
 			final List<AnnotationUsage<QueryHint>> hints = extractQueryHints( jaxbNamedQuery );
-			queryAnnotation.setAttributeValue( "hints", hints );
+			applyAttributeIfSpecified( "hints", hints, queryAnnotation );
 
 			if ( jaxbNamedQuery.isCacheable() == Boolean.TRUE ) {
 				final MutableAnnotationUsage<QueryHint> cacheableHint = makeAnnotation( JpaAnnotations.QUERY_HINT );
@@ -972,9 +980,7 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 				queryAnnotation.setAttributeValue( "resultClass", classDetailsRegistry.resolveClassDetails( jaxbNamedQuery.getResultClass() ) );
 			}
 
-			if ( StringHelper.isNotEmpty( jaxbNamedQuery.getResultSetMapping() ) ) {
+			applyStringAttributeIfSpecified( "resultSetMapping", jaxbNamedQuery.getResultSetMapping(), queryAnnotation );
-				queryAnnotation.setAttributeValue( "resultSetMapping", jaxbNamedQuery.getResultSetMapping() );
-			}
 
 			applyEntityResults(
 					jaxbNamedQuery.getEntityResult(),
@@ -1046,24 +1052,24 @@ public class GlobalRegistrationsImpl implements GlobalRegistrations {
 			queryAnnotation.setAttributeValue( "procedureName", jaxbQuery.getProcedureName() );
 
 			final ArrayList<ClassDetails> resultClasses = arrayList( jaxbQuery.getResultClasses().size() );
-			queryAnnotation.setAttributeValue( "resultClasses", resultClasses );
+			applyAttributeIfSpecified( "resultClasses", resultClasses, queryAnnotation );
 			for ( String resultClassName : jaxbQuery.getResultClasses() ) {
 				resultClasses.add( classDetailsRegistry.resolveClassDetails( resultClassName ) );
 			}
 
-			queryAnnotation.setAttributeValue( "resultSetMappings", jaxbQuery.getResultSetMappings() );
+			applyAttributeIfSpecified( "resultSetMappings", jaxbQuery.getResultSetMappings(), queryAnnotation );
 
-			queryAnnotation.setAttributeValue( "hints", extractQueryHints( jaxbQuery ) );
+			applyAttributeIfSpecified( "hints", extractQueryHints( jaxbQuery ), queryAnnotation );
 
 			final ArrayList<AnnotationUsage<StoredProcedureParameter>> parameters = arrayList( jaxbQuery.getProcedureParameters().size() );
-			queryAnnotation.setAttributeValue( "parameters", parameters );
+			applyAttributeIfSpecified( "parameters", parameters, queryAnnotation );
 			for ( JaxbStoredProcedureParameterImpl jaxbProcedureParameter : jaxbQuery.getProcedureParameters() ) {
 				final MutableAnnotationUsage<StoredProcedureParameter> parameterAnnotation = makeAnnotation( JpaAnnotations.STORED_PROCEDURE_PARAMETER );
 				parameters.add( parameterAnnotation );
 
-				parameterAnnotation.setAttributeValue( "name", jaxbProcedureParameter.getName() );
+				applyStringAttributeIfSpecified( "name", jaxbProcedureParameter.getName(), parameterAnnotation );
-				parameterAnnotation.setAttributeValue( "mode", jaxbProcedureParameter.getMode() );
+				applyAttributeIfSpecified( "mode", jaxbProcedureParameter.getMode(), parameterAnnotation );
-				parameterAnnotation.setAttributeValue( "type", classDetailsRegistry.resolveClassDetails( jaxbProcedureParameter.getClazz() ) );
+				applyAttributeIfSpecified( "type", classDetailsRegistry.resolveClassDetails( jaxbProcedureParameter.getClazz() ), parameterAnnotation );
 			}
 		}
 	}

hibernate-core/src/main/java/org/hibernate/boot/models/internal/AnnotationUsageHelper.java

@@ -0,0 +1,27 @@
+package org.hibernate.boot.models.internal;
+
+import java.lang.annotation.Annotation;
+
+import org.hibernate.internal.util.StringHelper;
+import org.hibernate.models.spi.MutableAnnotationUsage;
+
+public class AnnotationUsageHelper {
+
+	public static <A extends Annotation> void applyAttributeIfSpecified(
+			String attributeName,
+			Object value,
+			MutableAnnotationUsage<A> annotationUsage) {
+		if ( value != null ) {
+			annotationUsage.setAttributeValue( attributeName, value );
+		}
+	}
+
+	public static <A extends Annotation> void applyStringAttributeIfSpecified(
+			String attributeName,
+			String value,
+			MutableAnnotationUsage<A> annotationUsage) {
+		if ( StringHelper.isNotEmpty( value ) ) {
+			annotationUsage.setAttributeValue( attributeName, value );
+		}
+	}
+}

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/ManagedTypeProcessor.java

@@ -7,10 +7,7 @@
 package org.hibernate.boot.models.xml.internal;
 
 import java.lang.reflect.Modifier;
-import java.util.Collection;
 import java.util.List;
-import java.util.Map;
-import java.util.Set;
 import java.util.function.Supplier;
 
 import org.hibernate.annotations.Cache;
@@ -21,15 +18,11 @@ import org.hibernate.annotations.SQLUpdate;
 import org.hibernate.annotations.TenantId;
 import org.hibernate.boot.internal.Abstract;
 import org.hibernate.boot.internal.Extends;
-import org.hibernate.boot.internal.LimitedCollectionClassification;
-import org.hibernate.boot.jaxb.mapping.spi.JaxbAnyMappingImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbAttributesContainer;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbAttributesContainerImpl;
-import org.hibernate.boot.jaxb.mapping.spi.JaxbBasicImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbCachingImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEmbeddableImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEmbeddedIdImpl;
-import org.hibernate.boot.jaxb.mapping.spi.JaxbEmbeddedImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappingsImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityOrMappedSuperclass;
@@ -37,9 +30,7 @@ import org.hibernate.boot.jaxb.mapping.spi.JaxbIdImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbManagedType;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbMappedSuperclassImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedEntityGraphImpl;
-import org.hibernate.boot.jaxb.mapping.spi.JaxbOneToOneImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbPersistentAttribute;
-import org.hibernate.boot.jaxb.mapping.spi.JaxbPluralAttribute;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbTenantIdImpl;
 import org.hibernate.boot.models.HibernateAnnotations;
 import org.hibernate.boot.models.JpaAnnotations;
@@ -78,7 +69,6 @@ import jakarta.persistence.MappedSuperclass;
 
 import static org.hibernate.internal.util.NullnessHelper.coalesce;
 import static org.hibernate.internal.util.NullnessHelper.coalesceSuppliedValues;
-import static org.hibernate.internal.util.NullnessHelper.nullif;
 
 /**
  * Helper for handling managed types defined in mapping XML, in either
@@ -500,8 +490,12 @@ public class ManagedTypeProcessor {
 					xmlDocumentContext.getModelBuildingContext()
 			);
 			classDetails.addAnnotationUsage( cacheableUsage );
-			XmlProcessingHelper.setIf( jaxbCaching.getRegion(), "region", cacheableUsage );
+			XmlProcessingHelper.applyAttributeIfSpecified( "region", jaxbCaching.getRegion(), cacheableUsage );
-			XmlProcessingHelper.setIf( convertCacheAccessType( jaxbCaching.getAccess() ), "access", cacheableUsage );
+			XmlProcessingHelper.applyAttributeIfSpecified(
+					"access",
+					convertCacheAccessType( jaxbCaching.getAccess() ),
+					cacheableUsage
+			);
 		}
 	}
 

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/XmlAnnotationHelper.java

@@ -155,7 +155,6 @@ import jakarta.persistence.UniqueConstraint;
 
 import static java.util.Collections.emptyList;
 import static org.hibernate.boot.models.xml.internal.XmlProcessingHelper.makeNestedAnnotation;
-import static org.hibernate.internal.util.NullnessHelper.coalesce;
 
 /**
  * Helper for creating annotation from equivalent JAXB
@@ -173,9 +172,7 @@ public class XmlAnnotationHelper {
 			MutableClassDetails classDetails,
 			XmlDocumentContext xmlDocumentContext) {
 		final MutableAnnotationUsage<Entity> entityUsage = XmlProcessingHelper.getOrMakeAnnotation( Entity.class, classDetails, xmlDocumentContext );
-		if ( StringHelper.isNotEmpty( jaxbEntity.getName() ) ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "name", jaxbEntity.getName(), entityUsage );
-			entityUsage.setAttributeValue( "name", jaxbEntity.getName() );
-		}
 	}
 
 	public static MutableAnnotationUsage<Access> createAccessAnnotation(
@@ -194,7 +191,7 @@ public class XmlAnnotationHelper {
 		final MutableAnnotationUsage<AttributeAccessor> accessorAnn = XmlProcessingHelper.makeAnnotation( AttributeAccessor.class, memberDetails, xmlDocumentContext );
 		memberDetails.addAnnotationUsage( accessorAnn );
 		// todo : this is the old, deprecated form
-		accessorAnn.setAttributeValue( "value", attributeAccessor );
+		XmlProcessingHelper.applyAttributeIfSpecified( "value", attributeAccessor, accessorAnn );
 	}
 
 	public static void applyColumn(
@@ -580,7 +577,8 @@ public class XmlAnnotationHelper {
 			final AnnotationDescriptor<UniqueConstraint> uniqueConstraintDescriptor = xmlDocumentContext.getModelBuildingContext()
 					.getAnnotationDescriptorRegistry()
 					.getDescriptor( UniqueConstraint.class );
-			applyOr( jaxbUniqueConstraint, JaxbUniqueConstraintImpl::getName, "name", uniqueConstraintAnn, uniqueConstraintDescriptor );
+			XmlProcessingHelper.applyAttributeIfSpecified( "name", jaxbUniqueConstraint.getName(), uniqueConstraintAnn );
+			XmlProcessingHelper.applyAttributeIfSpecified( "options", jaxbUniqueConstraint.getOptions(), uniqueConstraintAnn );
 			uniqueConstraintAnn.setAttributeValue( "columnNames", jaxbUniqueConstraint.getColumnName() );
 			uniqueConstraints.add( uniqueConstraintAnn );
 		} );
@@ -771,8 +769,8 @@ public class XmlAnnotationHelper {
 
 		final MutableAnnotationUsage<GeneratedValue> generatedValueAnn = XmlProcessingHelper.makeAnnotation( GeneratedValue.class, memberDetails, xmlDocumentContext );
 		memberDetails.addAnnotationUsage( generatedValueAnn );
-		generatedValueAnn.setAttributeValue( "strategy", jaxbGeneratedValue.getStrategy() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "strategy", jaxbGeneratedValue.getStrategy(), generatedValueAnn );
-		generatedValueAnn.setAttributeValue( "generator", jaxbGeneratedValue.getGenerator() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "generator", jaxbGeneratedValue.getGenerator(), generatedValueAnn );
 	}
 
 	public static void applySequenceGenerator(
@@ -790,14 +788,13 @@ public class XmlAnnotationHelper {
 				xmlDocumentContext
 		);
 
-		if ( StringHelper.isNotEmpty( jaxbGenerator.getSequenceName() ) ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "sequenceName", jaxbGenerator.getSequenceName(), sequenceAnn );
-			sequenceAnn.setAttributeValue( "sequenceName", jaxbGenerator.getSequenceName() );
-		}
 
-		sequenceAnn.setAttributeValue( "catalog", jaxbGenerator.getCatalog() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "catalog", jaxbGenerator.getCatalog(), sequenceAnn );
-		sequenceAnn.setAttributeValue( "schema", jaxbGenerator.getSchema() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "schema", jaxbGenerator.getSchema(), sequenceAnn );
-		sequenceAnn.setAttributeValue( "initialValue", jaxbGenerator.getInitialValue() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "initialValue", jaxbGenerator.getInitialValue(), sequenceAnn );
-		sequenceAnn.setAttributeValue( "allocationSize", jaxbGenerator.getInitialValue() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "allocationSize", jaxbGenerator.getInitialValue(), sequenceAnn );
+		XmlProcessingHelper.applyAttributeIfSpecified( "options", jaxbGenerator.getOptions(), sequenceAnn );
 	}
 
 	public static void applyTableGenerator(
@@ -810,15 +807,15 @@ public class XmlAnnotationHelper {
 
 		final MutableAnnotationUsage<TableGenerator> annotationUsage = XmlProcessingHelper.makeAnnotation( TableGenerator.class, memberDetails, xmlDocumentContext );
 		memberDetails.addAnnotationUsage( annotationUsage );
-		annotationUsage.setAttributeValue( "name", jaxbGenerator.getName() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "name", jaxbGenerator.getName(), annotationUsage );
-		annotationUsage.setAttributeValue( "table", jaxbGenerator.getTable() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "table", jaxbGenerator.getTable(), annotationUsage );
-		annotationUsage.setAttributeValue( "catalog", jaxbGenerator.getCatalog() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "catalog", jaxbGenerator.getCatalog(), annotationUsage );
-		annotationUsage.setAttributeValue( "schema", jaxbGenerator.getSchema() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "schema", jaxbGenerator.getSchema(), annotationUsage );
-		annotationUsage.setAttributeValue( "pkColumnName", jaxbGenerator.getPkColumnName() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "pkColumnName", jaxbGenerator.getPkColumnName(), annotationUsage );
-		annotationUsage.setAttributeValue( "valueColumnName", jaxbGenerator.getValueColumnName() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "valueColumnName", jaxbGenerator.getValueColumnName(), annotationUsage );
-		annotationUsage.setAttributeValue( "pkColumnValue", jaxbGenerator.getPkColumnValue() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "pkColumnValue", jaxbGenerator.getPkColumnValue(), annotationUsage );
-		annotationUsage.setAttributeValue( "initialValue", jaxbGenerator.getInitialValue() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "initialValue", jaxbGenerator.getInitialValue(), annotationUsage );
-		annotationUsage.setAttributeValue( "allocationSize", jaxbGenerator.getInitialValue() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "allocationSize", jaxbGenerator.getInitialValue(), annotationUsage );
 		applyUniqueConstraints( jaxbGenerator.getUniqueConstraint(), memberDetails, annotationUsage, xmlDocumentContext );
 		applyIndexes( jaxbGenerator.getIndex(), memberDetails, annotationUsage, xmlDocumentContext );
 	}
@@ -897,7 +894,7 @@ public class XmlAnnotationHelper {
 					xmlDocumentContext
 			);
 			memberDetails.addAnnotationUsage( annotationUsage );
-			annotationUsage.setAttributeValue( "name", jaxbOverride.getName() );
+			XmlProcessingHelper.applyAttributeIfSpecified( "name", jaxbOverride.getName(), annotationUsage );
 			final List<JaxbJoinColumnImpl> joinColumns = jaxbOverride.getJoinColumns();
 			if ( CollectionHelper.isNotEmpty( joinColumns ) ) {
 				annotationUsage.setAttributeValue( "joinColumns", createJoinColumns( joinColumns, memberDetails, xmlDocumentContext ) );
@@ -957,14 +954,15 @@ public class XmlAnnotationHelper {
 		final ClassDetails converter;
 		if ( StringHelper.isNotEmpty( jaxbConvert.getConverter() ) ) {
 			converter = classDetailsRegistry.resolveClassDetails( jaxbConvert.getConverter() );
-		}
-		else {
-			// allowable for disable-conversion
-			converter = null;
-		}
 			annotationUsage.setAttributeValue( "converter", converter );
-		annotationUsage.setAttributeValue( "attributeName", prefixIfNotAlready( jaxbConvert.getAttributeName(), namePrefix ) );
+		}
-		annotationUsage.setAttributeValue( "disableConversion", jaxbConvert.isDisableConversion() );
+
+		XmlProcessingHelper.applyAttributeIfSpecified(
+				"attributeName",
+				prefixIfNotAlready( jaxbConvert.getAttributeName(), namePrefix ),
+				annotationUsage
+		);
+		XmlProcessingHelper.applyAttributeIfSpecified( "disableConversion", jaxbConvert.isDisableConversion(), annotationUsage );
 	}
 
 	public static void applyTable(
@@ -1010,34 +1008,6 @@ public class XmlAnnotationHelper {
 		applyCheckConstraints( jaxbTable, target, tableAnn, xmlDocumentContext );
 	}
 
-	private static <A extends Annotation> void applyAttributeIfSpecified(
-			MutableAnnotationUsage<A> annotationUsage,
-			String attributeName,
-			String value) {
-		if ( StringHelper.isNotEmpty( value ) ) {
-			annotationUsage.setAttributeValue( attributeName, value );
-		}
-	}
-
-	private static <A extends Annotation, V> void applyAttributeIfSpecified(
-			MutableAnnotationUsage<A> annotationUsage,
-			String attributeName,
-			V... values) {
-		final V coalesced = coalesce( values );
-		if ( coalesced != null ) {
-			annotationUsage.setAttributeValue( attributeName, coalesced );
-		}
-	}
-
-	private static <A extends Annotation> void applyAttributeIfSpecified(
-			MutableAnnotationUsage<A> tableAnn,
-			String attributeName,
-			Object value) {
-		if ( value != null ) {
-			tableAnn.setAttributeValue( attributeName, value );
-		}
-	}
-
 	public static void applyNaturalId(
 			JaxbNaturalId jaxbNaturalId,
 			MutableMemberDetails backingMember,
@@ -1070,7 +1040,7 @@ public class XmlAnnotationHelper {
 		classDetails.addAnnotationUsage( annotationUsage );
 
 		final JaxbCachingImpl jaxbCaching = jaxbNaturalId.getCaching();
-		annotationUsage.setAttributeValue( "region", jaxbCaching.getRegion() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "region", jaxbCaching.getRegion(), annotationUsage );
 	}
 
 	public static void applyId(
@@ -1116,7 +1086,7 @@ public class XmlAnnotationHelper {
 				classDetails,
 				xmlDocumentContext
 		);
-		inheritanceAnn.setAttributeValue( "strategy", jaxbEntity.getInheritance().getStrategy() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "strategy", jaxbEntity.getInheritance().getStrategy(), inheritanceAnn );
 	}
 
 	public static ClassDetails resolveJavaType(String value, XmlDocumentContext xmlDocumentContext) {
@@ -1299,8 +1269,8 @@ public class XmlAnnotationHelper {
 				xmlDocumentContext
 		);
 
-		applyAttributeIfSpecified( filterAnn, "condition", jaxbFilter.getCondition() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "condition", jaxbFilter.getCondition(), filterAnn );
-		applyAttributeIfSpecified( filterAnn, "deduceAliasInjectionPoints", jaxbFilter.isAutoAliasInjection() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "deduceAliasInjectionPoints", jaxbFilter.isAutoAliasInjection(), filterAnn );
 
 		final List<JaxbHbmFilterImpl.JaxbAliasesImpl> aliases = jaxbFilter.getAliases();
 		if ( !CollectionHelper.isEmpty( aliases ) ) {
@@ -1316,7 +1286,7 @@ public class XmlAnnotationHelper {
 		for ( JaxbHbmFilterImpl.JaxbAliasesImpl alias : aliases ) {
 			final MutableAnnotationUsage<SqlFragmentAlias> aliasAnn = makeNestedAnnotation( SqlFragmentAlias.class, target, xmlDocumentContext );
 			aliasAnn.setAttributeValue( "alias", alias.getAlias() );
-			applyAttributeIfSpecified( aliasAnn, "table", alias.getTable() );
+			XmlProcessingHelper.applyAttributeIfSpecified( "table", alias.getTable(), aliasAnn );
 			if ( StringHelper.isNotEmpty( alias.getEntity() ) ) {
 				aliasAnn.setAttributeValue(
 						"entity",
@@ -1362,7 +1332,7 @@ public class XmlAnnotationHelper {
 			final MutableAnnotationUsage<A> annotation = XmlProcessingHelper.getOrMakeAnnotation( annotationType, target, xmlDocumentContext );
 			annotation.setAttributeValue( "sql", jaxbCustomSql.getValue() );
 			annotation.setAttributeValue( "callable", jaxbCustomSql.isCallable() );
-			applyAttributeIfSpecified( annotation, "table", jaxbCustomSql.getTable() );
+			XmlProcessingHelper.applyAttributeIfSpecified( "table", jaxbCustomSql.getTable(), annotation );
 			if ( jaxbCustomSql.getResultCheck() != null ) {
 				annotation.setAttributeValue( "check", getResultCheckStyle( jaxbCustomSql.getResultCheck() ) );
 			}
@@ -1474,7 +1444,7 @@ public class XmlAnnotationHelper {
 			XmlDocumentContext xmlDocumentContext) {
 		if ( rowId != null ) {
 			final MutableAnnotationUsage<RowId> rowIdAnn = XmlProcessingHelper.getOrMakeAnnotation( RowId.class, target, xmlDocumentContext );
-			applyAttributeIfSpecified( rowIdAnn, "value", rowId );
+			XmlProcessingHelper.applyAttributeIfSpecified( "value", rowId, rowIdAnn );
 		}
 	}
 
@@ -1500,21 +1470,8 @@ public class XmlAnnotationHelper {
 			);
 
 			final AnnotationDescriptor<NamedEntityGraph> namedEntityGraphAnnotationDescriptor = namedEntityGraphAnn.getAnnotationDescriptor();
-			applyOr(
+			XmlProcessingHelper.applyAttributeIfSpecified( "name", namedEntityGraph.getName(), namedEntityGraphAnn );
-					namedEntityGraph,
+			XmlProcessingHelper.applyAttributeIfSpecified( "includeAllAttributes", namedEntityGraph.isIncludeAllAttributes(), namedEntityGraphAnn );
-					JaxbNamedEntityGraphImpl::getName,
-					"name",
-					namedEntityGraphAnn,
-					namedEntityGraphAnnotationDescriptor
-			);
-
-			applyOr(
-					namedEntityGraph,
-					JaxbNamedEntityGraphImpl::isIncludeAllAttributes,
-					"includeAllAttributes",
-					namedEntityGraphAnn,
-					namedEntityGraphAnnotationDescriptor
-			);
 
 			namedEntityGraphAnn.setAttributeValue(
 					"attributeNodes",
@@ -1557,7 +1514,7 @@ public class XmlAnnotationHelper {
 					target,
 					xmlDocumentContext
 			);
-			applyAttributeIfSpecified( namedSubgraphNodeAnn, "name", subGraphsNodeName );
+			XmlProcessingHelper.applyAttributeIfSpecified( "name", subGraphsNodeName, namedSubgraphNodeAnn );
 
 			final String clazz = subclassSubgraphNode.getClazz();
 			if ( clazz == null ) {
@@ -1601,7 +1558,7 @@ public class XmlAnnotationHelper {
 					target,
 					xmlDocumentContext
 			);
-			applyAttributeIfSpecified( namedAttributeNodeAnn, "value", namedAttributeNode.getName() );
+			XmlProcessingHelper.applyAttributeIfSpecified( "value", namedAttributeNode.getName(), namedAttributeNodeAnn );
 			final AnnotationDescriptor<NamedAttributeNode> namedAttributeNodeDescriptor = xmlDocumentContext
 					.getModelBuildingContext()
 					.getAnnotationDescriptorRegistry()
@@ -1633,7 +1590,7 @@ public class XmlAnnotationHelper {
 		if ( discriminatorValue != null ) {
 			final MutableAnnotationUsage<DiscriminatorValue> rowIdAnn = XmlProcessingHelper
 					.getOrMakeAnnotation( DiscriminatorValue.class, target, xmlDocumentContext );
-			applyAttributeIfSpecified( rowIdAnn, "value", discriminatorValue );
+			XmlProcessingHelper.applyAttributeIfSpecified( "value", discriminatorValue, rowIdAnn );
 		}
 	}
 
@@ -1704,7 +1661,7 @@ public class XmlAnnotationHelper {
 		);
 
 		discriminatorFormulaAnn.setAttributeValue( "value", jaxbDiscriminatorFormula.getFragment() );
-		discriminatorFormulaAnn.setAttributeValue( "discriminatorType", jaxbDiscriminatorFormula.getDiscriminatorType() );
+		XmlProcessingHelper.applyAttributeIfSpecified( "discriminatorType", jaxbDiscriminatorFormula.getDiscriminatorType(), discriminatorFormulaAnn );
 
 		if ( jaxbDiscriminatorFormula.isForceSelection() ) {
 			final MutableAnnotationUsage<DiscriminatorOptions> existingOptionsAnnotation = (MutableAnnotationUsage<DiscriminatorOptions>) target.getAnnotationUsage( DiscriminatorOptions.class );

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/XmlProcessingHelper.java

@@ -247,4 +247,22 @@ public class XmlProcessingHelper {
 
 		annotationUsage.setAttributeValue( attributeName, value );
 	}
+
+	public static <A extends Annotation> void applyAttributeIfSpecified(
+			String attributeName,
+			String value,
+			MutableAnnotationUsage<A> annotationUsage) {
+		if ( StringHelper.isNotEmpty( value ) ) {
+			annotationUsage.setAttributeValue( attributeName, value );
+		}
+	}
+
+	public static <A extends Annotation> void applyAttributeIfSpecified(
+			String attributeName,
+			Object value,
+			MutableAnnotationUsage<A> tableAnn) {
+		if ( value != null ) {
+			tableAnn.setAttributeValue( attributeName, value );
+		}
+	}
 }

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/AnyMappingAttributeProcessing.java

@@ -78,7 +78,7 @@ public class AnyMappingAttributeProcessing {
 		}
 
 		final DiscriminatorType discriminatorType = jaxbDiscriminator.getType();
-		anyDiscriminatorAnn.setAttributeValue( "value", discriminatorType );
+		XmlProcessingHelper.applyAttributeIfSpecified( "value", discriminatorType, anyDiscriminatorAnn );
 
 		final JaxbColumnImpl jaxbColumn = jaxbDiscriminator.getColumn();
 		final MutableAnnotationUsage<Column> columnAnn = XmlProcessingHelper.makeAnnotation( Column.class, memberDetails, xmlDocumentContext );

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/CommonAttributeProcessing.java

@@ -74,7 +74,7 @@ public class CommonAttributeProcessing {
 				.getClassDetailsRegistry()
 				.getClassDetails( attributeAccessor );
 		final MutableAnnotationUsage<AttributeAccessor> accessAnn = XmlProcessingHelper.makeAnnotation( AttributeAccessor.class, memberDetails, xmlDocumentContext );
-		accessAnn.setAttributeValue( "strategy", strategyClassDetails );
+		XmlProcessingHelper.applyAttributeIfSpecified( "strategy", strategyClassDetails, accessAnn );
 	}
 
 	public static <A extends Annotation> void applyOptionality(
@@ -105,9 +105,7 @@ public class CommonAttributeProcessing {
 			MutableAnnotationUsage<A> attributeAnn,
 			XmlDocumentContext xmlDocumentContext) {
 		final FetchType fetchType = jaxbAttribute.getFetch();
-		if ( fetchType != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "fetch", fetchType, attributeAnn );
-			attributeAnn.setAttributeValue( "fetch", fetchType );
-		}
 
 		if ( jaxbAttribute instanceof JaxbSingularAssociationAttribute jaxbSingularAttribute ) {
 			final JaxbSingularFetchModeImpl jaxbFetchMode = jaxbSingularAttribute.getFetchMode();

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ElementCollectionAttributeProcessing.java

@@ -6,13 +6,11 @@
  */
 package org.hibernate.boot.models.xml.internal.attr;
 
-import org.hibernate.boot.internal.Target;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbCollectionTableImpl;
 import org.hibernate.boot.jaxb.mapping.spi.JaxbElementCollectionImpl;
 import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper;
 import org.hibernate.boot.models.xml.internal.XmlProcessingHelper;
 import org.hibernate.boot.models.xml.spi.XmlDocumentContext;
-import org.hibernate.internal.util.StringHelper;
 import org.hibernate.models.spi.AnnotationDescriptor;
 import org.hibernate.models.spi.MutableAnnotationUsage;
 import org.hibernate.models.spi.MutableClassDetails;
@@ -47,13 +45,18 @@ public class ElementCollectionAttributeProcessing {
 				memberDetails,
 				xmlDocumentContext
 		);
-		XmlProcessingHelper.setIf( jaxbElementCollection.getFetch(), "fetch", elementCollectionAnn );
+		XmlProcessingHelper.applyAttributeIfSpecified(
-		elementCollectionAnn.setAttributeValue(
+				"fetch",
+				jaxbElementCollection.getFetch(),
+				elementCollectionAnn
+		);
+		XmlProcessingHelper.applyAttributeIfSpecified(
 				"targetClass",
 				XmlAnnotationHelper.resolveJavaType(
 						jaxbElementCollection.getTargetClass(),
 						xmlDocumentContext.getModelBuildingContext()
-				)
+				).determineRawClass(),
+				elementCollectionAnn
 		);
 
 		CommonAttributeProcessing.applyAttributeBasics( jaxbElementCollection, memberDetails, elementCollectionAnn, accessType, xmlDocumentContext );

hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/ColumnProcessing.java

@@ -18,9 +18,10 @@ import org.hibernate.boot.jaxb.mapping.spi.db.JaxbColumnSizable;
 import org.hibernate.boot.jaxb.mapping.spi.db.JaxbColumnStandard;
 import org.hibernate.boot.jaxb.mapping.spi.db.JaxbColumnUniqueable;
 import org.hibernate.boot.jaxb.mapping.spi.db.JaxbCommentable;
+import org.hibernate.boot.models.internal.AnnotationUsageHelper;
 import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper;
+import org.hibernate.boot.models.xml.internal.XmlProcessingHelper;
 import org.hibernate.boot.models.xml.spi.XmlDocumentContext;
-import org.hibernate.internal.util.StringHelper;
 import org.hibernate.models.spi.MutableAnnotationTarget;
 import org.hibernate.models.spi.MutableAnnotationUsage;
 
@@ -135,83 +136,62 @@ public class ColumnProcessing {
 			JaxbColumn jaxbColumn,
 			MutableAnnotationUsage<A> columnAnn,
 			XmlDocumentContext xmlDocumentContext) {
-		if ( StringHelper.isNotEmpty( jaxbColumn.getName() ) ) {
+		AnnotationUsageHelper.applyStringAttributeIfSpecified( "name", jaxbColumn.getName(), columnAnn );
-			columnAnn.setAttributeValue( "name", jaxbColumn.getName() );
-		}
 
-		if ( StringHelper.isNotEmpty( jaxbColumn.getTable() ) ) {
+		AnnotationUsageHelper.applyStringAttributeIfSpecified( "table", jaxbColumn.getTable(), columnAnn );
-			columnAnn.setAttributeValue( "table", jaxbColumn.getTable() );
-		}
 	}
 
 	private static <A extends Annotation> void applyColumnNullness(
 			JaxbColumnNullable jaxbColumn,
 			MutableAnnotationUsage<A> columnAnn,
 			XmlDocumentContext xmlDocumentContext) {
-		if ( jaxbColumn.isNullable() != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "unique", jaxbColumn.isNullable(), columnAnn );
-			columnAnn.setAttributeValue( "unique", jaxbColumn.isNullable() );
-		}
 	}
 
 	private static <A extends Annotation> void applyColumnMutability(
 			JaxbColumnMutable jaxbColumn,
 			MutableAnnotationUsage<A> columnAnn,
 			XmlDocumentContext xmlDocumentContext) {
-		if ( jaxbColumn.isInsertable() != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "insertable", jaxbColumn.isInsertable(), columnAnn );
-			columnAnn.setAttributeValue( "insertable", jaxbColumn.isInsertable() );
-		}
 
-		if ( jaxbColumn.isUpdatable() != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "updatable", jaxbColumn.isUpdatable(), columnAnn );
-			columnAnn.setAttributeValue( "updatable", jaxbColumn.isUpdatable() );
-		}
 	}
 
 	private static <A extends Annotation> void applyColumnSizing(
 			JaxbColumnSizable jaxbColumn,
 			MutableAnnotationUsage<A> columnAnn,
 			XmlDocumentContext xmlDocumentContext) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "length", jaxbColumn.getLength(), columnAnn );
 
-		if ( jaxbColumn.getLength() != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "precision", jaxbColumn.getPrecision(), columnAnn );
-			columnAnn.setAttributeValue( "length", jaxbColumn.getLength() );
-		}
 
-		if ( jaxbColumn.getPrecision() != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "scale", jaxbColumn.getScale(), columnAnn );
-			columnAnn.setAttributeValue( "precision", jaxbColumn.getPrecision() );
-		}
-
-		if ( jaxbColumn.getScale() != null ) {
-			columnAnn.setAttributeValue( "scale", jaxbColumn.getScale() );
-		}
 	}
 
 	private static <A extends Annotation> void applyColumnUniqueness(
 			JaxbColumnUniqueable jaxbColumn,
 			MutableAnnotationUsage<A> columnAnn,
 			XmlDocumentContext xmlDocumentContext) {
-		if ( jaxbColumn.isUnique() != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "unique", jaxbColumn.isUnique(), columnAnn );
-			columnAnn.setAttributeValue( "unique", jaxbColumn.isUnique() );
-		}
 	}
 
 	private static <A extends Annotation> void applyColumnDefinition(
 			JaxbColumnDefinable jaxbColumn,
 			MutableAnnotationUsage<A> columnAnn,
 			XmlDocumentContext xmlDocumentContext) {
-		if ( StringHelper.isNotEmpty( jaxbColumn.getColumnDefinition() ) ) {
+		XmlProcessingHelper.applyAttributeIfSpecified(
-			columnAnn.setAttributeValue( "columnDefinition", jaxbColumn.getColumnDefinition() );
+				"columnDefinition",
-		}
+				jaxbColumn.getColumnDefinition(),
+				columnAnn
+		);
 
-		if ( jaxbColumn.getOptions() != null ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "options", jaxbColumn.getOptions(), columnAnn );
-			columnAnn.setAttributeValue( "options", jaxbColumn.getOptions() );
-		}
 	}
 
 	private static <A extends Annotation> void applyColumnComment(
 			JaxbCommentable jaxbColumn,
 			MutableAnnotationUsage<A> columnAnn,
 			XmlDocumentContext xmlDocumentContext) {
-		if ( StringHelper.isNotEmpty( jaxbColumn.getComment() ) ) {
+		XmlProcessingHelper.applyAttributeIfSpecified( "comment", jaxbColumn.getComment(), columnAnn );
-			columnAnn.setAttributeValue( "comment", jaxbColumn.getComment() );
-		}
 	}
 }