diff --git a/hibernate-core/hibernate-core.gradle b/hibernate-core/hibernate-core.gradle index c966350c33..de482ee5e8 100644 --- a/hibernate-core/hibernate-core.gradle +++ b/hibernate-core/hibernate-core.gradle @@ -31,7 +31,6 @@ dependencies { implementation libs.jandex implementation libs.classmate implementation libs.byteBuddy - implementation libs.hcann implementation jakartaLibs.jaxbApi implementation jakartaLibs.jaxb diff --git a/hibernate-core/src/main/java/org/hibernate/boot/internal/BootstrapContextImpl.java b/hibernate-core/src/main/java/org/hibernate/boot/internal/BootstrapContextImpl.java index 02fcdb120f..103656b133 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/internal/BootstrapContextImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/internal/BootstrapContextImpl.java @@ -13,8 +13,6 @@ import java.util.HashMap; import java.util.Map; import org.hibernate.AssertionFailure; -import org.hibernate.annotations.common.reflection.ReflectionManager; -import org.hibernate.annotations.common.reflection.java.JavaReflectionManager; import org.hibernate.boot.CacheRegionDefinition; import org.hibernate.boot.archive.scan.internal.StandardScanOptions; import org.hibernate.boot.archive.scan.spi.ScanEnvironment; @@ -23,7 +21,6 @@ import org.hibernate.boot.archive.scan.spi.Scanner; import org.hibernate.boot.archive.spi.ArchiveDescriptorFactory; import org.hibernate.boot.model.TypeBeanInstanceProducer; import org.hibernate.boot.model.convert.spi.ConverterDescriptor; -import org.hibernate.boot.model.internal.JPAXMLOverriddenMetadataProvider; import org.hibernate.boot.model.relational.AuxiliaryDatabaseObject; import org.hibernate.boot.registry.StandardServiceRegistry; import org.hibernate.boot.registry.classloading.spi.ClassLoaderService; @@ -64,7 +61,6 @@ public class BootstrapContextImpl implements BootstrapContext { private boolean isJpaBootstrap; - private final JavaReflectionManager hcannReflectionManager; private final ClassmateContext classmateContext; private ScanOptions scanOptions; @@ -88,7 +84,6 @@ public class BootstrapContextImpl implements BootstrapContext { this.metadataBuildingOptions = metadataBuildingOptions; this.classLoaderAccess = new ClassLoaderAccessImpl( serviceRegistry.getService( ClassLoaderService.class ) ); - this.hcannReflectionManager = generateHcannReflectionManager(); final StrategySelector strategySelector = serviceRegistry.requireService( StrategySelector.class ); final ConfigurationService configService = serviceRegistry.requireService( ConfigurationService.class ); @@ -188,11 +183,6 @@ public class BootstrapContextImpl implements BootstrapContext { return scannerSetting; } - @Override - public ReflectionManager getReflectionManager() { - return hcannReflectionManager; - } - @Override public IndexView getJandexView() { return jandexView; @@ -338,11 +328,4 @@ public class BootstrapContextImpl implements BootstrapContext { } cacheRegionDefinitions.add( cacheRegionDefinition ); } - - private JavaReflectionManager generateHcannReflectionManager() { - final JavaReflectionManager reflectionManager = new JavaReflectionManager(); - reflectionManager.setMetadataProvider( new JPAXMLOverriddenMetadataProvider( this ) ); - return reflectionManager; - } - } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java b/hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java index d8e16ea5c6..e07490da4e 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/internal/InFlightMetadataCollectorImpl.java @@ -29,7 +29,6 @@ import org.hibernate.SessionFactory; import org.hibernate.annotations.CollectionTypeRegistration; import org.hibernate.annotations.Imported; import org.hibernate.annotations.Parameter; -import org.hibernate.annotations.common.reflection.XClass; import org.hibernate.boot.CacheRegionDefinition; import org.hibernate.boot.SessionFactoryBuilder; import org.hibernate.boot.model.IdentifierGeneratorDefinition; @@ -1318,7 +1317,7 @@ public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector, private final Map annotatedClassTypeMap = new HashMap<>(); @Override - public AnnotatedClassType getClassType(XClass clazz) { + public AnnotatedClassType getClassType(ClassDetails clazz) { AnnotatedClassType type = annotatedClassTypeMap.get( clazz.getName() ); if ( type == null ) { return addClassType( clazz ); @@ -1329,13 +1328,13 @@ public class InFlightMetadataCollectorImpl implements InFlightMetadataCollector, } @Override - public AnnotatedClassType addClassType(XClass clazz) { + public AnnotatedClassType addClassType(ClassDetails clazz) { final AnnotatedClassType type = getAnnotatedClassType(clazz); annotatedClassTypeMap.put( clazz.getName(), type ); return type; } - private static AnnotatedClassType getAnnotatedClassType(XClass clazz) { + private static AnnotatedClassType getAnnotatedClassType(ClassDetails clazz) { if ( clazz.isAnnotationPresent( Entity.class ) ) { if ( clazz.isAnnotationPresent( Embeddable.class ) ) { throw new AnnotationException( "Invalid class annotated both '@Entity' and '@Embeddable': '" + clazz.getName() + "'" ); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AutoApplicableConverterDescriptorStandardImpl.java b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AutoApplicableConverterDescriptorStandardImpl.java index 02cc553534..6dd5ee3ed0 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AutoApplicableConverterDescriptorStandardImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/convert/internal/AutoApplicableConverterDescriptorStandardImpl.java @@ -11,7 +11,6 @@ import java.util.List; import java.util.Map; import org.hibernate.HibernateException; -import org.hibernate.annotations.common.reflection.XProperty; import org.hibernate.boot.model.convert.spi.AutoApplicableConverterDescriptor; import org.hibernate.boot.model.convert.spi.ConverterDescriptor; import org.hibernate.boot.spi.MetadataBuildingContext; diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationBinder.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationBinder.java index 08c7a5cc53..e194a0c757 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationBinder.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/AnnotationBinder.java @@ -79,8 +79,6 @@ public final class AnnotationBinder { private AnnotationBinder() {} public static void bindDefaults(MetadataBuildingContext context) { - // todo (jpa32) - remove this. left for now for easy debugging - final Map defaults = context.getBootstrapContext().getReflectionManager().getDefaults(); final GlobalRegistrations globalRegistrations = context.getMetadataCollector().getGlobalRegistrations(); // id generators ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/CollectionBinder.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/CollectionBinder.java index a87b010363..3e545e8db3 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/CollectionBinder.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/CollectionBinder.java @@ -75,7 +75,6 @@ import org.hibernate.annotations.SqlFragmentAlias; import org.hibernate.annotations.Synchronize; import org.hibernate.annotations.Where; import org.hibernate.annotations.WhereJoinTable; -import org.hibernate.annotations.common.reflection.ReflectionManager; import org.hibernate.boot.BootLogging; import org.hibernate.boot.model.IdentifierGeneratorDefinition; import org.hibernate.boot.model.TypeDefinition; @@ -500,7 +499,6 @@ public abstract class CollectionBinder { + "' is annotated both '@OneToMany' and '@ManyToMany'" ); } final String mappedBy; - final ReflectionManager reflectionManager = context.getBootstrapContext().getReflectionManager(); if ( oneToManyAnn != null ) { if ( joinColumns.isSecondary() ) { throw new AnnotationException( "Collection '" + getPath( propertyHolder, inferredData ) diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/HCANNHelper.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/HCANNHelper.java deleted file mode 100644 index a54f8846b7..0000000000 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/HCANNHelper.java +++ /dev/null @@ -1,118 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. - */ -package org.hibernate.boot.model.internal; - -import java.lang.annotation.Annotation; -import java.lang.reflect.AnnotatedElement; -import java.lang.reflect.Member; - -import org.hibernate.Internal; -import org.hibernate.annotations.common.reflection.XAnnotatedElement; -import org.hibernate.annotations.common.reflection.XProperty; -import org.hibernate.annotations.common.reflection.java.JavaXMember; - -/** - * Manage the various fun-ness of dealing with HCANN... - * - * @author Steve Ebersole - */ -@Internal -public final class HCANNHelper { - - public static boolean hasAnnotation( - AnnotatedElement element, - Class annotationToCheck) { - if ( element == null ) { - return false; - } - - return element.isAnnotationPresent( annotationToCheck ); - } - - public static boolean hasAnnotation( - AnnotatedElement element, - Class annotationToCheck, - Class annotationToCheck2) { - if ( element == null ) { - return false; - } - - return element.isAnnotationPresent( annotationToCheck ) - || element.isAnnotationPresent( annotationToCheck2 ); - } - - public static boolean hasAnnotation( - XAnnotatedElement element, - Class annotationToCheck) { - if ( element == null ) { - return false; - } - - return element.isAnnotationPresent( annotationToCheck ); - } - - public static boolean hasAnnotation( - XAnnotatedElement element, - Class annotationToCheck, - Class annotationToCheck2) { - if ( element == null ) { - return false; - } - - return element.isAnnotationPresent( annotationToCheck ) - || element.isAnnotationPresent( annotationToCheck2); - } - - public static boolean hasAnnotation( - XAnnotatedElement element, - Class... annotationsToCheck) { - assert annotationsToCheck != null && annotationsToCheck.length > 0; - - if ( element == null ) { - return false; - } - - for ( int i = 0; i < annotationsToCheck.length; i++ ) { - if ( element.isAnnotationPresent( annotationsToCheck[i] ) ) { - return true; - } - } - - return false; - } - - /** - * @deprecated Prefer using {@link #annotatedElementSignature(JavaXMember)} - */ - @Deprecated - public static String annotatedElementSignature(XProperty property) { - return getUnderlyingMember( property ).toString(); - } - - public static String annotatedElementSignature(final JavaXMember member) { - return getUnderlyingMember( member ).toString(); - } - - /** - * @deprecated Prefer using {@link #getUnderlyingMember(JavaXMember)} - */ - @Deprecated - public static Member getUnderlyingMember(XProperty property) { - if ( property instanceof JavaXMember ) { - JavaXMember member = (JavaXMember) property; - return member.getMember(); - } - else { - throw new org.hibernate.HibernateException( "Can only extract Member from a XProperty which is a JavaXMember" ); - } - } - - public static Member getUnderlyingMember(final JavaXMember member) { - return member.getMember(); - } - -} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/JPAXMLOverriddenAnnotationReader.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/JPAXMLOverriddenAnnotationReader.java deleted file mode 100644 index 840435fed2..0000000000 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/JPAXMLOverriddenAnnotationReader.java +++ /dev/null @@ -1,3257 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. - */ -package org.hibernate.boot.model.internal; - -import java.beans.Introspector; -import java.lang.annotation.Annotation; -import java.lang.reflect.AccessibleObject; -import java.lang.reflect.AnnotatedElement; -import java.lang.reflect.Field; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.Collections; -import java.util.HashMap; -import java.util.HashSet; -import java.util.List; -import java.util.Map; -import java.util.Set; -import java.util.function.Function; - -import org.hibernate.AnnotationException; -import org.hibernate.annotations.Any; -import org.hibernate.annotations.Cache; -import org.hibernate.annotations.CacheConcurrencyStrategy; -import org.hibernate.annotations.Cascade; -import org.hibernate.annotations.Columns; -import org.hibernate.annotations.JdbcTypeCode; -import org.hibernate.annotations.ManyToAny; -import org.hibernate.annotations.Parameter; -import org.hibernate.annotations.Subselect; -import org.hibernate.annotations.TenantId; -import org.hibernate.annotations.Type; -import org.hibernate.annotations.UuidGenerator; -import org.hibernate.annotations.common.annotationfactory.AnnotationDescriptor; -import org.hibernate.annotations.common.annotationfactory.AnnotationFactory; -import org.hibernate.annotations.common.reflection.AnnotationReader; -import org.hibernate.annotations.common.reflection.ReflectionUtil; -import org.hibernate.boot.jaxb.mapping.spi.JaxbAssociationOverrideImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbAttributeOverrideImpl; -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.JaxbCascadeTypeImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbCollectionTableImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbColumnResultImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbConfigurationParameterImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbConstructorResultImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbConvertImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbDiscriminatorColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbElementCollectionImpl; -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.JaxbEmptyTypeImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntity; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityListenerContainerImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityListenerImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityOrMappedSuperclass; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityResultImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbFieldResultImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbGeneratedValueImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbIdClassImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbIdImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbIndexImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbInheritanceImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinTableCapable; -import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinTableImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbLifecycleCallbackContainer; -import org.hibernate.boot.jaxb.mapping.spi.JaxbLobImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbManagedType; -import org.hibernate.boot.jaxb.mapping.spi.JaxbManyToManyImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbManyToOneImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbMapKeyClassImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbMapKeyColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbMapKeyImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbMapKeyJoinColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbMappedSuperclassImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedAttributeNodeImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedEntityGraphImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedNativeQueryImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedQueryImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedStoredProcedureQueryImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedSubgraphImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbOneToManyImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbOneToOneImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbOrderColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPrimaryKeyJoinColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbQueryHintImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbSecondaryTableImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbSequenceGeneratorImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbSqlResultSetMappingImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbStoredProcedureParameterImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbSynchronizedTableImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbTableGeneratorImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbTableImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbTenantIdImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbUniqueConstraintImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbUserTypeImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbUuidGeneratorImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbVersionImpl; -import org.hibernate.boot.registry.classloading.spi.ClassLoadingException; -import org.hibernate.boot.spi.BootstrapContext; -import org.hibernate.boot.spi.ClassLoaderAccess; -import org.hibernate.internal.CoreLogging; -import org.hibernate.internal.CoreMessageLogger; -import org.hibernate.internal.util.StringHelper; -import org.hibernate.jpa.AvailableHints; - -import jakarta.persistence.Access; -import jakarta.persistence.AccessType; -import jakarta.persistence.AssociationOverride; -import jakarta.persistence.AssociationOverrides; -import jakarta.persistence.AttributeOverride; -import jakarta.persistence.AttributeOverrides; -import jakarta.persistence.Basic; -import jakarta.persistence.Cacheable; -import jakarta.persistence.CascadeType; -import jakarta.persistence.CollectionTable; -import jakarta.persistence.Column; -import jakarta.persistence.ColumnResult; -import jakarta.persistence.ConstructorResult; -import jakarta.persistence.Convert; -import jakarta.persistence.Converts; -import jakarta.persistence.DiscriminatorColumn; -import jakarta.persistence.DiscriminatorType; -import jakarta.persistence.DiscriminatorValue; -import jakarta.persistence.ElementCollection; -import jakarta.persistence.Embeddable; -import jakarta.persistence.Embedded; -import jakarta.persistence.EmbeddedId; -import jakarta.persistence.Entity; -import jakarta.persistence.EntityListeners; -import jakarta.persistence.EntityResult; -import jakarta.persistence.EnumType; -import jakarta.persistence.Enumerated; -import jakarta.persistence.ExcludeDefaultListeners; -import jakarta.persistence.ExcludeSuperclassListeners; -import jakarta.persistence.FetchType; -import jakarta.persistence.FieldResult; -import jakarta.persistence.ForeignKey; -import jakarta.persistence.GeneratedValue; -import jakarta.persistence.GenerationType; -import jakarta.persistence.Id; -import jakarta.persistence.IdClass; -import jakarta.persistence.Index; -import jakarta.persistence.Inheritance; -import jakarta.persistence.InheritanceType; -import jakarta.persistence.JoinColumn; -import jakarta.persistence.JoinColumns; -import jakarta.persistence.JoinTable; -import jakarta.persistence.Lob; -import jakarta.persistence.ManyToMany; -import jakarta.persistence.ManyToOne; -import jakarta.persistence.MapKey; -import jakarta.persistence.MapKeyClass; -import jakarta.persistence.MapKeyColumn; -import jakarta.persistence.MapKeyEnumerated; -import jakarta.persistence.MapKeyJoinColumn; -import jakarta.persistence.MapKeyJoinColumns; -import jakarta.persistence.MapKeyTemporal; -import jakarta.persistence.MappedSuperclass; -import jakarta.persistence.MapsId; -import jakarta.persistence.NamedAttributeNode; -import jakarta.persistence.NamedEntityGraph; -import jakarta.persistence.NamedEntityGraphs; -import jakarta.persistence.NamedNativeQueries; -import jakarta.persistence.NamedNativeQuery; -import jakarta.persistence.NamedQueries; -import jakarta.persistence.NamedQuery; -import jakarta.persistence.NamedStoredProcedureQueries; -import jakarta.persistence.NamedStoredProcedureQuery; -import jakarta.persistence.NamedSubgraph; -import jakarta.persistence.OneToMany; -import jakarta.persistence.OneToOne; -import jakarta.persistence.OrderBy; -import jakarta.persistence.OrderColumn; -import jakarta.persistence.ParameterMode; -import jakarta.persistence.PostLoad; -import jakarta.persistence.PostPersist; -import jakarta.persistence.PostRemove; -import jakarta.persistence.PostUpdate; -import jakarta.persistence.PrePersist; -import jakarta.persistence.PreRemove; -import jakarta.persistence.PreUpdate; -import jakarta.persistence.PrimaryKeyJoinColumn; -import jakarta.persistence.PrimaryKeyJoinColumns; -import jakarta.persistence.QueryHint; -import jakarta.persistence.SecondaryTable; -import jakarta.persistence.SecondaryTables; -import jakarta.persistence.SequenceGenerator; -import jakarta.persistence.SqlResultSetMapping; -import jakarta.persistence.SqlResultSetMappings; -import jakarta.persistence.StoredProcedureParameter; -import jakarta.persistence.Table; -import jakarta.persistence.TableGenerator; -import jakarta.persistence.Temporal; -import jakarta.persistence.TemporalType; -import jakarta.persistence.Transient; -import jakarta.persistence.UniqueConstraint; -import jakarta.persistence.Version; - -import static org.hibernate.boot.model.internal.HCANNHelper.hasAnnotation; -import static org.hibernate.boot.model.internal.PropertyMappingElementCollector.JAXB_TRANSIENT_NAME; -import static org.hibernate.boot.model.internal.PropertyMappingElementCollector.PERSISTENT_ATTRIBUTE_NAME; -import static org.hibernate.internal.util.StringHelper.isEmpty; -import static org.hibernate.internal.util.StringHelper.isNotEmpty; - -/** - * Encapsulates the overriding of Java annotations from an EJB 3.0 descriptor (orm.xml, ...). - * - * @author Paolo Perrotta - * @author Davide Marchignoli - * @author Emmanuel Bernard - * @author Hardy Ferentschik - */ -@SuppressWarnings({ "unchecked", "ToArrayCallWithZeroLengthArrayArgument" }) -public class JPAXMLOverriddenAnnotationReader implements AnnotationReader { - private static final CoreMessageLogger LOG = CoreLogging.messageLogger( JPAXMLOverriddenAnnotationReader.class ); - - private static final String SCHEMA_VALIDATION = "Activate schema validation for more information"; - private static final String WORD_SEPARATOR = "-"; - - private enum PropertyType { - PROPERTY, - FIELD, - METHOD - } - - private static final Map, String> annotationToXml; - - static { - annotationToXml = new HashMap<>(); - annotationToXml.put( Entity.class, "entity" ); - annotationToXml.put( MappedSuperclass.class, "mapped-superclass" ); - annotationToXml.put( Embeddable.class, "embeddable" ); - annotationToXml.put( Table.class, "table" ); - annotationToXml.put( SecondaryTable.class, "secondary-table" ); - annotationToXml.put( SecondaryTables.class, "secondary-table" ); - annotationToXml.put( PrimaryKeyJoinColumn.class, "primary-key-join-column" ); - annotationToXml.put( PrimaryKeyJoinColumns.class, "primary-key-join-column" ); - annotationToXml.put( IdClass.class, "id-class" ); - annotationToXml.put( Inheritance.class, "inheritance" ); - annotationToXml.put( DiscriminatorValue.class, "discriminator-value" ); - annotationToXml.put( DiscriminatorColumn.class, "discriminator-column" ); - annotationToXml.put( SequenceGenerator.class, "sequence-generator" ); - annotationToXml.put( TableGenerator.class, "table-generator" ); - annotationToXml.put( NamedEntityGraph.class, "named-entity-graph" ); - annotationToXml.put( NamedEntityGraphs.class, "named-entity-graph" ); - annotationToXml.put( NamedQuery.class, "named-query" ); - annotationToXml.put( NamedQueries.class, "named-query" ); - annotationToXml.put( NamedNativeQuery.class, "named-native-query" ); - annotationToXml.put( NamedNativeQueries.class, "named-native-query" ); - annotationToXml.put( NamedStoredProcedureQuery.class, "named-stored-procedure-query" ); - annotationToXml.put( NamedStoredProcedureQueries.class, "named-stored-procedure-query" ); - annotationToXml.put( SqlResultSetMapping.class, "sql-result-set-mapping" ); - annotationToXml.put( SqlResultSetMappings.class, "sql-result-set-mapping" ); - annotationToXml.put( ExcludeDefaultListeners.class, "exclude-default-listeners" ); - annotationToXml.put( ExcludeSuperclassListeners.class, "exclude-superclass-listeners" ); -// annotationToXml.put( AccessType.class, "access" ); - // FIXME: adding same annotation as a key multiple times: - annotationToXml.put( AttributeOverride.class, "attribute-override" ); - annotationToXml.put( AttributeOverrides.class, "attribute-override" ); - annotationToXml.put( AttributeOverride.class, "association-override" ); - annotationToXml.put( AttributeOverrides.class, "association-override" ); - annotationToXml.put( AttributeOverride.class, "map-key-attribute-override" ); - annotationToXml.put( AttributeOverrides.class, "map-key-attribute-override" ); - annotationToXml.put( Id.class, "id" ); - annotationToXml.put( EmbeddedId.class, "embedded-id" ); - annotationToXml.put( GeneratedValue.class, "generated-value" ); - annotationToXml.put( Column.class, "column" ); - annotationToXml.put( Columns.class, "column" ); - annotationToXml.put( Temporal.class, "temporal" ); - annotationToXml.put( Lob.class, "lob" ); - annotationToXml.put( Enumerated.class, "enumerated" ); - annotationToXml.put( Version.class, "version" ); - annotationToXml.put( Transient.class, "transient" ); - annotationToXml.put( Basic.class, "basic" ); - annotationToXml.put( Embedded.class, "embedded" ); - annotationToXml.put( ManyToOne.class, "many-to-one" ); - annotationToXml.put( OneToOne.class, "one-to-one" ); - annotationToXml.put( OneToMany.class, "one-to-many" ); - annotationToXml.put( ManyToMany.class, "many-to-many" ); - annotationToXml.put( Any.class, "any" ); - annotationToXml.put( ManyToAny.class, "many-to-any" ); - annotationToXml.put( JoinTable.class, "join-table" ); - annotationToXml.put( JoinColumn.class, "join-column" ); - annotationToXml.put( JoinColumns.class, "join-column" ); - annotationToXml.put( MapKey.class, "map-key" ); - annotationToXml.put( OrderBy.class, "order-by" ); - annotationToXml.put( EntityListeners.class, "entity-listeners" ); - annotationToXml.put( PrePersist.class, "pre-persist" ); - annotationToXml.put( PreRemove.class, "pre-remove" ); - annotationToXml.put( PreUpdate.class, "pre-update" ); - annotationToXml.put( PostPersist.class, "post-persist" ); - annotationToXml.put( PostRemove.class, "post-remove" ); - annotationToXml.put( PostUpdate.class, "post-update" ); - annotationToXml.put( PostLoad.class, "post-load" ); - annotationToXml.put( CollectionTable.class, "collection-table" ); - annotationToXml.put( MapKeyClass.class, "map-key-class" ); - annotationToXml.put( MapKeyTemporal.class, "map-key-temporal" ); - annotationToXml.put( MapKeyEnumerated.class, "map-key-enumerated" ); - annotationToXml.put( MapKeyColumn.class, "map-key-column" ); - annotationToXml.put( MapKeyJoinColumn.class, "map-key-join-column" ); - annotationToXml.put( MapKeyJoinColumns.class, "map-key-join-column" ); - annotationToXml.put( OrderColumn.class, "order-column" ); - annotationToXml.put( Cacheable.class, "cacheable" ); - annotationToXml.put( Index.class, "index" ); - annotationToXml.put( ForeignKey.class, "foreign-key" ); - annotationToXml.put( Convert.class, "convert" ); - annotationToXml.put( Converts.class, "convert" ); - annotationToXml.put( ConstructorResult.class, "constructor-result" ); - annotationToXml.put( Type.class, "type" ); - annotationToXml.put( JdbcTypeCode.class, "jdbc-type-code" ); - annotationToXml.put( UuidGenerator.class, "uuid-generator" ); - } - - private final XMLContext xmlContext; - private final ClassLoaderAccess classLoaderAccess; - private final AnnotatedElement element; - private final String className; - private final String propertyName; - private final PropertyType propertyType; - private transient Annotation[] annotations; - private transient Map annotationsMap; - private transient PropertyMappingElementCollector elementsForProperty; - private AccessibleObject mirroredAttribute; - - JPAXMLOverriddenAnnotationReader( - AnnotatedElement el, - XMLContext xmlContext, - ClassLoaderAccess classLoaderAccess) { - this.element = el; - this.xmlContext = xmlContext; - this.classLoaderAccess = classLoaderAccess; - - if ( el instanceof Class clazz ) { - className = clazz.getName(); - propertyName = null; - propertyType = null; - } - else if ( el instanceof Field field ) { - className = field.getDeclaringClass().getName(); - propertyName = field.getName(); - propertyType = PropertyType.FIELD; - String expectedGetter = "get" + Character.toUpperCase( propertyName.charAt( 0 ) ) + propertyName.substring( - 1 - ); - try { - mirroredAttribute = field.getDeclaringClass().getDeclaredMethod( expectedGetter ); - } - catch (NoSuchMethodException e) { - //no method - } - } - else if ( el instanceof Method method ) { - className = method.getDeclaringClass().getName(); - String methodName = method.getName(); - - // YUCK! The null here is the 'boundType', we'd rather get the TypeEnvironment() - if ( ReflectionUtil.isProperty( method, null, PersistentAttributeFilter.INSTANCE ) ) { - if ( methodName.startsWith( "get" ) ) { - propertyName = Introspector.decapitalize( methodName.substring( "get".length() ) ); - } - else if ( methodName.startsWith( "is" ) ) { - propertyName = Introspector.decapitalize( methodName.substring( "is".length() ) ); - } - else { - throw new RuntimeException( "Method " + methodName + " is not a property getter" ); - } - propertyType = PropertyType.PROPERTY; - try { - mirroredAttribute = method.getDeclaringClass().getDeclaredField( propertyName ); - } - catch (NoSuchFieldException e) { - //no method - } - } - else { - propertyName = methodName; - propertyType = PropertyType.METHOD; - } - } - else { - className = null; - propertyName = null; - propertyType = null; - } - } - - // For tests only - public JPAXMLOverriddenAnnotationReader( - AnnotatedElement el, - XMLContext xmlContext, - BootstrapContext bootstrapContext) { - this( el, xmlContext, bootstrapContext.getClassLoaderAccess() ); - } - - public T getAnnotation(Class annotationType) { - initAnnotations(); - return (T) annotationsMap.get( annotationType ); - } - - public boolean isAnnotationPresent(Class annotationType) { - initAnnotations(); - return annotationsMap.containsKey( annotationType ); - } - - public Annotation[] getAnnotations() { - initAnnotations(); - return annotations; - } - - /* - * The idea is to create annotation proxies for the xml configuration elements. Using this proxy annotations together - * with the {@link JPAMetadataProvider} allows to handle xml configuration the same way as annotation configuration. - */ - private void initAnnotations() { - if ( annotations == null ) { - // We don't want the global catalog and schema here: they are applied much later, - // when SQL gets rendered. - XMLContext.Default defaults = xmlContext.getDefaultWithoutGlobalCatalogAndSchema( className ); - if ( className != null && propertyName == null ) { - //is a class - final JaxbManagedType managedTypeOverride = xmlContext.getManagedTypeOverride( className ); - Annotation[] annotations = getPhysicalAnnotations(); - List annotationList = new ArrayList<>( annotations.length + 5 ); - annotationsMap = new HashMap<>( annotations.length + 5 ); - for ( Annotation annotation : annotations ) { - if ( !annotationToXml.containsKey( annotation.annotationType() ) ) { - //unknown annotations are left over - annotationList.add( annotation ); - } - } - addIfNotNull( annotationList, getEntity( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getMappedSuperclass( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getEmbeddable( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getTable( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getSecondaryTables( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getPrimaryKeyJoinColumns( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getIdClass( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getCacheable( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getCaching( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getInheritance( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getDiscriminatorValue( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getDiscriminatorColumn( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getSequenceGenerator( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getTableGenerator( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getNamedQueries( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getNamedNativeQueries( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getNamedStoredProcedureQueries( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getNamedEntityGraphs( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getSqlResultSetMappings( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getExcludeDefaultListeners( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getExcludeSuperclassListeners( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getAccessType( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getAttributeOverrides( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getAssociationOverrides( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getEntityListeners( managedTypeOverride, defaults ) ); - addIfNotNull( annotationList, getConverts( managedTypeOverride, defaults ) ); - - this.annotations = annotationList.toArray( new Annotation[0] ); - for ( Annotation ann : this.annotations ) { - annotationsMap.put( ann.annotationType(), ann ); - } - checkForOrphanProperties( managedTypeOverride ); - } - else if ( className != null ) { //&& propertyName != null ) { //always true but less confusing - final JaxbManagedType managedTypeOverride = xmlContext.getManagedTypeOverride( className ); - final JaxbEntityListenerImpl entityListenerOverride = xmlContext.getEntityListenerOverride( className ); - Annotation[] annotations = getPhysicalAnnotations(); - List annotationList = new ArrayList<>( annotations.length + 5 ); - annotationsMap = new HashMap<>( annotations.length + 5 ); - for ( Annotation annotation : annotations ) { - if ( !annotationToXml.containsKey( annotation.annotationType() ) ) { - //unknown annotations are left over - annotationList.add( annotation ); - } - } - preCalculateElementsForProperty( managedTypeOverride, entityListenerOverride ); - Transient transientAnn = getTransient( defaults ); - if ( transientAnn != null ) { - annotationList.add( transientAnn ); - } - else { - if ( defaults.canUseJavaAnnotations() ) { - Annotation annotation = getPhysicalAnnotation( Access.class ); - addIfNotNull( annotationList, annotation ); - } - getId( annotationList, defaults ); - getEmbeddedId( annotationList, defaults ); - getEmbedded( annotationList, defaults ); - getBasic( annotationList, defaults ); - getVersion( annotationList, defaults ); - getManyToOne( annotationList, defaults ); - getOneToOne( annotationList, defaults ); - getOneToMany( annotationList, defaults ); - getManyToMany( annotationList, defaults ); - getAny( annotationList, defaults ); - getManyToAny( annotationList, defaults ); - getElementCollection( annotationList, defaults ); - addIfNotNull( annotationList, getSequenceGenerator( elementsForProperty, defaults ) ); - addIfNotNull( annotationList, getTableGenerator( elementsForProperty, defaults ) ); - addIfNotNull( annotationList, getConvertsForAttribute( elementsForProperty, defaults ) ); - } - processEventAnnotations( annotationList, defaults ); - //FIXME use annotationsMap rather than annotationList this will be faster since the annotation type is usually known at put() time - this.annotations = annotationList.toArray( new Annotation[0] ); - for ( Annotation ann : this.annotations ) { - annotationsMap.put( ann.annotationType(), ann ); - } - } - else { - this.annotations = getPhysicalAnnotations(); - annotationsMap = new HashMap<>( annotations.length + 5 ); - for ( Annotation ann : this.annotations ) { - annotationsMap.put( ann.annotationType(), ann ); - } - } - } - } - - private Annotation getConvertsForAttribute(PropertyMappingElementCollector elementsForProperty, XMLContext.Default defaults) { - final Map convertAnnotationsMap = new HashMap<>(); - - for ( JaxbBasicImpl element : elementsForProperty.getBasic() ) { - JaxbConvertImpl convert = element.getConvert(); - if ( convert != null ) { - applyXmlDefinedConverts( Collections.singletonList( convert ), defaults, null, - convertAnnotationsMap ); - } - } - for ( JaxbEmbeddedImpl element : elementsForProperty.getEmbedded() ) { - applyXmlDefinedConverts( element.getConverts(), defaults, propertyName, convertAnnotationsMap ); - } - for ( JaxbElementCollectionImpl element : elementsForProperty.getElementCollection() ) { - applyXmlDefinedConverts( element.getConverts(), defaults, propertyName, convertAnnotationsMap ); - } - - // NOTE : per section 12.2.3.16 of the spec is additive, although only if "metadata-complete" is not - // specified in the XML - - if ( defaults.canUseJavaAnnotations() ) { - // todo : note sure how to best handle attributeNamePrefix here - applyPhysicalConvertAnnotations( propertyName, convertAnnotationsMap ); - } - - if ( !convertAnnotationsMap.isEmpty() ) { - final AnnotationDescriptor groupingDescriptor = new AnnotationDescriptor( Converts.class ); - groupingDescriptor.setValue( - "value", - convertAnnotationsMap.values().toArray( new Convert[0] ) - ); - return AnnotationFactory.create( groupingDescriptor ); - } - - return null; - } - - private Converts getConverts(JaxbManagedType root, XMLContext.Default defaults) { - // NOTE : we use a map here to make sure that an xml and annotation referring to the same attribute - // properly overrides. Bit sparse, but easy... - final Map convertAnnotationsMap = new HashMap<>(); - - if ( root instanceof JaxbEntityImpl ) { - applyXmlDefinedConverts( ( (JaxbEntityImpl) root ).getConverts(), defaults, null, convertAnnotationsMap ); - } - - // NOTE : per section 12.2.3.16 of the spec is additive, although only if "metadata-complete" is not - // specified in the XML - - if ( defaults.canUseJavaAnnotations() ) { - applyPhysicalConvertAnnotations( null, convertAnnotationsMap ); - } - - if ( !convertAnnotationsMap.isEmpty() ) { - final AnnotationDescriptor groupingDescriptor = new AnnotationDescriptor( Converts.class ); - groupingDescriptor.setValue( - "value", - convertAnnotationsMap.values().toArray( new Convert[0] ) - ); - return AnnotationFactory.create( groupingDescriptor ); - } - - return null; - } - - private void applyXmlDefinedConverts( - List elements, - XMLContext.Default defaults, - String attributeNamePrefix, - Map convertAnnotationsMap) { - for ( JaxbConvertImpl convertElement : elements ) { - final AnnotationDescriptor convertAnnotationDescriptor = new AnnotationDescriptor( Convert.class ); - copyAttribute( convertAnnotationDescriptor, "attribute-name", convertElement.getAttributeName(), false ); - copyAttribute( convertAnnotationDescriptor, "disable-conversion", convertElement.isDisableConversion(), false ); - - final String converter = convertElement.getConverter(); - if ( converter != null ) { - final String converterClassName = XMLContext.buildSafeClassName( - converter, - defaults - ); - try { - final Class converterClass = classLoaderAccess.classForName( converterClassName ); - convertAnnotationDescriptor.setValue( "converter", converterClass ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find specified converter class id-class: " + converterClassName, e ); - } - } - final Convert convertAnnotation = AnnotationFactory.create( convertAnnotationDescriptor ); - final String qualifiedAttributeName = qualifyConverterAttributeName( - attributeNamePrefix, - convertAnnotation.attributeName() - ); - convertAnnotationsMap.put( qualifiedAttributeName, convertAnnotation ); - } - - } - - private String qualifyConverterAttributeName(String attributeNamePrefix, String specifiedAttributeName) { - String qualifiedAttributeName; - if ( isNotEmpty( specifiedAttributeName ) ) { - if ( isNotEmpty( attributeNamePrefix ) ) { - qualifiedAttributeName = attributeNamePrefix + '.' + specifiedAttributeName; - } - else { - qualifiedAttributeName = specifiedAttributeName; - } - } - else { - qualifiedAttributeName = ""; - } - return qualifiedAttributeName; - } - - private void applyPhysicalConvertAnnotations( - String attributeNamePrefix, - Map convertAnnotationsMap) { - final Convert physicalAnnotation = getPhysicalAnnotation( Convert.class ); - if ( physicalAnnotation != null ) { - // only add if no XML element named a converter for this attribute - final String qualifiedAttributeName = qualifyConverterAttributeName( attributeNamePrefix, physicalAnnotation.attributeName() ); - if ( !convertAnnotationsMap.containsKey( qualifiedAttributeName ) ) { - convertAnnotationsMap.put( qualifiedAttributeName, physicalAnnotation ); - } - } - final Converts physicalGroupingAnnotation = getPhysicalAnnotation( Converts.class ); - if ( physicalGroupingAnnotation != null ) { - for ( Convert convertAnnotation : physicalGroupingAnnotation.value() ) { - // again, only add if no XML element named a converter for this attribute - final String qualifiedAttributeName = qualifyConverterAttributeName( attributeNamePrefix, convertAnnotation.attributeName() ); - if ( !convertAnnotationsMap.containsKey( qualifiedAttributeName ) ) { - convertAnnotationsMap.put( qualifiedAttributeName, convertAnnotation ); - } - } - } - } - - private void checkForOrphanProperties(JaxbManagedType root) { - Class clazz; - try { - clazz = classLoaderAccess.classForName( className ); - } - catch (ClassLoadingException e) { - //a primitive type most likely - return; - } - JaxbAttributesContainer container = root != null ? root.getAttributes() : null; - //put entity.attributes elements - if ( container != null ) { - //precompute the list of properties - //TODO is it really useful... - Set properties = new HashSet<>(); - for ( Field field : clazz.getFields() ) { - properties.add( field.getName() ); - } - for ( Method method : clazz.getMethods() ) { - String name = method.getName(); - if ( name.startsWith( "get" ) ) { - properties.add( Introspector.decapitalize( name.substring( "get".length() ) ) ); - } - else if ( name.startsWith( "is" ) ) { - properties.add( Introspector.decapitalize( name.substring( "is".length() ) ) ); - } - } - if ( container instanceof JaxbAttributesContainerImpl jaxbAttributes ) { - checkForOrphanProperties( jaxbAttributes.getIdAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( jaxbAttributes.getEmbeddedIdAttribute(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( jaxbAttributes.getVersion(), properties, PERSISTENT_ATTRIBUTE_NAME ); - } - checkForOrphanProperties( container.getBasicAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( container.getManyToOneAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( container.getOneToManyAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( container.getOneToOneAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( container.getManyToManyAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( container.getElementCollectionAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( container.getEmbeddedAttributes(), properties, PERSISTENT_ATTRIBUTE_NAME ); - checkForOrphanProperties( container.getTransients(), properties, JAXB_TRANSIENT_NAME ); - } - } - - private void checkForOrphanProperties( - List elements, - Set properties, - Function nameGetter) { - for ( T element : elements ) { - checkForOrphanProperties( element, properties, nameGetter ); - } - } - - private void checkForOrphanProperties( - T element, - Set properties, - Function nameGetter) { - if ( element == null ) { - return; - } - String propertyName = nameGetter.apply( element ); - if ( !properties.contains( propertyName ) ) { - LOG.propertyNotFound( StringHelper.qualify( className, propertyName ) ); - } - } - - /** - * Adds {@code annotation} to the list (only if it's not null) and then returns it. - * - * @param annotationList The list of annotations. - * @param annotation The annotation to add to the list. - * @return The annotation which was added to the list or {@code null}. - */ - private void addIfNotNull(List annotationList, Annotation annotation) { - if ( annotation != null ) { - annotationList.add( annotation ); - } - } - - private Annotation getTableGenerator(PropertyMappingElementCollector elementsForProperty, XMLContext.Default defaults) { - for ( JaxbIdImpl element : elementsForProperty.getId() ) { - JaxbTableGeneratorImpl subelement = element.getTableGenerator(); - if ( subelement != null ) { - return buildTableGeneratorAnnotation( subelement, defaults ); - } - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( TableGenerator.class ); - } - else { - return null; - } - } - - private Annotation getSequenceGenerator(PropertyMappingElementCollector elementsForProperty, XMLContext.Default defaults) { - for ( JaxbIdImpl element : elementsForProperty.getId() ) { - JaxbSequenceGeneratorImpl subelement = element.getSequenceGenerator(); - if ( subelement != null ) { - return buildSequenceGeneratorAnnotation( subelement ); - } - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( SequenceGenerator.class ); - } - else { - return null; - } - } - - private void processEventAnnotations(List annotationList, XMLContext.Default defaults) { - boolean eventElement = false; - if ( !elementsForProperty.getPrePersist().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PrePersist.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - eventElement = true; - } - else if ( !elementsForProperty.getPreRemove().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PreRemove.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - eventElement = true; - } - else if ( !elementsForProperty.getPreUpdate().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PreUpdate.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - eventElement = true; - } - else if ( !elementsForProperty.getPostPersist().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PostPersist.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - eventElement = true; - } - else if ( !elementsForProperty.getPostRemove().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PostRemove.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - eventElement = true; - } - else if ( !elementsForProperty.getPostUpdate().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PostUpdate.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - eventElement = true; - } - else if ( !elementsForProperty.getPostLoad().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PostLoad.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - eventElement = true; - } - if ( !eventElement && defaults.canUseJavaAnnotations() ) { - Annotation ann = getPhysicalAnnotation( PrePersist.class ); - addIfNotNull( annotationList, ann ); - ann = getPhysicalAnnotation( PreRemove.class ); - addIfNotNull( annotationList, ann ); - ann = getPhysicalAnnotation( PreUpdate.class ); - addIfNotNull( annotationList, ann ); - ann = getPhysicalAnnotation( PostPersist.class ); - addIfNotNull( annotationList, ann ); - ann = getPhysicalAnnotation( PostRemove.class ); - addIfNotNull( annotationList, ann ); - ann = getPhysicalAnnotation( PostUpdate.class ); - addIfNotNull( annotationList, ann ); - ann = getPhysicalAnnotation( PostLoad.class ); - addIfNotNull( annotationList, ann ); - } - } - - private EntityListeners getEntityListeners(JaxbManagedType root, XMLContext.Default defaults) { - JaxbEntityListenerContainerImpl container = root instanceof JaxbEntityOrMappedSuperclass - ? ( (JaxbEntityOrMappedSuperclass) root ).getEntityListenerContainer() - : null; - if ( container != null ) { - final List> entityListenerClasses = new ArrayList<>(); - for ( JaxbEntityListenerImpl entityListener : container.getEntityListeners() ) { - String className = entityListener.getClazz(); - try { - entityListenerClasses.add( - classLoaderAccess.classForName( - XMLContext.buildSafeClassName( className, defaults ) - ) - ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( - "Unable to find class: " + className, e - ); - } - } - AnnotationDescriptor ad = new AnnotationDescriptor( EntityListeners.class ); - ad.setValue( "value", entityListenerClasses.toArray( new Class[ 0 ] ) ); - return AnnotationFactory.create( ad ); - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( EntityListeners.class ); - } - else { - return null; - } - } - - private JoinTable overridesDefaultsInJoinTable(Annotation annotation, XMLContext.Default defaults) { - //no element but might have some default or some annotation - boolean defaultToJoinTable = !( isPhysicalAnnotationPresent( JoinColumn.class ) - || isPhysicalAnnotationPresent( JoinColumns.class ) ); - final Class annotationClass = annotation.annotationType(); - defaultToJoinTable = defaultToJoinTable && - ( ( annotationClass == ManyToMany.class && isEmpty( ( (ManyToMany) annotation ).mappedBy() ) ) - || ( annotationClass == OneToMany.class && isEmpty( ( (OneToMany) annotation ).mappedBy() ) ) - || ( annotationClass == ElementCollection.class ) - ); - final Class annotationType = JoinTable.class; - if ( defaultToJoinTable - && ( isNotEmpty( defaults.getCatalog() ) - || isNotEmpty( defaults.getSchema() ) ) ) { - AnnotationDescriptor ad = new AnnotationDescriptor( annotationType ); - if ( defaults.canUseJavaAnnotations() ) { - JoinTable table = getPhysicalAnnotation( annotationType ); - if ( table != null ) { - ad.setValue( "name", table.name() ); - ad.setValue( "schema", table.schema() ); - ad.setValue( "catalog", table.catalog() ); - ad.setValue( "uniqueConstraints", table.uniqueConstraints() ); - ad.setValue( "joinColumns", table.joinColumns() ); - ad.setValue( "inverseJoinColumns", table.inverseJoinColumns() ); - } - } - if ( isEmpty( (String) ad.valueOf( "schema" ) ) - && isNotEmpty( defaults.getSchema() ) ) { - ad.setValue( "schema", defaults.getSchema() ); - } - if ( isEmpty( (String) ad.valueOf( "catalog" ) ) - && isNotEmpty( defaults.getCatalog() ) ) { - ad.setValue( "catalog", defaults.getCatalog() ); - } - return AnnotationFactory.create( ad ); - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( annotationType ); - } - else { - return null; - } - } - - private Annotation overridesDefaultCascadePersist(Annotation annotation, XMLContext.Default defaults) { - if ( Boolean.TRUE.equals( defaults.getCascadePersist() ) ) { - final Class annotationType = annotation.annotationType(); - - if ( annotationType == ManyToOne.class ) { - ManyToOne manyToOne = (ManyToOne) annotation; - List cascades = new ArrayList<>( Arrays.asList( manyToOne.cascade() ) ); - if ( !cascades.contains( CascadeType.ALL ) && !cascades.contains( CascadeType.PERSIST ) ) { - cascades.add( CascadeType.PERSIST ); - } - else { - return annotation; - } - - AnnotationDescriptor ad = new AnnotationDescriptor( annotationType ); - ad.setValue( "cascade", cascades.toArray( new CascadeType[] {} ) ); - ad.setValue( "targetEntity", manyToOne.targetEntity() ); - ad.setValue( "fetch", manyToOne.fetch() ); - ad.setValue( "optional", manyToOne.optional() ); - - return AnnotationFactory.create( ad ); - } - else if ( annotationType == OneToOne.class ) { - OneToOne oneToOne = (OneToOne) annotation; - List cascades = new ArrayList<>( Arrays.asList( oneToOne.cascade() ) ); - if ( !cascades.contains( CascadeType.ALL ) && !cascades.contains( CascadeType.PERSIST ) ) { - cascades.add( CascadeType.PERSIST ); - } - else { - return annotation; - } - - AnnotationDescriptor ad = new AnnotationDescriptor( annotationType ); - ad.setValue( "cascade", cascades.toArray( new CascadeType[] {} ) ); - ad.setValue( "targetEntity", oneToOne.targetEntity() ); - ad.setValue( "fetch", oneToOne.fetch() ); - ad.setValue( "optional", oneToOne.optional() ); - ad.setValue( "mappedBy", oneToOne.mappedBy() ); - ad.setValue( "orphanRemoval", oneToOne.orphanRemoval() ); - - return AnnotationFactory.create( ad ); - } - } - return annotation; - } - - private void getJoinTable( - List annotationList, - JaxbJoinTableCapable associationAttribute, - XMLContext.Default defaults) { - addIfNotNull( annotationList, buildJoinTable( associationAttribute.getJoinTable(), defaults ) ); - } - - /* - * no partial overriding possible - */ - private JoinTable buildJoinTable(JaxbJoinTableImpl subelement, XMLContext.Default defaults) { - final Class annotationType = JoinTable.class; - if ( subelement == null ) { - return null; - } - //ignore java annotation, an element is defined - AnnotationDescriptor annotation = new AnnotationDescriptor( annotationType ); - copyAttribute( annotation, "name", subelement.getName(), false ); - copyAttribute( annotation, "catalog", subelement.getCatalog(), false ); - if ( isNotEmpty( defaults.getCatalog() ) - && isEmpty( (String) annotation.valueOf( "catalog" ) ) ) { - annotation.setValue( "catalog", defaults.getCatalog() ); - } - copyAttribute( annotation, "schema", subelement.getSchema(), false ); - if ( isNotEmpty( defaults.getSchema() ) - && isEmpty( (String) annotation.valueOf( "schema" ) ) ) { - annotation.setValue( "schema", defaults.getSchema() ); - } - buildUniqueConstraints( annotation, subelement.getUniqueConstraints() ); - buildIndex( annotation, subelement.getIndexes() ); - annotation.setValue( "joinColumns", getJoinColumns( subelement.getJoinColumn(), false ) ); - annotation.setValue( "inverseJoinColumns", getJoinColumns( subelement.getInverseJoinColumn(), true ) ); - return AnnotationFactory.create( annotation ); - } - - private void getOneToMany(List annotationList, XMLContext.Default defaults) { - Class annotationType = OneToMany.class; - List elements = elementsForProperty.getOneToMany(); - for ( JaxbOneToManyImpl element : elements ) { - AnnotationDescriptor ad = new AnnotationDescriptor( annotationType ); - addTargetClass( element.getTargetEntity(), ad, "target-entity", defaults ); - getFetchType( ad, element.getFetch() ); - getCascades( ad, element.getCascade(), defaults ); - getJoinTable( annotationList, element, defaults ); - buildJoinColumns( annotationList, element.getJoinColumn() ); - copyAttribute( ad, "orphan-removal", element.isOrphanRemoval(), false ); - copyAttribute( ad, "mapped-by", element.getMappedBy(), false ); - annotationList.add( AnnotationFactory.create( ad ) ); - - getOrderBy( annotationList, element.getOrderBy() ); - getMapKey( annotationList, element.getMapKey() ); - getMapKeyClass( annotationList, element.getMapKeyClass(), defaults ); - getMapKeyColumn( annotationList, element.getMapKeyColumn() ); - getOrderColumn( annotationList, element.getOrderColumn() ); - getMapKeyTemporal( annotationList, element.getMapKeyTemporal() ); - getMapKeyEnumerated( annotationList, element.getMapKeyEnumerated() ); - Annotation annotation = getMapKeyAttributeOverrides( element.getMapKeyAttributeOverrides(), defaults ); - addIfNotNull( annotationList, annotation ); - getMapKeyJoinColumns( annotationList, element.getMapKeyJoinColumns() ); - getAccessType( annotationList, element.getAccess() ); - } - afterGetAssociation( annotationType, annotationList, defaults ); - } - - /** - * As per section 12.2 of the JPA 2.0 specification, the association - * subelements (many-to-one, one-to-many, one-to-one, many-to-many, - * element-collection) completely override the mapping for the specified - * field or property. Thus, any methods which might in some contexts merge - * with annotations must not do so in this context. - * - * @see #getElementCollection(List, XMLContext.Default) - */ - private void getOneToOne(List annotationList, XMLContext.Default defaults) { - Class annotationType = OneToOne.class; - List elements = elementsForProperty.getOneToOne(); - for ( JaxbOneToOneImpl element : elements ) { - AnnotationDescriptor ad = new AnnotationDescriptor( annotationType ); - addTargetClass( element.getTargetEntity(), ad, "target-entity", defaults ); - getFetchType( ad, element.getFetch() ); - getCascades( ad, element.getCascade(), defaults ); - getJoinTable( annotationList, element, defaults ); - buildJoinColumns( annotationList, element.getJoinColumn() ); - Annotation annotation = getPrimaryKeyJoinColumns( element.getPrimaryKeyJoinColumn(), defaults, false ); - addIfNotNull( annotationList, annotation ); - copyAttribute( ad, "optional", element.isOptional(), false ); - copyAttribute( ad, "orphan-removal", element.isOrphanRemoval(), false ); - copyAttribute( ad, "mapped-by", element.getMappedBy(), false ); - annotationList.add( AnnotationFactory.create( ad ) ); - - getAssociationId( annotationList, element.isId() ); - getMapsId( annotationList, element.getMapsId() ); - getAccessType( annotationList, element.getAccess() ); - } - afterGetAssociation( annotationType, annotationList, defaults ); - } - - /** - * @see #getOneToOne(List, XMLContext.Default) - * @see #getElementCollection(List, XMLContext.Default) - */ - private void getManyToOne(List annotationList, XMLContext.Default defaults) { - Class annotationType = ManyToOne.class; - List elements = elementsForProperty.getManyToOne(); - for ( JaxbManyToOneImpl element : elements ) { - AnnotationDescriptor ad = new AnnotationDescriptor( annotationType ); - addTargetClass( element.getTargetEntity(), ad, "target-entity", defaults ); - getFetchType( ad, element.getFetch() ); - getCascades( ad, element.getCascade(), defaults ); - getJoinTable( annotationList, element, defaults ); - buildJoinColumns( annotationList, element.getJoinColumns() ); - copyAttribute( ad, "optional", element.isOptional(), false ); - annotationList.add( AnnotationFactory.create( ad ) ); - - getAssociationId( annotationList, element.isId() ); - getMapsId( annotationList, element.getMapsId() ); - getAccessType( annotationList, element.getAccess() ); - } - afterGetAssociation( annotationType, annotationList, defaults ); - } - - /** - * @see #getOneToOne(List, XMLContext.Default) - * @see #getElementCollection(List, XMLContext.Default) - */ - private void getManyToMany(List annotationList, XMLContext.Default defaults) { - Class annotationType = ManyToMany.class; - List elements = elementsForProperty.getManyToMany(); - for ( JaxbManyToManyImpl element : elements ) { - AnnotationDescriptor ad = new AnnotationDescriptor( annotationType ); - addTargetClass( element.getTargetEntity(), ad, "target-entity", defaults ); - getFetchType( ad, element.getFetch() ); - getCascades( ad, element.getCascade(), defaults ); - getJoinTable( annotationList, element, defaults ); - copyAttribute( ad, "mapped-by", element.getMappedBy(), false ); - annotationList.add( AnnotationFactory.create( ad ) ); - - getOrderBy( annotationList, element.getOrderBy() ); - getMapKey( annotationList, element.getMapKey() ); - getMapKeyClass( annotationList, element.getMapKeyClass(), defaults ); - getMapKeyColumn( annotationList, element.getMapKeyColumn() ); - getOrderColumn( annotationList, element.getOrderColumn() ); - getMapKeyTemporal( annotationList, element.getMapKeyTemporal() ); - getMapKeyEnumerated( annotationList, element.getMapKeyEnumerated() ); - Annotation annotation = getMapKeyAttributeOverrides( element.getMapKeyAttributeOverrides(), defaults ); - addIfNotNull( annotationList, annotation ); - getMapKeyJoinColumns( annotationList, element.getMapKeyJoinColumns() ); - getAccessType( annotationList, element.getAccess() ); - } - afterGetAssociation( annotationType, annotationList, defaults ); - } - - private void getAny(List annotationList, XMLContext.Default defaults) { - // No support for "any" in JPA's orm.xml; we will just use the "physical" annotations. - // TODO HHH-10176 We should allow "any" associations, but the JPA XSD doesn't allow that. We would need our own XSD. - afterGetAssociation( Any.class, annotationList, defaults ); - } - - private void getManyToAny(List annotationList, XMLContext.Default defaults) { - // No support for "many-to-any" in JPA's orm.xml; we will just use the annotations. - // TODO HHH-10176 We should allow "many-to-any" associations, but the JPA XSD doesn't allow that. We would need our own XSD. - afterGetAssociation( ManyToAny.class, annotationList, defaults ); - } - - private void afterGetAssociation( - Class annotationType, - List annotationList, - XMLContext.Default defaults) { - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - Annotation annotation = getPhysicalAnnotation( annotationType ); - if ( annotation != null ) { - annotation = overridesDefaultCascadePersist( annotation, defaults ); - annotationList.add( annotation ); - annotation = overridesDefaultsInJoinTable( annotation, defaults ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( JoinColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( JoinColumns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( PrimaryKeyJoinColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( PrimaryKeyJoinColumns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKey.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( OrderBy.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Lob.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Enumerated.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Temporal.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Column.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Columns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyClass.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyTemporal.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyEnumerated.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyJoinColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyJoinColumns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( OrderColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Cascade.class ); - addIfNotNull( annotationList, annotation ); - } - else if ( isPhysicalAnnotationPresent( ElementCollection.class ) ) { //JPA2 - annotation = overridesDefaultsInJoinTable( getPhysicalAnnotation( ElementCollection.class ), defaults ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKey.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( OrderBy.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Lob.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Enumerated.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Temporal.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Column.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( OrderColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyClass.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyTemporal.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyEnumerated.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyJoinColumn.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( MapKeyJoinColumns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( CollectionTable.class ); - addIfNotNull( annotationList, annotation ); - } - } - } - - private void getMapKeyJoinColumns(List annotationList, List elements) { - MapKeyJoinColumn[] joinColumns = buildMapKeyJoinColumns( elements ); - if ( joinColumns.length > 0 ) { - AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyJoinColumns.class ); - ad.setValue( "value", joinColumns ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private MapKeyJoinColumn[] buildMapKeyJoinColumns(List elements) { - List joinColumns = new ArrayList<>(); - if ( elements != null ) { - for ( JaxbMapKeyJoinColumnImpl element : elements ) { - AnnotationDescriptor column = new AnnotationDescriptor( MapKeyJoinColumn.class ); - copyAttribute( column, "name", element.getName(), false ); - copyAttribute( column, "referenced-column-name", element.getReferencedColumnName(), false ); - copyAttribute( column, "unique", element.isUnique(), false ); - copyAttribute( column, "nullable", element.isNullable(), false ); - copyAttribute( column, "insertable", element.isInsertable(), false ); - copyAttribute( column, "updatable", element.isUpdatable(), false ); - copyAttribute( column, "column-definition", element.getColumnDefinition(), false ); - copyAttribute( column, "table", element.getTable(), false ); - joinColumns.add( AnnotationFactory.create( column ) ); - } - } - return joinColumns.toArray( new MapKeyJoinColumn[ 0 ] ); - } - - private AttributeOverrides getMapKeyAttributeOverrides(List elements, XMLContext.Default defaults) { - List attributes = buildAttributeOverrides( elements, "map-key-attribute-override" ); - return mergeAttributeOverrides( defaults, attributes, false ); - } - - private Cache getCaching(JaxbManagedType root, XMLContext.Default defaults) { - if ( root instanceof JaxbEntityImpl jaxbEntity ) { - final JaxbCachingImpl caching = jaxbEntity.getCaching(); - if ( caching != null ) { - final AnnotationDescriptor ad = new AnnotationDescriptor( Cache.class ); - ad.setValue( "usage", CacheConcurrencyStrategy.fromAccessType( caching.getAccess() ) ); - ad.setValue( "region", caching.getRegion() ); - ad.setValue( "includeLazy", caching.isIncludeLazy() ); - return AnnotationFactory.create( ad ); - } - } - - if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( Cache.class ); - } - else { - return null; - } - } - - private Cacheable getCacheable(JaxbManagedType root, XMLContext.Default defaults) { - if ( root instanceof JaxbEntityImpl jaxbRootEntity ) { - Boolean attValue = jaxbRootEntity.isCacheable(); - if ( attValue != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Cacheable.class ); - ad.setValue( "value", attValue ); - return AnnotationFactory.create( ad ); - } - } - if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( Cacheable.class ); - } - else { - return null; - } - } - - /** - * Adds a @MapKeyEnumerated annotation to the specified annotationList if the specified element - * contains a map-key-enumerated sub-element. This should only be the case for - * element-collection, many-to-many, or one-to-many associations. - */ - private void getMapKeyEnumerated(List annotationList, EnumType enumType) { - if ( enumType != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyEnumerated.class ); - ad.setValue( "value", enumType ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - /** - * Adds a @MapKeyTemporal annotation to the specified annotationList if the specified element - * contains a map-key-temporal sub-element. This should only be the case for element-collection, - * many-to-many, or one-to-many associations. - */ - private void getMapKeyTemporal(List annotationList, TemporalType temporalType) { - if ( temporalType != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyTemporal.class ); - ad.setValue( "value", temporalType ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - /** - * Adds an @OrderColumn annotation to the specified annotationList if the specified element - * contains an order-column sub-element. This should only be the case for element-collection, - * many-to-many, or one-to-many associations. - */ - private void getOrderColumn(List annotationList, JaxbOrderColumnImpl element) { - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( OrderColumn.class ); - copyAttribute( ad, "name", element.getName(), false ); - copyAttribute( ad, "nullable", element.isNullable(), false ); - copyAttribute( ad, "insertable", element.isInsertable(), false ); - copyAttribute( ad, "updatable", element.isUpdatable(), false ); - copyAttribute( ad, "column-definition", element.getColumnDefinition(), false ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - /** - * Adds a @MapsId annotation to the specified annotationList if the specified element has the - * maps-id attribute set. This should only be the case for many-to-one or one-to-one - * associations. - */ - private void getMapsId(List annotationList, String mapsId) { - if ( mapsId != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( MapsId.class ); - ad.setValue( "value", mapsId ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - /** - * Adds an @Id annotation to the specified annotationList if the specified element has the id - * attribute set to true. This should only be the case for many-to-one or one-to-one - * associations. - */ - private void getAssociationId(List annotationList, Boolean isId) { - if ( Boolean.TRUE.equals( isId ) ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Id.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void addTargetClass(String className, AnnotationDescriptor ad, String nodeName, XMLContext.Default defaults) { - if ( className != null ) { - Class clazz; - try { - clazz = classLoaderAccess.classForName( XMLContext.buildSafeClassName( className, defaults ) ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find " + nodeName + ": " + className, e ); - } - ad.setValue( getJavaAttributeNameFromXMLOne( nodeName ), clazz ); - } - } - - /** - * As per sections 12.2.3.23.9, 12.2.4.8.9 and 12.2.5.3.6 of the JPA 2.0 - * specification, the element-collection subelement completely overrides the - * mapping for the specified field or property. Thus, any methods which - * might in some contexts merge with annotations must not do so in this - * context. - */ - private void getElementCollection(List annotationList, XMLContext.Default defaults) { - for ( JaxbElementCollectionImpl element : elementsForProperty.getElementCollection() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( ElementCollection.class ); - addTargetClass( element.getTargetClass(), ad, "target-class", defaults ); - getFetchType( ad, element.getFetch() ); - getOrderBy( annotationList, element.getOrderBy() ); - getOrderColumn( annotationList, element.getOrderColumn() ); - getMapKey( annotationList, element.getMapKey() ); - getMapKeyClass( annotationList, element.getMapKeyClass(), defaults ); - getMapKeyTemporal( annotationList, element.getMapKeyTemporal() ); - getMapKeyEnumerated( annotationList, element.getMapKeyEnumerated() ); - getMapKeyColumn( annotationList, element.getMapKeyColumn() ); - getMapKeyJoinColumns( annotationList, element.getMapKeyJoinColumns() ); - Annotation annotation = getColumn( element.getColumn(), false, "element-collection" ); - addIfNotNull( annotationList, annotation ); - getTemporal( annotationList, element.getTemporal() ); - getEnumerated( annotationList, element.getEnumerated() ); - getLob( annotationList, element.getLob() ); - //Both map-key-attribute-overrides and attribute-overrides - //translate into AttributeOverride annotations, which need - //need to be wrapped in the same AttributeOverrides annotation. - List attributes = new ArrayList<>(); - attributes.addAll( buildAttributeOverrides( element.getMapKeyAttributeOverrides(), "map-key-attribute-override" ) ); - attributes.addAll( buildAttributeOverrides( element.getAttributeOverrides(), "attribute-override" ) ); - annotation = mergeAttributeOverrides( defaults, attributes, false ); - addIfNotNull( annotationList, annotation ); - annotation = getAssociationOverrides( element.getAssociationOverrides(), defaults, false ); - addIfNotNull( annotationList, annotation ); - getCollectionTable( annotationList, element.getCollectionTable(), defaults ); - annotationList.add( AnnotationFactory.create( ad ) ); - getAccessType( annotationList, element.getAccess() ); - } - } - - private void getOrderBy(List annotationList, String orderBy) { - if ( orderBy != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( OrderBy.class ); - ad.setValue( "value", orderBy ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getMapKey(List annotationList, JaxbMapKeyImpl element) { - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( MapKey.class ); - copyAttribute( ad, "name", element.getName(), false ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getMapKeyColumn(List annotationList, JaxbMapKeyColumnImpl element) { - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyColumn.class ); - copyAttribute( ad, "name", element.getName(), false ); - copyAttribute( ad, "unique", element.isUnique(), false ); - copyAttribute( ad, "nullable", element.isNullable(), false ); - copyAttribute( ad, "insertable", element.isInsertable(), false ); - copyAttribute( ad, "updatable", element.isUpdatable(), false ); - copyAttribute( ad, "column-definition", element.getColumnDefinition(), false ); - copyAttribute( ad, "table", element.getTable(), false ); - copyAttribute( ad, "length", element.getLength(), false ); - copyAttribute( ad, "precision", element.getPrecision(), false ); - copyAttribute( ad, "scale", element.getScale(), false ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getMapKeyClass(List annotationList, JaxbMapKeyClassImpl element, XMLContext.Default defaults) { - String nodeName = "map-key-class"; - if ( element != null ) { - String mapKeyClassName = element.getClazz(); - AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyClass.class ); - if ( isNotEmpty( mapKeyClassName ) ) { - Class clazz; - try { - clazz = classLoaderAccess.classForName( - XMLContext.buildSafeClassName( mapKeyClassName, defaults ) - ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( - "Unable to find " + nodeName + ": " + mapKeyClassName, e - ); - } - ad.setValue( "value", clazz ); - } - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getCollectionTable(List annotationList, JaxbCollectionTableImpl element, XMLContext.Default defaults) { - if ( element != null ) { - AnnotationDescriptor annotation = new AnnotationDescriptor( CollectionTable.class ); - copyAttribute( annotation, "name", element.getName(), false ); - copyAttribute( annotation, "catalog", element.getCatalog(), false ); - if ( isNotEmpty( defaults.getCatalog() ) - && isEmpty( (String) annotation.valueOf( "catalog" ) ) ) { - annotation.setValue( "catalog", defaults.getCatalog() ); - } - copyAttribute( annotation, "schema", element.getSchema(), false ); - if ( isNotEmpty( defaults.getSchema() ) - && isEmpty( (String) annotation.valueOf( "schema" ) ) ) { - annotation.setValue( "schema", defaults.getSchema() ); - } - JoinColumn[] joinColumns = getJoinColumns( element.getJoinColumns(), false ); - if ( joinColumns.length > 0 ) { - annotation.setValue( "joinColumns", joinColumns ); - } - buildUniqueConstraints( annotation, element.getUniqueConstraints() ); - buildIndex( annotation, element.getIndexes() ); - annotationList.add( AnnotationFactory.create( annotation ) ); - } - } - - private void buildJoinColumns(List annotationList, List elements) { - JoinColumn[] joinColumns = getJoinColumns( elements, false ); - if ( joinColumns.length > 0 ) { - AnnotationDescriptor ad = new AnnotationDescriptor( JoinColumns.class ); - ad.setValue( "value", joinColumns ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getCascades(AnnotationDescriptor ad, JaxbCascadeTypeImpl element, XMLContext.Default defaults) { - List cascades = new ArrayList<>(); - if ( element != null ) { - if ( element.getCascadeAll() != null ) { - cascades.add( CascadeType.ALL ); - } - if ( element.getCascadePersist() != null ) { - cascades.add( CascadeType.PERSIST ); - } - if ( element.getCascadeMerge() != null ) { - cascades.add( CascadeType.MERGE ); - } - if ( element.getCascadeRemove() != null ) { - cascades.add( CascadeType.REMOVE ); - } - if ( element.getCascadeRefresh() != null ) { - cascades.add( CascadeType.REFRESH ); - } - if ( element.getCascadeDetach() != null ) { - cascades.add( CascadeType.DETACH ); - } - } - if ( Boolean.TRUE.equals( defaults.getCascadePersist() ) - && !cascades.contains( CascadeType.ALL ) && !cascades.contains( CascadeType.PERSIST ) ) { - cascades.add( CascadeType.PERSIST ); - } - if ( !cascades.isEmpty() ) { - ad.setValue( "cascade", cascades.toArray( new CascadeType[0] ) ); - } - } - - private void getEmbedded(List annotationList, XMLContext.Default defaults) { - for ( JaxbEmbeddedImpl element : elementsForProperty.getEmbedded() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Embedded.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - Annotation annotation = getAttributeOverrides( element.getAttributeOverrides(), defaults, false ); - addIfNotNull( annotationList, annotation ); - annotation = getAssociationOverrides( element.getAssociationOverrides(), defaults, false ); - addIfNotNull( annotationList, annotation ); - getAccessType( annotationList, element.getAccess() ); - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - Annotation annotation = getPhysicalAnnotation( Embedded.class ); - if ( annotation != null ) { - annotationList.add( annotation ); - annotation = getPhysicalAnnotation( AttributeOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverrides.class ); - addIfNotNull( annotationList, annotation ); - } - } - } - - private Transient getTransient(XMLContext.Default defaults) { - if ( !elementsForProperty.getTransient().isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Transient.class ); - return AnnotationFactory.create( ad ); - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( Transient.class ); - } - else { - return null; - } - } - - private void getVersion(List annotationList, XMLContext.Default defaults) { - for ( JaxbVersionImpl element : elementsForProperty.getVersion() ) { - Annotation annotation = buildColumns( element.getColumn(), "version" ); - addIfNotNull( annotationList, annotation ); - getTemporal( annotationList, element.getTemporal() ); - AnnotationDescriptor basic = new AnnotationDescriptor( Version.class ); - annotationList.add( AnnotationFactory.create( basic ) ); - getAccessType( annotationList, element.getAccess() ); - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - //we have nothing, so Java annotations might occur - Annotation annotation = getPhysicalAnnotation( Version.class ); - if ( annotation != null ) { - annotationList.add( annotation ); - annotation = getPhysicalAnnotation( Column.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Columns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Temporal.class ); - addIfNotNull( annotationList, annotation ); - } - } - } - - private void getBasic(List annotationList, XMLContext.Default defaults) { - for ( JaxbBasicImpl element : elementsForProperty.getBasic() ) { - Annotation annotation = buildColumns( element.getColumn(), "basic" ); - addIfNotNull( annotationList, annotation ); - getAccessType( annotationList, element.getAccess() ); - getTemporal( annotationList, element.getTemporal() ); - getLob( annotationList, element.getLob() ); - getEnumerated( annotationList, element.getEnumerated() ); - AnnotationDescriptor basic = new AnnotationDescriptor( Basic.class ); - getFetchType( basic, element.getFetch() ); - copyAttribute( basic, "optional", element.isOptional(), false ); - annotationList.add( AnnotationFactory.create( basic ) ); - getType( annotationList, element.getType() ); - getJdbcTypeCode( annotationList, element.getJdbcTypeCode() ); - getTenantId( annotationList, element ); - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - //no annotation presence constraint, basic is the default - Annotation annotation = getPhysicalAnnotation( Basic.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Lob.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Enumerated.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Temporal.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Column.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Columns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Type.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( JdbcTypeCode.class ); - addIfNotNull( annotationList, annotation ); - } - } - - private void getTenantId(List annotationList, JaxbBasicImpl element) { - if ( element instanceof JaxbTenantIdImpl ) { - AnnotationDescriptor ad = new AnnotationDescriptor( TenantId.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getType(List annotationList, JaxbUserTypeImpl type) { - if ( type != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Type.class ); - ad.setValue( "value", classLoaderAccess.classForName( type.getValue() ) ); - Parameter[] parameters = new Parameter[type.getParameters().size()]; - for ( int i = 0; i < parameters.length; i++ ) { - JaxbConfigurationParameterImpl parameter = type.getParameters().get( i ); - AnnotationDescriptor param = new AnnotationDescriptor( Parameter.class ); - param.setValue( "name", parameter.getName() ); - param.setValue( "value", parameter.getValue() ); - parameters[i] = AnnotationFactory.create( param ); - } - ad.setValue( "parameters", parameters ); - - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getUuidGenerator(List annotationList, JaxbUuidGeneratorImpl uuidGenerator) { - if ( uuidGenerator != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( UuidGenerator.class ); - ad.setValue( "style", uuidGenerator.getStyle() ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getJdbcTypeCode(List annotationList, Integer jdbcTypeCode) { - if ( jdbcTypeCode != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( JdbcTypeCode.class ); - ad.setValue( "value", jdbcTypeCode ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getEnumerated(List annotationList, EnumType enumType) { - if ( enumType != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Enumerated.class ); - ad.setValue( "value", enumType ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getLob(List annotationList, JaxbLobImpl element) { - if ( element != null ) { - annotationList.add( AnnotationFactory.create( new AnnotationDescriptor( Lob.class ) ) ); - } - } - - private void getFetchType(AnnotationDescriptor descriptor, FetchType type) { - if ( type != null ) { - descriptor.setValue( "fetch", type ); - } - } - - private void getEmbeddedId(List annotationList, XMLContext.Default defaults) { - for ( JaxbEmbeddedIdImpl element : elementsForProperty.getEmbeddedId() ) { - if ( isProcessingId( defaults ) ) { - Annotation annotation = getAttributeOverrides( element.getAttributeOverrides(), defaults, false ); - addIfNotNull( annotationList, annotation ); - // TODO HHH-10176 We should allow association overrides here, but the JPA XSD doesn't allow that. We would need our own XSD. - AnnotationDescriptor ad = new AnnotationDescriptor( EmbeddedId.class ); - annotationList.add( AnnotationFactory.create( ad ) ); - getAccessType( annotationList, element.getAccess() ); - } - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - Annotation annotation = getPhysicalAnnotation( EmbeddedId.class ); - if ( annotation != null ) { - annotationList.add( annotation ); - annotation = getPhysicalAnnotation( Column.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Columns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( GeneratedValue.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Temporal.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( TableGenerator.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( SequenceGenerator.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverrides.class ); - addIfNotNull( annotationList, annotation ); - } - } - } - - private void preCalculateElementsForProperty(JaxbManagedType managedType, JaxbEntityListenerImpl entityListener) { - elementsForProperty = new PropertyMappingElementCollector( propertyName ); - JaxbAttributesContainer attributes = managedType == null ? null : managedType.getAttributes(); - //put entity.attributes elements - if ( attributes != null ) { - elementsForProperty.collectPersistentAttributesIfMatching( attributes ); - } - //add pre-* etc from entity and pure entity listener classes - if ( managedType instanceof JaxbLifecycleCallbackContainer ) { - elementsForProperty.collectLifecycleCallbacksIfMatching( (JaxbLifecycleCallbackContainer) managedType ); - } - if ( entityListener != null ) { - elementsForProperty.collectLifecycleCallbacksIfMatching( entityListener ); - } - elementsForProperty.collectTenantIdIfMatching( managedType ); - } - - private void getId(List annotationList, XMLContext.Default defaults) { - for ( JaxbIdImpl element : elementsForProperty.getId() ) { - boolean processId = isProcessingId( defaults ); - if ( processId ) { - Annotation annotation = buildColumns( element.getColumn(), "id" ); - addIfNotNull( annotationList, annotation ); - annotation = buildGeneratedValue( element.getGeneratedValue() ); - addIfNotNull( annotationList, annotation ); - getTemporal( annotationList, element.getTemporal() ); - //FIXME: fix the priority of xml over java for generator names - annotation = getTableGenerator( element.getTableGenerator(), defaults ); - addIfNotNull( annotationList, annotation ); - annotation = getSequenceGenerator( element.getSequenceGenerator(), defaults ); - addIfNotNull( annotationList, annotation ); - AnnotationDescriptor id = new AnnotationDescriptor( Id.class ); - annotationList.add( AnnotationFactory.create( id ) ); - getAccessType( annotationList, element.getAccess() ); - getType( annotationList, element.getType() ); - getJdbcTypeCode( annotationList, element.getJdbcTypeCode() ); - getUuidGenerator( annotationList, element.getUuidGenerator() ); - } - } - if ( elementsForProperty.isEmpty() && defaults.canUseJavaAnnotations() ) { - Annotation annotation = getPhysicalAnnotation( Id.class ); - if ( annotation != null ) { - annotationList.add( annotation ); - annotation = getPhysicalAnnotation( Column.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Columns.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( GeneratedValue.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( Temporal.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( TableGenerator.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( SequenceGenerator.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AttributeOverrides.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverride.class ); - addIfNotNull( annotationList, annotation ); - annotation = getPhysicalAnnotation( AssociationOverrides.class ); - addIfNotNull( annotationList, annotation ); - } - } - } - - private boolean isProcessingId(XMLContext.Default defaults) { - boolean isExplicit = defaults.getAccess() != null; - boolean correctAccess = ( PropertyType.PROPERTY.equals( propertyType ) && AccessType.PROPERTY.equals( defaults.getAccess() ) ) - || ( PropertyType.FIELD.equals( propertyType ) && AccessType.FIELD.equals( defaults.getAccess() ) ); - boolean hasId = defaults.canUseJavaAnnotations() - && ( isPhysicalAnnotationPresent( Id.class ) || isPhysicalAnnotationPresent( EmbeddedId.class ) ); - boolean mirrorAttributeIsId = defaults.canUseJavaAnnotations() - && hasAnnotation( mirroredAttribute, Id.class, EmbeddedId.class ); - boolean propertyIsDefault = PropertyType.PROPERTY.equals( propertyType ) - && !mirrorAttributeIsId; - return correctAccess || ( !isExplicit && hasId ) || ( !isExplicit && propertyIsDefault ); - } - - private Columns buildColumns(JaxbColumnImpl element, String nodeName) { - if ( element == null ) { - return null; - } - List columns = new ArrayList<>( 1 ); - columns.add( getColumn( element, false, nodeName ) ); - AnnotationDescriptor columnsDescr = new AnnotationDescriptor( Columns.class ); - columnsDescr.setValue( "columns", columns.toArray( new Column[0] ) ); - return AnnotationFactory.create( columnsDescr ); - } - - private Columns buildColumns(List elements, String nodeName) { - List columns = new ArrayList<>( elements.size() ); - for ( JaxbColumnImpl element : elements ) { - columns.add( getColumn( element, false, nodeName ) ); - } - if ( !columns.isEmpty() ) { - AnnotationDescriptor columnsDescr = new AnnotationDescriptor( Columns.class ); - columnsDescr.setValue( "columns", columns.toArray( new Column[ columns.size() ] ) ); - return AnnotationFactory.create( columnsDescr ); - } - else { - return null; - } - } - - private GeneratedValue buildGeneratedValue(JaxbGeneratedValueImpl element) { - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( GeneratedValue.class ); - GenerationType strategy = element.getStrategy(); - if ( strategy != null ) { - ad.setValue( "strategy", strategy ); - } - copyAttribute( ad, "generator", element.getGenerator(), false ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private void getTemporal(List annotationList, TemporalType type) { - if ( type != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Temporal.class ); - ad.setValue( "value", type ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private void getAccessType(List annotationList, AccessType type) { - if ( element == null ) { - return; - } - if ( type != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Access.class ); - - if ( ( AccessType.PROPERTY.equals( type ) && this.element instanceof Method ) || - ( AccessType.FIELD.equals( type ) && this.element instanceof Field ) ) { - return; - } - - ad.setValue( "value", type ); - annotationList.add( AnnotationFactory.create( ad ) ); - } - } - - private AssociationOverrides getAssociationOverrides(JaxbManagedType root, XMLContext.Default defaults) { - return getAssociationOverrides( - root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getAssociationOverrides() : Collections.emptyList(), - defaults, true - ); - } - - /** - * @param mergeWithAnnotations Whether to use Java annotations for this - * element, if present and not disabled by the XMLContext defaults. - * In some contexts (such as an element-collection mapping) merging - */ - private AssociationOverrides getAssociationOverrides( - List elements, - XMLContext.Default defaults, - boolean mergeWithAnnotations) { - List attributes = buildAssociationOverrides( elements, defaults ); - if ( mergeWithAnnotations && defaults.canUseJavaAnnotations() ) { - AssociationOverride annotation = getPhysicalAnnotation( AssociationOverride.class ); - addAssociationOverrideIfNeeded( annotation, attributes ); - AssociationOverrides annotations = getPhysicalAnnotation( AssociationOverrides.class ); - if ( annotations != null ) { - for ( AssociationOverride current : annotations.value() ) { - addAssociationOverrideIfNeeded( current, attributes ); - } - } - } - if ( !attributes.isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( AssociationOverrides.class ); - ad.setValue( "value", attributes.toArray( new AssociationOverride[0] ) ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private List buildAssociationOverrides(List elements, XMLContext.Default defaults) { - List overrides = new ArrayList<>(); - if ( elements != null && !elements.isEmpty() ) { - for ( JaxbAssociationOverrideImpl current : elements ) { - AnnotationDescriptor override = new AnnotationDescriptor( AssociationOverride.class ); - copyAttribute( override, "name", current.getName(), true ); - override.setValue( "joinColumns", getJoinColumns( current.getJoinColumns(), false ) ); - JoinTable joinTable = buildJoinTable( current.getJoinTable(), defaults ); - if ( joinTable != null ) { - override.setValue( "joinTable", joinTable ); - } - overrides.add( AnnotationFactory.create( override ) ); - } - } - return overrides; - } - - private JoinColumn[] getJoinColumns(List subelements, boolean isInverse) { - List joinColumns = new ArrayList<>(); - if ( subelements != null ) { - for ( JaxbJoinColumnImpl subelement : subelements ) { - AnnotationDescriptor column = new AnnotationDescriptor( JoinColumn.class ); - copyAttribute( column, "name", subelement.getName(), false ); - copyAttribute( column, "referenced-column-name", subelement.getReferencedColumnName(), false ); - copyAttribute( column, "unique", subelement.isUnique(), false ); - copyAttribute( column, "nullable", subelement.isNullable(), false ); - copyAttribute( column, "insertable", subelement.isInsertable(), false ); - copyAttribute( column, "updatable", subelement.isUpdatable(), false ); - copyAttribute( column, "column-definition", subelement.getColumnDefinition(), false ); - copyAttribute( column, "table", subelement.getTable(), false ); - joinColumns.add( AnnotationFactory.create( column ) ); - } - } - return joinColumns.toArray( new JoinColumn[0] ); - } - - private void addAssociationOverrideIfNeeded(AssociationOverride annotation, List overrides) { - if ( annotation != null ) { - String overrideName = annotation.name(); - boolean present = false; - for ( AssociationOverride current : overrides ) { - if ( current.name().equals( overrideName ) ) { - present = true; - break; - } - } - if ( !present ) { - overrides.add( annotation ); - } - } - } - - private AttributeOverrides getAttributeOverrides(JaxbManagedType root, XMLContext.Default defaults) { - return getAttributeOverrides( - root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getAttributeOverrides() : Collections.emptyList(), - defaults, true - ); - } - - /** - * @param mergeWithAnnotations Whether to use Java annotations for this - * element, if present and not disabled by the XMLContext defaults. - * In some contexts (such as an association mapping) merging with - * annotations is never allowed. - */ - private AttributeOverrides getAttributeOverrides( - List elements, - XMLContext.Default defaults, - boolean mergeWithAnnotations) { - List attributes = buildAttributeOverrides( elements, "attribute-override" ); - return mergeAttributeOverrides( defaults, attributes, mergeWithAnnotations ); - } - - /** - * @param mergeWithAnnotations Whether to use Java annotations for this - * element, if present and not disabled by the XMLContext defaults. - * In some contexts (such as an association mapping) merging with - * annotations is never allowed. - */ - private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults, List attributes, boolean mergeWithAnnotations) { - if ( mergeWithAnnotations && defaults.canUseJavaAnnotations() ) { - AttributeOverride annotation = getPhysicalAnnotation( AttributeOverride.class ); - addAttributeOverrideIfNeeded( annotation, attributes ); - AttributeOverrides annotations = getPhysicalAnnotation( AttributeOverrides.class ); - if ( annotations != null ) { - for ( AttributeOverride current : annotations.value() ) { - addAttributeOverrideIfNeeded( current, attributes ); - } - } - } - if ( !attributes.isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( AttributeOverrides.class ); - ad.setValue( "value", attributes.toArray( new AttributeOverride[ attributes.size() ] ) ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private List buildAttributeOverrides(List subelements, String nodeName) { - List overrides = new ArrayList<>(); - if ( subelements != null && !subelements.isEmpty() ) { - for ( JaxbAttributeOverrideImpl current : subelements ) { - AnnotationDescriptor override = new AnnotationDescriptor( AttributeOverride.class ); - copyAttribute( override, "name", current.getName(), true ); - JaxbColumnImpl column = current.getColumn(); - override.setValue( "column", getColumn( column, true, nodeName ) ); - overrides.add( AnnotationFactory.create( override ) ); - } - } - return overrides; - } - - private Column getColumn(JaxbColumnImpl element, boolean isMandatory, String nodeName) { - if ( element != null ) { - AnnotationDescriptor column = new AnnotationDescriptor( Column.class ); - copyAttribute( column, "name", element.getName(), false ); - copyAttribute( column, "unique", element.isUnique(), false ); - copyAttribute( column, "nullable", element.isNullable(), false ); - copyAttribute( column, "insertable", element.isInsertable(), false ); - copyAttribute( column, "updatable", element.isUpdatable(), false ); - copyAttribute( column, "column-definition", element.getColumnDefinition(), false ); - copyAttribute( column, "table", element.getTable(), false ); - copyAttribute( column, "length", element.getLength(), false ); - copyAttribute( column, "precision", element.getPrecision(), false ); - copyAttribute( column, "scale", element.getScale(), false ); - return AnnotationFactory.create( column ); - } - else { - if ( isMandatory ) { - throw new AnnotationException( nodeName + ".column is mandatory. " + SCHEMA_VALIDATION ); - } - return null; - } - } - - private void addAttributeOverrideIfNeeded(AttributeOverride annotation, List overrides) { - if ( annotation != null ) { - String overrideName = annotation.name(); - boolean present = false; - for ( AttributeOverride current : overrides ) { - if ( current.name().equals( overrideName ) ) { - present = true; - break; - } - } - if ( !present ) { - overrides.add( annotation ); - } - } - } - - private Access getAccessType(JaxbManagedType root, XMLContext.Default defaults) { - AccessType access = root == null ? null : root.getAccess(); - if ( access != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Access.class ); - ad.setValue( "value", access ); - return AnnotationFactory.create( ad ); - } - else if ( defaults.canUseJavaAnnotations() && isPhysicalAnnotationPresent( Access.class ) ) { - return getPhysicalAnnotation( Access.class ); - } - else if ( defaults.getAccess() != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Access.class ); - ad.setValue( "value", defaults.getAccess() ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private ExcludeSuperclassListeners getExcludeSuperclassListeners(JaxbManagedType root, XMLContext.Default defaults) { - return (ExcludeSuperclassListeners) getMarkerAnnotation( - ExcludeSuperclassListeners.class, - root instanceof JaxbEntityOrMappedSuperclass - ? ( (JaxbEntityOrMappedSuperclass) root ).getExcludeSuperclassListeners() - : null, - defaults - ); - } - - private ExcludeDefaultListeners getExcludeDefaultListeners(JaxbManagedType root, XMLContext.Default defaults) { - return (ExcludeDefaultListeners) getMarkerAnnotation( - ExcludeDefaultListeners.class, - root instanceof JaxbEntityOrMappedSuperclass - ? ( (JaxbEntityOrMappedSuperclass) root ).getExcludeDefaultListeners() - : null, - defaults - ); - } - - private Annotation getMarkerAnnotation( - Class clazz, - JaxbEmptyTypeImpl element, - XMLContext.Default defaults) { - if ( element != null ) { - return AnnotationFactory.create( new AnnotationDescriptor( clazz ) ); - } - else if ( defaults.canUseJavaAnnotations() ) { - //TODO wonder whether it should be excluded so that user can undone it - return getPhysicalAnnotation( clazz ); - } - else { - return null; - } - } - - private SqlResultSetMappings getSqlResultSetMappings(JaxbManagedType root, XMLContext.Default defaults) { - List results = root instanceof JaxbEntityImpl - ? buildSqlResultSetMappings( ( (JaxbEntityImpl) root ).getSqlResultSetMappings(), defaults, classLoaderAccess ) - : new ArrayList<>(); - if ( defaults.canUseJavaAnnotations() ) { - SqlResultSetMapping annotation = getPhysicalAnnotation( SqlResultSetMapping.class ); - addSqlResultsetMappingIfNeeded( annotation, results ); - SqlResultSetMappings annotations = getPhysicalAnnotation( SqlResultSetMappings.class ); - if ( annotations != null ) { - for ( SqlResultSetMapping current : annotations.value() ) { - addSqlResultsetMappingIfNeeded( current, results ); - } - } - } - if ( !results.isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( SqlResultSetMappings.class ); - ad.setValue( "value", results.toArray( new SqlResultSetMapping[ results.size() ] ) ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - public static List buildNamedEntityGraph( - List elements, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - List namedEntityGraphList = new ArrayList<>(); - for ( JaxbNamedEntityGraphImpl element : elements ) { - AnnotationDescriptor ann = new AnnotationDescriptor( NamedEntityGraph.class ); - copyAttribute( ann, "name", element.getName(), false ); - copyAttribute( ann, "include-all-attributes", element.isIncludeAllAttributes(), false ); - bindNamedAttributeNodes( element.getNamedAttributeNode(), ann ); - - bindNamedSubgraph( defaults, ann, "subgraphs", element.getSubgraph(), classLoaderAccess ); - bindNamedSubgraph( defaults, ann, "subclassSubgraphs", element.getSubclassSubgraph(), classLoaderAccess ); - namedEntityGraphList.add( AnnotationFactory.create( ann ) ); - } - return namedEntityGraphList; - } - - private static void bindNamedSubgraph( - XMLContext.Default defaults, - AnnotationDescriptor ann, - String annotationAttributeName, - List subgraphNodes, - ClassLoaderAccess classLoaderAccess) { - List annSubgraphNodes = new ArrayList<>(); - for ( JaxbNamedSubgraphImpl subgraphNode : subgraphNodes ) { - AnnotationDescriptor annSubgraphNode = new AnnotationDescriptor( NamedSubgraph.class ); - copyAttribute( annSubgraphNode, "name", subgraphNode.getName(), true ); - String clazzName = subgraphNode.getClazz(); - if ( StringHelper.isNotEmpty( clazzName ) ) { - final Class clazz; - try { - clazz = classLoaderAccess.classForName( - XMLContext.buildSafeClassName( clazzName, defaults ) - ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find entity-class: " + clazzName, e ); - } - annSubgraphNode.setValue( "type", clazz ); - } - bindNamedAttributeNodes( subgraphNode.getNamedAttributeNode(), annSubgraphNode ); - annSubgraphNodes.add( AnnotationFactory.create( annSubgraphNode ) ); - } - - ann.setValue( annotationAttributeName, annSubgraphNodes.toArray( new NamedSubgraph[ annSubgraphNodes.size() ] ) ); - } - - private static void bindNamedAttributeNodes(List elements, AnnotationDescriptor ann) { - List annNamedAttributeNodes = new ArrayList<>(); - for ( JaxbNamedAttributeNodeImpl element : elements ) { - AnnotationDescriptor annNamedAttributeNode = new AnnotationDescriptor( NamedAttributeNode.class ); - copyAttribute( annNamedAttributeNode, "value", "name", element.getName(), true ); - copyAttribute( annNamedAttributeNode, "subgraph", element.getSubgraph(), false ); - copyAttribute( annNamedAttributeNode, "key-subgraph", element.getKeySubgraph(), false ); - annNamedAttributeNodes.add( AnnotationFactory.create( annNamedAttributeNode ) ); - } - ann.setValue( "attributeNodes", annNamedAttributeNodes.toArray( new NamedAttributeNode[ 0 ] ) ); - } - - public static List buildNamedStoreProcedureQueries( - List elements, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - List namedStoredProcedureQueries = new ArrayList<>(); - for ( JaxbNamedStoredProcedureQueryImpl element : elements ) { - AnnotationDescriptor ann = new AnnotationDescriptor( NamedStoredProcedureQuery.class ); - copyAttribute( ann, "name", element.getName(), true ); - copyAttribute( ann, "procedure-name", element.getProcedureName(), true ); - - List storedProcedureParameters = new ArrayList<>(); - - for ( JaxbStoredProcedureParameterImpl parameterElement : element.getProcedureParameters() ) { - AnnotationDescriptor parameterDescriptor = new AnnotationDescriptor( StoredProcedureParameter.class ); - copyAttribute( parameterDescriptor, "name", parameterElement.getName(), false ); - ParameterMode modeValue = parameterElement.getMode(); - if ( modeValue == null ) { - parameterDescriptor.setValue( "mode", ParameterMode.IN ); - } - else { - parameterDescriptor.setValue( "mode", modeValue ); - } - String clazzName = parameterElement.getClazz(); - if ( StringHelper.isNotEmpty( clazzName ) ) { - Class clazz; - try { - clazz = classLoaderAccess.classForName( - XMLContext.buildSafeClassName( clazzName, defaults ) - ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find entity-class: " + clazzName, e ); - } - parameterDescriptor.setValue( "type", clazz ); - } - storedProcedureParameters.add( AnnotationFactory.create( parameterDescriptor ) ); - } - - ann.setValue( - "parameters", - storedProcedureParameters.toArray( new StoredProcedureParameter[ 0 ] ) - ); - - final List> returnClasses = new ArrayList<>(); - for ( String clazzName : element.getResultClasses() ) { - final Class clazz; - try { - clazz = classLoaderAccess.classForName( - XMLContext.buildSafeClassName( clazzName, defaults ) - ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find entity-class: " + clazzName, e ); - } - returnClasses.add( clazz ); - } - ann.setValue( "resultClasses", returnClasses.toArray( new Class[ 0 ] ) ); - - - ann.setValue( "resultSetMappings", element.getResultSetMappings().toArray( new String[ 0 ] ) ); - buildQueryHints( element.getHints(), ann, Collections.emptyMap() ); - namedStoredProcedureQueries.add( AnnotationFactory.create( ann ) ); - } - return namedStoredProcedureQueries; - - } - - public static List buildSqlResultSetMappings( - List elements, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - final List builtResultSetMappings = new ArrayList<>(); - - // iterate over each element - for ( JaxbSqlResultSetMappingImpl resultSetMappingElement : elements ) { - final AnnotationDescriptor resultSetMappingAnnotation = new AnnotationDescriptor( SqlResultSetMapping.class ); - copyAttribute( resultSetMappingAnnotation, "name", resultSetMappingElement.getName(), true ); - - // iterate over the sub-elements, which should include: - // * - // * - // * - - List entityResultAnnotations = null; - List columnResultAnnotations = null; - List constructorResultAnnotations = null; - - for ( JaxbEntityResultImpl resultElement : resultSetMappingElement.getEntityResult() ) { - if ( entityResultAnnotations == null ) { - entityResultAnnotations = new ArrayList<>(); - } - // process the - entityResultAnnotations.add( buildEntityResult( resultElement, defaults, classLoaderAccess ) ); - } - for ( JaxbColumnResultImpl resultElement : resultSetMappingElement.getColumnResult() ) { - if ( columnResultAnnotations == null ) { - columnResultAnnotations = new ArrayList<>(); - } - columnResultAnnotations.add( buildColumnResult( resultElement, defaults, classLoaderAccess ) ); - } - for ( JaxbConstructorResultImpl resultElement : resultSetMappingElement.getConstructorResult() ) { - if ( constructorResultAnnotations == null ) { - constructorResultAnnotations = new ArrayList<>(); - } - constructorResultAnnotations.add( buildConstructorResult( resultElement, defaults, classLoaderAccess ) ); - } - - if ( entityResultAnnotations != null && !entityResultAnnotations.isEmpty() ) { - resultSetMappingAnnotation.setValue( - "entities", - entityResultAnnotations.toArray( new EntityResult[ entityResultAnnotations.size() ] ) - ); - } - if ( columnResultAnnotations != null && !columnResultAnnotations.isEmpty() ) { - resultSetMappingAnnotation.setValue( - "columns", - columnResultAnnotations.toArray( new ColumnResult[ columnResultAnnotations.size() ] ) - ); - } - if ( constructorResultAnnotations != null && !constructorResultAnnotations.isEmpty() ) { - resultSetMappingAnnotation.setValue( - "classes", - constructorResultAnnotations.toArray( new ConstructorResult[ constructorResultAnnotations.size() ] ) - ); - } - - builtResultSetMappings.add( AnnotationFactory.create( resultSetMappingAnnotation ) ); - } - - return builtResultSetMappings; - } - - private static EntityResult buildEntityResult( - JaxbEntityResultImpl entityResultElement, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - final AnnotationDescriptor entityResultDescriptor = new AnnotationDescriptor( EntityResult.class ); - - final Class entityClass = resolveClassReference( entityResultElement.getEntityClass(), defaults, classLoaderAccess ); - entityResultDescriptor.setValue( "entityClass", entityClass ); - - copyAttribute( entityResultDescriptor, "discriminator-column", entityResultElement.getDiscriminatorColumn(), false ); - - // process the sub-elements - List fieldResultAnnotations = new ArrayList<>(); - for ( JaxbFieldResultImpl fieldResult : entityResultElement.getFieldResult() ) { - AnnotationDescriptor fieldResultDescriptor = new AnnotationDescriptor( FieldResult.class ); - copyAttribute( fieldResultDescriptor, "name", fieldResult.getName(), true ); - copyAttribute( fieldResultDescriptor, "column", fieldResult.getColumn(), true ); - fieldResultAnnotations.add( AnnotationFactory.create( fieldResultDescriptor ) ); - } - entityResultDescriptor.setValue( - "fields", - fieldResultAnnotations.toArray( new FieldResult[ fieldResultAnnotations.size() ] ) - ); - return AnnotationFactory.create( entityResultDescriptor ); - } - - private static Class resolveClassReference( - String className, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - if ( className == null ) { - throw new AnnotationException( " without entity-class. " + SCHEMA_VALIDATION ); - } - try { - return classLoaderAccess.classForName( - XMLContext.buildSafeClassName( className, defaults ) - ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find specified class: " + className, e ); - } - } - - private static ColumnResult buildColumnResult( - JaxbColumnResultImpl columnResultElement, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - AnnotationDescriptor columnResultDescriptor = new AnnotationDescriptor( ColumnResult.class ); - copyAttribute( columnResultDescriptor, "name", columnResultElement.getName(), true ); - final String columnTypeName = columnResultElement.getClazz(); - if ( isNotEmpty( columnTypeName ) ) { - columnResultDescriptor.setValue( "type", resolveClassReference( columnTypeName, defaults, classLoaderAccess ) ); - } - return AnnotationFactory.create( columnResultDescriptor ); - } - - private static ConstructorResult buildConstructorResult( - JaxbConstructorResultImpl constructorResultElement, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - AnnotationDescriptor constructorResultDescriptor = new AnnotationDescriptor( ConstructorResult.class ); - - final Class entityClass = resolveClassReference( constructorResultElement.getTargetClass(), defaults, classLoaderAccess ); - constructorResultDescriptor.setValue( "targetClass", entityClass ); - - List columnResultAnnotations = new ArrayList<>(); - for ( JaxbColumnResultImpl columnResultElement : constructorResultElement.getColumns() ) { - columnResultAnnotations.add( buildColumnResult( columnResultElement, defaults, classLoaderAccess ) ); - } - constructorResultDescriptor.setValue( - "columns", - columnResultAnnotations.toArray( new ColumnResult[ columnResultAnnotations.size() ] ) - ); - - return AnnotationFactory.create( constructorResultDescriptor ); - } - - private void addSqlResultsetMappingIfNeeded(SqlResultSetMapping annotation, List resultsets) { - if ( annotation != null ) { - String resultsetName = annotation.name(); - boolean present = false; - for ( SqlResultSetMapping current : resultsets ) { - if ( current.name().equals( resultsetName ) ) { - present = true; - break; - } - } - if ( !present ) { - resultsets.add( annotation ); - } - } - } - - private NamedQueries getNamedQueries(JaxbManagedType root, XMLContext.Default defaults) { - //TODO avoid the Proxy Creation (@NamedQueries) when possible - List queries = root instanceof JaxbEntityImpl - ? buildNamedQueries( ( (JaxbEntityImpl) root ).getNamedQueries(), defaults, classLoaderAccess ) - : new ArrayList<>(); - if ( defaults.canUseJavaAnnotations() ) { - NamedQuery annotation = getPhysicalAnnotation( NamedQuery.class ); - addNamedQueryIfNeeded( annotation, queries ); - NamedQueries annotations = getPhysicalAnnotation( NamedQueries.class ); - if ( annotations != null ) { - for ( NamedQuery current : annotations.value() ) { - addNamedQueryIfNeeded( current, queries ); - } - } - } - if ( !queries.isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( NamedQueries.class ); - ad.setValue( "value", queries.toArray( new NamedQuery[queries.size()] ) ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private void addNamedQueryIfNeeded(NamedQuery annotation, List queries) { - if ( annotation != null ) { - String queryName = annotation.name(); - boolean present = false; - for ( NamedQuery current : queries ) { - if ( current.name().equals( queryName ) ) { - present = true; - break; - } - } - if ( !present ) { - queries.add( annotation ); - } - } - } - - private NamedEntityGraphs getNamedEntityGraphs(JaxbManagedType root, XMLContext.Default defaults) { - List queries = root instanceof JaxbEntityImpl - ? buildNamedEntityGraph( ( (JaxbEntityImpl) root ).getNamedEntityGraphs(), defaults, classLoaderAccess ) - : new ArrayList<>(); - if ( defaults.canUseJavaAnnotations() ) { - NamedEntityGraph annotation = getPhysicalAnnotation( NamedEntityGraph.class ); - addNamedEntityGraphIfNeeded( annotation, queries ); - NamedEntityGraphs annotations = getPhysicalAnnotation( NamedEntityGraphs.class ); - if ( annotations != null ) { - for ( NamedEntityGraph current : annotations.value() ) { - addNamedEntityGraphIfNeeded( current, queries ); - } - } - } - if ( !queries.isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( NamedEntityGraphs.class ); - ad.setValue( "value", queries.toArray( new NamedEntityGraph[queries.size()] ) ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private void addNamedEntityGraphIfNeeded(NamedEntityGraph annotation, List queries) { - if ( annotation != null ) { - String queryName = annotation.name(); - boolean present = false; - for ( NamedEntityGraph current : queries ) { - if ( current.name().equals( queryName ) ) { - present = true; - break; - } - } - if ( !present ) { - queries.add( annotation ); - } - } - - } - - private NamedStoredProcedureQueries getNamedStoredProcedureQueries(JaxbManagedType root, XMLContext.Default defaults) { - List queries = root instanceof JaxbEntityImpl - ? buildNamedStoreProcedureQueries( ( (JaxbEntityImpl) root ).getNamedStoredProcedureQueries(), defaults, classLoaderAccess ) - : new ArrayList<>(); - if ( defaults.canUseJavaAnnotations() ) { - NamedStoredProcedureQuery annotation = getPhysicalAnnotation( NamedStoredProcedureQuery.class ); - addNamedStoredProcedureQueryIfNeeded( annotation, queries ); - NamedStoredProcedureQueries annotations = getPhysicalAnnotation( NamedStoredProcedureQueries.class ); - if ( annotations != null ) { - for ( NamedStoredProcedureQuery current : annotations.value() ) { - addNamedStoredProcedureQueryIfNeeded( current, queries ); - } - } - } - if ( !queries.isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( NamedStoredProcedureQueries.class ); - ad.setValue( "value", queries.toArray( new NamedStoredProcedureQuery[queries.size()] ) ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private void addNamedStoredProcedureQueryIfNeeded(NamedStoredProcedureQuery annotation, List queries) { - if ( annotation != null ) { - String queryName = annotation.name(); - boolean present = false; - for ( NamedStoredProcedureQuery current : queries ) { - if ( current.name().equals( queryName ) ) { - present = true; - break; - } - } - if ( !present ) { - queries.add( annotation ); - } - } - } - - - private NamedNativeQueries getNamedNativeQueries( - JaxbManagedType root, - XMLContext.Default defaults) { - List queries = root instanceof JaxbEntityImpl - ? buildNamedNativeQueries( ( (JaxbEntityImpl) root ).getNamedNativeQueries(), defaults, classLoaderAccess ) - : new ArrayList<>(); - if ( defaults.canUseJavaAnnotations() ) { - NamedNativeQuery annotation = getPhysicalAnnotation( NamedNativeQuery.class ); - addNamedNativeQueryIfNeeded( annotation, queries ); - NamedNativeQueries annotations = getPhysicalAnnotation( NamedNativeQueries.class ); - if ( annotations != null ) { - for ( NamedNativeQuery current : annotations.value() ) { - addNamedNativeQueryIfNeeded( current, queries ); - } - } - } - if ( !queries.isEmpty() ) { - AnnotationDescriptor ad = new AnnotationDescriptor( NamedNativeQueries.class ); - ad.setValue( "value", queries.toArray( new NamedNativeQuery[queries.size()] ) ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private void addNamedNativeQueryIfNeeded(NamedNativeQuery annotation, List queries) { - if ( annotation != null ) { - String queryName = annotation.name(); - boolean present = false; - for ( NamedNativeQuery current : queries ) { - if ( current.name().equals( queryName ) ) { - present = true; - break; - } - } - if ( !present ) { - queries.add( annotation ); - } - } - } - - private static void buildQueryHints( - List elements, - AnnotationDescriptor ann, - Map additionalHints) { - List queryHints = new ArrayList<>( elements.size() + additionalHints.size() ); - for ( Map.Entry entry : additionalHints.entrySet() ) { - AnnotationDescriptor hintDescriptor = new AnnotationDescriptor( QueryHint.class ); - hintDescriptor.setValue( "name", entry.getKey() ); - hintDescriptor.setValue( "value", entry.getValue() ); - queryHints.add( AnnotationFactory.create( hintDescriptor ) ); - } - for ( JaxbQueryHintImpl hint : elements ) { - String value = hint.getName(); - if ( value == null ) { - throw new AnnotationException( " without name. " + SCHEMA_VALIDATION ); - } - if ( additionalHints.containsKey( value ) ) { - continue; - } - AnnotationDescriptor hintDescriptor = new AnnotationDescriptor( QueryHint.class ); - hintDescriptor.setValue( "name", value ); - value = hint.getValue(); - if ( value == null ) { - throw new AnnotationException( " without value. " + SCHEMA_VALIDATION ); - } - hintDescriptor.setValue( "value", value ); - queryHints.add( AnnotationFactory.create( hintDescriptor ) ); - } - ann.setValue( "hints", queryHints.toArray( new QueryHint[queryHints.size()] ) ); - } - - public static List buildNamedQueries( - List elements, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - List namedQueries = new ArrayList<>(); - for ( JaxbNamedQueryImpl element : elements ) { - AnnotationDescriptor ann = new AnnotationDescriptor( NamedQuery.class ); - copyAttribute( ann, "name", element.getName(), false ); - copyAttribute( ann, "query", element.getQuery(), true ); - Map additionalHints = new HashMap<>(); - addHint( additionalHints, AvailableHints.HINT_CACHEABLE, element.isCacheable() ); - addHint( additionalHints, AvailableHints.HINT_CACHE_MODE, element.getCacheMode() ); - addHint( additionalHints, AvailableHints.HINT_CACHE_REGION, element.getCacheRegion() ); - addHint( additionalHints, AvailableHints.HINT_COMMENT, element.getComment() ); - addHint( additionalHints, AvailableHints.HINT_FETCH_SIZE, element.getFetchSize() ); - addHint( additionalHints, AvailableHints.HINT_FLUSH_MODE, element.getFlushMode() ); - addHint( additionalHints, AvailableHints.HINT_TIMEOUT, element.getTimeout() ); - buildQueryHints( element.getHints(), ann, additionalHints ); - copyAttribute( ann, "lock-mode", element.getLockMode(), false ); - namedQueries.add( AnnotationFactory.create( ann ) ); - } - return namedQueries; - } - - public static List buildNamedNativeQueries( - List elements, - XMLContext.Default defaults, - ClassLoaderAccess classLoaderAccess) { - List namedQueries = new ArrayList<>(); - for ( JaxbNamedNativeQueryImpl element : elements ) { - AnnotationDescriptor ann = new AnnotationDescriptor( NamedNativeQuery.class ); - copyAttribute( ann, "name", element.getName(), false ); - copyAttribute( ann, "query", element.getQuery(), true ); - Map additionalHints = new HashMap<>(); - addHint( additionalHints, AvailableHints.HINT_CACHEABLE, element.isCacheable() ); - addHint( additionalHints, AvailableHints.HINT_CACHE_MODE, element.getCacheMode() ); - addHint( additionalHints, AvailableHints.HINT_CACHE_REGION, element.getCacheRegion() ); - addHint( additionalHints, AvailableHints.HINT_COMMENT, element.getComment() ); - addHint( additionalHints, AvailableHints.HINT_FETCH_SIZE, element.getFetchSize() ); - addHint( additionalHints, AvailableHints.HINT_FLUSH_MODE, element.getFlushMode() ); - addHint( additionalHints, AvailableHints.HINT_TIMEOUT, element.getTimeout() ); - addSynchronizationsHint( additionalHints, element.getSynchronizations() ); - buildQueryHints( element.getHints(), ann, additionalHints ); - String clazzName = element.getResultClass(); - if ( isNotEmpty( clazzName ) ) { - Class clazz; - try { - clazz = classLoaderAccess.classForName( - XMLContext.buildSafeClassName( clazzName, defaults ) - ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find entity-class: " + clazzName, e ); - } - ann.setValue( "resultClass", clazz ); - } - copyAttribute( ann, "result-set-mapping", element.getResultSetMapping(), false ); - namedQueries.add( AnnotationFactory.create( ann ) ); - } - return namedQueries; - } - - private static void addHint(Map hints, String hint, Object value) { - if ( value != null ) { - hints.put( hint, value.toString() ); - } - } - - private static void addSynchronizationsHint( - Map hints, - List synchronizations) { - if ( synchronizations.isEmpty() ) { - return; - } - StringBuilder sb = new StringBuilder(); - sb.append( synchronizations.get( 0 ).getTable() ); - for ( int i = 1; i < synchronizations.size(); i++ ) { - sb.append( ' ' ); - sb.append( synchronizations.get( i ).getTable() ); - } - hints.put( AvailableHints.HINT_NATIVE_SPACES, sb.toString() ); - } - - private TableGenerator getTableGenerator(JaxbManagedType root, XMLContext.Default defaults) { - return getTableGenerator( - root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getTableGenerators() : null, - defaults - ); - } - - private TableGenerator getTableGenerator(JaxbTableGeneratorImpl element, XMLContext.Default defaults) { - if ( element != null ) { - return buildTableGeneratorAnnotation( element, defaults ); - } - else if ( defaults.canUseJavaAnnotations() && isPhysicalAnnotationPresent( TableGenerator.class ) ) { - TableGenerator tableAnn = getPhysicalAnnotation( TableGenerator.class ); - if ( isNotEmpty( defaults.getSchema() ) - || isNotEmpty( defaults.getCatalog() ) ) { - AnnotationDescriptor annotation = new AnnotationDescriptor( TableGenerator.class ); - annotation.setValue( "name", tableAnn.name() ); - annotation.setValue( "table", tableAnn.table() ); - annotation.setValue( "catalog", tableAnn.table() ); - if ( isEmpty( (String) annotation.valueOf( "catalog" ) ) - && isNotEmpty( defaults.getCatalog() ) ) { - annotation.setValue( "catalog", defaults.getCatalog() ); - } - annotation.setValue( "schema", tableAnn.table() ); - if ( isEmpty( (String) annotation.valueOf( "schema" ) ) - && isNotEmpty( defaults.getSchema() ) ) { - annotation.setValue( "catalog", defaults.getSchema() ); - } - annotation.setValue( "pkColumnName", tableAnn.pkColumnName() ); - annotation.setValue( "valueColumnName", tableAnn.valueColumnName() ); - annotation.setValue( "pkColumnValue", tableAnn.pkColumnValue() ); - annotation.setValue( "initialValue", tableAnn.initialValue() ); - annotation.setValue( "allocationSize", tableAnn.allocationSize() ); - annotation.setValue( "uniqueConstraints", tableAnn.uniqueConstraints() ); - return AnnotationFactory.create( annotation ); - } - else { - return tableAnn; - } - } - else { - return null; - } - } - - public static TableGenerator buildTableGeneratorAnnotation(JaxbTableGeneratorImpl element, XMLContext.Default defaults) { - AnnotationDescriptor ad = new AnnotationDescriptor( TableGenerator.class ); - copyAttribute( ad, "name", element.getName(), false ); - copyAttribute( ad, "table", element.getTable(), false ); - copyAttribute( ad, "catalog", element.getCatalog(), false ); - copyAttribute( ad, "schema", element.getSchema(), false ); - copyAttribute( ad, "pk-column-name", element.getPkColumnName(), false ); - copyAttribute( ad, "value-column-name", element.getValueColumnName(), false ); - copyAttribute( ad, "pk-column-value", element.getPkColumnValue(), false ); - copyAttribute( ad, "initial-value", element.getInitialValue(), false ); - copyAttribute( ad, "allocation-size", element.getAllocationSize(), false ); - buildUniqueConstraints( ad, element.getUniqueConstraints() ); - if ( isEmpty( (String) ad.valueOf( "schema" ) ) - && isNotEmpty( defaults.getSchema() ) ) { - ad.setValue( "schema", defaults.getSchema() ); - } - if ( isEmpty( (String) ad.valueOf( "catalog" ) ) - && isNotEmpty( defaults.getCatalog() ) ) { - ad.setValue( "catalog", defaults.getCatalog() ); - } - return AnnotationFactory.create( ad ); - } - - private SequenceGenerator getSequenceGenerator(JaxbManagedType root, XMLContext.Default defaults) { - return getSequenceGenerator( - root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getSequenceGenerators() : null, - defaults - ); - } - - private SequenceGenerator getSequenceGenerator(JaxbSequenceGeneratorImpl element, XMLContext.Default defaults) { - if ( element != null ) { - return buildSequenceGeneratorAnnotation( element ); - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( SequenceGenerator.class ); - } - else { - return null; - } - } - - public static SequenceGenerator buildSequenceGeneratorAnnotation(JaxbSequenceGeneratorImpl element) { - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( SequenceGenerator.class ); - copyAttribute( ad, "name", element.getName(), false ); - copyAttribute( ad, "sequence-name", element.getSequenceName(), false ); - copyAttribute( ad, "initial-value", element.getInitialValue(), false ); - copyAttribute( ad, "allocation-size", element.getAllocationSize(), false ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private DiscriminatorColumn getDiscriminatorColumn(JaxbManagedType root, XMLContext.Default defaults) { - JaxbDiscriminatorColumnImpl element = root instanceof JaxbEntityImpl - ? ( (JaxbEntityImpl) root ).getDiscriminatorColumn() - : null; - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( DiscriminatorColumn.class ); - copyAttribute( ad, "name", element.getName(), false ); - copyAttribute( ad, "column-definition", element.getColumnDefinition(), false ); - DiscriminatorType type = element.getDiscriminatorType(); - if ( type != null ) { - ad.setValue( "discriminatorType", type ); - } - copyAttribute( ad, "length", element.getLength(), false ); - return AnnotationFactory.create( ad ); - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( DiscriminatorColumn.class ); - } - else { - return null; - } - } - - private DiscriminatorValue getDiscriminatorValue(JaxbManagedType root, XMLContext.Default defaults) { - String element = root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getDiscriminatorValue() : null; - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( DiscriminatorValue.class ); - ad.setValue( "value", element ); - return AnnotationFactory.create( ad ); - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( DiscriminatorValue.class ); - } - else { - return null; - } - } - - private Inheritance getInheritance(JaxbManagedType root, XMLContext.Default defaults) { - JaxbInheritanceImpl element = root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getInheritance() : null; - if ( element != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( Inheritance.class ); - InheritanceType strategy = element.getStrategy(); - if ( strategy != null ) { - ad.setValue( "strategy", strategy ); - } - return AnnotationFactory.create( ad ); - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( Inheritance.class ); - } - else { - return null; - } - } - - private IdClass getIdClass(JaxbManagedType root, XMLContext.Default defaults) { - final JaxbIdClassImpl element = root instanceof JaxbEntityOrMappedSuperclass - ? ( (JaxbEntityOrMappedSuperclass) root ).getIdClass() - : null; - if ( element != null ) { - String className = element.getClazz(); - if ( className != null ) { - AnnotationDescriptor ad = new AnnotationDescriptor( IdClass.class ); - Class clazz; - try { - clazz = classLoaderAccess.classForName( XMLContext.buildSafeClassName( className, defaults ) ); - } - catch (ClassLoadingException e) { - throw new AnnotationException( "Unable to find id-class: " + className, e ); - } - ad.setValue( "value", clazz ); - return AnnotationFactory.create( ad ); - } - else { - throw new AnnotationException( "id-class without class. " + SCHEMA_VALIDATION ); - } - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( IdClass.class ); - } - else { - return null; - } - } - - private PrimaryKeyJoinColumns getPrimaryKeyJoinColumns(JaxbManagedType root, XMLContext.Default defaults) { - return getPrimaryKeyJoinColumns( - root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getPrimaryKeyJoinColumns() : Collections.emptyList(), - defaults, true - ); - } - - /** - * @param mergeWithAnnotations Whether to use Java annotations for this - * element, if present and not disabled by the XMLContext defaults. - * In some contexts (such as an association mapping) merging with - */ - private PrimaryKeyJoinColumns getPrimaryKeyJoinColumns( - List elements, - XMLContext.Default defaults, - boolean mergeWithAnnotations) { - PrimaryKeyJoinColumn[] columns = buildPrimaryKeyJoinColumns( elements ); - if ( mergeWithAnnotations ) { - if ( columns.length == 0 && defaults.canUseJavaAnnotations() ) { - PrimaryKeyJoinColumn annotation = getPhysicalAnnotation( PrimaryKeyJoinColumn.class ); - if ( annotation != null ) { - columns = new PrimaryKeyJoinColumn[] { annotation }; - } - else { - PrimaryKeyJoinColumns annotations = getPhysicalAnnotation( PrimaryKeyJoinColumns.class ); - columns = annotations != null ? annotations.value() : columns; - } - } - } - if ( columns.length > 0 ) { - AnnotationDescriptor ad = new AnnotationDescriptor( PrimaryKeyJoinColumns.class ); - ad.setValue( "value", columns ); - return AnnotationFactory.create( ad ); - } - else { - return null; - } - } - - private Entity getEntity(JaxbManagedType element, XMLContext.Default defaults) { - if ( element == null ) { - return defaults.canUseJavaAnnotations() ? getPhysicalAnnotation( Entity.class ) : null; - } - else { - if ( element instanceof JaxbEntityImpl entityElement ) { - AnnotationDescriptor entity = new AnnotationDescriptor( Entity.class ); - copyAttribute( entity, "name", entityElement.getName(), false ); - if ( defaults.canUseJavaAnnotations() - && isEmpty( (String) entity.valueOf( "name" ) ) ) { - Entity javaAnn = getPhysicalAnnotation( Entity.class ); - if ( javaAnn != null ) { - entity.setValue( "name", javaAnn.name() ); - } - } - return AnnotationFactory.create( entity ); - } - else { - return null; //this is not an entity - } - } - } - - private MappedSuperclass getMappedSuperclass(JaxbManagedType element, XMLContext.Default defaults) { - if ( element == null ) { - return defaults.canUseJavaAnnotations() ? getPhysicalAnnotation( MappedSuperclass.class ) : null; - } - else { - if ( element instanceof JaxbMappedSuperclassImpl ) { - AnnotationDescriptor entity = new AnnotationDescriptor( MappedSuperclass.class ); - return AnnotationFactory.create( entity ); - } - else { - return null; //this is not an entity - } - } - } - - private Embeddable getEmbeddable(JaxbManagedType element, XMLContext.Default defaults) { - if ( element == null ) { - return defaults.canUseJavaAnnotations() ? getPhysicalAnnotation( Embeddable.class ) : null; - } - else { - if ( element instanceof JaxbEmbeddableImpl ) { - AnnotationDescriptor entity = new AnnotationDescriptor( Embeddable.class ); - return AnnotationFactory.create( entity ); - } - else { - //this is not an entity - return null; - } - } - } - - private Subselect getTableExpression(JaxbEntityImpl entity, XMLContext.Default defaults) { - final String tableExpression = entity.getTableExpression(); - if ( isEmpty( tableExpression ) ) { - return null; - } - - final AnnotationDescriptor annotation = new AnnotationDescriptor( Subselect.class ); - annotation.setValue( "value", tableExpression ); - return AnnotationFactory.create( annotation ); - } - - private Table getTable(JaxbManagedType root, XMLContext.Default defaults) { - final JaxbTableImpl element = root instanceof JaxbEntityImpl ? ( (JaxbEntityImpl) root ).getTable() : null; - if ( element == null ) { - //no element but might have some default or some annotation - if ( isNotEmpty( defaults.getCatalog() ) - || isNotEmpty( defaults.getSchema() ) ) { - AnnotationDescriptor annotation = new AnnotationDescriptor( Table.class ); - if ( defaults.canUseJavaAnnotations() ) { - Table table = getPhysicalAnnotation( Table.class ); - if ( table != null ) { - annotation.setValue( "name", table.name() ); - annotation.setValue( "schema", table.schema() ); - annotation.setValue( "catalog", table.catalog() ); - annotation.setValue( "uniqueConstraints", table.uniqueConstraints() ); - annotation.setValue( "indexes", table.indexes() ); - } - } - if ( isEmpty( (String) annotation.valueOf( "schema" ) ) - && isNotEmpty( defaults.getSchema() ) ) { - annotation.setValue( "schema", defaults.getSchema() ); - } - if ( isEmpty( (String) annotation.valueOf( "catalog" ) ) - && isNotEmpty( defaults.getCatalog() ) ) { - annotation.setValue( "catalog", defaults.getCatalog() ); - } - return AnnotationFactory.create( annotation ); - } - else if ( defaults.canUseJavaAnnotations() ) { - return getPhysicalAnnotation( Table.class ); - } - else { - return null; - } - } - else { - //ignore java annotation, an element is defined - AnnotationDescriptor annotation = new AnnotationDescriptor( Table.class ); - copyAttribute( annotation, "name", element.getName(), false ); - copyAttribute( annotation, "catalog", element.getCatalog(), false ); - if ( isNotEmpty( defaults.getCatalog() ) - && isEmpty( (String) annotation.valueOf( "catalog" ) ) ) { - annotation.setValue( "catalog", defaults.getCatalog() ); - } - copyAttribute( annotation, "schema", element.getSchema(), false ); - if ( isNotEmpty( defaults.getSchema() ) - && isEmpty( (String) annotation.valueOf( "schema" ) ) ) { - annotation.setValue( "schema", defaults.getSchema() ); - } - buildUniqueConstraints( annotation, element.getUniqueConstraints() ); - buildIndex( annotation, element.getIndexes() ); - return AnnotationFactory.create( annotation ); - } - } - - private SecondaryTables getSecondaryTables(JaxbManagedType root, XMLContext.Default defaults) { - final List elements = root instanceof JaxbEntity - ? ( (JaxbEntity) root ).getSecondaryTables() - : Collections.emptyList(); - final List secondaryTables = new ArrayList<>( 3 ); - for ( JaxbSecondaryTableImpl element : elements ) { - AnnotationDescriptor annotation = new AnnotationDescriptor( SecondaryTable.class ); - copyAttribute( annotation, "name", element.getName(), false ); - copyAttribute( annotation, "catalog", element.getCatalog(), false ); - if ( isNotEmpty( defaults.getCatalog() ) - && isEmpty( (String) annotation.valueOf( "catalog" ) ) ) { - annotation.setValue( "catalog", defaults.getCatalog() ); - } - copyAttribute( annotation, "schema", element.getSchema(), false ); - if ( isNotEmpty( defaults.getSchema() ) - && isEmpty( (String) annotation.valueOf( "schema" ) ) ) { - annotation.setValue( "schema", defaults.getSchema() ); - } - buildUniqueConstraints( annotation, element.getUniqueConstraint() ); - buildIndex( annotation, element.getIndex() ); - annotation.setValue( "pkJoinColumns", - buildPrimaryKeyJoinColumns( element.getPrimaryKeyJoinColumn() ) ); - secondaryTables.add( AnnotationFactory.create( annotation ) ); - } - /* - * You can't have both secondary tables in XML and Java, - * since there would be no way to "remove" a secondary table - */ - if ( secondaryTables.isEmpty() && defaults.canUseJavaAnnotations() ) { - SecondaryTable secTableAnn = getPhysicalAnnotation( SecondaryTable.class ); - overridesDefaultInSecondaryTable( secTableAnn, defaults, secondaryTables ); - SecondaryTables secTablesAnn = getPhysicalAnnotation( SecondaryTables.class ); - if ( secTablesAnn != null ) { - for ( SecondaryTable table : secTablesAnn.value() ) { - overridesDefaultInSecondaryTable( table, defaults, secondaryTables ); - } - } - } - if ( !secondaryTables.isEmpty() ) { - AnnotationDescriptor descriptor = new AnnotationDescriptor( SecondaryTables.class ); - descriptor.setValue( "value", secondaryTables.toArray( new SecondaryTable[secondaryTables.size()] ) ); - return AnnotationFactory.create( descriptor ); - } - else { - return null; - } - } - - private void overridesDefaultInSecondaryTable( - SecondaryTable secTableAnn, XMLContext.Default defaults, List secondaryTables - ) { - if ( secTableAnn != null ) { - //handle default values - if ( isNotEmpty( defaults.getCatalog() ) - || isNotEmpty( defaults.getSchema() ) ) { - AnnotationDescriptor annotation = new AnnotationDescriptor( SecondaryTable.class ); - annotation.setValue( "name", secTableAnn.name() ); - annotation.setValue( "schema", secTableAnn.schema() ); - annotation.setValue( "catalog", secTableAnn.catalog() ); - annotation.setValue( "uniqueConstraints", secTableAnn.uniqueConstraints() ); - annotation.setValue( "pkJoinColumns", secTableAnn.pkJoinColumns() ); - if ( isEmpty( (String) annotation.valueOf( "schema" ) ) - && isNotEmpty( defaults.getSchema() ) ) { - annotation.setValue( "schema", defaults.getSchema() ); - } - if ( isEmpty( (String) annotation.valueOf( "catalog" ) ) - && isNotEmpty( defaults.getCatalog() ) ) { - annotation.setValue( "catalog", defaults.getCatalog() ); - } - secondaryTables.add( AnnotationFactory.create( annotation ) ); - } - else { - secondaryTables.add( secTableAnn ); - } - } - } - - private static void buildIndex(AnnotationDescriptor annotation, List elements) { - Index[] indexes = new Index[ elements.size() ]; - int i = 0; - for ( JaxbIndexImpl element : elements ) { - AnnotationDescriptor indexAnn = new AnnotationDescriptor( Index.class ); - copyAttribute( indexAnn, "name", element.getName(), false ); - copyAttribute( indexAnn, "column-list", element.getColumnList(), true ); - copyAttribute( indexAnn, "unique", element.isUnique(), false ); - indexes[ i++ ] = AnnotationFactory.create( indexAnn ); - } - annotation.setValue( "indexes", indexes ); - } - - private static void buildUniqueConstraints( - AnnotationDescriptor annotation, - List elements) { - UniqueConstraint[] uniqueConstraints = new UniqueConstraint[ elements.size() ]; - int i = 0; - for ( JaxbUniqueConstraintImpl element : elements ) { - String[] columnNames = element.getColumnName().toArray( new String[ 0 ] ); - AnnotationDescriptor ucAnn = new AnnotationDescriptor( UniqueConstraint.class ); - copyAttribute( ucAnn, "name", element.getName(), false ); - ucAnn.setValue( "columnNames", columnNames ); - uniqueConstraints[ i++ ] = AnnotationFactory.create( ucAnn ); - } - annotation.setValue( "uniqueConstraints", uniqueConstraints ); - } - - private PrimaryKeyJoinColumn[] buildPrimaryKeyJoinColumns(List elements) { - PrimaryKeyJoinColumn[] pkJoinColumns = new PrimaryKeyJoinColumn[ elements.size() ]; - int i = 0; - for ( JaxbPrimaryKeyJoinColumnImpl element : elements ) { - AnnotationDescriptor pkAnn = new AnnotationDescriptor( PrimaryKeyJoinColumn.class ); - copyAttribute( pkAnn, "name", element.getName(), false ); - copyAttribute( pkAnn, "referenced-column-name", element.getReferencedColumnName(), false ); - copyAttribute( pkAnn, "column-definition", element.getColumnDefinition(), false ); - pkJoinColumns[ i++ ] = AnnotationFactory.create( pkAnn ); - } - return pkJoinColumns; - } - - /** - * Copy an attribute from an XML element to an annotation descriptor. The name of the annotation attribute is - * computed from the name of the XML attribute by {@link #getJavaAttributeNameFromXMLOne(String)}. - * - * @param annotation annotation descriptor where to copy to the attribute. - * @param attributeName name of the XML attribute to copy. - * @param attributeValue value of the XML attribute to copy. - * @param mandatory whether the attribute is mandatory. - */ - private static void copyAttribute( - final AnnotationDescriptor annotation, - final String attributeName, final Object attributeValue, - final boolean mandatory) { - copyAttribute( - annotation, - getJavaAttributeNameFromXMLOne( attributeName ), - attributeName, - attributeValue, - mandatory - ); - } - - /** - * Copy an attribute from an XML element to an annotation descriptor. The name of the annotation attribute is - * explicitly given. - * - * @param annotation annotation where to copy to the attribute. - * @param annotationAttributeName name of the annotation attribute where to copy. - * @param attributeValue value of the XML attribute to copy. - * @param mandatory whether the attribute is mandatory. - */ - private static void copyAttribute( - final AnnotationDescriptor annotation, - final String annotationAttributeName, final Object attributeName, - final Object attributeValue, - boolean mandatory) { - if ( attributeValue != null ) { - annotation.setValue( annotationAttributeName, attributeValue ); - } - else { - if ( mandatory ) { - throw new AnnotationException( - annotationToXml.getOrDefault( annotation.type(), annotation.type().getName() ) - + "." + attributeName - + " is mandatory in XML overriding. " + SCHEMA_VALIDATION - ); - } - } - } - - private static String getJavaAttributeNameFromXMLOne(String attributeName) { - StringBuilder annotationAttributeName = new StringBuilder( attributeName ); - int index = annotationAttributeName.indexOf( WORD_SEPARATOR ); - while ( index != -1 ) { - annotationAttributeName.deleteCharAt( index ); - annotationAttributeName.setCharAt( - index, Character.toUpperCase( annotationAttributeName.charAt( index ) ) - ); - index = annotationAttributeName.indexOf( WORD_SEPARATOR ); - } - return annotationAttributeName.toString(); - } - - private T getPhysicalAnnotation(Class annotationType) { - return element.getAnnotation( annotationType ); - } - - private boolean isPhysicalAnnotationPresent(Class annotationType) { - return element.isAnnotationPresent( annotationType ); - } - - private Annotation[] getPhysicalAnnotations() { - return element.getAnnotations(); - } - -} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/JPAXMLOverriddenMetadataProvider.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/JPAXMLOverriddenMetadataProvider.java deleted file mode 100644 index e6109a1c20..0000000000 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/JPAXMLOverriddenMetadataProvider.java +++ /dev/null @@ -1,203 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. - */ -package org.hibernate.boot.model.internal; - -import java.lang.reflect.AnnotatedElement; -import java.util.ArrayList; -import java.util.Collections; -import java.util.HashMap; -import java.util.List; -import java.util.Map; - -import org.hibernate.annotations.common.reflection.AnnotationReader; -import org.hibernate.annotations.common.reflection.MetadataProvider; -import org.hibernate.annotations.common.reflection.java.JavaMetadataProvider; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappingsImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbSequenceGeneratorImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbTableGeneratorImpl; -import org.hibernate.boot.registry.classloading.spi.ClassLoadingException; -import org.hibernate.boot.spi.BootstrapContext; -import org.hibernate.boot.spi.ClassLoaderAccess; - -import jakarta.persistence.EntityListeners; -import jakarta.persistence.NamedNativeQuery; -import jakarta.persistence.NamedQuery; -import jakarta.persistence.NamedStoredProcedureQuery; -import jakarta.persistence.SequenceGenerator; -import jakarta.persistence.SqlResultSetMapping; -import jakarta.persistence.TableGenerator; - -/** - * MetadataProvider aware of the JPA Deployment descriptor (orm.xml, ...). - * - * @author Emmanuel Bernard - */ -@SuppressWarnings("unchecked") -public class JPAXMLOverriddenMetadataProvider implements MetadataProvider { - - private static final MetadataProvider STATELESS_BASE_DELEGATE = new JavaMetadataProvider(); - - private final ClassLoaderAccess classLoaderAccess; - private final XMLContext xmlContext; - - /** - * We allow fully disabling XML sources so to improve the efficiency of - * the boot process for those not using it. - */ - private final boolean xmlMappingEnabled; - - private Map defaults; - private Map cache; - - public JPAXMLOverriddenMetadataProvider(BootstrapContext bootstrapContext) { - this( bootstrapContext.getClassLoaderAccess(), bootstrapContext ); - } - - public JPAXMLOverriddenMetadataProvider(ClassLoaderAccess classLoaderAccess, BootstrapContext bootstrapContext) { - this.classLoaderAccess = classLoaderAccess; - this.xmlContext = new XMLContext( classLoaderAccess, bootstrapContext.getClassmateContext() ); - this.xmlMappingEnabled = bootstrapContext.getMetadataBuildingOptions().isXmlMappingEnabled(); - } - - //all of the above can be safely rebuilt from XMLContext: only XMLContext this object is serialized - @Override - public AnnotationReader getAnnotationReader(AnnotatedElement annotatedElement) { - if ( cache == null ) { - cache = new HashMap<>(50 ); - } - AnnotationReader reader = cache.get( annotatedElement ); - if (reader == null) { - if ( xmlContext.hasContext() ) { - reader = new JPAXMLOverriddenAnnotationReader( annotatedElement, xmlContext, classLoaderAccess ); - } - else { - reader = STATELESS_BASE_DELEGATE.getAnnotationReader( annotatedElement ); - } - cache.put( annotatedElement, reader ); - } - return reader; - } - - // @Override - // FIXME this method was introduced in HCANN 5.1.1: we can't mark it as @Override yet, - // but it's expected to be invoked when we're running with the right HCANN version. - public void reset() { - //It's better to remove the HashMap, as it could grow rather large: - //when doing a clear() the internal buckets array is not scaled down. - this.cache = null; - } - - @Override - public Map getDefaults() { - if ( !xmlMappingEnabled ) { - return Collections.emptyMap(); - } - else { - if ( defaults == null ) { - defaults = new HashMap<>(); - XMLContext.Default xmlDefaults = xmlContext.getDefaultWithGlobalCatalogAndSchema(); - - defaults.put( "schema", xmlDefaults.getSchema() ); - defaults.put( "catalog", xmlDefaults.getCatalog() ); - defaults.put( "delimited-identifier", xmlDefaults.getDelimitedIdentifier() ); - defaults.put( "cascade-persist", xmlDefaults.getCascadePersist() ); - List entityListeners = new ArrayList(); - for ( String className : xmlContext.getDefaultEntityListeners() ) { - try { - entityListeners.add( classLoaderAccess.classForName( className ) ); - } - catch (ClassLoadingException e) { - throw new IllegalStateException( "Default entity listener class not found: " + className ); - } - } - defaults.put( EntityListeners.class, entityListeners ); - for ( JaxbEntityMappingsImpl entityMappings : xmlContext.getAllDocuments() ) { - List jaxbSequenceGenerators = entityMappings.getSequenceGenerators(); - List sequenceGenerators = (List) defaults.get( SequenceGenerator.class ); - if ( sequenceGenerators == null ) { - sequenceGenerators = new ArrayList<>(); - defaults.put( SequenceGenerator.class, sequenceGenerators ); - } - for ( JaxbSequenceGeneratorImpl element : jaxbSequenceGenerators ) { - sequenceGenerators.add( JPAXMLOverriddenAnnotationReader.buildSequenceGeneratorAnnotation( element ) ); - } - - List jaxbTableGenerators = entityMappings.getTableGenerators(); - List tableGenerators = (List) defaults.get( TableGenerator.class ); - if ( tableGenerators == null ) { - tableGenerators = new ArrayList<>(); - defaults.put( TableGenerator.class, tableGenerators ); - } - for ( JaxbTableGeneratorImpl element : jaxbTableGenerators ) { - tableGenerators.add( - JPAXMLOverriddenAnnotationReader.buildTableGeneratorAnnotation( - element, - xmlDefaults - ) - ); - } - - List namedQueries = ( List ) defaults.get( NamedQuery.class ); - if ( namedQueries == null ) { - namedQueries = new ArrayList<>(); - defaults.put( NamedQuery.class, namedQueries ); - } - List currentNamedQueries = JPAXMLOverriddenAnnotationReader.buildNamedQueries( - entityMappings.getNamedQueries(), - xmlDefaults, - classLoaderAccess - ); - namedQueries.addAll( currentNamedQueries ); - - List namedNativeQueries = ( List ) defaults.get( NamedNativeQuery.class ); - if ( namedNativeQueries == null ) { - namedNativeQueries = new ArrayList<>(); - defaults.put( NamedNativeQuery.class, namedNativeQueries ); - } - List currentNamedNativeQueries = JPAXMLOverriddenAnnotationReader.buildNamedNativeQueries( - entityMappings.getNamedNativeQueries(), - xmlDefaults, - classLoaderAccess - ); - namedNativeQueries.addAll( currentNamedNativeQueries ); - - List sqlResultSetMappings = ( List ) defaults.get( - SqlResultSetMapping.class - ); - if ( sqlResultSetMappings == null ) { - sqlResultSetMappings = new ArrayList<>(); - defaults.put( SqlResultSetMapping.class, sqlResultSetMappings ); - } - List currentSqlResultSetMappings = JPAXMLOverriddenAnnotationReader.buildSqlResultSetMappings( - entityMappings.getSqlResultSetMappings(), - xmlDefaults, - classLoaderAccess - ); - sqlResultSetMappings.addAll( currentSqlResultSetMappings ); - - List namedStoredProcedureQueries = (List)defaults.get( NamedStoredProcedureQuery.class ); - if(namedStoredProcedureQueries==null){ - namedStoredProcedureQueries = new ArrayList<>( ); - defaults.put( NamedStoredProcedureQuery.class, namedStoredProcedureQueries ); - } - List currentNamedStoredProcedureQueries = JPAXMLOverriddenAnnotationReader - .buildNamedStoreProcedureQueries( - entityMappings.getNamedProcedureQueries(), - xmlDefaults, - classLoaderAccess - ); - namedStoredProcedureQueries.addAll( currentNamedStoredProcedureQueries ); - } - } - return defaults; - } - } - - public XMLContext getXMLContext() { - return xmlContext; - } -} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/PersistentAttributeFilter.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/PersistentAttributeFilter.java deleted file mode 100644 index c4e3bb674d..0000000000 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/PersistentAttributeFilter.java +++ /dev/null @@ -1,30 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. - */ -package org.hibernate.boot.model.internal; - -import org.hibernate.annotations.common.reflection.Filter; - -/** - * @author Emmanuel Bernard - * @author Steve Ebersole - */ -public class PersistentAttributeFilter implements Filter { - /** - * Singleton access - */ - public static final PersistentAttributeFilter INSTANCE = new PersistentAttributeFilter(); - - @Override - public boolean returnStatic() { - return false; - } - - @Override - public boolean returnTransient() { - return false; - } -} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/PropertyMappingElementCollector.java b/hibernate-core/src/main/java/org/hibernate/boot/model/internal/PropertyMappingElementCollector.java deleted file mode 100644 index 24ebc47527..0000000000 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/internal/PropertyMappingElementCollector.java +++ /dev/null @@ -1,224 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. - */ -package org.hibernate.boot.model.internal; - -import java.util.ArrayList; -import java.util.Collections; -import java.util.List; -import java.util.function.Function; - -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.JaxbElementCollectionImpl; -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.JaxbIdImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbLifecycleCallback; -import org.hibernate.boot.jaxb.mapping.spi.JaxbLifecycleCallbackContainer; -import org.hibernate.boot.jaxb.mapping.spi.JaxbManagedType; -import org.hibernate.boot.jaxb.mapping.spi.JaxbManyToManyImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbManyToOneImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbOneToManyImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbOneToOneImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPersistentAttribute; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPostLoadImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPostPersistImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPostRemoveImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPostUpdateImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPrePersistImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPreRemoveImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbPreUpdateImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbTenantIdImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbTransientImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbVersionImpl; - - -/** - * Reproduces what we used to do with a {@code List} in {@link JPAXMLOverriddenAnnotationReader}, - * with the following constraints: - *
    - *
  • Preserve type safety
    • - *
  • Only create lists if we actually have elements (most lists should be empty in most cases)
    • - *
- */ -public final class PropertyMappingElementCollector { - public static final Function PERSISTENT_ATTRIBUTE_NAME = JaxbPersistentAttribute::getName; - public static final Function JAXB_TRANSIENT_NAME = JaxbTransientImpl::getName; - static final Function LIFECYCLE_CALLBACK_NAME = JaxbLifecycleCallback::getMethodName; - - private final String propertyName; - - private List id; - private List embeddedId; - private List version; - private List basic; - private List embedded; - private List oneToOne; - private List manyToOne; - private List elementCollection; - private List oneToMany; - private List manyToMany; - private List _transient; - - private List prePersist; - private List postPersist; - private List preRemove; - private List postRemove; - private List preUpdate; - private List postUpdate; - private List postLoad; - - public PropertyMappingElementCollector(String propertyName) { - this.propertyName = propertyName; - } - - public boolean isEmpty() { - return allNullOrEmpty( id, embeddedId, basic, version, manyToOne, oneToMany, oneToOne, manyToMany, - elementCollection, embedded, _transient, - prePersist, postPersist, preRemove, postRemove, preUpdate, postUpdate, postLoad ); - } - - private boolean allNullOrEmpty(List... lists) { - for ( List list : lists ) { - if ( list != null && !list.isEmpty() ) { - return false; - } - } - return true; - } - - private List defaultToEmpty(List list) { - return list == null ? Collections.emptyList() : list; - } - - public void collectPersistentAttributesIfMatching(JaxbAttributesContainer container) { - if ( container instanceof JaxbAttributesContainerImpl jaxbAttributes ) { - id = collectIfMatching( id, jaxbAttributes.getIdAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - embeddedId = collectIfMatching( embeddedId, jaxbAttributes.getEmbeddedIdAttribute(), PERSISTENT_ATTRIBUTE_NAME ); - version = collectIfMatching( version, jaxbAttributes.getVersion(), PERSISTENT_ATTRIBUTE_NAME ); - } - basic = collectIfMatching( basic, container.getBasicAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - manyToOne = collectIfMatching( manyToOne, container.getManyToOneAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - oneToMany = collectIfMatching( oneToMany, container.getOneToManyAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - oneToOne = collectIfMatching( oneToOne, container.getOneToOneAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - manyToMany = collectIfMatching( manyToMany, container.getManyToManyAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - elementCollection = collectIfMatching( elementCollection, container.getElementCollectionAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - embedded = collectIfMatching( embedded, container.getEmbeddedAttributes(), PERSISTENT_ATTRIBUTE_NAME ); - _transient = collectIfMatching( _transient, container.getTransients(), JAXB_TRANSIENT_NAME ); - } - - public void collectLifecycleCallbacksIfMatching(JaxbLifecycleCallbackContainer container) { - prePersist = collectIfMatching( prePersist, container.getPrePersist(), LIFECYCLE_CALLBACK_NAME ); - postPersist = collectIfMatching( postPersist, container.getPostPersist(), LIFECYCLE_CALLBACK_NAME ); - preRemove = collectIfMatching( preRemove, container.getPreRemove(), LIFECYCLE_CALLBACK_NAME ); - postRemove = collectIfMatching( postRemove, container.getPostRemove(), LIFECYCLE_CALLBACK_NAME ); - preUpdate = collectIfMatching( preUpdate, container.getPreUpdate(), LIFECYCLE_CALLBACK_NAME ); - postUpdate = collectIfMatching( postUpdate, container.getPostUpdate(), LIFECYCLE_CALLBACK_NAME ); - postLoad = collectIfMatching( postLoad, container.getPostLoad(), LIFECYCLE_CALLBACK_NAME ); - } - - public void collectTenantIdIfMatching(JaxbManagedType managedType) { - if ( managedType instanceof JaxbEntityImpl ) { - JaxbTenantIdImpl tenantId = ( (JaxbEntityImpl) managedType ).getTenantId(); - basic = collectIfMatching( basic, tenantId, PERSISTENT_ATTRIBUTE_NAME ); - } - } - - private List collectIfMatching(List collected, List candidates, - Function nameGetter) { - List result = collected; - for ( T candidate : candidates ) { - result = collectIfMatching( result, candidate, nameGetter ); - } - return result; - } - - private List collectIfMatching(List collected, T candidate, Function nameGetter) { - List result = collected; - if ( candidate != null && propertyName.equals( nameGetter.apply( candidate ) ) ) { - if ( result == null ) { - result = new ArrayList<>(); - } - result.add( candidate ); - } - return result; - } - - public List getId() { - return defaultToEmpty( id ); - } - - public List getEmbeddedId() { - return defaultToEmpty( embeddedId ); - } - - public List getBasic() { - return defaultToEmpty( basic ); - } - - public List getVersion() { - return defaultToEmpty( version ); - } - - public List getManyToOne() { - return defaultToEmpty( manyToOne ); - } - - public List getOneToMany() { - return defaultToEmpty( oneToMany ); - } - - public List getOneToOne() { - return defaultToEmpty( oneToOne ); - } - - public List getManyToMany() { - return defaultToEmpty( manyToMany ); - } - - public List getElementCollection() { - return defaultToEmpty( elementCollection ); - } - - public List getEmbedded() { - return defaultToEmpty( embedded ); - } - - public List getTransient() { - return defaultToEmpty( _transient ); - } - - public List getPrePersist() { - return defaultToEmpty( prePersist ); - } - - public List getPostPersist() { - return defaultToEmpty( postPersist ); - } - - public List getPreRemove() { - return defaultToEmpty( preRemove ); - } - - public List getPostRemove() { - return defaultToEmpty( postRemove ); - } - - public List getPreUpdate() { - return defaultToEmpty( preUpdate ); - } - - public List getPostUpdate() { - return defaultToEmpty( postUpdate ); - } - - public List getPostLoad() { - return defaultToEmpty( postLoad ); - } -} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/OverriddenMappingDefaults.java b/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/OverriddenMappingDefaults.java index ce5677a00f..b854090132 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/OverriddenMappingDefaults.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/OverriddenMappingDefaults.java @@ -33,6 +33,7 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { private final boolean entitiesImplicitlyLazy; private final boolean pluralAttributesImplicitlyLazy; private final AccessType implicitCacheAccessType; + private final EnumSet cascadeTypes; private final CollectionClassification implicitListClassification; public OverriddenMappingDefaults( @@ -44,7 +45,7 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { String implicitDiscriminatorColumnName, String implicitPackageName, boolean autoImportEnabled, - String implicitCascadeStyleName, + EnumSet cascadeTypes, jakarta.persistence.AccessType implicitPropertyAccessType, String implicitPropertyAccessorName, boolean entitiesImplicitlyLazy, @@ -59,6 +60,7 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { this.implicitDiscriminatorColumnName = implicitDiscriminatorColumnName; this.implicitPackageName = implicitPackageName; this.autoImportEnabled = autoImportEnabled; + this.cascadeTypes = cascadeTypes; this.implicitPropertyAccessType = implicitPropertyAccessType; this.implicitPropertyAccessorName = implicitPropertyAccessorName; this.entitiesImplicitlyLazy = entitiesImplicitlyLazy; @@ -109,7 +111,7 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { @Override public EnumSet getDefaultCascadeTypes() { - return EnumSet.noneOf( CascadeType.class ); + return cascadeTypes; } @Override @@ -151,7 +153,7 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { private String implicitDiscriminatorColumnName; private String implicitPackageName; private boolean autoImportEnabled; - private String implicitCascadeStyleName; + private EnumSet implicitCascadeTypes; private jakarta.persistence.AccessType implicitPropertyAccessType; private String implicitPropertyAccessorName; private boolean entitiesImplicitlyLazy; @@ -168,7 +170,8 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { this.implicitDiscriminatorColumnName = parentDefaults.getDefaultDiscriminatorColumnName(); this.implicitPackageName = parentDefaults.getDefaultPackageName(); this.autoImportEnabled = parentDefaults.isDefaultAutoImport(); - this.implicitCascadeStyleName = "none"; + + this.implicitCascadeTypes = parentDefaults.getDefaultCascadeTypes(); this.implicitPropertyAccessorName = parentDefaults.getDefaultAccessStrategyName(); this.entitiesImplicitlyLazy = parentDefaults.isDefaultEntityLaziness(); this.pluralAttributesImplicitlyLazy = parentDefaults.isDefaultCollectionLaziness(); @@ -227,12 +230,12 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { return this; } - public Builder setImplicitCascadeStyleName(String implicitCascadeStyleName) { - if ( StringHelper.isNotEmpty( implicitCascadeStyleName ) ) { - this.implicitCascadeStyleName = implicitCascadeStyleName; - } - return this; - } +// public Builder setImplicitCascadeStyleName(String implicitCascadeStyleName) { +// if ( StringHelper.isNotEmpty( implicitCascadeStyleName ) ) { +// this.implicitCascadeStyleName = implicitCascadeStyleName; +// } +// return this; +// } public Builder setImplicitPropertyAccessType(jakarta.persistence.AccessType accessType) { if ( accessType != null ) { @@ -286,7 +289,7 @@ public class OverriddenMappingDefaults implements EffectiveMappingDefaults { implicitDiscriminatorColumnName, implicitPackageName, autoImportEnabled, - implicitCascadeStyleName, + implicitCascadeTypes, implicitPropertyAccessType, implicitPropertyAccessorName, entitiesImplicitlyLazy, diff --git a/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/MappingDocument.java b/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/MappingDocument.java index 53dba5fd34..39180cc7b1 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/MappingDocument.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/MappingDocument.java @@ -72,7 +72,7 @@ public class MappingDocument implements HbmLocalMetadataBuildingContext, Metadat .setImplicitCatalogName( documentRoot.getCatalog() ) .setImplicitPackageName( documentRoot.getPackage() ) .setImplicitPropertyAccessorName( documentRoot.getDefaultAccess() ) - .setImplicitCascadeStyleName( documentRoot.getDefaultCascade() ) +// .setImplicitCascadeStyleName( documentRoot.getDefaultCascade() ) .setEntitiesImplicitlyLazy( documentRoot.isDefaultLazy() ) .setAutoImportEnabled( documentRoot.isAutoImport() ) .setPluralAttributesImplicitlyLazy( documentRoot.isDefaultLazy() ) diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/internal/AnnotationUsageHelper.java b/hibernate-core/src/main/java/org/hibernate/boot/models/internal/AnnotationUsageHelper.java index 973c943313..472c48fadb 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/internal/AnnotationUsageHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/internal/AnnotationUsageHelper.java @@ -8,34 +8,26 @@ package org.hibernate.boot.models.internal; import java.lang.annotation.Annotation; -import org.hibernate.internal.util.StringHelper; +import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; import org.hibernate.models.spi.AnnotationDescriptor; import org.hibernate.models.spi.AnnotationTarget; -import org.hibernate.models.spi.AnnotationUsage; import org.hibernate.models.spi.MutableAnnotationUsage; -import org.hibernate.models.spi.MutableClassDetails; import org.hibernate.models.spi.SourceModelBuildingContext; -import jakarta.persistence.NamedQueries; - public class AnnotationUsageHelper { public static void applyAttributeIfSpecified( String attributeName, Object value, MutableAnnotationUsage annotationUsage) { - if ( value != null ) { - annotationUsage.setAttributeValue( attributeName, value ); - } + XmlAnnotationHelper.applyOptionalAttribute( annotationUsage, attributeName, value ); } public static void applyStringAttributeIfSpecified( String attributeName, String value, MutableAnnotationUsage annotationUsage) { - if ( StringHelper.isNotEmpty( value ) ) { - annotationUsage.setAttributeValue( attributeName, value ); - } + XmlAnnotationHelper.applyOptionalAttribute( annotationUsage, attributeName, value ); } public static MutableAnnotationUsage getOrCreateUsage( diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/XmlAnnotationHelper.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/XmlAnnotationHelper.java index 7b47470c84..7bf233ad64 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/XmlAnnotationHelper.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/XmlAnnotationHelper.java @@ -11,7 +11,6 @@ import java.lang.reflect.Field; import java.math.BigDecimal; import java.math.BigInteger; import java.util.ArrayList; -import java.util.Collections; import java.util.List; import java.util.UUID; import java.util.function.Function; @@ -60,22 +59,17 @@ import org.hibernate.boot.jaxb.mapping.spi.JaxbDiscriminatorFormulaImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbEmbeddedIdImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbEntity; import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityListenerImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbForeignKeyImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbGeneratedValueImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbHbmFilterImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbIdClassImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbIdImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbIndexImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinTableImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbLifecycleCallback; import org.hibernate.boot.jaxb.mapping.spi.JaxbLifecycleCallbackContainer; import org.hibernate.boot.jaxb.mapping.spi.JaxbLobImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbMapKeyColumnImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbMapKeyJoinColumnImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedAttributeNodeImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedEntityGraphImpl; -import org.hibernate.boot.jaxb.mapping.spi.JaxbNamedSubgraphImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbNationalizedImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbNaturalId; import org.hibernate.boot.jaxb.mapping.spi.JaxbSchemaAware; @@ -86,12 +80,15 @@ import org.hibernate.boot.jaxb.mapping.spi.JaxbUniqueConstraintImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbUserTypeImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbUuidGeneratorImpl; import org.hibernate.boot.jaxb.mapping.spi.db.JaxbCheckable; -import org.hibernate.boot.jaxb.mapping.spi.db.JaxbColumnJoined; import org.hibernate.boot.jaxb.mapping.spi.db.JaxbTableMapping; +import org.hibernate.boot.models.JpaAnnotations; import org.hibernate.boot.models.categorize.spi.JpaEventListener; import org.hibernate.boot.models.categorize.spi.JpaEventListenerStyle; import org.hibernate.boot.models.internal.AnnotationUsageHelper; import org.hibernate.boot.models.xml.internal.db.ColumnProcessing; +import org.hibernate.boot.models.xml.internal.db.ForeignKeyProcessing; +import org.hibernate.boot.models.xml.internal.db.JoinColumnProcessing; +import org.hibernate.boot.models.xml.internal.db.TableProcessing; import org.hibernate.boot.models.xml.spi.XmlDocument; import org.hibernate.boot.models.xml.spi.XmlDocumentContext; import org.hibernate.engine.spi.ExecuteUpdateResultCheckStyle; @@ -126,21 +123,15 @@ import jakarta.persistence.Entity; import jakarta.persistence.EntityListeners; import jakarta.persistence.EnumType; import jakarta.persistence.Enumerated; -import jakarta.persistence.ForeignKey; import jakarta.persistence.GeneratedValue; import jakarta.persistence.Id; import jakarta.persistence.IdClass; import jakarta.persistence.Index; import jakarta.persistence.Inheritance; import jakarta.persistence.JoinColumn; -import jakarta.persistence.JoinColumns; -import jakarta.persistence.JoinTable; import jakarta.persistence.Lob; import jakarta.persistence.MapKeyColumn; import jakarta.persistence.MapKeyJoinColumn; -import jakarta.persistence.NamedAttributeNode; -import jakarta.persistence.NamedEntityGraph; -import jakarta.persistence.NamedSubgraph; import jakarta.persistence.PostLoad; import jakarta.persistence.PostPersist; import jakarta.persistence.PostRemove; @@ -157,7 +148,6 @@ import jakarta.persistence.UniqueConstraint; import static java.lang.Boolean.FALSE; import static java.util.Collections.emptyList; -import static org.hibernate.boot.models.JpaAnnotations.NAMED_ATTRIBUTE_NODE; import static org.hibernate.boot.models.xml.internal.XmlProcessingHelper.makeNestedAnnotation; /** @@ -167,6 +157,52 @@ import static org.hibernate.boot.models.xml.internal.XmlProcessingHelper.makeNes */ public class XmlAnnotationHelper { + public static void applyOptionalAttribute(MutableAnnotationUsage annotationUsage, String attributeName, Object value) { + if ( value != null ) { + annotationUsage.setAttributeValue( attributeName, value ); + } + } + + public static void applyOptionalAttribute(MutableAnnotationUsage annotationUsage, String attributeName, String value) { + if ( StringHelper.isNotEmpty( value ) ) { + annotationUsage.setAttributeValue( attributeName, value ); + } + } + + public static void applyOptionalAttribute( + MutableAnnotationUsage annotationUsage, + String attributeName, + S valueSource, + Function valueExtractor) { + if ( valueSource == null ) { + return; + } + + final Object value = valueExtractor.apply( valueSource ); + if ( value == null ) { + return; + } + + annotationUsage.setAttributeValue( attributeName, value ); + } + + public static void applyOptionalStringAttribute( + MutableAnnotationUsage annotationUsage, + String attributeName, + S valueSource, + Function valueExtractor) { + if ( valueSource == null ) { + return; + } + + final String value = valueExtractor.apply( valueSource ); + if ( StringHelper.isEmpty( value ) ) { + return; + } + + annotationUsage.setAttributeValue( attributeName, value ); + } + /** * Handle creating {@linkplain Entity @Entity} from an {@code } element. * Used in both complete and override modes. @@ -217,127 +253,7 @@ public class XmlAnnotationHelper { return null; } - return createJoinColumnAnnotation( jaxbJoinColumn, memberDetails, JoinColumn.class, xmlDocumentContext ); - } - - public static MutableAnnotationUsage applyJoinColumn( - JaxbJoinColumnImpl jaxbJoinColumn, - XmlDocumentContext xmlDocumentContext) { - if ( jaxbJoinColumn == null ) { - return null; - } - - return createJoinColumnAnnotation( jaxbJoinColumn, JoinColumn.class, xmlDocumentContext ); - } - - public static MutableAnnotationUsage createJoinColumnAnnotation( - JaxbColumnJoined jaxbJoinColumn, - MutableMemberDetails memberDetails, - Class annotationType, - XmlDocumentContext xmlDocumentContext) { - final MutableAnnotationUsage joinColumnAnn = XmlProcessingHelper.getOrMakeNamedAnnotation( - annotationType, - jaxbJoinColumn.getName(), - memberDetails, - xmlDocumentContext - ); - final AnnotationDescriptor joinColumnDescriptor = xmlDocumentContext - .getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( annotationType ); - - ColumnProcessing.applyColumnDetails( jaxbJoinColumn, memberDetails, joinColumnAnn, xmlDocumentContext ); - - applyOr( jaxbJoinColumn, JaxbColumnJoined::getReferencedColumnName, "referencedColumnName", joinColumnAnn, joinColumnDescriptor ); - - final JaxbForeignKeyImpl jaxbForeignKey = jaxbJoinColumn.getForeignKey(); - if ( jaxbForeignKey != null ) { - joinColumnAnn.setAttributeValue( - "foreignKey", - createForeignKeyAnnotation( jaxbForeignKey, memberDetails, xmlDocumentContext ) - ); - } - - return joinColumnAnn; - } - - public static MutableAnnotationUsage createJoinColumnAnnotation( - JaxbColumnJoined jaxbJoinColumn, - Class annotationType, - XmlDocumentContext xmlDocumentContext) { - final MutableAnnotationUsage joinColumnAnn = XmlProcessingHelper.getOrMakeAnnotation( annotationType, xmlDocumentContext ); - final AnnotationDescriptor joinColumnDescriptor = xmlDocumentContext - .getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( annotationType ); - - ColumnProcessing.applyColumnDetails( jaxbJoinColumn, joinColumnAnn, xmlDocumentContext ); - - applyOr( jaxbJoinColumn, JaxbColumnJoined::getReferencedColumnName, "referencedColumnName", joinColumnAnn, joinColumnDescriptor ); - - final JaxbForeignKeyImpl jaxbForeignKey = jaxbJoinColumn.getForeignKey(); - if ( jaxbForeignKey != null ) { - joinColumnAnn.setAttributeValue( - "foreignKey", - createForeignKeyAnnotation( jaxbForeignKey, xmlDocumentContext ) - ); - } - - return joinColumnAnn; - } - - public static void applyJoinColumns( - List jaxbJoinColumns, - MutableMemberDetails memberDetails, - XmlDocumentContext xmlDocumentContext) { - if ( CollectionHelper.isEmpty( jaxbJoinColumns ) ) { - return; - } - - if ( jaxbJoinColumns.size() == 1 ) { - XmlAnnotationHelper.applyJoinColumn( jaxbJoinColumns.get( 0 ), memberDetails, xmlDocumentContext ); - } - else { - final MutableAnnotationUsage columnsAnn = XmlProcessingHelper.makeAnnotation( - JoinColumns.class, - memberDetails, - xmlDocumentContext - ); - columnsAnn.setAttributeValue( "value", createJoinColumns( jaxbJoinColumns, memberDetails, xmlDocumentContext ) ); - } - } - - public static List> createJoinColumns( - List jaxbJoinColumns, - MutableMemberDetails memberDetails, - XmlDocumentContext xmlDocumentContext) { - if ( CollectionHelper.isEmpty( jaxbJoinColumns ) ) { - return Collections.emptyList(); - } - final List> joinColumns = new ArrayList<>( jaxbJoinColumns.size() ); - jaxbJoinColumns.forEach( jaxbJoinColumn -> { - final MutableAnnotationUsage annotationUsage = createJoinColumnAnnotation( - jaxbJoinColumn, - memberDetails, - JoinColumn.class, - xmlDocumentContext - ); - joinColumns.add( annotationUsage ); - } ); - return joinColumns; - } - - public static List> createJoinColumns( - List jaxbJoinColumns, - XmlDocumentContext xmlDocumentContext) { - if ( CollectionHelper.isEmpty( jaxbJoinColumns ) ) { - return Collections.emptyList(); - } - final List> joinColumns = new ArrayList<>( jaxbJoinColumns.size() ); - jaxbJoinColumns.forEach( jaxbJoinColumn -> { - joinColumns.add( applyJoinColumn( jaxbJoinColumn, xmlDocumentContext ) ); - } ); - return joinColumns; + return JoinColumnProcessing.createJoinColumnAnnotation( jaxbJoinColumn, memberDetails, JoinColumn.class, xmlDocumentContext ); } public static void applyOr( @@ -460,57 +376,6 @@ public class XmlAnnotationHelper { applyOr( jaxbCollectionId, JaxbCollectionIdImpl::getGenerator, "generator", collectionIdAnn, collectionIdDescriptor ); } - public static void applyForeignKey( - JaxbForeignKeyImpl jaxbForeignKey, - MutableMemberDetails memberDetails, - XmlDocumentContext xmlDocumentContext) { - if ( jaxbForeignKey == null ) { - return; - } - - createForeignKeyAnnotation( jaxbForeignKey, memberDetails, xmlDocumentContext ); - } - - public static MutableAnnotationUsage createForeignKeyAnnotation( - JaxbForeignKeyImpl jaxbForeignKey, - MutableMemberDetails memberDetails, - XmlDocumentContext xmlDocumentContext) { - final MutableAnnotationUsage foreignKeyAnn = XmlProcessingHelper.getOrMakeNamedAnnotation( - ForeignKey.class, - jaxbForeignKey.getName(), - memberDetails, - xmlDocumentContext - ); - final AnnotationDescriptor foreignKeyDescriptor = xmlDocumentContext - .getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( ForeignKey.class ); - - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getName, "name", foreignKeyAnn, foreignKeyDescriptor ); - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getConstraintMode, "value", foreignKeyAnn, foreignKeyDescriptor ); - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getForeignKeyDefinition, "foreignKeyDefinition", foreignKeyAnn, foreignKeyDescriptor ); - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getOptions, "options", foreignKeyAnn, foreignKeyDescriptor ); - - return foreignKeyAnn; - } - - public static MutableAnnotationUsage createForeignKeyAnnotation( - JaxbForeignKeyImpl jaxbForeignKey, - XmlDocumentContext xmlDocumentContext) { - final MutableAnnotationUsage foreignKeyAnn = XmlProcessingHelper.getOrMakeAnnotation( ForeignKey.class, xmlDocumentContext ); - final AnnotationDescriptor foreignKeyDescriptor = xmlDocumentContext - .getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( ForeignKey.class ); - - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getName, "name", foreignKeyAnn, foreignKeyDescriptor ); - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getConstraintMode, "value", foreignKeyAnn, foreignKeyDescriptor ); - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getForeignKeyDefinition, "foreignKeyDefinition", foreignKeyAnn, foreignKeyDescriptor ); - applyOr( jaxbForeignKey, JaxbForeignKeyImpl::getOptions, "options", foreignKeyAnn, foreignKeyDescriptor ); - - return foreignKeyAnn; - } - public static void applyMapKeyColumn( JaxbMapKeyColumnImpl jaxbMapKeyColumn, MutableMemberDetails memberDetails, @@ -532,7 +397,7 @@ public class XmlAnnotationHelper { return; } - createJoinColumnAnnotation( jaxbMapKeyJoinColumn, memberDetails, MapKeyJoinColumn.class, xmlDocumentContext ); + JoinColumnProcessing.createJoinColumnAnnotation( jaxbMapKeyJoinColumn, memberDetails, MapKeyJoinColumn.class, xmlDocumentContext ); } public static void applyCascading( @@ -545,7 +410,7 @@ public class XmlAnnotationHelper { // We always use Hibernate specific `org.hibernate.annotations.CascadeType` // since it is a superset of `jakarta.persistence.CascadeType` - final List cascadeTypes = new ArrayList<>(); + final List cascadeTypes = new ArrayList<>( xmlDocumentContext.getEffectiveDefaults().getDefaultCascadeTypes() ); if ( jaxbCascadeType.getCascadeAll() != null ) { cascadeTypes.add( CascadeType.ALL ); } @@ -587,23 +452,19 @@ public class XmlAnnotationHelper { return; } - final List> uniqueConstraints = new ArrayList<>( jaxbUniqueConstraints.size() ); - jaxbUniqueConstraints.forEach( jaxbUniqueConstraint -> { - final MutableAnnotationUsage uniqueConstraintAnn = XmlProcessingHelper.getOrMakeAnnotation( - UniqueConstraint.class, - target, - xmlDocumentContext - ); - final AnnotationDescriptor uniqueConstraintDescriptor = xmlDocumentContext.getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( UniqueConstraint.class ); - XmlProcessingHelper.applyAttributeIfSpecified( "name", jaxbUniqueConstraint.getName(), uniqueConstraintAnn ); - XmlProcessingHelper.applyAttributeIfSpecified( "options", jaxbUniqueConstraint.getOptions(), uniqueConstraintAnn ); - uniqueConstraintAnn.setAttributeValue( "columnNames", jaxbUniqueConstraint.getColumnName() ); - uniqueConstraints.add( uniqueConstraintAnn ); - } ); + final List> uniqueConstraintUsages = new ArrayList<>( jaxbUniqueConstraints.size() ); + annotationUsage.setAttributeValue( "uniqueConstraints", uniqueConstraintUsages ); - annotationUsage.setAttributeValue( "uniqueConstraints", uniqueConstraints ); + jaxbUniqueConstraints.forEach( (jaxbUniqueConstraint) -> { + final MutableAnnotationUsage ucUsage = JpaAnnotations.UNIQUE_CONSTRAINT.createUsage( + target, + xmlDocumentContext.getModelBuildingContext() + ); + XmlAnnotationHelper.applyOptionalAttribute( ucUsage, "name", jaxbUniqueConstraint.getName() ); + XmlAnnotationHelper.applyOptionalAttribute( ucUsage, "options", jaxbUniqueConstraint.getOptions() ); + ucUsage.setAttributeValue( "columnNames", jaxbUniqueConstraint.getColumnName() ); + uniqueConstraintUsages.add( ucUsage ); + } ); } public static void applyIndexes( @@ -633,52 +494,6 @@ public class XmlAnnotationHelper { annotationUsage.setAttributeValue( "indexes", indexes ); } - public static MutableAnnotationUsage applyJoinTable( - JaxbJoinTableImpl jaxbJoinTable, - MutableMemberDetails memberDetails, - XmlDocumentContext xmlDocumentContext) { - if ( jaxbJoinTable == null ) { - return null; - } - - final MutableAnnotationUsage joinTableAnn = XmlProcessingHelper.getOrMakeAnnotation( - JoinTable.class, - memberDetails, - xmlDocumentContext - ); - final AnnotationDescriptor joinTableDescriptor = xmlDocumentContext.getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( JoinTable.class ); - - applyOr( jaxbJoinTable, JaxbJoinTableImpl::getName, "name", joinTableAnn, joinTableDescriptor ); - applyTableAttributes( jaxbJoinTable, memberDetails, joinTableAnn, joinTableDescriptor, xmlDocumentContext ); - - final List joinColumns = jaxbJoinTable.getJoinColumn(); - if ( CollectionHelper.isNotEmpty( joinColumns ) ) { - joinTableAnn.setAttributeValue( "joinColumns", createJoinColumns( joinColumns, xmlDocumentContext ) ); - } - - final List inverseJoinColumns = jaxbJoinTable.getInverseJoinColumn(); - if ( CollectionHelper.isNotEmpty( inverseJoinColumns ) ) { - joinTableAnn.setAttributeValue( "inverseJoinColumns", createJoinColumns( inverseJoinColumns, xmlDocumentContext ) ); - } - - if ( jaxbJoinTable.getForeignKey() != null ) { - joinTableAnn.setAttributeValue( - "foreignKey", - createForeignKeyAnnotation( jaxbJoinTable.getForeignKey(), xmlDocumentContext ) - ); - } - if ( jaxbJoinTable.getInverseForeignKey() != null ) { - joinTableAnn.setAttributeValue( - "inverseForeignKey", - createForeignKeyAnnotation( jaxbJoinTable.getInverseForeignKey(), memberDetails, xmlDocumentContext ) - ); - } - - return joinTableAnn; - } - public static void applyCheckConstraints( JaxbCheckable jaxbCheckable, MutableAnnotationTarget target, @@ -912,18 +727,18 @@ public class XmlAnnotationHelper { XmlProcessingHelper.applyAttributeIfSpecified( "name", jaxbOverride.getName(), annotationUsage ); final List joinColumns = jaxbOverride.getJoinColumns(); if ( CollectionHelper.isNotEmpty( joinColumns ) ) { - annotationUsage.setAttributeValue( "joinColumns", createJoinColumns( joinColumns, memberDetails, xmlDocumentContext ) ); + annotationUsage.setAttributeValue( "joinColumns", JoinColumnProcessing.createJoinColumns( joinColumns, memberDetails, xmlDocumentContext ) ); } if ( jaxbOverride.getJoinTable() != null ) { annotationUsage.setAttributeValue( "joinTable", - applyJoinTable( jaxbOverride.getJoinTable(), memberDetails, xmlDocumentContext ) + TableProcessing.applyJoinTable( jaxbOverride.getJoinTable(), memberDetails, xmlDocumentContext ) ); } if ( jaxbOverride.getForeignKeys() != null ) { annotationUsage.setAttributeValue( "foreignKey", - createForeignKeyAnnotation( jaxbOverride.getForeignKeys(), memberDetails, xmlDocumentContext ) + ForeignKeyProcessing.createForeignKeyAnnotation( jaxbOverride.getForeignKeys(), memberDetails, xmlDocumentContext ) ); } } ); @@ -1602,7 +1417,7 @@ public class XmlAnnotationHelper { ); final ClassDetails classDetails = xmlDocumentContext.getModelBuildingContext() .getClassDetailsRegistry() - .findClassDetails( qualifiedName ); + .resolveClassDetails( qualifiedName ); if ( classDetails != null ) { return classDetails.getName(); } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/CommonPluralAttributeProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/CommonPluralAttributeProcessing.java index c75068f552..3149f908c9 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/CommonPluralAttributeProcessing.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/CommonPluralAttributeProcessing.java @@ -21,6 +21,7 @@ import org.hibernate.boot.jaxb.mapping.spi.JaxbOrderColumnImpl; import org.hibernate.boot.jaxb.mapping.spi.JaxbPluralAttribute; import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; import org.hibernate.boot.models.xml.internal.XmlProcessingHelper; +import org.hibernate.boot.models.xml.internal.db.ForeignKeyProcessing; import org.hibernate.boot.models.xml.spi.XmlDocumentContext; import org.hibernate.internal.util.StringHelper; import org.hibernate.models.spi.AnnotationDescriptor; @@ -149,7 +150,7 @@ public class CommonPluralAttributeProcessing { XmlAnnotationHelper.applyMapKeyJoinColumn( jaxbMapKeyJoinColumn, memberDetails, xmlDocumentContext ); } ); - XmlAnnotationHelper.applyForeignKey( jaxbPluralAttribute.getMapKeyForeignKey(), memberDetails, xmlDocumentContext ); + ForeignKeyProcessing.applyForeignKey( jaxbPluralAttribute.getMapKeyForeignKey(), memberDetails, xmlDocumentContext ); // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // filters and custom sql diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ElementCollectionAttributeProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ElementCollectionAttributeProcessing.java index e9989701b8..87bc29730e 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ElementCollectionAttributeProcessing.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ElementCollectionAttributeProcessing.java @@ -10,6 +10,8 @@ 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.internal.db.ForeignKeyProcessing; +import org.hibernate.boot.models.xml.internal.db.JoinColumnProcessing; import org.hibernate.boot.models.xml.spi.XmlDocumentContext; import org.hibernate.models.spi.AnnotationDescriptor; import org.hibernate.models.spi.MutableAnnotationUsage; @@ -120,12 +122,12 @@ public class ElementCollectionAttributeProcessing { ); XmlAnnotationHelper.applyOr( jaxbCollectionTable, JaxbCollectionTableImpl::getOptions, "options", collectionTableAnn, collectionTableDescriptor ); - collectionTableAnn.setAttributeValue( "joinColumns", XmlAnnotationHelper.createJoinColumns( jaxbCollectionTable.getJoinColumns(), xmlDocumentContext ) ); + collectionTableAnn.setAttributeValue( "joinColumns", JoinColumnProcessing.transformJoinColumnList( jaxbCollectionTable.getJoinColumns(), xmlDocumentContext ) ); if ( jaxbCollectionTable.getForeignKeys() != null ) { collectionTableAnn.setAttributeValue( "foreignKey", - XmlAnnotationHelper.createForeignKeyAnnotation( jaxbCollectionTable.getForeignKeys(), xmlDocumentContext ) + ForeignKeyProcessing.createNestedForeignKeyAnnotation( jaxbCollectionTable.getForeignKeys(), memberDetails, xmlDocumentContext ) ); } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToManyAttributeProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToManyAttributeProcessing.java index e7e18d8504..7ef55534ae 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToManyAttributeProcessing.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToManyAttributeProcessing.java @@ -9,6 +9,7 @@ package org.hibernate.boot.models.xml.internal.attr; import org.hibernate.boot.jaxb.mapping.spi.JaxbManyToManyImpl; import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; import org.hibernate.boot.models.xml.internal.XmlProcessingHelper; +import org.hibernate.boot.models.xml.internal.db.TableProcessing; import org.hibernate.boot.models.xml.spi.XmlDocumentContext; import org.hibernate.internal.util.StringHelper; import org.hibernate.models.spi.MutableClassDetails; @@ -54,7 +55,7 @@ public class ManyToManyAttributeProcessing { CommonPluralAttributeProcessing.applyPluralAttributeStructure( jaxbManyToMany, memberDetails, xmlDocumentContext ); - XmlAnnotationHelper.applyJoinTable( jaxbManyToMany.getJoinTable(), memberDetails, xmlDocumentContext ); + TableProcessing.applyJoinTable( jaxbManyToMany.getJoinTable(), memberDetails, xmlDocumentContext ); XmlAnnotationHelper.applySqlJoinTableRestriction( jaxbManyToMany.getSqlJoinTableRestriction(), memberDetails, xmlDocumentContext ); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToOneAttributeProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToOneAttributeProcessing.java index 8080a64bc5..797d0e8a22 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToOneAttributeProcessing.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/ManyToOneAttributeProcessing.java @@ -15,8 +15,10 @@ import org.hibernate.annotations.OnDelete; import org.hibernate.annotations.OnDeleteAction; import org.hibernate.boot.internal.Target; import org.hibernate.boot.jaxb.mapping.spi.JaxbManyToOneImpl; +import org.hibernate.boot.models.JpaAnnotations; import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; import org.hibernate.boot.models.xml.internal.XmlProcessingHelper; +import org.hibernate.boot.models.xml.internal.db.JoinColumnProcessing; import org.hibernate.boot.models.xml.spi.XmlDocumentContext; import org.hibernate.internal.util.StringHelper; import org.hibernate.internal.util.collections.CollectionHelper; @@ -56,7 +58,8 @@ public class ManyToOneAttributeProcessing { CommonAttributeProcessing.applyAttributeBasics( jaxbManyToOne, memberDetails, manyToOneAnn, accessType, xmlDocumentContext ); - XmlAnnotationHelper.applyJoinColumns( jaxbManyToOne.getJoinColumns(), memberDetails, xmlDocumentContext ); + JoinColumnProcessing.applyJoinColumns( jaxbManyToOne.getJoinColumns(), memberDetails, xmlDocumentContext ); + applyNotFound( memberDetails, jaxbManyToOne, manyToOneAnn, xmlDocumentContext ); applyOnDelete( memberDetails, jaxbManyToOne, manyToOneAnn, xmlDocumentContext ); applyTarget( memberDetails, jaxbManyToOne, manyToOneAnn, xmlDocumentContext ); @@ -69,21 +72,17 @@ public class ManyToOneAttributeProcessing { MutableMemberDetails memberDetails, JaxbManyToOneImpl jaxbManyToOne, XmlDocumentContext xmlDocumentContext) { - final MutableAnnotationUsage manyToOneAnn = XmlProcessingHelper.getOrMakeAnnotation( ManyToOne.class, memberDetails, xmlDocumentContext ); - final AnnotationDescriptor manyToOneDescriptor = xmlDocumentContext - .getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( ManyToOne.class ); - - XmlAnnotationHelper.applyOr( - jaxbManyToOne, - JaxbManyToOneImpl::getFetch, + final MutableAnnotationUsage manyToOneUsage = XmlProcessingHelper.getOrMakeAnnotation( ManyToOne.class, memberDetails, xmlDocumentContext ); + XmlAnnotationHelper.applyOptionalAttribute( + manyToOneUsage, "fetch", - manyToOneAnn, - manyToOneDescriptor + jaxbManyToOne.getFetch() ); - return manyToOneAnn; + if ( jaxbManyToOne.isId() == Boolean.TRUE ) { + memberDetails.applyAnnotationUsage( JpaAnnotations.ID, xmlDocumentContext.getModelBuildingContext() ); + } + return manyToOneUsage; } private static void applyNotFound( diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToManyAttributeProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToManyAttributeProcessing.java index c79bcc7191..a01f1b42d1 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToManyAttributeProcessing.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToManyAttributeProcessing.java @@ -12,6 +12,7 @@ import org.hibernate.annotations.OnDelete; import org.hibernate.boot.jaxb.mapping.spi.JaxbOneToManyImpl; import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; import org.hibernate.boot.models.xml.internal.XmlProcessingHelper; +import org.hibernate.boot.models.xml.internal.db.TableProcessing; import org.hibernate.boot.models.xml.spi.XmlDocumentContext; import org.hibernate.internal.util.StringHelper; import org.hibernate.models.spi.AnnotationDescriptor; @@ -55,7 +56,7 @@ public class OneToManyAttributeProcessing { // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ // join-table - XmlAnnotationHelper.applyJoinTable( jaxbOneToMany.getJoinTable(), memberDetails, xmlDocumentContext ); + TableProcessing.applyJoinTable( jaxbOneToMany.getJoinTable(), memberDetails, xmlDocumentContext ); XmlAnnotationHelper.applySqlJoinTableRestriction( jaxbOneToMany.getSqlJoinTableRestriction(), memberDetails, xmlDocumentContext ); diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToOneAttributeProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToOneAttributeProcessing.java index e92926dce0..c1018250e9 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToOneAttributeProcessing.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/attr/OneToOneAttributeProcessing.java @@ -8,11 +8,13 @@ package org.hibernate.boot.models.xml.internal.attr; import org.hibernate.boot.internal.Target; import org.hibernate.boot.jaxb.mapping.spi.JaxbOneToOneImpl; -import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; +import org.hibernate.boot.models.HibernateAnnotations; +import org.hibernate.boot.models.JpaAnnotations; import org.hibernate.boot.models.xml.internal.XmlProcessingHelper; +import org.hibernate.boot.models.xml.internal.db.JoinColumnProcessing; +import org.hibernate.boot.models.xml.internal.db.TableProcessing; 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; import org.hibernate.models.spi.MutableMemberDetails; @@ -22,7 +24,6 @@ import jakarta.persistence.OneToOne; import static org.hibernate.boot.models.xml.internal.XmlAnnotationHelper.applyCascading; import static org.hibernate.boot.models.xml.internal.XmlAnnotationHelper.determineTargetName; -import static org.hibernate.boot.models.xml.internal.XmlProcessingHelper.getOrMakeAnnotation; import static org.hibernate.boot.models.xml.internal.attr.CommonAttributeProcessing.applyAttributeBasics; import static org.hibernate.internal.util.NullnessHelper.coalesce; @@ -50,12 +51,29 @@ public class OneToOneAttributeProcessing { xmlDocumentContext ); - XmlAnnotationHelper.applyJoinTable( jaxbOneToOne.getJoinTable(), memberDetails, xmlDocumentContext ); - applyAttributeBasics( jaxbOneToOne, memberDetails, oneToOneAnn, accessType, xmlDocumentContext ); applyTarget( memberDetails, jaxbOneToOne, oneToOneAnn, xmlDocumentContext ); applyCascading( jaxbOneToOne.getCascade(), memberDetails, xmlDocumentContext ); + TableProcessing.applyJoinTable( jaxbOneToOne.getJoinTable(), memberDetails, xmlDocumentContext ); + JoinColumnProcessing.applyJoinColumns( jaxbOneToOne.getJoinColumn(), memberDetails, xmlDocumentContext ); + JoinColumnProcessing.applyPrimaryKeyJoinColumns( jaxbOneToOne.getPrimaryKeyJoinColumn(), memberDetails, xmlDocumentContext ); + + if ( jaxbOneToOne.isId() == Boolean.TRUE ) { + memberDetails.applyAnnotationUsage( + JpaAnnotations.ID, + xmlDocumentContext.getModelBuildingContext() + ); + } + + if ( StringHelper.isNotEmpty( jaxbOneToOne.getMapsId() ) ) { + memberDetails.applyAnnotationUsage( + JpaAnnotations.MAPS_ID, + (usage) -> usage.setAttributeValue( "value", jaxbOneToOne.getMapsId() ), + xmlDocumentContext.getModelBuildingContext() + ); + } + return memberDetails; } @@ -63,21 +81,24 @@ public class OneToOneAttributeProcessing { MutableMemberDetails memberDetails, JaxbOneToOneImpl jaxbOneToOne, XmlDocumentContext xmlDocumentContext) { - final MutableAnnotationUsage oneToOneAnn = getOrMakeAnnotation( OneToOne.class, memberDetails, xmlDocumentContext ); - final AnnotationDescriptor oneToOneDescriptor = xmlDocumentContext - .getModelBuildingContext() - .getAnnotationDescriptorRegistry() - .getDescriptor( OneToOne.class ); - - XmlAnnotationHelper.applyOr( - jaxbOneToOne, - JaxbOneToOneImpl::getFetch, - "fetch", - oneToOneAnn, - oneToOneDescriptor + return memberDetails.applyAnnotationUsage( + JpaAnnotations.ONE_TO_ONE, + (usage) -> { + if ( jaxbOneToOne.getFetch() != null ) { + usage.setAttributeValue( "fetch", jaxbOneToOne.getFetch() ); + } + if ( jaxbOneToOne.isOptional() != null ) { + usage.setAttributeValue( "optional", jaxbOneToOne.isOptional() ); + } + if ( StringHelper.isNotEmpty( jaxbOneToOne.getMappedBy() ) ) { + usage.setAttributeValue( "mappedBy", jaxbOneToOne.getMappedBy() ); + } + if ( jaxbOneToOne.isOrphanRemoval() != null ) { + usage.setAttributeValue( "orphanRemoval", jaxbOneToOne.isOrphanRemoval() ); + } + }, + xmlDocumentContext.getModelBuildingContext() ); - - return oneToOneAnn; } @SuppressWarnings("unused") @@ -91,8 +112,12 @@ public class OneToOneAttributeProcessing { return; } - final MutableAnnotationUsage targetAnn = XmlProcessingHelper.makeAnnotation( Target.class, memberDetails, xmlDocumentContext ); - targetAnn.setAttributeValue( "value", determineTargetName( targetEntityName, xmlDocumentContext ) ); + final MutableAnnotationUsage targetUsage = memberDetails.applyAnnotationUsage( + HibernateAnnotations.TARGET, + xmlDocumentContext.getModelBuildingContext() + ); + final String targetName = determineTargetName( targetEntityName, xmlDocumentContext ); + targetUsage.setAttributeValue( "value", targetName ); } } diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/ForeignKeyProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/ForeignKeyProcessing.java new file mode 100644 index 0000000000..51c7d940c2 --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/ForeignKeyProcessing.java @@ -0,0 +1,72 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later. + * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. + */ +package org.hibernate.boot.models.xml.internal.db; + +import org.hibernate.boot.jaxb.mapping.spi.JaxbForeignKeyImpl; +import org.hibernate.boot.models.JpaAnnotations; +import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; +import org.hibernate.boot.models.xml.spi.XmlDocumentContext; +import org.hibernate.models.spi.MemberDetails; +import org.hibernate.models.spi.MutableAnnotationUsage; +import org.hibernate.models.spi.MutableMemberDetails; + +import jakarta.persistence.ForeignKey; + +/** + * @author Steve Ebersole + */ +public class ForeignKeyProcessing { + + public static void applyForeignKey( + JaxbForeignKeyImpl jaxbForeignKey, + MutableMemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + if ( jaxbForeignKey == null ) { + return; + } + + createForeignKeyAnnotation( jaxbForeignKey, memberDetails, xmlDocumentContext ); + } + + public static MutableAnnotationUsage createForeignKeyAnnotation( + JaxbForeignKeyImpl jaxbForeignKey, + MutableMemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + if ( jaxbForeignKey == null ) { + return null; + } + return memberDetails.applyAnnotationUsage( + JpaAnnotations.FOREIGN_KEY, + (foreignKeyUsage) -> { + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "name", jaxbForeignKey.getName() ); + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "value", jaxbForeignKey.getConstraintMode() ); + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "foreignKeyDefinition", jaxbForeignKey.getForeignKeyDefinition() ); + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "options", jaxbForeignKey.getOptions() ); + }, + xmlDocumentContext.getModelBuildingContext() + ); + } + + public static MutableAnnotationUsage createNestedForeignKeyAnnotation( + JaxbForeignKeyImpl jaxbForeignKey, + MemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + assert jaxbForeignKey != null; + + final MutableAnnotationUsage foreignKeyUsage = JpaAnnotations.FOREIGN_KEY.createUsage( + memberDetails, + xmlDocumentContext.getModelBuildingContext() + ); + + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "name", jaxbForeignKey.getName() ); + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "value", jaxbForeignKey.getConstraintMode() ); + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "foreignKeyDefinition", jaxbForeignKey.getForeignKeyDefinition() ); + XmlAnnotationHelper.applyOptionalAttribute( foreignKeyUsage, "options", jaxbForeignKey.getOptions() ); + + return foreignKeyUsage; + } +} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/JoinColumnProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/JoinColumnProcessing.java new file mode 100644 index 0000000000..8509f090cd --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/JoinColumnProcessing.java @@ -0,0 +1,184 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later. + * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. + */ +package org.hibernate.boot.models.xml.internal.db; + +import java.lang.annotation.Annotation; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import org.hibernate.boot.jaxb.mapping.spi.JaxbForeignKeyImpl; +import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinColumnImpl; +import org.hibernate.boot.jaxb.mapping.spi.JaxbPrimaryKeyJoinColumnImpl; +import org.hibernate.boot.jaxb.mapping.spi.db.JaxbColumnJoined; +import org.hibernate.boot.models.JpaAnnotations; +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.collections.CollectionHelper; +import org.hibernate.models.spi.AnnotationUsage; +import org.hibernate.models.spi.MutableAnnotationUsage; +import org.hibernate.models.spi.MutableMemberDetails; + +import jakarta.persistence.CollectionTable; +import jakarta.persistence.JoinColumn; +import jakarta.persistence.JoinColumns; +import jakarta.persistence.JoinTable; +import jakarta.persistence.PrimaryKeyJoinColumn; +import jakarta.persistence.PrimaryKeyJoinColumns; + +/** + * XML -> AnnotationUsage support for {@linkplain JaxbColumnJoined} + * + * @author Steve Ebersole + */ +public class JoinColumnProcessing { + /** + * Support for {@linkplain JaxbPrimaryKeyJoinColumnImpl} to {@linkplain PrimaryKeyJoinColumns} transformation + * + * @see JaxbPrimaryKeyJoinColumnImpl + */ + public static void applyPrimaryKeyJoinColumns( + List jaxbJoinColumns, + MutableMemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + if ( CollectionHelper.isEmpty( jaxbJoinColumns ) ) { + return; + } + + final MutableAnnotationUsage columnsUsage = memberDetails.applyAnnotationUsage( + JpaAnnotations.PRIMARY_KEY_JOIN_COLUMNS, + xmlDocumentContext.getModelBuildingContext() + ); + final List> columnUsages = CollectionHelper.arrayList( jaxbJoinColumns.size() ); + columnsUsage.setAttributeValue( "value", columnUsages ); + + jaxbJoinColumns.forEach( (jaxbJoinColumn) -> { + final MutableAnnotationUsage columnUsage = JpaAnnotations.PRIMARY_KEY_JOIN_COLUMN.createUsage( + memberDetails, + xmlDocumentContext.getModelBuildingContext() + ); + columnUsages.add( columnUsage ); + + transferJoinColumn( + jaxbJoinColumn, + columnUsage, + memberDetails, + xmlDocumentContext + ); + } ); + } + + private static void transferJoinColumn( + JaxbColumnJoined jaxbJoinColumn, + MutableAnnotationUsage joinColumnUsage, + MutableMemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + ColumnProcessing.applyColumnDetails( jaxbJoinColumn, memberDetails, joinColumnUsage, xmlDocumentContext ); + XmlAnnotationHelper.applyOptionalAttribute( + joinColumnUsage, + "referencedColumnName", + jaxbJoinColumn.getReferencedColumnName() + ); + + final JaxbForeignKeyImpl jaxbForeignKey = jaxbJoinColumn.getForeignKey(); + if ( jaxbForeignKey != null ) { + joinColumnUsage.setAttributeValue( + "foreignKey", + ForeignKeyProcessing.createNestedForeignKeyAnnotation( jaxbForeignKey, memberDetails, xmlDocumentContext ) + ); + } + } + + /** + * Support for {@linkplain JaxbJoinColumnImpl} to {@linkplain JoinColumn} transformation. + * Used when the List is the value of an annotation attribute other than its repetition container. + * For example, {@linkplain CollectionTable#joinColumns()}, {@linkplain JoinTable#joinColumns()} and + * {@linkplain JoinTable#inverseJoinColumns()} + */ + public static List> transformJoinColumnList( + List jaxbJoinColumns, + XmlDocumentContext xmlDocumentContext) { + if ( CollectionHelper.isEmpty( jaxbJoinColumns ) ) { + return Collections.emptyList(); + } + final List> joinColumns = new ArrayList<>( jaxbJoinColumns.size() ); + jaxbJoinColumns.forEach( jaxbJoinColumn -> { + joinColumns.add( createJoinColumnAnnotation( jaxbJoinColumn, JoinColumn.class, xmlDocumentContext ) ); + } ); + return joinColumns; + } + + public static MutableAnnotationUsage createJoinColumnAnnotation( + JaxbColumnJoined jaxbJoinColumn, + MutableMemberDetails memberDetails, + Class annotationType, + XmlDocumentContext xmlDocumentContext) { + final MutableAnnotationUsage joinColumnAnn = XmlProcessingHelper.getOrMakeNamedAnnotation( + annotationType, + jaxbJoinColumn.getName(), + memberDetails, + xmlDocumentContext + ); + transferJoinColumn( jaxbJoinColumn, joinColumnAnn, memberDetails, xmlDocumentContext ); + return joinColumnAnn; + } + + public static MutableAnnotationUsage createJoinColumnAnnotation( + JaxbColumnJoined jaxbJoinColumn, + Class annotationType, + XmlDocumentContext xmlDocumentContext) { + final MutableAnnotationUsage joinColumnAnn = XmlProcessingHelper.getOrMakeAnnotation( annotationType, xmlDocumentContext ); + transferJoinColumn( jaxbJoinColumn, joinColumnAnn, null, xmlDocumentContext ); + return joinColumnAnn; + } + + public static List> createJoinColumns( + List jaxbJoinColumns, + MutableMemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + if ( CollectionHelper.isEmpty( jaxbJoinColumns ) ) { + return Collections.emptyList(); + } + final List> joinColumns = new ArrayList<>( jaxbJoinColumns.size() ); + jaxbJoinColumns.forEach( jaxbJoinColumn -> { + final MutableAnnotationUsage joinColumnUsage = JpaAnnotations.JOIN_COLUMN.createUsage( + memberDetails, + xmlDocumentContext.getModelBuildingContext() + ); + transferJoinColumn( + jaxbJoinColumn, + joinColumnUsage, + memberDetails, + xmlDocumentContext + ); + joinColumns.add( joinColumnUsage ); + } ); + return joinColumns; + } + + public static void applyJoinColumns( + List jaxbJoinColumns, + MutableMemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + if ( CollectionHelper.isEmpty( jaxbJoinColumns ) ) { + return; + } + + if ( jaxbJoinColumns.size() == 1 ) { + XmlAnnotationHelper.applyJoinColumn( jaxbJoinColumns.get( 0 ), memberDetails, xmlDocumentContext ); + } + else { + final MutableAnnotationUsage columnsAnn = XmlProcessingHelper.makeAnnotation( + JoinColumns.class, + memberDetails, + xmlDocumentContext + ); + columnsAnn.setAttributeValue( "value", createJoinColumns( jaxbJoinColumns, memberDetails, xmlDocumentContext ) ); + } + } +} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/TableProcessing.java b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/TableProcessing.java new file mode 100644 index 0000000000..96acc884a5 --- /dev/null +++ b/hibernate-core/src/main/java/org/hibernate/boot/models/xml/internal/db/TableProcessing.java @@ -0,0 +1,67 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * License: GNU Lesser General Public License (LGPL), version 2.1 or later. + * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. + */ +package org.hibernate.boot.models.xml.internal.db; + +import java.util.List; + +import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinColumnImpl; +import org.hibernate.boot.jaxb.mapping.spi.JaxbJoinTableImpl; +import org.hibernate.boot.models.JpaAnnotations; +import org.hibernate.boot.models.xml.internal.XmlAnnotationHelper; +import org.hibernate.boot.models.xml.spi.XmlDocumentContext; +import org.hibernate.internal.util.collections.CollectionHelper; +import org.hibernate.models.spi.MutableAnnotationUsage; +import org.hibernate.models.spi.MutableMemberDetails; + +import jakarta.persistence.JoinTable; + +/** + * @author Steve Ebersole + */ +public class TableProcessing { + public static MutableAnnotationUsage applyJoinTable( + JaxbJoinTableImpl jaxbJoinTable, + MutableMemberDetails memberDetails, + XmlDocumentContext xmlDocumentContext) { + if ( jaxbJoinTable == null ) { + return null; + } + + final MutableAnnotationUsage joinTableUsage = memberDetails.applyAnnotationUsage( + JpaAnnotations.JOIN_TABLE, + xmlDocumentContext.getModelBuildingContext() + ); + + XmlAnnotationHelper.applyOptionalAttribute( joinTableUsage, "name", jaxbJoinTable.getName() ); + XmlAnnotationHelper.applyTableAttributes( jaxbJoinTable, memberDetails, joinTableUsage, JpaAnnotations.JOIN_TABLE, xmlDocumentContext ); + + final List joinColumns = jaxbJoinTable.getJoinColumn(); + if ( CollectionHelper.isNotEmpty( joinColumns ) ) { + joinTableUsage.setAttributeValue( "joinColumns", JoinColumnProcessing.transformJoinColumnList( joinColumns, xmlDocumentContext ) ); + } + + final List inverseJoinColumns = jaxbJoinTable.getInverseJoinColumn(); + if ( CollectionHelper.isNotEmpty( inverseJoinColumns ) ) { + joinTableUsage.setAttributeValue( "inverseJoinColumns", JoinColumnProcessing.transformJoinColumnList( inverseJoinColumns, xmlDocumentContext ) ); + } + + if ( jaxbJoinTable.getForeignKey() != null ) { + joinTableUsage.setAttributeValue( + "foreignKey", + ForeignKeyProcessing.createNestedForeignKeyAnnotation( jaxbJoinTable.getForeignKey(), memberDetails, xmlDocumentContext ) + ); + } + if ( jaxbJoinTable.getInverseForeignKey() != null ) { + joinTableUsage.setAttributeValue( + "inverseForeignKey", + ForeignKeyProcessing.createNestedForeignKeyAnnotation( jaxbJoinTable.getInverseForeignKey(), memberDetails, xmlDocumentContext ) + ); + } + + return joinTableUsage; + } +} diff --git a/hibernate-core/src/main/java/org/hibernate/boot/spi/BootstrapContext.java b/hibernate-core/src/main/java/org/hibernate/boot/spi/BootstrapContext.java index 9ad568e877..4d5cf7dc2c 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/spi/BootstrapContext.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/spi/BootstrapContext.java @@ -10,8 +10,6 @@ import java.util.Collection; import java.util.Map; import org.hibernate.Incubating; -import org.hibernate.Internal; -import org.hibernate.annotations.common.reflection.ReflectionManager; import org.hibernate.boot.CacheRegionDefinition; import org.hibernate.boot.Metadata; import org.hibernate.boot.archive.scan.spi.ScanEnvironment; @@ -158,19 +156,6 @@ public interface BootstrapContext { */ Object getScanner(); - /** - * Retrieve the Hibernate Commons Annotations {@link ReflectionManager}. - * - * @apiNote Supported for internal use only. This method will go away as - * we migrate away from Hibernate Commons Annotations to Jandex for - * annotation handling and XMl to annotation merging. - * - * @deprecated HCANN is deprecated in favor of hibernate-models - */ - @Internal - @Deprecated - ReflectionManager getReflectionManager(); - /** * Access to the Jandex index passed by call to * {@link org.hibernate.boot.MetadataBuilder#applyIndexView(IndexView)}, if any. diff --git a/hibernate-core/src/main/java/org/hibernate/boot/spi/InFlightMetadataCollector.java b/hibernate-core/src/main/java/org/hibernate/boot/spi/InFlightMetadataCollector.java index 74ac9a295b..c6ed36e995 100644 --- a/hibernate-core/src/main/java/org/hibernate/boot/spi/InFlightMetadataCollector.java +++ b/hibernate-core/src/main/java/org/hibernate/boot/spi/InFlightMetadataCollector.java @@ -16,7 +16,6 @@ import org.hibernate.DuplicateMappingException; import org.hibernate.HibernateException; import org.hibernate.MappingException; import org.hibernate.annotations.CollectionTypeRegistration; -import org.hibernate.annotations.common.reflection.XClass; import org.hibernate.boot.internal.NamedProcedureCallDefinitionImpl; import org.hibernate.boot.model.IdentifierGeneratorDefinition; import org.hibernate.boot.model.NamedEntityGraphDefinition; @@ -326,10 +325,6 @@ public interface InFlightMetadataCollector extends MetadataImplementor { void addDefaultResultSetMapping(NamedResultSetMappingDescriptor definition); void addDefaultNamedProcedureCall(NamedProcedureCallDefinitionImpl procedureCallDefinition); - - AnnotatedClassType addClassType(XClass clazz); - AnnotatedClassType getClassType(XClass clazz); - AnnotatedClassType addClassType(ClassDetails classDetails); AnnotatedClassType getClassType(ClassDetails classDetails); diff --git a/hibernate-core/src/main/java/org/hibernate/internal/SessionFactoryImpl.java b/hibernate-core/src/main/java/org/hibernate/internal/SessionFactoryImpl.java index e05b45e712..5a2ce4f576 100644 --- a/hibernate-core/src/main/java/org/hibernate/internal/SessionFactoryImpl.java +++ b/hibernate-core/src/main/java/org/hibernate/internal/SessionFactoryImpl.java @@ -325,11 +325,6 @@ public class SessionFactoryImpl extends QueryParameterBindingTypeResolverImpl im typeConfiguration.scope( this ); observer.sessionFactoryCreated( this ); - - // As last operation, delete all caches from ReflectionManager - // (not modelled as a listener as we want this to be last) - bootstrapContext.getReflectionManager().reset(); - } catch ( Exception e ) { disintegrate( e, integratorObserver ); diff --git a/hibernate-core/src/main/java/org/hibernate/jpa/event/internal/CallbackDefinitionResolverLegacyImpl.java b/hibernate-core/src/main/java/org/hibernate/jpa/event/internal/CallbackDefinitionResolverLegacyImpl.java deleted file mode 100644 index 61c6d47d03..0000000000 --- a/hibernate-core/src/main/java/org/hibernate/jpa/event/internal/CallbackDefinitionResolverLegacyImpl.java +++ /dev/null @@ -1,276 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html - */ -package org.hibernate.jpa.event.internal; - -import java.lang.annotation.ElementType; -import java.lang.annotation.Target; -import java.lang.reflect.Method; -import java.util.ArrayList; -import java.util.List; - -import org.hibernate.annotations.common.reflection.ReflectionManager; -import org.hibernate.annotations.common.reflection.XClass; -import org.hibernate.annotations.common.reflection.XMethod; -import org.hibernate.internal.util.ReflectHelper; -import org.hibernate.jpa.event.spi.CallbackDefinition; -import org.hibernate.jpa.event.spi.CallbackType; -import org.hibernate.mapping.Property; -import org.hibernate.models.spi.AnnotationUsage; -import org.hibernate.models.spi.ClassDetails; -import org.hibernate.models.spi.MethodDetails; -import org.hibernate.property.access.spi.Getter; - -import org.jboss.logging.Logger; - -import jakarta.persistence.Entity; -import jakarta.persistence.EntityListeners; -import jakarta.persistence.ExcludeDefaultListeners; -import jakarta.persistence.ExcludeSuperclassListeners; -import jakarta.persistence.MappedSuperclass; -import jakarta.persistence.PersistenceException; - -/** - * Resolves JPA callback definitions using a HCANN ReflectionManager. - *

- * "legacy" in that we want to move to Jandex instead. - * - * @author Steve Ebersole - */ -public final class CallbackDefinitionResolverLegacyImpl { - private static final Logger log = Logger.getLogger( CallbackDefinitionResolverLegacyImpl.class ); - - public static List resolveEntityCallbacks( - ReflectionManager reflectionManager, - ClassDetails entityClass, - CallbackType callbackType) { - List callbackDefinitions = new ArrayList<>(); - List callbacksMethodNames = new ArrayList<>(); - List> orderedListeners = new ArrayList<>(); - ClassDetails currentClazz = entityClass; - boolean stopListeners = false; - boolean stopDefaultListeners = false; - do { - CallbackDefinition callbackDefinition = null; - final List methodsDetailsList = currentClazz.getMethods(); - for ( MethodDetails methodDetails : methodsDetailsList ) { - if ( !methodDetails.hasAnnotationUsage( callbackType.getCallbackAnnotation() ) ) { - continue; - } - if ( callbacksMethodNames.contains( methodDetails.getName() ) ) { - continue; - } - - //overridden method, remove the superclass overridden method - if ( callbackDefinition == null ) { - final Method javaMethod = (Method) methodDetails.toJavaMember(); - callbackDefinition = new EntityCallback.Definition( javaMethod, callbackType ); - Class returnType = javaMethod.getReturnType(); - Class[] args = javaMethod.getParameterTypes(); - if ( returnType != Void.TYPE || args.length != 0 ) { - throw new RuntimeException( - "Callback methods annotated on the bean class must return void and take no arguments: " - + callbackType.getCallbackAnnotation().getName() + " - " + methodDetails - ); - } - ReflectHelper.ensureAccessibility( javaMethod ); - if ( log.isDebugEnabled() ) { - log.debugf( - "Adding %s as %s callback for entity %s", - methodDetails.getName(), - callbackType.getCallbackAnnotation().getSimpleName(), - entityClass.getName() - ); - } - callbackDefinitions.add( 0, callbackDefinition ); //superclass first - callbacksMethodNames.add( 0, methodDetails.getName() ); - } - else { - throw new PersistenceException( - "You can only annotate one callback method with " - + callbackType.getCallbackAnnotation().getName() + " in bean class: " + entityClass.getName() - ); - } - } - if ( !stopListeners ) { - applyListeners( currentClazz, orderedListeners ); - stopListeners = currentClazz.hasAnnotationUsage( ExcludeSuperclassListeners.class ); - stopDefaultListeners = currentClazz.hasAnnotationUsage( ExcludeDefaultListeners.class ); - } - - do { - currentClazz = currentClazz.getSuperClass(); - } - while ( currentClazz != null - && !( currentClazz.hasAnnotationUsage( Entity.class ) - || currentClazz.hasAnnotationUsage( MappedSuperclass.class ) ) - ); - } - while ( currentClazz != null ); - - //handle default listeners - if ( !stopDefaultListeners ) { - @SuppressWarnings("unchecked") - List> defaultListeners = (List>) - reflectionManager.getDefaults().get( EntityListeners.class ); - - if ( defaultListeners != null ) { - int defaultListenerSize = defaultListeners.size(); - for ( int i = defaultListenerSize - 1; i >= 0; i-- ) { - orderedListeners.add( defaultListeners.get( i ) ); - } - } - } - - for ( Class listener : orderedListeners ) { - CallbackDefinition callbackDefinition = null; - if ( listener != null ) { - XClass xListener = reflectionManager.toXClass( listener ); - callbacksMethodNames = new ArrayList<>(); - List methods = xListener.getDeclaredMethods(); - for ( final XMethod xMethod : methods ) { - if ( xMethod.isAnnotationPresent( callbackType.getCallbackAnnotation() ) ) { - final Method method = reflectionManager.toMethod( xMethod ); - final String methodName = method.getName(); - if ( !callbacksMethodNames.contains( methodName ) ) { - //overridden method, remove the superclass overridden method - if ( callbackDefinition == null ) { - callbackDefinition = new ListenerCallback.Definition( listener, method, callbackType ); - - Class returnType = method.getReturnType(); - Class[] args = method.getParameterTypes(); - if ( returnType != Void.TYPE || args.length != 1 ) { - throw new PersistenceException( - "Callback methods annotated in a listener bean class must return void and take one argument: " - + callbackType.getCallbackAnnotation().getName() + " - " + method - ); - } - ReflectHelper.ensureAccessibility( method ); - if ( log.isDebugEnabled() ) { - log.debugf( - "Adding %s as %s callback for entity %s", - methodName, - callbackType.getCallbackAnnotation().getSimpleName(), - entityClass.getName() - ); - } - callbackDefinitions.add( 0, callbackDefinition ); // listeners first - } - else { - throw new PersistenceException( - "You can only annotate one callback method with " - + callbackType.getCallbackAnnotation().getName() - + " in bean class: " + entityClass.getName() - + " and callback listener: " + listener.getName() - ); - } - } - } - } - } - } - return callbackDefinitions; - } - - public static List resolveEmbeddableCallbacks( - ReflectionManager reflectionManager, - Class entityClass, - Property embeddableProperty, - CallbackType callbackType) { - final Class embeddableClass = embeddableProperty.getType().getReturnedClass(); - final XClass embeddableXClass = reflectionManager.toXClass( embeddableClass ); - final Getter embeddableGetter = embeddableProperty.getGetter( entityClass ); - final List callbackDefinitions = new ArrayList<>(); - final List callbacksMethodNames = new ArrayList<>(); - XClass currentClazz = embeddableXClass; - do { - CallbackDefinition callbackDefinition = null; - List methods = currentClazz.getDeclaredMethods(); - for ( final XMethod xMethod : methods ) { - if ( xMethod.isAnnotationPresent( callbackType.getCallbackAnnotation() ) ) { - Method method = reflectionManager.toMethod( xMethod ); - final String methodName = method.getName(); - if ( !callbacksMethodNames.contains( methodName ) ) { - //overridden method, remove the superclass overridden method - if ( callbackDefinition == null ) { - callbackDefinition = new EmbeddableCallback.Definition( embeddableGetter, method, callbackType ); - Class returnType = method.getReturnType(); - Class[] args = method.getParameterTypes(); - if ( returnType != Void.TYPE || args.length != 0 ) { - throw new RuntimeException( - "Callback methods annotated on the bean class must return void and take no arguments: " - + callbackType.getCallbackAnnotation().getName() + " - " + xMethod - ); - } - ReflectHelper.ensureAccessibility( method ); - if ( log.isDebugEnabled() ) { - log.debugf( - "Adding %s as %s callback for entity %s", - methodName, - callbackType.getCallbackAnnotation().getSimpleName(), - embeddableXClass.getName() - ); - } - callbackDefinitions.add( 0, callbackDefinition ); //superclass first - callbacksMethodNames.add( 0, methodName ); - } - else { - throw new PersistenceException( - "You can only annotate one callback method with " - + callbackType.getCallbackAnnotation().getName() + " in bean class: " + embeddableXClass.getName() - ); - } - } - } - } - - do { - currentClazz = currentClazz.getSuperclass(); - } - while ( currentClazz != null && !currentClazz.isAnnotationPresent( MappedSuperclass.class ) ); - } - while ( currentClazz != null ); - - return callbackDefinitions; - } - - private static boolean useAnnotationAnnotatedByListener; - - static { - //check whether reading annotations of annotations is useful or not - useAnnotationAnnotatedByListener = false; - Target target = EntityListeners.class.getAnnotation( Target.class ); - if ( target != null ) { - for ( ElementType type : target.value() ) { - if ( type.equals( ElementType.ANNOTATION_TYPE ) ) { - useAnnotationAnnotatedByListener = true; - break; - } - } - } - } - - private static void applyListeners(ClassDetails currentClazz, List> listOfListeners) { - final AnnotationUsage entityListeners = currentClazz.getAnnotationUsage( EntityListeners.class ); - if ( entityListeners != null ) { - final List listeners = entityListeners.getList( "value" ); - for ( ClassDetails listener : listeners ) { - listOfListeners.add( listener.toJavaClass() ); - } - } - - if ( useAnnotationAnnotatedByListener ) { - final List> metaAnnotatedUsageList = currentClazz.getMetaAnnotated( EntityListeners.class ); - for ( AnnotationUsage metaAnnotatedUsage : metaAnnotatedUsageList ) { - final AnnotationUsage metaAnnotatedListeners = metaAnnotatedUsage.getAnnotationDescriptor().getAnnotationUsage( EntityListeners.class ); - final List listeners = metaAnnotatedListeners.getList( "value" ); - for ( ClassDetails listener : listeners ) { - listOfListeners.add( listener.toJavaClass() ); - } - } - } - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/reflection/JPAXMLOverriddenAnnotationReaderTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/reflection/JPAXMLOverriddenAnnotationReaderTest.java deleted file mode 100644 index 73e3c8007b..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/reflection/JPAXMLOverriddenAnnotationReaderTest.java +++ /dev/null @@ -1,469 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. - */ -package org.hibernate.orm.test.annotations.reflection; - -import java.io.IOException; -import java.lang.reflect.Field; -import java.lang.reflect.Method; - -import org.hibernate.annotations.Columns; -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappingsImpl; -import org.hibernate.boot.model.internal.JPAXMLOverriddenAnnotationReader; -import org.hibernate.boot.model.internal.XMLContext; -import org.hibernate.orm.test.internal.util.xml.XMLMappingHelper; - -import org.hibernate.testing.TestForIssue; -import org.hibernate.testing.boot.BootstrapContextImpl; -import org.hibernate.testing.junit4.BaseUnitTestCase; -import org.junit.After; -import org.junit.Before; -import org.junit.Test; - -import jakarta.persistence.AssociationOverrides; -import jakarta.persistence.AttributeOverrides; -import jakarta.persistence.Basic; -import jakarta.persistence.Column; -import jakarta.persistence.Converts; -import jakarta.persistence.DiscriminatorColumn; -import jakarta.persistence.DiscriminatorValue; -import jakarta.persistence.ElementCollection; -import jakarta.persistence.Embedded; -import jakarta.persistence.EmbeddedId; -import jakarta.persistence.Entity; -import jakarta.persistence.EntityListeners; -import jakarta.persistence.EnumType; -import jakarta.persistence.Enumerated; -import jakarta.persistence.ExcludeDefaultListeners; -import jakarta.persistence.ExcludeSuperclassListeners; -import jakarta.persistence.FetchType; -import jakarta.persistence.GeneratedValue; -import jakarta.persistence.GenerationType; -import jakarta.persistence.Id; -import jakarta.persistence.IdClass; -import jakarta.persistence.Inheritance; -import jakarta.persistence.InheritanceType; -import jakarta.persistence.JoinColumns; -import jakarta.persistence.JoinTable; -import jakarta.persistence.Lob; -import jakarta.persistence.ManyToMany; -import jakarta.persistence.MapKey; -import jakarta.persistence.MappedSuperclass; -import jakarta.persistence.NamedNativeQueries; -import jakarta.persistence.NamedQueries; -import jakarta.persistence.OneToMany; -import jakarta.persistence.OneToOne; -import jakarta.persistence.OrderBy; -import jakarta.persistence.PostLoad; -import jakarta.persistence.PostPersist; -import jakarta.persistence.PrePersist; -import jakarta.persistence.PrimaryKeyJoinColumn; -import jakarta.persistence.PrimaryKeyJoinColumns; -import jakarta.persistence.SecondaryTable; -import jakarta.persistence.SecondaryTables; -import jakarta.persistence.SequenceGenerator; -import jakarta.persistence.SqlResultSetMappings; -import jakarta.persistence.Table; -import jakarta.persistence.TableGenerator; -import jakarta.persistence.Temporal; -import jakarta.persistence.TemporalType; -import jakarta.persistence.Transient; -import jakarta.persistence.Version; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertNull; -import static org.junit.Assert.assertTrue; - -/** - * @author Emmanuel Bernard - */ -@TestForIssue(jiraKey = "HHH-14529") -public class JPAXMLOverriddenAnnotationReaderTest extends BaseUnitTestCase { - - private BootstrapContextImpl bootstrapContext; - - @Before - public void init() { - bootstrapContext = new BootstrapContextImpl(); - } - - @After - public void destroy() { - bootstrapContext.close(); - } - - @Test - public void testMappedSuperclassAnnotations() throws Exception { - XMLContext context = buildContext( - "org/hibernate/orm/test/annotations/reflection/metadata-complete.xml" - ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( Organization.class, context, bootstrapContext ); - assertTrue( reader.isAnnotationPresent( MappedSuperclass.class ) ); - } - - @Test - public void testEntityRelatedAnnotations() throws Exception { - XMLContext context = buildContext( "org/hibernate/orm/test/annotations/reflection/orm.xml" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( Administration.class, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Entity.class ) ); - assertEquals( - "Default value in xml entity should not override @Entity.name", "JavaAdministration", - reader.getAnnotation( Entity.class ).name() - ); - assertNotNull( reader.getAnnotation( Table.class ) ); - assertEquals( "@Table not overridden", "tbl_admin", reader.getAnnotation( Table.class ).name() ); - // The default schema is assigned later, when we generate SQL. - // See DefaultCatalogAndSchemaTest. - assertEquals( "Default schema overridden too soon", "", reader.getAnnotation( Table.class ).schema() ); - assertEquals( - "Proper @Table.uniqueConstraints", 2, - reader.getAnnotation( Table.class ).uniqueConstraints()[0].columnNames().length - ); - String columnName = reader.getAnnotation( Table.class ).uniqueConstraints()[0].columnNames()[0]; - assertTrue( - "Proper @Table.uniqueConstraints", "firstname".equals( columnName ) || "lastname".equals( columnName ) - ); - assertNull( "Both Java and XML used", reader.getAnnotation( SecondaryTable.class ) ); - assertNotNull( "XML does not work", reader.getAnnotation( SecondaryTables.class ) ); - SecondaryTable[] tables = reader.getAnnotation( SecondaryTables.class ).value(); - assertEquals( 1, tables.length ); - assertEquals( "admin2", tables[0].name() ); - assertEquals( "unique constraints ignored", 1, tables[0].uniqueConstraints().length ); - assertEquals( "pk join column ignored", 1, tables[0].pkJoinColumns().length ); - assertEquals( "pk join column ignored", "admin_id", tables[0].pkJoinColumns()[0].name() ); - assertNotNull( "Sequence Overriding not working", reader.getAnnotation( SequenceGenerator.class ) ); - assertEquals( - "wrong sequence name", "seqhilo", reader.getAnnotation( SequenceGenerator.class ).sequenceName() - ); - assertEquals( "default fails", 50, reader.getAnnotation( SequenceGenerator.class ).allocationSize() ); - assertNotNull( "TableOverriding not working", reader.getAnnotation( TableGenerator.class ) ); - assertEquals( "wrong tble name", "tablehilo", reader.getAnnotation( TableGenerator.class ).table() ); - // The default schema is assigned later, when we generate SQL. - // See DefaultCatalogAndSchemaTest. - assertEquals( "Default schema overridden too soon", "", reader.getAnnotation( TableGenerator.class ).schema() ); - - reader = new JPAXMLOverriddenAnnotationReader( Match.class, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Table.class ) ); - assertEquals( - "Java annotation not taken into account", "matchtable", reader.getAnnotation( Table.class ).name() - ); - assertEquals( - "Java annotation not taken into account", "matchschema", reader.getAnnotation( Table.class ).schema() - ); - // The default schema is assigned later, when we generate SQL. - // See DefaultCatalogAndSchemaTest. - assertEquals( "Default catalog overridden too soon", "", reader.getAnnotation( Table.class ).catalog() ); - assertNotNull( "SecondaryTable swallowed", reader.getAnnotation( SecondaryTables.class ) ); - // The default schema is assigned later, when we generate SQL. - // See DefaultCatalogAndSchemaTest. - assertEquals( - "Default schema not taken into account", "", - reader.getAnnotation( SecondaryTables.class ).value()[0].schema() - ); - assertNotNull( reader.getAnnotation( Inheritance.class ) ); - assertEquals( - "inheritance strategy not overridden", InheritanceType.JOINED, - reader.getAnnotation( Inheritance.class ).strategy() - ); - assertNotNull( "NamedQuery not overridden", reader.getAnnotation( NamedQueries.class ) ); - assertEquals( "No deduplication", 3, reader.getAnnotation( NamedQueries.class ).value().length ); - assertEquals( - "deduplication kept the Java version", 1, - reader.getAnnotation( NamedQueries.class ).value()[1].hints().length - ); - assertEquals( - "org.hibernate.timeout", reader.getAnnotation( NamedQueries.class ).value()[1].hints()[0].name() - ); - assertNotNull( "NamedNativeQuery not overridden", reader.getAnnotation( NamedNativeQueries.class ) ); - assertEquals( "No deduplication", 3, reader.getAnnotation( NamedNativeQueries.class ).value().length ); - assertEquals( - "deduplication kept the Java version", 1, - reader.getAnnotation( NamedNativeQueries.class ).value()[1].hints().length - ); - assertEquals( - "org.hibernate.timeout", reader.getAnnotation( NamedNativeQueries.class ).value()[1].hints()[0].name() - ); - assertNotNull( reader.getAnnotation( SqlResultSetMappings.class ) ); - assertEquals( - "competitor1Point", reader.getAnnotation( SqlResultSetMappings.class ).value()[0].columns()[0].name() - ); - assertEquals( - "competitor1Point", - reader.getAnnotation( SqlResultSetMappings.class ).value()[0].entities()[0].fields()[0].column() - ); - assertNotNull( reader.getAnnotation( ExcludeSuperclassListeners.class ) ); - assertNotNull( reader.getAnnotation( ExcludeDefaultListeners.class ) ); - - reader = new JPAXMLOverriddenAnnotationReader( Competition.class, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( MappedSuperclass.class ) ); - - reader = new JPAXMLOverriddenAnnotationReader( TennisMatch.class, context, bootstrapContext ); - assertNull( "Mutualize PKJC into PKJCs", reader.getAnnotation( PrimaryKeyJoinColumn.class ) ); - assertNotNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) ); - assertEquals( - "PrimaryKeyJoinColumn overrden", "id", - reader.getAnnotation( PrimaryKeyJoinColumns.class ).value()[0].name() - ); - assertNotNull( reader.getAnnotation( AttributeOverrides.class ) ); - assertEquals( "Wrong deduplication", 3, reader.getAnnotation( AttributeOverrides.class ).value().length ); - assertEquals( - "Wrong priority (XML vs java annotations)", "fld_net", - reader.getAnnotation( AttributeOverrides.class ).value()[0].column().name() - ); - assertEquals( - "Column mapping", 2, reader.getAnnotation( AttributeOverrides.class ).value()[1].column().scale() - ); - assertEquals( - "Column mapping", true, reader.getAnnotation( AttributeOverrides.class ).value()[1].column().unique() - ); - assertNotNull( reader.getAnnotation( AssociationOverrides.class ) ); - assertEquals( "no XML processing", 1, reader.getAnnotation( AssociationOverrides.class ).value().length ); - assertEquals( - "wrong xml processing", "id", - reader.getAnnotation( AssociationOverrides.class ).value()[0].joinColumns()[0].referencedColumnName() - ); - - - reader = new JPAXMLOverriddenAnnotationReader( SocialSecurityPhysicalAccount.class, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( IdClass.class ) ); - assertEquals( "id-class not used", SocialSecurityNumber.class, reader.getAnnotation( IdClass.class ).value() ); - assertEquals( - "discriminator-value not used", "Physical", reader.getAnnotation( DiscriminatorValue.class ).value() - ); - assertNotNull( "discriminator-column not used", reader.getAnnotation( DiscriminatorColumn.class ) ); - assertEquals( - "discriminator-column.name default value broken", "DTYPE", - reader.getAnnotation( DiscriminatorColumn.class ).name() - ); - assertEquals( - "discriminator-column.length broken", 34, reader.getAnnotation( DiscriminatorColumn.class ).length() - ); - } - - @Test - public void testEntityRelatedAnnotationsMetadataComplete() throws Exception { - XMLContext context = buildContext( - "org/hibernate/orm/test/annotations/reflection/metadata-complete.xml" - ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( Administration.class, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Entity.class ) ); - assertEquals( - "Metadata complete should ignore java annotations", "", reader.getAnnotation( Entity.class ).name() - ); - // The default schema is assigned later, when we generate SQL. - // See DefaultCatalogAndSchemaTest. - assertNull( "Default schema overridden too soon", reader.getAnnotation( Table.class ) ); - - reader = new JPAXMLOverriddenAnnotationReader( Match.class, context, bootstrapContext ); - // The default schema is assigned later, when we generate SQL. - // See DefaultCatalogAndSchemaTest. - assertNull( "Default schema overridden too soon", reader.getAnnotation( Table.class ) ); - assertNull( "Ignore Java annotation", reader.getAnnotation( SecondaryTable.class ) ); - assertNull( "Ignore Java annotation", reader.getAnnotation( SecondaryTables.class ) ); - assertNull( "Ignore Java annotation", reader.getAnnotation( Inheritance.class ) ); - assertNull( reader.getAnnotation( NamedQueries.class ) ); - assertNull( reader.getAnnotation( NamedNativeQueries.class ) ); - - reader = new JPAXMLOverriddenAnnotationReader( TennisMatch.class, context, bootstrapContext ); - assertNull( reader.getAnnotation( PrimaryKeyJoinColumn.class ) ); - assertNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) ); - - reader = new JPAXMLOverriddenAnnotationReader( Competition.class, context, bootstrapContext ); - assertNull( reader.getAnnotation( MappedSuperclass.class ) ); - - reader = new JPAXMLOverriddenAnnotationReader( SocialSecurityMoralAccount.class, context, bootstrapContext ); - assertNull( reader.getAnnotation( IdClass.class ) ); - assertNull( reader.getAnnotation( DiscriminatorValue.class ) ); - assertNull( reader.getAnnotation( DiscriminatorColumn.class ) ); - assertNull( reader.getAnnotation( SequenceGenerator.class ) ); - assertNull( reader.getAnnotation( TableGenerator.class ) ); - } - - @Test - public void testIdRelatedAnnotations() throws Exception { - XMLContext context = buildContext( "org/hibernate/orm/test/annotations/reflection/orm.xml" ); - Method method = Administration.class.getDeclaredMethod( "getId" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( method, context, bootstrapContext ); - assertNull( reader.getAnnotation( Id.class ) ); - assertNull( reader.getAnnotation( Column.class ) ); - Field field = Administration.class.getDeclaredField( "id" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Id.class ) ); - assertNotNull( reader.getAnnotation( GeneratedValue.class ) ); - assertEquals( GenerationType.SEQUENCE, reader.getAnnotation( GeneratedValue.class ).strategy() ); - assertEquals( "generator", reader.getAnnotation( GeneratedValue.class ).generator() ); - assertNotNull( reader.getAnnotation( SequenceGenerator.class ) ); - assertEquals( "seq", reader.getAnnotation( SequenceGenerator.class ).sequenceName() ); - assertNotNull( reader.getAnnotation( Columns.class ) ); - assertEquals( 1, reader.getAnnotation( Columns.class ).columns().length ); - assertEquals( "fld_id", reader.getAnnotation( Columns.class ).columns()[0].name() ); - assertNotNull( reader.getAnnotation( Temporal.class ) ); - assertEquals( TemporalType.DATE, reader.getAnnotation( Temporal.class ).value() ); - - context = buildContext( - "org/hibernate/orm/test/annotations/reflection/metadata-complete.xml" - ); - method = Administration.class.getDeclaredMethod( "getId" ); - reader = new JPAXMLOverriddenAnnotationReader( method, context, bootstrapContext ); - assertNotNull( - "Default access type when not defined in metadata complete should be property", - reader.getAnnotation( Id.class ) - ); - field = Administration.class.getDeclaredField( "id" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNull( - "Default access type when not defined in metadata complete should be property", - reader.getAnnotation( Id.class ) - ); - - method = BusTrip.class.getDeclaredMethod( "getId" ); - reader = new JPAXMLOverriddenAnnotationReader( method, context, bootstrapContext ); - assertNull( reader.getAnnotation( EmbeddedId.class ) ); - field = BusTrip.class.getDeclaredField( "id" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( EmbeddedId.class ) ); - assertNotNull( reader.getAnnotation( AttributeOverrides.class ) ); - assertEquals( 1, reader.getAnnotation( AttributeOverrides.class ).value().length ); - } - - @Test - public void testBasicRelatedAnnotations() throws Exception { - XMLContext context = buildContext( - "org/hibernate/orm/test/annotations/reflection/metadata-complete.xml" - ); - Field field = BusTrip.class.getDeclaredField( "status" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Enumerated.class ) ); - assertEquals( EnumType.STRING, reader.getAnnotation( Enumerated.class ).value() ); - assertEquals( false, reader.getAnnotation( Basic.class ).optional() ); - field = BusTrip.class.getDeclaredField( "serial" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Lob.class ) ); - assertEquals( "serialbytes", reader.getAnnotation( Columns.class ).columns()[0].name() ); - field = BusTrip.class.getDeclaredField( "terminusTime" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Temporal.class ) ); - assertEquals( TemporalType.TIMESTAMP, reader.getAnnotation( Temporal.class ).value() ); - assertEquals( FetchType.LAZY, reader.getAnnotation( Basic.class ).fetch() ); - - field = BusTripPk.class.getDeclaredField( "busDriver" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertTrue( reader.isAnnotationPresent( Basic.class ) ); - } - - @Test - public void testVersionRelatedAnnotations() throws Exception { - XMLContext context = buildContext( "org/hibernate/orm/test/annotations/reflection/orm.xml" ); - Method method = Administration.class.getDeclaredMethod( "getVersion" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( method, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Version.class ) ); - - Field field = Match.class.getDeclaredField( "version" ); - assertNotNull( reader.getAnnotation( Version.class ) ); - } - - @Test - public void testTransientAndEmbeddedRelatedAnnotations() throws Exception { - XMLContext context = buildContext( "org/hibernate/orm/test/annotations/reflection/orm.xml" ); - - Field field = Administration.class.getDeclaredField( "transientField" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Transient.class ) ); - assertNull( reader.getAnnotation( Basic.class ) ); - - field = Match.class.getDeclaredField( "playerASSN" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( Embedded.class ) ); - } - - @Test - public void testAssociationRelatedAnnotations() throws Exception { - XMLContext context = buildContext( "org/hibernate/orm/test/annotations/reflection/orm.xml" ); - - Field field = Administration.class.getDeclaredField( "defaultBusTrip" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( OneToOne.class ) ); - assertNull( reader.getAnnotation( JoinColumns.class ) ); - assertNotNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) ); - assertEquals( "pk", reader.getAnnotation( PrimaryKeyJoinColumns.class ).value()[0].name() ); - assertEquals( 5, reader.getAnnotation( OneToOne.class ).cascade().length ); - assertEquals( FetchType.LAZY, reader.getAnnotation( OneToOne.class ).fetch() ); - assertEquals( "test", reader.getAnnotation( OneToOne.class ).mappedBy() ); - - context = buildContext( - "org/hibernate/orm/test/annotations/reflection/metadata-complete.xml" - ); - field = BusTrip.class.getDeclaredField( "players" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( OneToMany.class ) ); - assertNotNull( reader.getAnnotation( JoinColumns.class ) ); - assertEquals( 2, reader.getAnnotation( JoinColumns.class ).value().length ); - assertEquals( "driver", reader.getAnnotation( JoinColumns.class ).value()[0].name() ); - assertNotNull( reader.getAnnotation( MapKey.class ) ); - assertEquals( "name", reader.getAnnotation( MapKey.class ).name() ); - - field = BusTrip.class.getDeclaredField( "roads" ); - reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( ManyToMany.class ) ); - assertNotNull( reader.getAnnotation( JoinTable.class ) ); - assertEquals( "bus_road", reader.getAnnotation( JoinTable.class ).name() ); - assertEquals( 2, reader.getAnnotation( JoinTable.class ).joinColumns().length ); - assertEquals( 1, reader.getAnnotation( JoinTable.class ).inverseJoinColumns().length ); - assertEquals( 2, reader.getAnnotation( JoinTable.class ).uniqueConstraints()[0].columnNames().length ); - assertNotNull( reader.getAnnotation( OrderBy.class ) ); - assertEquals( "maxSpeed", reader.getAnnotation( OrderBy.class ).value() ); - } - - @Test - @TestForIssue(jiraKey = "HHH-11924") - public void testElementCollectionConverter() throws Exception { - XMLContext context = buildContext( "org/hibernate/orm/test/annotations/reflection/orm.xml" ); - - Field field = Company.class.getDeclaredField( "organizations" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( field, context, bootstrapContext ); - assertNotNull( reader.getAnnotation( ElementCollection.class ) ); - assertNotNull( reader.getAnnotation( Converts.class ) ); - assertNotNull( reader.getAnnotation( Converts.class ).value() ); - assertTrue( reader.getAnnotation( Converts.class ).value().length == 1 ); - assertEquals(OrganizationConverter.class, reader.getAnnotation( Converts.class ).value()[0].converter()); - } - - @Test - public void testEntityListeners() throws Exception { - XMLContext context = buildContext( "org/hibernate/orm/test/annotations/reflection/orm.xml" ); - - Method method = Administration.class.getDeclaredMethod( "calculate" ); - JPAXMLOverriddenAnnotationReader reader = new JPAXMLOverriddenAnnotationReader( method, context, bootstrapContext ); - assertTrue( reader.isAnnotationPresent( PrePersist.class ) ); - - reader = new JPAXMLOverriddenAnnotationReader( Administration.class, context, bootstrapContext ); - assertTrue( reader.isAnnotationPresent( EntityListeners.class ) ); - assertEquals( 1, reader.getAnnotation( EntityListeners.class ).value().length ); - assertEquals( LogListener.class, reader.getAnnotation( EntityListeners.class ).value()[0] ); - - method = LogListener.class.getDeclaredMethod( "noLog", Object.class ); - reader = new JPAXMLOverriddenAnnotationReader( method, context, bootstrapContext ); - assertTrue( reader.isAnnotationPresent( PostLoad.class ) ); - - method = LogListener.class.getDeclaredMethod( "log", Object.class ); - reader = new JPAXMLOverriddenAnnotationReader( method, context, bootstrapContext ); - assertTrue( reader.isAnnotationPresent( PrePersist.class ) ); - assertFalse( reader.isAnnotationPresent( PostPersist.class ) ); - - assertEquals( 1, context.getDefaultEntityListeners().size() ); - assertEquals( OtherLogListener.class.getName(), context.getDefaultEntityListeners().get( 0 ) ); - } - - private XMLContext buildContext(String ormfile) throws IOException { - XMLMappingHelper xmlHelper = new XMLMappingHelper(); - JaxbEntityMappingsImpl mappings = xmlHelper.readOrmXmlMappings( ormfile ); - XMLContext context = new XMLContext( bootstrapContext ); - context.addDocument( mappings ); - return context; - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/type/dynamicparameterized/MyStringType.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/type/dynamicparameterized/MyStringType.java index 4f73065015..ff02bf8352 100644 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/type/dynamicparameterized/MyStringType.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/type/dynamicparameterized/MyStringType.java @@ -30,7 +30,6 @@ import java.sql.SQLException; import java.sql.Types; import java.util.Properties; -import org.hibernate.annotations.common.reflection.XProperty; import org.hibernate.engine.spi.SharedSessionContractImplementor; import org.hibernate.models.spi.FieldDetails; import org.hibernate.usertype.DynamicParameterizedType; diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlElementCollectionTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlElementCollectionTest.java deleted file mode 100644 index 718baf066e..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlElementCollectionTest.java +++ /dev/null @@ -1,708 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or . - */ -package org.hibernate.orm.test.annotations.xml.ejb3; - -import jakarta.persistence.Access; -import jakarta.persistence.AccessType; -import jakarta.persistence.AssociationOverride; -import jakarta.persistence.AssociationOverrides; -import jakarta.persistence.AttributeOverride; -import jakarta.persistence.AttributeOverrides; -import jakarta.persistence.CollectionTable; -import jakarta.persistence.Column; -import jakarta.persistence.ElementCollection; -import jakarta.persistence.EnumType; -import jakarta.persistence.Enumerated; -import jakarta.persistence.FetchType; -import jakarta.persistence.JoinColumn; -import jakarta.persistence.JoinTable; -import jakarta.persistence.Lob; -import jakarta.persistence.MapKey; -import jakarta.persistence.MapKeyClass; -import jakarta.persistence.MapKeyColumn; -import jakarta.persistence.MapKeyEnumerated; -import jakarta.persistence.MapKeyJoinColumn; -import jakarta.persistence.MapKeyJoinColumns; -import jakarta.persistence.MapKeyTemporal; -import jakarta.persistence.OrderBy; -import jakarta.persistence.OrderColumn; -import jakarta.persistence.Temporal; -import jakarta.persistence.TemporalType; -import jakarta.persistence.UniqueConstraint; - -import org.hibernate.testing.TestForIssue; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -@TestForIssue(jiraKey = "HHH-14529") -public class Ejb3XmlElementCollectionTest extends Ejb3XmlTestCase { - @Test - public void testNoChildren() throws Exception { - reader = getReader( Entity2.class, "field1", "element-collection.orm1.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( Column.class ); - assertAnnotationNotPresent( Temporal.class ); - assertAnnotationNotPresent( Enumerated.class ); - assertAnnotationNotPresent( Lob.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationNotPresent( AttributeOverrides.class ); - assertAnnotationNotPresent( AssociationOverride.class ); - assertAnnotationNotPresent( AssociationOverrides.class ); - assertAnnotationNotPresent( CollectionTable.class ); - assertAnnotationNotPresent( Access.class ); - ElementCollection relAnno = reader.getAnnotation( ElementCollection.class ); - assertEquals( FetchType.LAZY, relAnno.fetch() ); - assertEquals( void.class, relAnno.targetClass() ); - } - - @Test - public void testOrderBy() throws Exception { - reader = getReader( Entity2.class, "field1", "element-collection.orm2.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertEquals( - "col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class ) - .value() - ); - } - - @Test - public void testOrderColumnNoAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "element-collection.orm3.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationPresent( OrderColumn.class ); - OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class ); - assertEquals( "", orderColumnAnno.columnDefinition() ); - assertEquals( "", orderColumnAnno.name() ); - assertTrue( orderColumnAnno.insertable() ); - assertTrue( orderColumnAnno.nullable() ); - assertTrue( orderColumnAnno.updatable() ); - } - - @Test - public void testOrderColumnAllAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "element-collection.orm4.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationPresent( OrderColumn.class ); - OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class ); - assertEquals( "int", orderColumnAnno.columnDefinition() ); - assertEquals( "col1", orderColumnAnno.name() ); - assertFalse( orderColumnAnno.insertable() ); - assertFalse( orderColumnAnno.nullable() ); - assertFalse( orderColumnAnno.updatable() ); - } - - @Test - public void testMapKeyNoAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm5.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( "", reader.getAnnotation( MapKey.class ).name() ); - } - - @Test - public void testMapKeyAllAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm6.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() ); - } - - @Test - public void testMapKeyClass() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm7.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - Entity2.class, reader.getAnnotation( MapKeyClass.class ) - .value() - ); - } - - @Test - public void testMapKeyTemporal() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm8.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - TemporalType.DATE, reader.getAnnotation( - MapKeyTemporal.class - ).value() - ); - } - - @Test - public void testMapKeyEnumerated() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm9.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - EnumType.STRING, reader.getAnnotation( - MapKeyEnumerated.class - ).value() - ); - } - - /** - * When there's a single map key attribute override, we still wrap it with - * an AttributeOverrides annotation. - */ - @Test - public void testSingleMapKeyAttributeOverride() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm10.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 1, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "col1", overrides[0].column().name() ); - } - - @Test - public void testMultipleMapKeyAttributeOverrides() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm11.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 2, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "", overrides[0].column().name() ); - assertFalse( overrides[0].column().unique() ); - assertTrue( overrides[0].column().nullable() ); - assertTrue( overrides[0].column().insertable() ); - assertTrue( overrides[0].column().updatable() ); - assertEquals( "", overrides[0].column().columnDefinition() ); - assertEquals( "", overrides[0].column().table() ); - assertEquals( 255, overrides[0].column().length() ); - assertEquals( 0, overrides[0].column().precision() ); - assertEquals( 0, overrides[0].column().scale() ); - assertEquals( "field2", overrides[1].name() ); - assertEquals( "col1", overrides[1].column().name() ); - assertTrue( overrides[1].column().unique() ); - assertFalse( overrides[1].column().nullable() ); - assertFalse( overrides[1].column().insertable() ); - assertFalse( overrides[1].column().updatable() ); - assertEquals( "int", overrides[1].column().columnDefinition() ); - assertEquals( "table1", overrides[1].column().table() ); - assertEquals( 50, overrides[1].column().length() ); - assertEquals( 2, overrides[1].column().precision() ); - assertEquals( 1, overrides[1].column().scale() ); - } - - @Test - public void testMapKeyColumnNoAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm12.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class ); - assertEquals( "", keyColAnno.columnDefinition() ); - assertEquals( "", keyColAnno.name() ); - assertEquals( "", keyColAnno.table() ); - assertFalse( keyColAnno.nullable() ); - assertTrue( keyColAnno.insertable() ); - assertFalse( keyColAnno.unique() ); - assertTrue( keyColAnno.updatable() ); - assertEquals( 255, keyColAnno.length() ); - assertEquals( 0, keyColAnno.precision() ); - assertEquals( 0, keyColAnno.scale() ); - } - - @Test - public void testMapKeyColumnAllAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm13.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class ); - assertEquals( "int", keyColAnno.columnDefinition() ); - assertEquals( "col1", keyColAnno.name() ); - assertEquals( "table1", keyColAnno.table() ); - assertTrue( keyColAnno.nullable() ); - assertFalse( keyColAnno.insertable() ); - assertTrue( keyColAnno.unique() ); - assertFalse( keyColAnno.updatable() ); - assertEquals( 50, keyColAnno.length() ); - assertEquals( 2, keyColAnno.precision() ); - assertEquals( 1, keyColAnno.scale() ); - } - - /** - * When there's a single map key join column, we still wrap it with a - * MapKeyJoinColumns annotation. - */ - @Test - public void testSingleMapKeyJoinColumn() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm14.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyJoinColumns joinColumnsAnno = reader - .getAnnotation( MapKeyJoinColumns.class ); - MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 1, joinColumns.length ); - assertEquals( "col1", joinColumns[0].name() ); - } - - @Test - public void testMultipleMapKeyJoinColumns() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm15.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyJoinColumns joinColumnsAnno = reader - .getAnnotation( MapKeyJoinColumns.class ); - MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertFalse( joinColumns[0].unique() ); - assertFalse( joinColumns[0].nullable() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertTrue( joinColumns[1].unique() ); - assertTrue( joinColumns[1].nullable() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertEquals( "table1", joinColumns[1].table() ); - } - - @Test - public void testColumnNoAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm16.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( Column.class ); - Column column = reader.getAnnotation( Column.class ); - assertEquals( "", column.name() ); - assertFalse( column.unique() ); - assertTrue( column.nullable() ); - assertTrue( column.insertable() ); - assertTrue( column.updatable() ); - assertEquals( "", column.columnDefinition() ); - assertEquals( "", column.table() ); - assertEquals( 255, column.length() ); - assertEquals( 0, column.precision() ); - assertEquals( 0, column.scale() ); - } - - @Test - public void testColumnAllAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm17.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( Column.class ); - Column column = reader.getAnnotation( Column.class ); - assertEquals( "col1", column.name() ); - assertTrue( column.unique() ); - assertFalse( column.nullable() ); - assertFalse( column.insertable() ); - assertFalse( column.updatable() ); - assertEquals( "int", column.columnDefinition() ); - assertEquals( "table1", column.table() ); - assertEquals( 50, column.length() ); - assertEquals( 2, column.precision() ); - assertEquals( 1, column.scale() ); - } - - @Test - public void testTemporal() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm18.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( Temporal.class ); - assertAnnotationNotPresent( Enumerated.class ); - assertAnnotationNotPresent( Lob.class ); - assertEquals( - TemporalType.DATE, reader.getAnnotation( - Temporal.class - ).value() - ); - } - - @Test - public void testEnumerated() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm19.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( Temporal.class ); - assertAnnotationPresent( Enumerated.class ); - assertAnnotationNotPresent( Lob.class ); - assertEquals( - EnumType.STRING, reader.getAnnotation( - Enumerated.class - ).value() - ); - } - - @Test - public void testLob() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm20.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( Temporal.class ); - assertAnnotationNotPresent( Enumerated.class ); - assertAnnotationPresent( Lob.class ); - } - - /** - * When there's a single attribute override, we still wrap it with an - * AttributeOverrides annotation. - */ - @Test - public void testSingleAttributeOverride() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm21.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 1, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "col1", overrides[0].column().name() ); - } - - @Test - public void testMultipleAttributeOverrides() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm22.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 2, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "", overrides[0].column().name() ); - assertFalse( overrides[0].column().unique() ); - assertTrue( overrides[0].column().nullable() ); - assertTrue( overrides[0].column().insertable() ); - assertTrue( overrides[0].column().updatable() ); - assertEquals( "", overrides[0].column().columnDefinition() ); - assertEquals( "", overrides[0].column().table() ); - assertEquals( 255, overrides[0].column().length() ); - assertEquals( 0, overrides[0].column().precision() ); - assertEquals( 0, overrides[0].column().scale() ); - assertEquals( "field2", overrides[1].name() ); - assertEquals( "col1", overrides[1].column().name() ); - assertTrue( overrides[1].column().unique() ); - assertFalse( overrides[1].column().nullable() ); - assertFalse( overrides[1].column().insertable() ); - assertFalse( overrides[1].column().updatable() ); - assertEquals( "int", overrides[1].column().columnDefinition() ); - assertEquals( "table1", overrides[1].column().table() ); - assertEquals( 50, overrides[1].column().length() ); - assertEquals( 2, overrides[1].column().precision() ); - assertEquals( 1, overrides[1].column().scale() ); - } - - /** - * Tests that map-key-attribute-override and attribute-override elements - * both end up in the AttributeOverrides annotation. - */ - @Test - public void testMixedAttributeOverrides() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm23.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 2, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "col1", overrides[0].column().name() ); - assertEquals( "field2", overrides[1].name() ); - assertEquals( "col2", overrides[1].column().name() ); - } - - /** - * When there's a single association override, we still wrap it with an - * AssociationOverrides annotation. - */ - @Test - public void testSingleAssociationOverride() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm24.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( AssociationOverride.class ); - assertAnnotationPresent( AssociationOverrides.class ); - AssociationOverrides overridesAnno = reader.getAnnotation( AssociationOverrides.class ); - AssociationOverride[] overrides = overridesAnno.value(); - assertEquals( 1, overrides.length ); - assertEquals( "association1", overrides[0].name() ); - assertEquals( 0, overrides[0].joinColumns().length ); - assertEquals( "", overrides[0].joinTable().name() ); - } - - @Test - public void testMultipleAssociationOverridesJoinColumns() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm25.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( AssociationOverride.class ); - assertAnnotationPresent( AssociationOverrides.class ); - AssociationOverrides overridesAnno = reader.getAnnotation( AssociationOverrides.class ); - AssociationOverride[] overrides = overridesAnno.value(); - assertEquals( 2, overrides.length ); - //First, an association using join table - assertEquals( "association1", overrides[0].name() ); - assertEquals( 0, overrides[0].joinColumns().length ); - - JoinTable joinTableAnno = overrides[0].joinTable(); - assertEquals( "catalog1", joinTableAnno.catalog() ); - assertEquals( "table1", joinTableAnno.name() ); - assertEquals( "schema1", joinTableAnno.schema() ); - - //JoinColumns - JoinColumn[] joinColumns = joinTableAnno.joinColumns(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table2", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - - //InverseJoinColumns - JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns(); - assertEquals( 2, inverseJoinColumns.length ); - assertEquals( "", inverseJoinColumns[0].name() ); - assertEquals( "", inverseJoinColumns[0].referencedColumnName() ); - assertEquals( "", inverseJoinColumns[0].table() ); - assertEquals( "", inverseJoinColumns[0].columnDefinition() ); - assertTrue( inverseJoinColumns[0].insertable() ); - assertTrue( inverseJoinColumns[0].updatable() ); - assertTrue( inverseJoinColumns[0].nullable() ); - assertFalse( inverseJoinColumns[0].unique() ); - assertEquals( "col3", inverseJoinColumns[1].name() ); - assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() ); - assertEquals( "table3", inverseJoinColumns[1].table() ); - assertEquals( "int", inverseJoinColumns[1].columnDefinition() ); - assertFalse( inverseJoinColumns[1].insertable() ); - assertFalse( inverseJoinColumns[1].updatable() ); - assertFalse( inverseJoinColumns[1].nullable() ); - assertTrue( inverseJoinColumns[1].unique() ); - - //UniqueConstraints - UniqueConstraint[] uniqueConstraints = joinTableAnno - .uniqueConstraints(); - assertEquals( 2, uniqueConstraints.length ); - assertEquals( "", uniqueConstraints[0].name() ); - assertEquals( 1, uniqueConstraints[0].columnNames().length ); - assertEquals( "col5", uniqueConstraints[0].columnNames()[0] ); - assertEquals( "uq1", uniqueConstraints[1].name() ); - assertEquals( 2, uniqueConstraints[1].columnNames().length ); - assertEquals( "col6", uniqueConstraints[1].columnNames()[0] ); - assertEquals( "col7", uniqueConstraints[1].columnNames()[1] ); - - //Second, an association using join columns - assertEquals( "association2", overrides[1].name() ); - - //JoinColumns - joinColumns = overrides[1].joinColumns(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col8", joinColumns[1].name() ); - assertEquals( "col9", joinColumns[1].referencedColumnName() ); - assertEquals( "table4", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - } - - @Test - public void testCollectionTableNoChildren() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm26.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( CollectionTable.class ); - CollectionTable tableAnno = reader.getAnnotation( CollectionTable.class ); - assertEquals( "", tableAnno.name() ); - assertEquals( "", tableAnno.catalog() ); - assertEquals( "", tableAnno.schema() ); - assertEquals( 0, tableAnno.joinColumns().length ); - assertEquals( 0, tableAnno.uniqueConstraints().length ); - } - - @Test - public void testCollectionTableAllChildren() throws Exception { - reader = getReader( Entity3.class, "field1", "element-collection.orm27.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationPresent( CollectionTable.class ); - CollectionTable tableAnno = reader.getAnnotation( CollectionTable.class ); - assertEquals( "table1", tableAnno.name() ); - assertEquals( "catalog1", tableAnno.catalog() ); - assertEquals( "schema1", tableAnno.schema() ); - - //JoinColumns - JoinColumn[] joinColumns = tableAnno.joinColumns(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table2", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - - //UniqueConstraints - UniqueConstraint[] uniqueConstraints = tableAnno.uniqueConstraints(); - assertEquals( 2, uniqueConstraints.length ); - assertEquals( "", uniqueConstraints[0].name() ); - assertEquals( 1, uniqueConstraints[0].columnNames().length ); - assertEquals( "col3", uniqueConstraints[0].columnNames()[0] ); - assertEquals( "uq1", uniqueConstraints[1].name() ); - assertEquals( 2, uniqueConstraints[1].columnNames().length ); - assertEquals( "col4", uniqueConstraints[1].columnNames()[0] ); - assertEquals( "col5", uniqueConstraints[1].columnNames()[1] ); - } - - @Test - public void testAllAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "element-collection.orm28.xml" ); - assertAnnotationPresent( ElementCollection.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( Column.class ); - assertAnnotationNotPresent( Temporal.class ); - assertAnnotationNotPresent( Enumerated.class ); - assertAnnotationNotPresent( Lob.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationNotPresent( AttributeOverrides.class ); - assertAnnotationNotPresent( AssociationOverride.class ); - assertAnnotationNotPresent( AssociationOverrides.class ); - assertAnnotationNotPresent( CollectionTable.class ); - assertAnnotationPresent( Access.class ); - ElementCollection relAnno = reader.getAnnotation( ElementCollection.class ); - assertEquals( FetchType.EAGER, relAnno.fetch() ); - assertEquals( Entity3.class, relAnno.targetClass() ); - assertEquals( - AccessType.PROPERTY, reader.getAnnotation( Access.class ) - .value() - ); - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlManyToManyTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlManyToManyTest.java deleted file mode 100644 index eacf152a70..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlManyToManyTest.java +++ /dev/null @@ -1,500 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or . - */ -package org.hibernate.orm.test.annotations.xml.ejb3; - -import jakarta.persistence.Access; -import jakarta.persistence.AccessType; -import jakarta.persistence.AttributeOverride; -import jakarta.persistence.AttributeOverrides; -import jakarta.persistence.CascadeType; -import jakarta.persistence.EnumType; -import jakarta.persistence.FetchType; -import jakarta.persistence.JoinColumn; -import jakarta.persistence.JoinColumns; -import jakarta.persistence.JoinTable; -import jakarta.persistence.ManyToMany; -import jakarta.persistence.MapKey; -import jakarta.persistence.MapKeyClass; -import jakarta.persistence.MapKeyColumn; -import jakarta.persistence.MapKeyEnumerated; -import jakarta.persistence.MapKeyJoinColumn; -import jakarta.persistence.MapKeyJoinColumns; -import jakarta.persistence.MapKeyTemporal; -import jakarta.persistence.OrderBy; -import jakarta.persistence.OrderColumn; -import jakarta.persistence.TemporalType; -import jakarta.persistence.UniqueConstraint; - -import org.hibernate.testing.TestForIssue; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -@TestForIssue(jiraKey = "HHH-14529") -public class Ejb3XmlManyToManyTest extends Ejb3XmlTestCase { - @Test - public void testNoChildren() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm1.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationNotPresent( Access.class ); - ManyToMany relAnno = reader.getAnnotation( ManyToMany.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.LAZY, relAnno.fetch() ); - assertEquals( "", relAnno.mappedBy() ); - assertEquals( void.class, relAnno.targetEntity() ); - } - - @Test - public void testOrderBy() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm2.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertEquals( - "col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class ) - .value() - ); - } - - @Test - public void testOrderColumnNoAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm3.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationPresent( OrderColumn.class ); - OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class ); - assertEquals( "", orderColumnAnno.columnDefinition() ); - assertEquals( "", orderColumnAnno.name() ); - assertTrue( orderColumnAnno.insertable() ); - assertTrue( orderColumnAnno.nullable() ); - assertTrue( orderColumnAnno.updatable() ); - } - - @Test - public void testOrderColumnAllAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm4.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationPresent( OrderColumn.class ); - OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class ); - assertEquals( "int", orderColumnAnno.columnDefinition() ); - assertEquals( "col1", orderColumnAnno.name() ); - assertFalse( orderColumnAnno.insertable() ); - assertFalse( orderColumnAnno.nullable() ); - assertFalse( orderColumnAnno.updatable() ); - } - - @Test - public void testMapKeyNoAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm5.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( "", reader.getAnnotation( MapKey.class ).name() ); - } - - @Test - public void testMapKeyAllAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm6.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() ); - } - - @Test - public void testMapKeyClass() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm7.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - Entity2.class, reader.getAnnotation( MapKeyClass.class ) - .value() - ); - } - - @Test - public void testMapKeyTemporal() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm8.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - TemporalType.DATE, reader.getAnnotation( - MapKeyTemporal.class - ).value() - ); - } - - @Test - public void testMapKeyEnumerated() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm9.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - EnumType.STRING, reader.getAnnotation( - MapKeyEnumerated.class - ).value() - ); - } - - /** - * When there's a single map key attribute override, we still wrap it with - * an AttributeOverrides annotation. - */ - @Test - public void testSingleMapKeyAttributeOverride() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm10.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 1, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "col1", overrides[0].column().name() ); - } - - @Test - public void testMultipleMapKeyAttributeOverrides() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm11.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 2, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "", overrides[0].column().name() ); - assertFalse( overrides[0].column().unique() ); - assertTrue( overrides[0].column().nullable() ); - assertTrue( overrides[0].column().insertable() ); - assertTrue( overrides[0].column().updatable() ); - assertEquals( "", overrides[0].column().columnDefinition() ); - assertEquals( "", overrides[0].column().table() ); - assertEquals( 255, overrides[0].column().length() ); - assertEquals( 0, overrides[0].column().precision() ); - assertEquals( 0, overrides[0].column().scale() ); - assertEquals( "field2", overrides[1].name() ); - assertEquals( "col1", overrides[1].column().name() ); - assertTrue( overrides[1].column().unique() ); - assertFalse( overrides[1].column().nullable() ); - assertFalse( overrides[1].column().insertable() ); - assertFalse( overrides[1].column().updatable() ); - assertEquals( "int", overrides[1].column().columnDefinition() ); - assertEquals( "table1", overrides[1].column().table() ); - assertEquals( 50, overrides[1].column().length() ); - assertEquals( 2, overrides[1].column().precision() ); - assertEquals( 1, overrides[1].column().scale() ); - } - - @Test - public void testMapKeyColumnNoAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm12.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class ); - assertEquals( "", keyColAnno.columnDefinition() ); - assertEquals( "", keyColAnno.name() ); - assertEquals( "", keyColAnno.table() ); - assertFalse( keyColAnno.nullable() ); - assertTrue( keyColAnno.insertable() ); - assertFalse( keyColAnno.unique() ); - assertTrue( keyColAnno.updatable() ); - assertEquals( 255, keyColAnno.length() ); - assertEquals( 0, keyColAnno.precision() ); - assertEquals( 0, keyColAnno.scale() ); - } - - @Test - public void testMapKeyColumnAllAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm13.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class ); - assertEquals( "int", keyColAnno.columnDefinition() ); - assertEquals( "col1", keyColAnno.name() ); - assertEquals( "table1", keyColAnno.table() ); - assertTrue( keyColAnno.nullable() ); - assertFalse( keyColAnno.insertable() ); - assertTrue( keyColAnno.unique() ); - assertFalse( keyColAnno.updatable() ); - assertEquals( 50, keyColAnno.length() ); - assertEquals( 2, keyColAnno.precision() ); - assertEquals( 1, keyColAnno.scale() ); - } - - /** - * When there's a single map key join column, we still wrap it with a - * MapKeyJoinColumns annotation. - */ - @Test - public void testSingleMapKeyJoinColumn() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm14.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyJoinColumns joinColumnsAnno = reader - .getAnnotation( MapKeyJoinColumns.class ); - MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 1, joinColumns.length ); - assertEquals( "col1", joinColumns[0].name() ); - } - - @Test - public void testMultipleMapKeyJoinColumns() throws Exception { - reader = getReader( Entity3.class, "field1", "many-to-many.orm15.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyJoinColumns joinColumnsAnno = reader - .getAnnotation( MapKeyJoinColumns.class ); - MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertFalse( joinColumns[0].unique() ); - assertFalse( joinColumns[0].nullable() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertTrue( joinColumns[1].unique() ); - assertTrue( joinColumns[1].nullable() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertEquals( "table1", joinColumns[1].table() ); - } - - @Test - public void testJoinTableNoChildren() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm16.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "", joinTableAnno.catalog() ); - assertEquals( "", joinTableAnno.name() ); - assertEquals( "", joinTableAnno.schema() ); - assertEquals( 0, joinTableAnno.joinColumns().length ); - assertEquals( 0, joinTableAnno.inverseJoinColumns().length ); - assertEquals( 0, joinTableAnno.uniqueConstraints().length ); - } - - @Test - public void testJoinTableAllChildren() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm17.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "cat1", joinTableAnno.catalog() ); - assertEquals( "table1", joinTableAnno.name() ); - assertEquals( "schema1", joinTableAnno.schema() ); - - // JoinColumns - JoinColumn[] joinColumns = joinTableAnno.joinColumns(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table2", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - - // InverseJoinColumns - JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns(); - assertEquals( 2, inverseJoinColumns.length ); - assertEquals( "", inverseJoinColumns[0].name() ); - assertEquals( "", inverseJoinColumns[0].referencedColumnName() ); - assertEquals( "", inverseJoinColumns[0].table() ); - assertEquals( "", inverseJoinColumns[0].columnDefinition() ); - assertTrue( inverseJoinColumns[0].insertable() ); - assertTrue( inverseJoinColumns[0].updatable() ); - assertTrue( inverseJoinColumns[0].nullable() ); - assertFalse( inverseJoinColumns[0].unique() ); - assertEquals( "col3", inverseJoinColumns[1].name() ); - assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() ); - assertEquals( "table3", inverseJoinColumns[1].table() ); - assertEquals( "int", inverseJoinColumns[1].columnDefinition() ); - assertFalse( inverseJoinColumns[1].insertable() ); - assertFalse( inverseJoinColumns[1].updatable() ); - assertFalse( inverseJoinColumns[1].nullable() ); - assertTrue( inverseJoinColumns[1].unique() ); - - // UniqueConstraints - UniqueConstraint[] uniqueConstraints = joinTableAnno - .uniqueConstraints(); - assertEquals( 2, uniqueConstraints.length ); - assertEquals( "", uniqueConstraints[0].name() ); - assertEquals( 1, uniqueConstraints[0].columnNames().length ); - assertEquals( "col5", uniqueConstraints[0].columnNames()[0] ); - assertEquals( "uq1", uniqueConstraints[1].name() ); - assertEquals( 2, uniqueConstraints[1].columnNames().length ); - assertEquals( "col6", uniqueConstraints[1].columnNames()[0] ); - assertEquals( "col7", uniqueConstraints[1].columnNames()[1] ); - } - - @Test - public void testCascadeAll() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm18.xml" ); - assertAnnotationPresent( ManyToMany.class ); - ManyToMany relAnno = reader.getAnnotation( ManyToMany.class ); - assertEquals( 1, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - } - - @Test - public void testCascadeSomeWithDefaultPersist() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm19.xml" ); - assertAnnotationPresent( ManyToMany.class ); - ManyToMany relAnno = reader.getAnnotation( ManyToMany.class ); - assertEquals( 4, relAnno.cascade().length ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[2] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] ); - } - - /** - * Make sure that it doesn't break the handler when {@link CascadeType#ALL} - * is specified in addition to a default cascade-persist or individual - * cascade settings. - */ - @Test - public void testCascadeAllPlusMore() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm20.xml" ); - assertAnnotationPresent( ManyToMany.class ); - ManyToMany relAnno = reader.getAnnotation( ManyToMany.class ); - assertEquals( 6, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] ); - assertEquals( CascadeType.MERGE, relAnno.cascade()[2] ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[5] ); - } - - @Test - public void testAllAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "many-to-many.orm21.xml" ); - assertAnnotationPresent( ManyToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationPresent( Access.class ); - ManyToMany relAnno = reader.getAnnotation( ManyToMany.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.EAGER, relAnno.fetch() ); - assertEquals( "field2", relAnno.mappedBy() ); - assertEquals( Entity3.class, relAnno.targetEntity() ); - assertEquals( - AccessType.PROPERTY, reader.getAnnotation( Access.class ) - .value() - ); - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlManyToOneTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlManyToOneTest.java deleted file mode 100644 index 539d078098..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlManyToOneTest.java +++ /dev/null @@ -1,237 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or . - */ -package org.hibernate.orm.test.annotations.xml.ejb3; - -import jakarta.persistence.Access; -import jakarta.persistence.AccessType; -import jakarta.persistence.CascadeType; -import jakarta.persistence.FetchType; -import jakarta.persistence.Id; -import jakarta.persistence.JoinColumn; -import jakarta.persistence.JoinColumns; -import jakarta.persistence.JoinTable; -import jakarta.persistence.ManyToOne; -import jakarta.persistence.MapsId; -import jakarta.persistence.UniqueConstraint; - -import org.hibernate.testing.TestForIssue; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -@TestForIssue(jiraKey = "HHH-14529") -public class Ejb3XmlManyToOneTest extends Ejb3XmlTestCase { - @Test - public void testNoJoins() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm1.xml" ); - assertAnnotationPresent( ManyToOne.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationNotPresent( Id.class ); - assertAnnotationNotPresent( MapsId.class ); - assertAnnotationNotPresent( Access.class ); - ManyToOne relAnno = reader.getAnnotation( ManyToOne.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.EAGER, relAnno.fetch() ); - assertTrue( relAnno.optional() ); - assertEquals( void.class, relAnno.targetEntity() ); - } - - /** - * When there's a single join column, we still wrap it with a JoinColumns - * annotation. - */ - @Test - public void testSingleJoinColumn() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm2.xml" ); - assertAnnotationPresent( ManyToOne.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinTable.class ); - JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class ); - JoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 1, joinColumns.length ); - assertEquals( "col1", joinColumns[0].name() ); - assertEquals( "col2", joinColumns[0].referencedColumnName() ); - assertEquals( "table1", joinColumns[0].table() ); - } - - @Test - public void testMultipleJoinColumns() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm3.xml" ); - assertAnnotationPresent( ManyToOne.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinTable.class ); - JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class ); - JoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table1", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - } - - @Test - public void testJoinTableNoChildren() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm4.xml" ); - assertAnnotationPresent( ManyToOne.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationPresent( JoinTable.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "", joinTableAnno.catalog() ); - assertEquals( "", joinTableAnno.name() ); - assertEquals( "", joinTableAnno.schema() ); - assertEquals( 0, joinTableAnno.joinColumns().length ); - assertEquals( 0, joinTableAnno.inverseJoinColumns().length ); - assertEquals( 0, joinTableAnno.uniqueConstraints().length ); - } - - @Test - public void testJoinTableAllChildren() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm5.xml" ); - assertAnnotationPresent( ManyToOne.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationPresent( JoinTable.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "cat1", joinTableAnno.catalog() ); - assertEquals( "table1", joinTableAnno.name() ); - assertEquals( "schema1", joinTableAnno.schema() ); - - // JoinColumns - JoinColumn[] joinColumns = joinTableAnno.joinColumns(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table2", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - - // InverseJoinColumns - JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns(); - assertEquals( 2, inverseJoinColumns.length ); - assertEquals( "", inverseJoinColumns[0].name() ); - assertEquals( "", inverseJoinColumns[0].referencedColumnName() ); - assertEquals( "", inverseJoinColumns[0].table() ); - assertEquals( "", inverseJoinColumns[0].columnDefinition() ); - assertTrue( inverseJoinColumns[0].insertable() ); - assertTrue( inverseJoinColumns[0].updatable() ); - assertTrue( inverseJoinColumns[0].nullable() ); - assertFalse( inverseJoinColumns[0].unique() ); - assertEquals( "col3", inverseJoinColumns[1].name() ); - assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() ); - assertEquals( "table3", inverseJoinColumns[1].table() ); - assertEquals( "int", inverseJoinColumns[1].columnDefinition() ); - assertFalse( inverseJoinColumns[1].insertable() ); - assertFalse( inverseJoinColumns[1].updatable() ); - assertFalse( inverseJoinColumns[1].nullable() ); - assertTrue( inverseJoinColumns[1].unique() ); - - // UniqueConstraints - UniqueConstraint[] uniqueConstraints = joinTableAnno - .uniqueConstraints(); - assertEquals( 2, uniqueConstraints.length ); - assertEquals( "", uniqueConstraints[0].name() ); - assertEquals( 1, uniqueConstraints[0].columnNames().length ); - assertEquals( "col5", uniqueConstraints[0].columnNames()[0] ); - assertEquals( "uq1", uniqueConstraints[1].name() ); - assertEquals( 2, uniqueConstraints[1].columnNames().length ); - assertEquals( "col6", uniqueConstraints[1].columnNames()[0] ); - assertEquals( "col7", uniqueConstraints[1].columnNames()[1] ); - } - - @Test - public void testAllAttributes() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm6.xml" ); - assertAnnotationPresent( ManyToOne.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationPresent( Id.class ); - assertAnnotationPresent( MapsId.class ); - assertAnnotationPresent( Access.class ); - ManyToOne relAnno = reader.getAnnotation( ManyToOne.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.LAZY, relAnno.fetch() ); - assertFalse( relAnno.optional() ); - assertEquals( Entity3.class, relAnno.targetEntity() ); - assertEquals( "col1", reader.getAnnotation( MapsId.class ).value() ); - assertEquals( - AccessType.PROPERTY, reader.getAnnotation( Access.class ) - .value() - ); - } - - @Test - public void testCascadeAll() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm7.xml" ); - assertAnnotationPresent( ManyToOne.class ); - ManyToOne relAnno = reader.getAnnotation( ManyToOne.class ); - assertEquals( 1, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - } - - @Test - public void testCascadeSomeWithDefaultPersist() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm8.xml" ); - assertAnnotationPresent( ManyToOne.class ); - ManyToOne relAnno = reader.getAnnotation( ManyToOne.class ); - assertEquals( 4, relAnno.cascade().length ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[2] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] ); - } - - /** - * Make sure that it doesn't break the handler when {@link CascadeType#ALL} - * is specified in addition to a default cascade-persist or individual - * cascade settings. - */ - @Test - public void testCascadeAllPlusMore() throws Exception { - reader = getReader( Entity1.class, "field1", "many-to-one.orm9.xml" ); - assertAnnotationPresent( ManyToOne.class ); - ManyToOne relAnno = reader.getAnnotation( ManyToOne.class ); - assertEquals( 6, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] ); - assertEquals( CascadeType.MERGE, relAnno.cascade()[2] ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[5] ); - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlOneToManyTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlOneToManyTest.java deleted file mode 100644 index ccbfac0dec..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlOneToManyTest.java +++ /dev/null @@ -1,553 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or . - */ -package org.hibernate.orm.test.annotations.xml.ejb3; - -import jakarta.persistence.Access; -import jakarta.persistence.AccessType; -import jakarta.persistence.AttributeOverride; -import jakarta.persistence.AttributeOverrides; -import jakarta.persistence.CascadeType; -import jakarta.persistence.EnumType; -import jakarta.persistence.FetchType; -import jakarta.persistence.JoinColumn; -import jakarta.persistence.JoinColumns; -import jakarta.persistence.JoinTable; -import jakarta.persistence.MapKey; -import jakarta.persistence.MapKeyClass; -import jakarta.persistence.MapKeyColumn; -import jakarta.persistence.MapKeyEnumerated; -import jakarta.persistence.MapKeyJoinColumn; -import jakarta.persistence.MapKeyJoinColumns; -import jakarta.persistence.MapKeyTemporal; -import jakarta.persistence.OneToMany; -import jakarta.persistence.OrderBy; -import jakarta.persistence.OrderColumn; -import jakarta.persistence.TemporalType; -import jakarta.persistence.UniqueConstraint; - -import org.hibernate.testing.TestForIssue; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -@TestForIssue(jiraKey = "HHH-14529") -public class Ejb3XmlOneToManyTest extends Ejb3XmlTestCase { - @Test - public void testNoChildren() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm1.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( Access.class ); - OneToMany relAnno = reader.getAnnotation( OneToMany.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.LAZY, relAnno.fetch() ); - assertEquals( "", relAnno.mappedBy() ); - assertFalse( relAnno.orphanRemoval() ); - assertEquals( void.class, relAnno.targetEntity() ); - } - - @Test - public void testOrderBy() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm2.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertEquals( - "col1 ASC, col2 DESC", reader.getAnnotation( OrderBy.class ) - .value() - ); - } - - @Test - public void testOrderColumnNoAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm3.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationPresent( OrderColumn.class ); - OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class ); - assertEquals( "", orderColumnAnno.columnDefinition() ); - assertEquals( "", orderColumnAnno.name() ); - assertTrue( orderColumnAnno.insertable() ); - assertTrue( orderColumnAnno.nullable() ); - assertTrue( orderColumnAnno.updatable() ); - } - - @Test - public void testOrderColumnAllAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm4.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationPresent( OrderColumn.class ); - OrderColumn orderColumnAnno = reader.getAnnotation( OrderColumn.class ); - assertEquals( "int", orderColumnAnno.columnDefinition() ); - assertEquals( "col1", orderColumnAnno.name() ); - assertFalse( orderColumnAnno.insertable() ); - assertFalse( orderColumnAnno.nullable() ); - assertFalse( orderColumnAnno.updatable() ); - } - - @Test - public void testMapKeyNoAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm5.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( "", reader.getAnnotation( MapKey.class ).name() ); - } - - @Test - public void testMapKeyAllAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm6.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( "field2", reader.getAnnotation( MapKey.class ).name() ); - } - - @Test - public void testMapKeyClass() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm7.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - Entity2.class, reader.getAnnotation( MapKeyClass.class ) - .value() - ); - } - - @Test - public void testMapKeyTemporal() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm8.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - TemporalType.DATE, reader.getAnnotation( - MapKeyTemporal.class - ).value() - ); - } - - @Test - public void testMapKeyEnumerated() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm9.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertEquals( - EnumType.STRING, reader.getAnnotation( - MapKeyEnumerated.class - ).value() - ); - } - - /** - * When there's a single map key attribute override, we still wrap it with - * an AttributeOverrides annotation. - */ - @Test - public void testSingleMapKeyAttributeOverride() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm10.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 1, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "col1", overrides[0].column().name() ); - } - - @Test - public void testMultipleMapKeyAttributeOverrides() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm11.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( AttributeOverride.class ); - assertAnnotationPresent( AttributeOverrides.class ); - AttributeOverrides overridesAnno = reader - .getAnnotation( AttributeOverrides.class ); - AttributeOverride[] overrides = overridesAnno.value(); - assertEquals( 2, overrides.length ); - assertEquals( "field1", overrides[0].name() ); - assertEquals( "", overrides[0].column().name() ); - assertFalse( overrides[0].column().unique() ); - assertTrue( overrides[0].column().nullable() ); - assertTrue( overrides[0].column().insertable() ); - assertTrue( overrides[0].column().updatable() ); - assertEquals( "", overrides[0].column().columnDefinition() ); - assertEquals( "", overrides[0].column().table() ); - assertEquals( 255, overrides[0].column().length() ); - assertEquals( 0, overrides[0].column().precision() ); - assertEquals( 0, overrides[0].column().scale() ); - assertEquals( "field2", overrides[1].name() ); - assertEquals( "col1", overrides[1].column().name() ); - assertTrue( overrides[1].column().unique() ); - assertFalse( overrides[1].column().nullable() ); - assertFalse( overrides[1].column().insertable() ); - assertFalse( overrides[1].column().updatable() ); - assertEquals( "int", overrides[1].column().columnDefinition() ); - assertEquals( "table1", overrides[1].column().table() ); - assertEquals( 50, overrides[1].column().length() ); - assertEquals( 2, overrides[1].column().precision() ); - assertEquals( 1, overrides[1].column().scale() ); - } - - @Test - public void testMapKeyColumnNoAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm12.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class ); - assertEquals( "", keyColAnno.columnDefinition() ); - assertEquals( "", keyColAnno.name() ); - assertEquals( "", keyColAnno.table() ); - assertFalse( keyColAnno.nullable() ); - assertTrue( keyColAnno.insertable() ); - assertFalse( keyColAnno.unique() ); - assertTrue( keyColAnno.updatable() ); - assertEquals( 255, keyColAnno.length() ); - assertEquals( 0, keyColAnno.precision() ); - assertEquals( 0, keyColAnno.scale() ); - } - - @Test - public void testMapKeyColumnAllAttributes() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm13.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyColumn keyColAnno = reader.getAnnotation( MapKeyColumn.class ); - assertEquals( "int", keyColAnno.columnDefinition() ); - assertEquals( "col1", keyColAnno.name() ); - assertEquals( "table1", keyColAnno.table() ); - assertTrue( keyColAnno.nullable() ); - assertFalse( keyColAnno.insertable() ); - assertTrue( keyColAnno.unique() ); - assertFalse( keyColAnno.updatable() ); - assertEquals( 50, keyColAnno.length() ); - assertEquals( 2, keyColAnno.precision() ); - assertEquals( 1, keyColAnno.scale() ); - } - - /** - * When there's a single map key join column, we still wrap it with a - * MapKeyJoinColumns annotation. - */ - @Test - public void testSingleMapKeyJoinColumn() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm14.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyJoinColumns joinColumnsAnno = reader - .getAnnotation( MapKeyJoinColumns.class ); - MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 1, joinColumns.length ); - assertEquals( "col1", joinColumns[0].name() ); - } - - @Test - public void testMultipleMapKeyJoinColumns() throws Exception { - reader = getReader( Entity3.class, "field1", "one-to-many.orm15.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - MapKeyJoinColumns joinColumnsAnno = reader - .getAnnotation( MapKeyJoinColumns.class ); - MapKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertFalse( joinColumns[0].unique() ); - assertFalse( joinColumns[0].nullable() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertTrue( joinColumns[1].unique() ); - assertTrue( joinColumns[1].nullable() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertEquals( "table1", joinColumns[1].table() ); - } - - @Test - public void testJoinTableNoChildren() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm16.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "", joinTableAnno.catalog() ); - assertEquals( "", joinTableAnno.name() ); - assertEquals( "", joinTableAnno.schema() ); - assertEquals( 0, joinTableAnno.joinColumns().length ); - assertEquals( 0, joinTableAnno.inverseJoinColumns().length ); - assertEquals( 0, joinTableAnno.uniqueConstraints().length ); - } - - @Test - public void testJoinTableAllChildren() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm17.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "cat1", joinTableAnno.catalog() ); - assertEquals( "table1", joinTableAnno.name() ); - assertEquals( "schema1", joinTableAnno.schema() ); - - // JoinColumns - JoinColumn[] joinColumns = joinTableAnno.joinColumns(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table2", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - - // InverseJoinColumns - JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns(); - assertEquals( 2, inverseJoinColumns.length ); - assertEquals( "", inverseJoinColumns[0].name() ); - assertEquals( "", inverseJoinColumns[0].referencedColumnName() ); - assertEquals( "", inverseJoinColumns[0].table() ); - assertEquals( "", inverseJoinColumns[0].columnDefinition() ); - assertTrue( inverseJoinColumns[0].insertable() ); - assertTrue( inverseJoinColumns[0].updatable() ); - assertTrue( inverseJoinColumns[0].nullable() ); - assertFalse( inverseJoinColumns[0].unique() ); - assertEquals( "col3", inverseJoinColumns[1].name() ); - assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() ); - assertEquals( "table3", inverseJoinColumns[1].table() ); - assertEquals( "int", inverseJoinColumns[1].columnDefinition() ); - assertFalse( inverseJoinColumns[1].insertable() ); - assertFalse( inverseJoinColumns[1].updatable() ); - assertFalse( inverseJoinColumns[1].nullable() ); - assertTrue( inverseJoinColumns[1].unique() ); - - // UniqueConstraints - UniqueConstraint[] uniqueConstraints = joinTableAnno - .uniqueConstraints(); - assertEquals( 2, uniqueConstraints.length ); - assertEquals( "", uniqueConstraints[0].name() ); - assertEquals( 1, uniqueConstraints[0].columnNames().length ); - assertEquals( "col5", uniqueConstraints[0].columnNames()[0] ); - assertEquals( "uq1", uniqueConstraints[1].name() ); - assertEquals( 2, uniqueConstraints[1].columnNames().length ); - assertEquals( "col6", uniqueConstraints[1].columnNames()[0] ); - assertEquals( "col7", uniqueConstraints[1].columnNames()[1] ); - } - - /** - * When there's a single join column, we still wrap it with a JoinColumns - * annotation. - */ - @Test - public void testSingleJoinColumn() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm18.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinTable.class ); - JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class ); - JoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 1, joinColumns.length ); - assertEquals( "col1", joinColumns[0].name() ); - assertEquals( "col2", joinColumns[0].referencedColumnName() ); - assertEquals( "table1", joinColumns[0].table() ); - } - - @Test - public void testMultipleJoinColumns() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm19.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinTable.class ); - JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class ); - JoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table1", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - } - - @Test - public void testCascadeAll() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm20.xml" ); - assertAnnotationPresent( OneToMany.class ); - OneToMany relAnno = reader.getAnnotation( OneToMany.class ); - assertEquals( 1, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - } - - @Test - public void testCascadeSomeWithDefaultPersist() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm21.xml" ); - assertAnnotationPresent( OneToMany.class ); - OneToMany relAnno = reader.getAnnotation( OneToMany.class ); - assertEquals( 4, relAnno.cascade().length ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[2] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] ); - } - - /** - * Make sure that it doesn't break the handler when {@link CascadeType#ALL} - * is specified in addition to a default cascade-persist or individual - * cascade settings. - */ - @Test - public void testCascadeAllPlusMore() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm22.xml" ); - assertAnnotationPresent( OneToMany.class ); - OneToMany relAnno = reader.getAnnotation( OneToMany.class ); - assertEquals( 6, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] ); - assertEquals( CascadeType.MERGE, relAnno.cascade()[2] ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[5] ); - } - - @Test - public void testAllAttributes() throws Exception { - reader = getReader( Entity2.class, "field1", "one-to-many.orm23.xml" ); - assertAnnotationPresent( OneToMany.class ); - assertAnnotationNotPresent( OrderBy.class ); - assertAnnotationNotPresent( OrderColumn.class ); - assertAnnotationNotPresent( MapKey.class ); - assertAnnotationNotPresent( MapKeyClass.class ); - assertAnnotationNotPresent( MapKeyTemporal.class ); - assertAnnotationNotPresent( MapKeyEnumerated.class ); - assertAnnotationNotPresent( MapKeyColumn.class ); - assertAnnotationNotPresent( MapKeyJoinColumns.class ); - assertAnnotationNotPresent( MapKeyJoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationPresent( Access.class ); - OneToMany relAnno = reader.getAnnotation( OneToMany.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.EAGER, relAnno.fetch() ); - assertEquals( "field2", relAnno.mappedBy() ); - assertTrue( relAnno.orphanRemoval() ); - assertEquals( Entity3.class, relAnno.targetEntity() ); - assertEquals( - AccessType.PROPERTY, reader.getAnnotation( Access.class ) - .value() - ); - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlOneToOneTest.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlOneToOneTest.java deleted file mode 100644 index b923e81d19..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlOneToOneTest.java +++ /dev/null @@ -1,301 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or . - */ -package org.hibernate.orm.test.annotations.xml.ejb3; - -import jakarta.persistence.Access; -import jakarta.persistence.AccessType; -import jakarta.persistence.CascadeType; -import jakarta.persistence.FetchType; -import jakarta.persistence.Id; -import jakarta.persistence.JoinColumn; -import jakarta.persistence.JoinColumns; -import jakarta.persistence.JoinTable; -import jakarta.persistence.MapsId; -import jakarta.persistence.OneToOne; -import jakarta.persistence.PrimaryKeyJoinColumn; -import jakarta.persistence.PrimaryKeyJoinColumns; -import jakarta.persistence.UniqueConstraint; - -import org.hibernate.testing.TestForIssue; -import org.junit.Test; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; - -@TestForIssue(jiraKey = "HHH-14529") -public class Ejb3XmlOneToOneTest extends Ejb3XmlTestCase { - @Test - public void testNoChildren() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm1.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationNotPresent( MapsId.class ); - assertAnnotationNotPresent( Id.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumns.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationNotPresent( Access.class ); - OneToOne relAnno = reader.getAnnotation( OneToOne.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.EAGER, relAnno.fetch() ); - assertEquals( "", relAnno.mappedBy() ); - assertTrue( relAnno.optional() ); - assertFalse( relAnno.orphanRemoval() ); - assertEquals( void.class, relAnno.targetEntity() ); - } - - /** - * When there's a single primary key join column, we still wrap it with - * a PrimaryKeyJoinColumns annotation. - */ - @Test - public void testSinglePrimaryKeyJoinColumn() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm2.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationPresent( PrimaryKeyJoinColumns.class ); - PrimaryKeyJoinColumns joinColumnsAnno = - reader.getAnnotation( PrimaryKeyJoinColumns.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - PrimaryKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 1, joinColumns.length ); - assertEquals( "col1", joinColumns[0].name() ); - assertEquals( "col2", joinColumns[0].referencedColumnName() ); - assertEquals( "int", joinColumns[0].columnDefinition() ); - } - - @Test - public void testMultiplePrimaryKeyJoinColumn() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm3.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationPresent( PrimaryKeyJoinColumns.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - PrimaryKeyJoinColumns joinColumnsAnno = - reader.getAnnotation( PrimaryKeyJoinColumns.class ); - PrimaryKeyJoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - } - - /** - * When there's a single join column, we still wrap it with a JoinColumns - * annotation. - */ - @Test - public void testSingleJoinColumn() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm4.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumns.class ); - assertAnnotationPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class ); - JoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 1, joinColumns.length ); - assertEquals( "col1", joinColumns[0].name() ); - assertEquals( "col2", joinColumns[0].referencedColumnName() ); - assertEquals( "table1", joinColumns[0].table() ); - } - - @Test - public void testMultipleJoinColumns() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm5.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinTable.class ); - JoinColumns joinColumnsAnno = reader.getAnnotation( JoinColumns.class ); - JoinColumn[] joinColumns = joinColumnsAnno.value(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table1", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - } - - @Test - public void testJoinTableNoChildren() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm6.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumns.class ); - assertAnnotationPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "", joinTableAnno.catalog() ); - assertEquals( "", joinTableAnno.name() ); - assertEquals( "", joinTableAnno.schema() ); - assertEquals( 0, joinTableAnno.joinColumns().length ); - assertEquals( 0, joinTableAnno.inverseJoinColumns().length ); - assertEquals( 0, joinTableAnno.uniqueConstraints().length ); - } - - @Test - public void testJoinTableAllChildren() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm7.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumns.class ); - assertAnnotationPresent( JoinTable.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - JoinTable joinTableAnno = reader.getAnnotation( JoinTable.class ); - assertEquals( "cat1", joinTableAnno.catalog() ); - assertEquals( "table1", joinTableAnno.name() ); - assertEquals( "schema1", joinTableAnno.schema() ); - - // JoinColumns - JoinColumn[] joinColumns = joinTableAnno.joinColumns(); - assertEquals( 2, joinColumns.length ); - assertEquals( "", joinColumns[0].name() ); - assertEquals( "", joinColumns[0].referencedColumnName() ); - assertEquals( "", joinColumns[0].table() ); - assertEquals( "", joinColumns[0].columnDefinition() ); - assertTrue( joinColumns[0].insertable() ); - assertTrue( joinColumns[0].updatable() ); - assertTrue( joinColumns[0].nullable() ); - assertFalse( joinColumns[0].unique() ); - assertEquals( "col1", joinColumns[1].name() ); - assertEquals( "col2", joinColumns[1].referencedColumnName() ); - assertEquals( "table2", joinColumns[1].table() ); - assertEquals( "int", joinColumns[1].columnDefinition() ); - assertFalse( joinColumns[1].insertable() ); - assertFalse( joinColumns[1].updatable() ); - assertFalse( joinColumns[1].nullable() ); - assertTrue( joinColumns[1].unique() ); - - // InverseJoinColumns - JoinColumn[] inverseJoinColumns = joinTableAnno.inverseJoinColumns(); - assertEquals( 2, inverseJoinColumns.length ); - assertEquals( "", inverseJoinColumns[0].name() ); - assertEquals( "", inverseJoinColumns[0].referencedColumnName() ); - assertEquals( "", inverseJoinColumns[0].table() ); - assertEquals( "", inverseJoinColumns[0].columnDefinition() ); - assertTrue( inverseJoinColumns[0].insertable() ); - assertTrue( inverseJoinColumns[0].updatable() ); - assertTrue( inverseJoinColumns[0].nullable() ); - assertFalse( inverseJoinColumns[0].unique() ); - assertEquals( "col3", inverseJoinColumns[1].name() ); - assertEquals( "col4", inverseJoinColumns[1].referencedColumnName() ); - assertEquals( "table3", inverseJoinColumns[1].table() ); - assertEquals( "int", inverseJoinColumns[1].columnDefinition() ); - assertFalse( inverseJoinColumns[1].insertable() ); - assertFalse( inverseJoinColumns[1].updatable() ); - assertFalse( inverseJoinColumns[1].nullable() ); - assertTrue( inverseJoinColumns[1].unique() ); - - // UniqueConstraints - UniqueConstraint[] uniqueConstraints = joinTableAnno - .uniqueConstraints(); - assertEquals( 2, uniqueConstraints.length ); - assertEquals( "", uniqueConstraints[0].name() ); - assertEquals( 1, uniqueConstraints[0].columnNames().length ); - assertEquals( "col5", uniqueConstraints[0].columnNames()[0] ); - assertEquals( "uq1", uniqueConstraints[1].name() ); - assertEquals( 2, uniqueConstraints[1].columnNames().length ); - assertEquals( "col6", uniqueConstraints[1].columnNames()[0] ); - assertEquals( "col7", uniqueConstraints[1].columnNames()[1] ); - } - - @Test - public void testCascadeAll() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm8.xml" ); - assertAnnotationPresent( OneToOne.class ); - OneToOne relAnno = reader.getAnnotation( OneToOne.class ); - assertEquals( 1, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - } - - @Test - public void testCascadeSomeWithDefaultPersist() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm9.xml" ); - assertAnnotationPresent( OneToOne.class ); - OneToOne relAnno = reader.getAnnotation( OneToOne.class ); - assertEquals( 4, relAnno.cascade().length ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[0] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[1] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[2] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[3] ); - } - - /** - * Make sure that it doesn't break the handler when {@link CascadeType#ALL} - * is specified in addition to a default cascade-persist or individual - * cascade settings. - */ - @Test - public void testCascadeAllPlusMore() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm10.xml" ); - assertAnnotationPresent( OneToOne.class ); - OneToOne relAnno = reader.getAnnotation( OneToOne.class ); - assertEquals( 6, relAnno.cascade().length ); - assertEquals( CascadeType.ALL, relAnno.cascade()[0] ); - assertEquals( CascadeType.PERSIST, relAnno.cascade()[1] ); - assertEquals( CascadeType.MERGE, relAnno.cascade()[2] ); - assertEquals( CascadeType.REMOVE, relAnno.cascade()[3] ); - assertEquals( CascadeType.REFRESH, relAnno.cascade()[4] ); - assertEquals( CascadeType.DETACH, relAnno.cascade()[5] ); - } - - @Test - public void testAllAttributes() throws Exception { - reader = getReader( Entity1.class, "field1", "one-to-one.orm11.xml" ); - assertAnnotationPresent( OneToOne.class ); - assertAnnotationPresent( MapsId.class ); - assertAnnotationPresent( Id.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumn.class ); - assertAnnotationNotPresent( PrimaryKeyJoinColumns.class ); - assertAnnotationNotPresent( JoinColumns.class ); - assertAnnotationNotPresent( JoinColumn.class ); - assertAnnotationNotPresent( JoinTable.class ); - assertAnnotationPresent( Access.class ); - OneToOne relAnno = reader.getAnnotation( OneToOne.class ); - assertEquals( 0, relAnno.cascade().length ); - assertEquals( FetchType.LAZY, relAnno.fetch() ); - assertEquals( "field2", relAnno.mappedBy() ); - assertFalse( relAnno.optional() ); - assertTrue( relAnno.orphanRemoval() ); - assertEquals( Entity3.class, relAnno.targetEntity() ); - assertEquals( - AccessType.PROPERTY, reader.getAnnotation( Access.class ) - .value() - ); - assertEquals( - "field3", reader.getAnnotation( MapsId.class ) - .value() - ); - } - -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlTestCase.java b/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlTestCase.java deleted file mode 100644 index 864984a372..0000000000 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/annotations/xml/ejb3/Ejb3XmlTestCase.java +++ /dev/null @@ -1,89 +0,0 @@ -/* - * Hibernate, Relational Persistence for Idiomatic Java - * - * License: GNU Lesser General Public License (LGPL), version 2.1 or later. - * See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html. - */ -package org.hibernate.orm.test.annotations.xml.ejb3; - -import java.io.InputStream; -import java.lang.annotation.Annotation; -import java.lang.reflect.AnnotatedElement; - -import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappingsImpl; -import org.hibernate.boot.model.internal.JPAXMLOverriddenAnnotationReader; -import org.hibernate.boot.model.internal.XMLContext; -import org.hibernate.orm.test.internal.util.xml.XMLMappingHelper; - -import org.hibernate.testing.boot.BootstrapContextImpl; -import org.hibernate.testing.junit4.BaseUnitTestCase; -import org.junit.After; -import org.junit.Before; - -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNotNull; -import static org.junit.Assert.assertTrue; - -/** - * Test superclass to provide utility methods for testing the mapping of JPA - * XML to JPA annotations. The configuration is built within each test, and no - * database is used. Thus, no schema generation or cleanup will be performed. - */ -public abstract class Ejb3XmlTestCase extends BaseUnitTestCase { - - protected JPAXMLOverriddenAnnotationReader reader; - - private BootstrapContextImpl bootstrapContext; - - protected Ejb3XmlTestCase() { - } - - @Before - public void init() { - bootstrapContext = new BootstrapContextImpl(); - } - - @After - public void destroy() { - bootstrapContext.close(); - } - - protected void assertAnnotationPresent(Class annotationType) { - assertTrue( - "Expected annotation " + annotationType.getSimpleName() + " was not present", - reader.isAnnotationPresent( annotationType ) - ); - } - - protected void assertAnnotationNotPresent(Class annotationType) { - assertFalse( - "Unexpected annotation " + annotationType.getSimpleName() + " was present", - reader.isAnnotationPresent( annotationType ) - ); - } - - protected JPAXMLOverriddenAnnotationReader getReader(Class entityClass, String fieldName, String ormResourceName) - throws Exception { - AnnotatedElement el = getAnnotatedElement( entityClass, fieldName ); - XMLContext xmlContext = getContext( ormResourceName ); - return new JPAXMLOverriddenAnnotationReader( el, xmlContext, bootstrapContext ); - } - - protected AnnotatedElement getAnnotatedElement(Class entityClass, String fieldName) throws Exception { - return entityClass.getDeclaredField( fieldName ); - } - - protected XMLContext getContext(String resourceName) throws Exception { - InputStream is = getClass().getResourceAsStream( resourceName ); - assertNotNull( "Could not load resource " + resourceName, is ); - return getContext( is, resourceName ); - } - - protected XMLContext getContext(InputStream is, String resourceName) throws Exception { - XMLMappingHelper xmlHelper = new XMLMappingHelper(); - JaxbEntityMappingsImpl mappings = xmlHelper.readOrmXmlMappings( is, resourceName ); - XMLContext context = new XMLContext( bootstrapContext ); - context.addDocument( mappings ); - return context; - } -} diff --git a/hibernate-core/src/test/java/org/hibernate/orm/test/boot/models/BootstrapContextTesting.java b/hibernate-core/src/test/java/org/hibernate/orm/test/boot/models/BootstrapContextTesting.java index 14323f97d8..70e0a5eee0 100644 --- a/hibernate-core/src/test/java/org/hibernate/orm/test/boot/models/BootstrapContextTesting.java +++ b/hibernate-core/src/test/java/org/hibernate/orm/test/boot/models/BootstrapContextTesting.java @@ -12,7 +12,6 @@ import java.util.Collections; import java.util.HashMap; import java.util.Map; -import org.hibernate.annotations.common.reflection.ReflectionManager; import org.hibernate.boot.CacheRegionDefinition; import org.hibernate.boot.archive.scan.internal.StandardScanOptions; import org.hibernate.boot.archive.scan.spi.ScanEnvironment; @@ -188,11 +187,6 @@ public class BootstrapContextTesting implements BootstrapContext { return scannerSetting; } - @Override - public ReflectionManager getReflectionManager() { - return null; - } - @Override public IndexView getJandexView() { return jandexIndex; diff --git a/hibernate-envers/hibernate-envers.gradle b/hibernate-envers/hibernate-envers.gradle index 409c61d187..75aa6ba8f2 100644 --- a/hibernate-envers/hibernate-envers.gradle +++ b/hibernate-envers/hibernate-envers.gradle @@ -15,7 +15,7 @@ dependencies { implementation jakartaLibs.jaxbApi implementation jakartaLibs.jaxb - implementation libs.hcann + implementation libs.hibernateModels implementation libs.jandex compileOnly libs.ant diff --git a/hibernate-platform/hibernate-platform.gradle b/hibernate-platform/hibernate-platform.gradle index 7eaed1feb1..54e47d4e44 100644 --- a/hibernate-platform/hibernate-platform.gradle +++ b/hibernate-platform/hibernate-platform.gradle @@ -35,7 +35,7 @@ dependencies { api project( ":hibernate-enhance-maven-plugin" ) api project( ":hibernate-ant" ) - api libs.hcann + api libs.hibernateModels api jakartaLibs.jpa api jakartaLibs.jta diff --git a/hibernate-testing/hibernate-testing.gradle b/hibernate-testing/hibernate-testing.gradle index 5ff768da16..b888aa182b 100644 --- a/hibernate-testing/hibernate-testing.gradle +++ b/hibernate-testing/hibernate-testing.gradle @@ -40,7 +40,7 @@ dependencies { api testLibs.log4j2 - implementation libs.hcann + implementation libs.hibernateModels implementation libs.jandex implementation testLibs.wildFlyTxnClient implementation testLibs.junit5Engine diff --git a/hibernate-testing/src/main/java/org/hibernate/testing/boot/BootstrapContextImpl.java b/hibernate-testing/src/main/java/org/hibernate/testing/boot/BootstrapContextImpl.java index 9a41fa125e..2b15c5137b 100644 --- a/hibernate-testing/src/main/java/org/hibernate/testing/boot/BootstrapContextImpl.java +++ b/hibernate-testing/src/main/java/org/hibernate/testing/boot/BootstrapContextImpl.java @@ -9,7 +9,6 @@ package org.hibernate.testing.boot; import java.util.Collection; import java.util.Map; -import org.hibernate.annotations.common.reflection.ReflectionManager; import org.hibernate.boot.CacheRegionDefinition; import org.hibernate.boot.archive.scan.spi.ScanEnvironment; import org.hibernate.boot.archive.scan.spi.ScanOptions; @@ -123,11 +122,6 @@ public class BootstrapContextImpl implements BootstrapContext { return delegate.getScanner(); } - @Override - public ReflectionManager getReflectionManager() { - return delegate.getReflectionManager(); - } - @Override public IndexView getJandexView() { return delegate.getJandexView(); diff --git a/settings.gradle b/settings.gradle index 9d7dad17a5..f24bc81cf3 100644 --- a/settings.gradle +++ b/settings.gradle @@ -70,7 +70,7 @@ dependencyResolutionManagement { def byteBuddyVersion = version "byteBuddy", "1.14.18" def classmateVersion = version "classmate", "1.5.1" def geolatteVersion = version "geolatte", "1.9.1" - def hibernateModelsVersion = version "hibernateModels", "0.7.6" + def hibernateModelsVersion = version "hibernateModels", "0.7.8" def jandexVersion = version "jandex", "3.2.0" def hcannVersion = version "hcann", "7.0.1.Final" def jacksonVersion = version "jackson", "2.17.0" @@ -104,7 +104,6 @@ dependencyResolutionManagement { library( "hibernateModels", "org.hibernate.models", "hibernate-models" ).versionRef( hibernateModelsVersion ) library( "jandex", "io.smallrye", "jandex" ).versionRef( jandexVersion ) library( "classmate", "com.fasterxml", "classmate" ).versionRef( classmateVersion ) - library( "hcann", "org.hibernate.common", "hibernate-commons-annotations" ).versionRef( hcannVersion ) library( "jackson", "com.fasterxml.jackson.core", "jackson-databind" ).versionRef( jacksonVersion ) library( "jacksonXml", "com.fasterxml.jackson.dataformat", "jackson-dataformat-xml" ).versionRef( jacksonVersion ) diff --git a/tooling/hibernate-enhance-maven-plugin/hibernate-enhance-maven-plugin.gradle b/tooling/hibernate-enhance-maven-plugin/hibernate-enhance-maven-plugin.gradle index 7d78e9cebb..373691241d 100644 --- a/tooling/hibernate-enhance-maven-plugin/hibernate-enhance-maven-plugin.gradle +++ b/tooling/hibernate-enhance-maven-plugin/hibernate-enhance-maven-plugin.gradle @@ -53,7 +53,8 @@ task processPluginXml(type: Copy) { generateMavenDependency(jakartaLibs.jpa)\ + generateMavenDependency(libs.antlr)\ + generateMavenDependency(jakartaLibs.jta)\ - + generateMavenDependency(libs.hcann)\ + + generateMavenDependency(libs.hibernateModels)\ + + generateMavenDependency(libs.jandex)\ + generateMavenDependency(libs.byteBuddy)\ + generateMavenDependency(libs.logging)\ + generateMavenDependency("org.hibernate:hibernate-core:" + project.version)]) diff --git a/tooling/metamodel-generator/hibernate-processor.gradle b/tooling/metamodel-generator/hibernate-processor.gradle index 924d7d2678..06abce2f5d 100644 --- a/tooling/metamodel-generator/hibernate-processor.gradle +++ b/tooling/metamodel-generator/hibernate-processor.gradle @@ -50,7 +50,7 @@ sourceSets { dependencies { // api - ewww... but Maven needs them this way api project( ':hibernate-core' ) - api libs.hcann + api libs.hibernateModels api libs.jandex api jakartaLibs.jaxbApi api jakartaLibs.jaxb