Hibernate
/
hibernate-orm
mirror of https://github.com/hibernate/hibernate-orm
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'upstream/main' into wip/6.0_merge_1

This commit is contained in:
Andrea Boriero 2021-04-20 09:45:47 +02:00
parent 607234e7bf 8389b1a7a2
commit c48606a5aa
62 changed files with 559 additions and 7546 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
hibernate-core/hibernate-core.gradle
View File

@ -50,11 +50,6 @@ dependencies {
compile( libraries.classmate )
compile( libraries.activation )
// We need dom4j for a number of things temporarily:
// 1) (unsupported) EntityMode.DOM4J support
// 2) Envers
// 3) hibernate-commons-annotations
compile( libraries.dom4j )
compile( libraries.commons_annotations )
// JAXB

7
hibernate-core/src/main/java/org/hibernate/boot/internal/BootstrapContextImpl.java
View File

@ -31,7 +31,6 @@ import org.hibernate.boot.spi.BootstrapContext;
import org.hibernate.boot.spi.ClassLoaderAccess;
import org.hibernate.boot.spi.MetadataBuildingOptions;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.cfg.annotations.reflection.JPAMetadataProvider;
import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenMetadataProvider;
import org.hibernate.engine.config.spi.ConfigurationService;
import org.hibernate.jpa.internal.MutableJpaComplianceImpl;
@ -320,13 +319,7 @@ public class BootstrapContextImpl implements BootstrapContext {
private JavaReflectionManager generateHcannReflectionManager() {
final JavaReflectionManager reflectionManager = new JavaReflectionManager();
if ( metadataBuildingOptions.getXmlMappingOptions().isPreferJaxb() ) {
reflectionManager.setMetadataProvider( new JPAXMLOverriddenMetadataProvider( this ) );
}
else {
// Legacy implementation based on DOM4J, for backwards compatibility.
reflectionManager.setMetadataProvider( new JPAMetadataProvider( this ) );
}
return reflectionManager;
}

13
hibernate-core/src/main/java/org/hibernate/boot/internal/MetadataBuilderImpl.java
View File

@ -28,7 +28,6 @@ import org.hibernate.boot.archive.spi.ArchiveDescriptorFactory;
import org.hibernate.boot.cfgxml.spi.CfgXmlAccessService;
import org.hibernate.boot.cfgxml.spi.LoadedConfig;
import org.hibernate.boot.cfgxml.spi.MappingReference;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.model.IdGeneratorStrategyInterpreter;
import org.hibernate.boot.model.TypeContributions;
import org.hibernate.boot.model.TypeContributor;
@ -555,7 +554,7 @@ public class MetadataBuilderImpl implements MetadataBuilderImplementor, TypeCont
private IdGeneratorInterpreterImpl idGenerationTypeInterpreter = new IdGeneratorInterpreterImpl();
private String schemaCharset;
private final XmlMappingOptions xmlMappingOptions;
private final boolean xmlMappingEnabled;
public MetadataBuildingOptionsImpl(StandardServiceRegistry serviceRegistry) {
this.serviceRegistry = serviceRegistry;
@ -567,7 +566,11 @@ public class MetadataBuilderImpl implements MetadataBuilderImplementor, TypeCont
this.multiTenancyStrategy = MultiTenancyStrategy.determineMultiTenancyStrategy( configService.getSettings() );
xmlMappingOptions = XmlMappingOptions.get( serviceRegistry );
this.xmlMappingEnabled = configService.getSetting(
AvailableSettings.XML_MAPPING_ENABLED,
StandardConverters.BOOLEAN,
true
);
this.implicitDiscriminatorsForJoinedInheritanceSupported = configService.getSetting(
AvailableSettings.IMPLICIT_DISCRIMINATOR_COLUMNS_FOR_JOINED_SUBCLASS,
@ -840,8 +843,8 @@ public class MetadataBuilderImpl implements MetadataBuilderImplementor, TypeCont
}
@Override
public XmlMappingOptions getXmlMappingOptions() {
return xmlMappingOptions;
public boolean isXmlMappingEnabled() {
return xmlMappingEnabled;
}
/**

12
hibernate-core/src/main/java/org/hibernate/boot/jaxb/internal/DefaultXmlMappingOptions.java
View File

@ -1,12 +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.jaxb.internal;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
public class DefaultXmlMappingOptions implements XmlMappingOptions {
}

49
hibernate-core/src/main/java/org/hibernate/boot/jaxb/internal/MappingBinder.java
View File

@ -10,11 +10,8 @@ import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
import org.hibernate.boot.MappingException;
import org.hibernate.boot.UnsupportedOrmXsdVersionException;
import org.hibernate.boot.jaxb.Origin;
import org.hibernate.boot.jaxb.hbm.spi.JaxbHbmHibernateMapping;
@ -22,17 +19,12 @@ import org.hibernate.boot.jaxb.internal.stax.HbmEventReader;
import org.hibernate.boot.jaxb.internal.stax.JpaOrmXmlEventReader;
import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
import org.hibernate.boot.jaxb.spi.Binding;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
import org.hibernate.boot.xsd.MappingXsdSupport;
import org.hibernate.internal.util.config.ConfigurationException;
import org.jboss.logging.Logger;
import org.dom4j.Document;
import org.dom4j.Node;
import org.dom4j.io.STAXEventReader;
/**
* @author Steve Ebersole
*/
@ -41,14 +33,11 @@ public class MappingBinder extends AbstractBinder {
private final XMLEventFactory xmlEventFactory = XMLEventFactory.newInstance();
private final XmlMappingOptions options;
private JAXBContext hbmJaxbContext;
private JAXBContext entityMappingsJaxbContext;
public MappingBinder(ClassLoaderService classLoaderService, boolean validateXml, XmlMappingOptions options) {
public MappingBinder(ClassLoaderService classLoaderService, boolean validateXml) {
super( classLoaderService, validateXml );
this.options = options;
}
@Override
@ -68,20 +57,12 @@ public class MappingBinder extends AbstractBinder {
}
else {
try {
if ( options.isPreferJaxb() ) {
log.debugf( "Performing JAXB binding of orm.xml document : %s", origin.toString() );
XMLEventReader reader = new JpaOrmXmlEventReader( staxEventReader, xmlEventFactory );
JaxbEntityMappings bindingRoot = jaxb( reader, MappingXsdSupport.INSTANCE.latestJpaDescriptor().getSchema(), entityMappingsJaxbContext(), origin );
return new Binding<>( bindingRoot, origin );
}
else {
log.debugf( "Performing DOM4J binding of orm.xml document : %s", origin.toString() );
final XMLEventReader reader = new JpaOrmXmlEventReader( staxEventReader, xmlEventFactory );
return new Binding<>( toDom4jDocument( reader, origin ), origin );
}
}
catch (JpaOrmXmlEventReader.BadVersionException e) {
throw new UnsupportedOrmXsdVersionException( e.getRequestedVersion(), origin );
}
@ -111,32 +92,4 @@ public class MappingBinder extends AbstractBinder {
}
return entityMappingsJaxbContext;
}
private Document toDom4jDocument(XMLEventReader jpaOrmXmlEventReader, Origin origin) {
// todo : do we need to build a DocumentFactory instance for use here?
// historically we did that to set TCCL since, iirc, dom4j uses TCCL
org.dom4j.io.STAXEventReader staxToDom4jReader = new STAXEventReader() {
@Override
public Node readNode(XMLEventReader reader) throws XMLStreamException {
// dom4j's reader misses handling of XML comments. So if the document we
// are trying to read has comments this process will blow up. So we
// override that to add that support as best we can
XMLEvent event = reader.peek();
if ( event instanceof javax.xml.stream.events.Comment ) {
return super.readComment( reader );
}
return super.readNode( reader );
}
};
try {
return staxToDom4jReader.readDocument( jpaOrmXmlEventReader );
}
catch (XMLStreamException e) {
throw new MappingException(
"An error occurred transforming orm.xml document from StAX to dom4j representation ",
e,
origin
);
}
}
}

86
hibernate-core/src/main/java/org/hibernate/boot/jaxb/spi/XmlMappingOptions.java
View File

@ -1,86 +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.jaxb.spi;
import org.hibernate.boot.jaxb.internal.DefaultXmlMappingOptions;
import org.hibernate.boot.registry.selector.spi.StrategySelector;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.engine.config.spi.ConfigurationService;
import org.hibernate.engine.config.spi.StandardConverters;
import org.hibernate.service.ServiceRegistry;
/**
* The options of XML mapping.
* <p>
* We're using an interface instead of simply configuration properties,
* so that we can override the options easily in integrations (Quarkus)
* and tests (to run the tests multiple times with different options).
*/
public interface XmlMappingOptions {
String DEFAULT_NAME = "default";
static XmlMappingOptions get(ServiceRegistry serviceRegistry) {
final ConfigurationService configService = serviceRegistry.getService( ConfigurationService.class );
// The config service may be null if we're using a BootstrapServiceRegistry,
// since configuration properties are unknown at that point.
// That can happen with MetadataSources in particular,
// because for some reason we allow MetadataSources to be built before the StandardServiceRegistry
// (and Quarkus relies on that).
// That's why we prefer to rely on strategies (see below):
// they can be customized without relying on configuration properties
// through the service loader.
boolean xmlMappingEnabled = configService == null || configService.getSetting(
AvailableSettings.XML_MAPPING_ENABLED,
StandardConverters.BOOLEAN,
true
);
XmlMappingOptions result;
if ( !xmlMappingEnabled ) {
result = new XmlMappingOptions() {
@Override
public boolean isEnabled() {
return false;
}
};
}
else {
StrategySelector strategySelector = serviceRegistry.getService( StrategySelector.class );
result = strategySelector.resolveDefaultableStrategy(
XmlMappingOptions.class,
XmlMappingOptions.DEFAULT_NAME,
new DefaultXmlMappingOptions()
);
}
return result;
}
/**
* Allows to skip processing of XML Mapping.
* This is for people using exclusively annotations to define their model, and might
* be able to improve efficiency of booting Hibernate ORM.
* By default, the XML mapping is taken into account.
*/
default boolean isEnabled() {
return true;
}
/**
* Whether to prefer JAXB implementations for XML parsing,
* or to rely on legacy behavior (JAXB for hbm.xml, DOM4J for orm.xml and Envers).
* <p>
* This option will be removed in a future major version (probably ORM 6.0)
* where JAXB will always be used.
*/
default boolean isPreferJaxb() {
return false;
}
}

20
hibernate-core/src/main/java/org/hibernate/boot/model/process/spi/MetadataBuildingProcess.java
View File

@ -15,7 +15,6 @@ import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.internal.InFlightMetadataCollectorImpl;
import org.hibernate.boot.internal.MetadataBuildingContextRootImpl;
import org.hibernate.boot.jaxb.internal.MappingBinder;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.model.TypeContributions;
import org.hibernate.boot.model.TypeContributor;
import org.hibernate.boot.model.process.internal.ManagedResourcesImpl;
@ -33,8 +32,11 @@ import org.hibernate.boot.spi.BootstrapContext;
import org.hibernate.boot.spi.MetadataBuildingOptions;
import org.hibernate.boot.spi.MetadataContributor;
import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.cfg.MetadataSourceType;
import org.hibernate.dialect.Dialect;
import org.hibernate.engine.config.spi.ConfigurationService;
import org.hibernate.engine.config.spi.StandardConverters;
import org.hibernate.engine.jdbc.spi.JdbcServices;
import org.hibernate.type.BasicType;
import org.hibernate.type.BasicTypeRegistry;
@ -95,11 +97,16 @@ public class MetadataBuildingProcess {
final MetadataSources sources,
final BootstrapContext bootstrapContext) {
final ManagedResourcesImpl managedResources = ManagedResourcesImpl.baseline( sources, bootstrapContext );
XmlMappingOptions xmlMappingOptions = XmlMappingOptions.get( bootstrapContext.getServiceRegistry() );
final ConfigurationService configService = bootstrapContext.getServiceRegistry().getService( ConfigurationService.class );
final boolean xmlMappingEnabled = configService.getSetting(
AvailableSettings.XML_MAPPING_ENABLED,
StandardConverters.BOOLEAN,
true
);
ScanningCoordinator.INSTANCE.coordinateScan(
managedResources,
bootstrapContext,
xmlMappingOptions.isEnabled() ? sources.getXmlMappingBinderAccess() : null
xmlMappingEnabled ? sources.getXmlMappingBinderAccess() : null
);
return managedResources;
}
@ -146,7 +153,7 @@ public class MetadataBuildingProcess {
final MetadataSourceProcessor processor = new MetadataSourceProcessor() {
private final MetadataSourceProcessor hbmProcessor =
options.getXmlMappingOptions().isEnabled()
options.isXmlMappingEnabled()
? new HbmMetadataSourceProcessorImpl( managedResources, rootMetadataBuildingContext )
: new NoOpMetadataSourceProcessorImpl();
@ -283,14 +290,13 @@ public class MetadataBuildingProcess {
metadataCollector.processSecondPasses( rootMetadataBuildingContext );
final XmlMappingOptions xmlMappingOptions = options.getXmlMappingOptions();
if ( xmlMappingOptions.isEnabled() ) {
if ( options.isXmlMappingEnabled() ) {
final Iterable<AdditionalJaxbMappingProducer> producers = classLoaderService.loadJavaServices( AdditionalJaxbMappingProducer.class );
if ( producers != null ) {
final EntityHierarchyBuilder hierarchyBuilder = new EntityHierarchyBuilder();
// final MappingBinder mappingBinder = new MappingBinder( true );
// We need to disable validation here. It seems Envers is not producing valid (according to schema) XML
final MappingBinder mappingBinder = new MappingBinder( classLoaderService, false, xmlMappingOptions );
final MappingBinder mappingBinder = new MappingBinder( classLoaderService, false );
for ( AdditionalJaxbMappingProducer producer : producers ) {
log.tracef( "Calling AdditionalJaxbMappingProducer : %s", producer );
Collection<MappingDocument> additionalMappings = producer.produceAdditionalMappings(

25
hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/annotations/AnnotationMetadataSourceProcessorImpl.java
View File

@ -24,7 +24,6 @@ import org.hibernate.boot.AttributeConverterInfo;
import org.hibernate.boot.internal.MetadataBuildingContextRootImpl;
import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
import org.hibernate.boot.jaxb.spi.Binding;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.model.convert.spi.ConverterDescriptor;
import org.hibernate.boot.model.process.spi.ManagedResources;
import org.hibernate.boot.model.source.spi.MetadataSourceProcessor;
@ -35,7 +34,6 @@ import org.hibernate.boot.spi.MetadataBuildingOptions;
import org.hibernate.cfg.AnnotationBinder;
import org.hibernate.cfg.InheritanceState;
import org.hibernate.cfg.annotations.reflection.AttributeConverterDefinitionCollector;
import org.hibernate.cfg.annotations.reflection.JPAMetadataProvider;
import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenMetadataProvider;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.internal.util.collections.CollectionHelper;
@ -43,8 +41,6 @@ import org.hibernate.internal.util.collections.CollectionHelper;
import org.jboss.jandex.IndexView;
import org.jboss.logging.Logger;
import org.dom4j.Document;
/**
* @author Steve Ebersole
*/
@ -80,11 +76,9 @@ public class AnnotationMetadataSourceProcessorImpl implements MetadataSourceProc
this.classLoaderService = rootMetadataBuildingContext.getBuildingOptions().getServiceRegistry().getService( ClassLoaderService.class );
MetadataBuildingOptions metadataBuildingOptions = rootMetadataBuildingContext.getBuildingOptions();
XmlMappingOptions xmlMappingOptions = metadataBuildingOptions.getXmlMappingOptions();
if ( xmlMappingOptions.isEnabled() ) {
if ( metadataBuildingOptions.isXmlMappingEnabled() ) {
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Ewww. This is temporary until we migrate to Jandex + StAX for annotation binding
if ( xmlMappingOptions.isPreferJaxb() ) {
final JPAXMLOverriddenMetadataProvider jpaMetadataProvider = (JPAXMLOverriddenMetadataProvider) ( (MetadataProviderInjector) reflectionManager )
.getMetadataProvider();
for ( Binding<?> xmlBinding : managedResources.getXmlMappingBindings() ) {
@ -100,23 +94,6 @@ public class AnnotationMetadataSourceProcessorImpl implements MetadataSourceProc
}
}
jpaMetadataProvider.getXMLContext().applyDiscoveredAttributeConverters( attributeConverterManager );
}
else {
final JPAMetadataProvider jpaMetadataProvider = (JPAMetadataProvider) ( (MetadataProviderInjector) reflectionManager )
.getMetadataProvider();
for ( Binding xmlBinding : managedResources.getXmlMappingBindings() ) {
if ( !org.dom4j.Document.class.isInstance( xmlBinding.getRoot() ) ) {
continue;
}
org.dom4j.Document dom4jDocument = (Document) xmlBinding.getRoot();
final List<String> classNames = jpaMetadataProvider.getXMLContext().addDocument( dom4jDocument );
for ( String className : classNames ) {
xClasses.add( toXClass( className, reflectionManager, classLoaderService ) );
}
}
jpaMetadataProvider.getXMLContext().applyDiscoveredAttributeConverters( attributeConverterManager );
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
}

3
hibernate-core/src/main/java/org/hibernate/boot/model/source/spi/AttributeSource.java
View File

@ -35,7 +35,8 @@ public interface AttributeSource extends ToolingHintContextContainer {
public boolean isSingular();
/**
* Ugh. This is the deprecated DOM4J entity-mode feature
* This is only useful to log warnings when these deprecated attributes are populated.
* It was only useful for DOM4J entity-mode, which was removed a long time ago.
*
* @return The xml node name
*/

4
hibernate-core/src/main/java/org/hibernate/boot/registry/selector/internal/StrategySelectorBuilder.java
View File

@ -9,8 +9,6 @@ package org.hibernate.boot.registry.selector.internal;
import java.util.ArrayList;
import java.util.List;
import org.hibernate.boot.jaxb.internal.DefaultXmlMappingOptions;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyComponentPathImpl;
import org.hibernate.boot.model.naming.ImplicitNamingStrategyJpaCompliantImpl;
@ -105,8 +103,6 @@ public class StrategySelectorBuilder {
addSqmMultiTableMutationStrategies( strategySelector );
addImplicitNamingStrategies( strategySelector );
addCacheKeysFactories( strategySelector );
strategySelector.registerStrategyImplementor( XmlMappingOptions.class, XmlMappingOptions.DEFAULT_NAME,
DefaultXmlMappingOptions.class );
// apply auto-discovered registrations
for ( StrategyRegistrationProvider provider : classLoaderService.loadJavaServices( StrategyRegistrationProvider.class ) ) {

5
hibernate-core/src/main/java/org/hibernate/boot/spi/AbstractDelegatingMetadataBuildingOptions.java
View File

@ -16,7 +16,6 @@ import org.hibernate.boot.CacheRegionDefinition;
import org.hibernate.boot.archive.scan.spi.ScanEnvironment;
import org.hibernate.boot.archive.scan.spi.ScanOptions;
import org.hibernate.boot.archive.spi.ArchiveDescriptorFactory;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.model.IdGeneratorStrategyInterpreter;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
@ -185,8 +184,8 @@ public abstract class AbstractDelegatingMetadataBuildingOptions implements Metad
}
@Override
public XmlMappingOptions getXmlMappingOptions() {
return delegate.getXmlMappingOptions();
public boolean isXmlMappingEnabled() {
return delegate.isXmlMappingEnabled();
}
}

5
hibernate-core/src/main/java/org/hibernate/boot/spi/MetadataBuildingOptions.java
View File

@ -15,7 +15,6 @@ import org.hibernate.boot.CacheRegionDefinition;
import org.hibernate.boot.archive.scan.spi.ScanEnvironment;
import org.hibernate.boot.archive.scan.spi.ScanOptions;
import org.hibernate.boot.archive.spi.ArchiveDescriptorFactory;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.model.IdGeneratorStrategyInterpreter;
import org.hibernate.boot.model.naming.ImplicitNamingStrategy;
import org.hibernate.boot.model.naming.PhysicalNamingStrategy;
@ -261,7 +260,7 @@ public interface MetadataBuildingOptions {
return null;
}
default XmlMappingOptions getXmlMappingOptions() {
return XmlMappingOptions.get( getServiceRegistry() );
default boolean isXmlMappingEnabled() {
return true;
}
}

8
hibernate-core/src/main/java/org/hibernate/boot/spi/XmlMappingBinderAccess.java
View File

@ -20,11 +20,7 @@ import org.hibernate.boot.jaxb.internal.InputStreamXmlSource;
import org.hibernate.boot.jaxb.internal.MappingBinder;
import org.hibernate.boot.jaxb.internal.UrlXmlSource;
import org.hibernate.boot.jaxb.spi.Binding;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.engine.config.spi.ConfigurationService;
import org.hibernate.engine.config.spi.StandardConverters;
import org.hibernate.service.ServiceRegistry;
import org.jboss.logging.Logger;
@ -41,12 +37,10 @@ public class XmlMappingBinderAccess {
public XmlMappingBinderAccess(ServiceRegistry serviceRegistry) {
this.classLoaderService = serviceRegistry.getService( ClassLoaderService.class );
XmlMappingOptions xmlMappingOptions = XmlMappingOptions.get( serviceRegistry );
// NOTE : The boolean here indicates whether or not to perform validation as we load XML documents.
// Should we expose this setting? Disabling would speed up JAXP and JAXB at runtime, but potentially
// at the cost of less obvious errors when a document is not valid.
this.mappingBinder = new MappingBinder( classLoaderService, true, xmlMappingOptions );
this.mappingBinder = new MappingBinder( classLoaderService, true );
}
public MappingBinder getMappingBinder() {

240
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/JPAMetadataProvider.java
View File

@ -1,240 +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.cfg.annotations.reflection;
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 javax.persistence.EntityListeners;
import javax.persistence.NamedNativeQuery;
import javax.persistence.NamedQuery;
import javax.persistence.NamedStoredProcedureQuery;
import javax.persistence.SequenceGenerator;
import javax.persistence.SqlResultSetMapping;
import javax.persistence.TableGenerator;
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.internal.ClassLoaderAccessImpl;
import org.hibernate.boot.registry.classloading.spi.ClassLoaderService;
import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
import org.hibernate.boot.spi.BootstrapContext;
import org.hibernate.boot.spi.ClassLoaderAccess;
import org.hibernate.boot.spi.ClassLoaderAccessDelegateImpl;
import org.hibernate.boot.spi.MetadataBuildingOptions;
import org.hibernate.internal.util.collections.CollectionHelper;
import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenMetadataProvider;
import org.dom4j.Element;
/**
* MetadataProvider aware of the JPA Deployment descriptor
*
* @author Emmanuel Bernard
*
* @deprecated This class is not API: do not use it from application code.
* This class will be removed in Hibernate ORM 6.0.
* For implementation code, use {@link JPAXMLOverriddenMetadataProvider}
* instead.
*/
@Deprecated
@SuppressWarnings("unchecked")
public final class JPAMetadataProvider 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<Object, Object> defaults;
private Map<AnnotatedElement, AnnotationReader> cache;
/**
* @deprecated Use {@link JPAMetadataProvider#JPAMetadataProvider(BootstrapContext)} instead.
*/
@Deprecated
public JPAMetadataProvider(final MetadataBuildingOptions metadataBuildingOptions) {
this( new ClassLoaderAccessDelegateImpl() {
ClassLoaderAccess delegate;
@Override
protected ClassLoaderAccess getDelegate() {
if ( delegate == null ) {
delegate = new ClassLoaderAccessImpl(
metadataBuildingOptions.getTempClassLoader(),
metadataBuildingOptions.getServiceRegistry().getService( ClassLoaderService.class )
);
}
return delegate;
}
},
metadataBuildingOptions.getXmlMappingOptions().isEnabled() );
}
public JPAMetadataProvider(BootstrapContext bootstrapContext) {
this( bootstrapContext.getClassLoaderAccess(),
bootstrapContext.getMetadataBuildingOptions().getXmlMappingOptions().isEnabled() );
}
JPAMetadataProvider(ClassLoaderAccess classLoaderAccess, boolean xmlMetadataEnabled) {
this.classLoaderAccess = classLoaderAccess;
this.xmlContext = new XMLContext( classLoaderAccess );
this.xmlMappingEnabled = xmlMetadataEnabled;
}
//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 JPAOverriddenAnnotationReader( annotatedElement, xmlContext, classLoaderAccess );
}
else {
reader = STATELESS_BASE_DELEGATE.getAnnotationReader( annotatedElement );
}
cache.put( annotatedElement, reader );
}
return reader;
}
@Override
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<Object, Object> getDefaults() {
if ( !xmlMappingEnabled ) {
return Collections.emptyMap();
}
else {
if ( defaults == null ) {
defaults = new HashMap<>();
XMLContext.Default xmlDefaults = xmlContext.getDefault( null );
defaults.put( "schema", xmlDefaults.getSchema() );
defaults.put( "catalog", xmlDefaults.getCatalog() );
defaults.put( "delimited-identifier", xmlDefaults.getDelimitedIdentifier() );
defaults.put( "cascade-persist", xmlDefaults.getCascadePersist() );
List<Class> 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 ( Element element : xmlContext.getAllDocuments() ) {
@SuppressWarnings( "unchecked" )
List<Element> elements = element.elements( "sequence-generator" );
List<SequenceGenerator> sequenceGenerators = ( List<SequenceGenerator> ) defaults.get( SequenceGenerator.class );
if ( sequenceGenerators == null ) {
sequenceGenerators = new ArrayList<>();
defaults.put( SequenceGenerator.class, sequenceGenerators );
}
for ( Element subelement : elements ) {
sequenceGenerators.add( JPAOverriddenAnnotationReader
.buildSequenceGeneratorAnnotation( subelement ) );
}
elements = element.elements( "table-generator" );
List<TableGenerator> tableGenerators = ( List<TableGenerator> ) defaults.get( TableGenerator.class );
if ( tableGenerators == null ) {
tableGenerators = new ArrayList<>();
defaults.put( TableGenerator.class, tableGenerators );
}
for ( Element subelement : elements ) {
tableGenerators.add(
JPAOverriddenAnnotationReader.buildTableGeneratorAnnotation(
subelement, xmlDefaults
)
);
}
List<NamedQuery> namedQueries = ( List<NamedQuery> ) defaults.get( NamedQuery.class );
if ( namedQueries == null ) {
namedQueries = new ArrayList<>();
defaults.put( NamedQuery.class, namedQueries );
}
List<NamedQuery> currentNamedQueries = JPAOverriddenAnnotationReader
.buildNamedQueries(
element,
false,
xmlDefaults,
classLoaderAccess
);
namedQueries.addAll( currentNamedQueries );
List<NamedNativeQuery> namedNativeQueries = ( List<NamedNativeQuery> ) defaults.get( NamedNativeQuery.class );
if ( namedNativeQueries == null ) {
namedNativeQueries = new ArrayList<>();
defaults.put( NamedNativeQuery.class, namedNativeQueries );
}
List<NamedNativeQuery> currentNamedNativeQueries = JPAOverriddenAnnotationReader
.buildNamedQueries(
element,
true,
xmlDefaults,
classLoaderAccess
);
namedNativeQueries.addAll( currentNamedNativeQueries );
List<SqlResultSetMapping> sqlResultSetMappings = ( List<SqlResultSetMapping> ) defaults.get(
SqlResultSetMapping.class
);
if ( sqlResultSetMappings == null ) {
sqlResultSetMappings = new ArrayList<>();
defaults.put( SqlResultSetMapping.class, sqlResultSetMappings );
}
List<SqlResultSetMapping> currentSqlResultSetMappings = JPAOverriddenAnnotationReader
.buildSqlResultsetMappings(
element,
xmlDefaults,
classLoaderAccess
);
sqlResultSetMappings.addAll( currentSqlResultSetMappings );
List<NamedStoredProcedureQuery> namedStoredProcedureQueries = (List<NamedStoredProcedureQuery>)defaults.get( NamedStoredProcedureQuery.class );
if(namedStoredProcedureQueries==null){
namedStoredProcedureQueries = new ArrayList<>( );
defaults.put( NamedStoredProcedureQuery.class, namedStoredProcedureQueries );
}
List<NamedStoredProcedureQuery> currentNamedStoredProcedureQueries = JPAOverriddenAnnotationReader
.buildNamedStoreProcedureQueries(
element,
xmlDefaults,
classLoaderAccess
);
namedStoredProcedureQueries.addAll( currentNamedStoredProcedureQueries );
}
}
return defaults;
}
}
public XMLContext getXMLContext() {
return xmlContext;
}
}

3094
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/JPAOverriddenAnnotationReader.java
View File

File diff suppressed because it is too large Load Diff

363
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/XMLContext.java
View File

@ -1,363 +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.cfg.annotations.reflection;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.persistence.AccessType;
import javax.persistence.AttributeConverter;
import org.hibernate.AnnotationException;
import org.hibernate.boot.AttributeConverterInfo;
import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
import org.hibernate.boot.spi.BootstrapContext;
import org.hibernate.boot.spi.ClassLoaderAccess;
import org.hibernate.cfg.AttributeConverterDefinition;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.internal.util.StringHelper;
import org.dom4j.Document;
import org.dom4j.Element;
/**
* A helper for consuming orm.xml mappings.
*
* @author Emmanuel Bernard
* @author Brett Meyer
*
* @deprecated This class is not API: do not use it from application code.
* This class will be removed in Hibernate ORM 6.0.
* For implementation code, use {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext} instead.
*/
@Deprecated
public class XMLContext implements Serializable {
private static final CoreMessageLogger LOG = CoreLogging.messageLogger( XMLContext.class );
private final ClassLoaderAccess classLoaderAccess;
private Default globalDefaults;
private Map<String, Element> classOverriding = new HashMap<>();
private Map<String, Default> defaultsOverriding = new HashMap<>();
private List<Element> defaultElements = new ArrayList<>();
private List<String> defaultEntityListeners = new ArrayList<>();
private boolean hasContext = false;
/**
* @deprecated Use {@link XMLContext#XMLContext(BootstrapContext)} instead.
*/
@Deprecated
public XMLContext(ClassLoaderAccess classLoaderAccess) {
this.classLoaderAccess = classLoaderAccess;
}
public XMLContext(BootstrapContext bootstrapContext) {
this.classLoaderAccess = bootstrapContext.getClassLoaderAccess();
}
/**
* @param doc The xml document to add
* @return Add an xml document to this context and return the list of added class names.
*/
@SuppressWarnings( "unchecked" )
public List<String> addDocument(Document doc) {
hasContext = true;
List<String> addedClasses = new ArrayList<>();
Element root = doc.getRootElement();
//global defaults
Element metadata = root.element( "persistence-unit-metadata" );
if ( metadata != null ) {
if ( globalDefaults == null ) {
globalDefaults = new Default();
globalDefaults.setMetadataComplete(
metadata.element( "xml-mapping-metadata-complete" ) != null ?
Boolean.TRUE :
null
);
Element defaultElement = metadata.element( "persistence-unit-defaults" );
if ( defaultElement != null ) {
Element unitElement = defaultElement.element( "schema" );
globalDefaults.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
unitElement = defaultElement.element( "catalog" );
globalDefaults.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
unitElement = defaultElement.element( "access" );
setAccess( unitElement, globalDefaults );
unitElement = defaultElement.element( "cascade-persist" );
globalDefaults.setCascadePersist( unitElement != null ? Boolean.TRUE : null );
unitElement = defaultElement.element( "delimited-identifiers" );
globalDefaults.setDelimitedIdentifiers( unitElement != null ? Boolean.TRUE : null );
defaultEntityListeners.addAll( addEntityListenerClasses( defaultElement, null, addedClasses ) );
}
}
else {
LOG.duplicateMetadata();
}
}
//entity mapping default
Default entityMappingDefault = new Default();
Element unitElement = root.element( "package" );
String packageName = unitElement != null ? unitElement.getTextTrim() : null;
entityMappingDefault.setPackageName( packageName );
unitElement = root.element( "schema" );
entityMappingDefault.setSchema( unitElement != null ? unitElement.getTextTrim() : null );
unitElement = root.element( "catalog" );
entityMappingDefault.setCatalog( unitElement != null ? unitElement.getTextTrim() : null );
unitElement = root.element( "access" );
setAccess( unitElement, entityMappingDefault );
defaultElements.add( root );
setLocalAttributeConverterDefinitions( root.elements( "converter" ) );
List<Element> entities = root.elements( "entity" );
addClass( entities, packageName, entityMappingDefault, addedClasses );
entities = root.elements( "mapped-superclass" );
addClass( entities, packageName, entityMappingDefault, addedClasses );
entities = root.elements( "embeddable" );
addClass( entities, packageName, entityMappingDefault, addedClasses );
return addedClasses;
}
private void setAccess(Element unitElement, Default defaultType) {
if ( unitElement != null ) {
String access = unitElement.getTextTrim();
setAccess( access, defaultType );
}
}
private void setAccess( String access, Default defaultType) {
AccessType type;
if ( access != null ) {
try {
type = AccessType.valueOf( access );
}
catch ( IllegalArgumentException e ) {
throw new AnnotationException( "Invalid access type: " + access + " (check your xml configuration)" );
}
defaultType.setAccess( type );
}
}
private void addClass(List<Element> entities, String packageName, Default defaults, List<String> addedClasses) {
for (Element element : entities) {
String className = buildSafeClassName( element.attributeValue( "class" ), packageName );
if ( classOverriding.containsKey( className ) ) {
//maybe switch it to warn?
throw new IllegalStateException( "Duplicate XML entry for " + className );
}
addedClasses.add( className );
classOverriding.put( className, element );
Default localDefault = new Default();
localDefault.override( defaults );
String metadataCompleteString = element.attributeValue( "metadata-complete" );
if ( metadataCompleteString != null ) {
localDefault.setMetadataComplete( Boolean.parseBoolean( metadataCompleteString ) );
}
String access = element.attributeValue( "access" );
setAccess( access, localDefault );
defaultsOverriding.put( className, localDefault );
LOG.debugf( "Adding XML overriding information for %s", className );
addEntityListenerClasses( element, packageName, addedClasses );
}
}
private List<String> addEntityListenerClasses(Element element, String packageName, List<String> addedClasses) {
List<String> localAddedClasses = new ArrayList<>();
Element listeners = element.element( "entity-listeners" );
if ( listeners != null ) {
@SuppressWarnings( "unchecked" )
List<Element> elements = listeners.elements( "entity-listener" );
for (Element listener : elements) {
String listenerClassName = buildSafeClassName( listener.attributeValue( "class" ), packageName );
if ( classOverriding.containsKey( listenerClassName ) ) {
//maybe switch it to warn?
if ( "entity-listener".equals( classOverriding.get( listenerClassName ).getName() ) ) {
LOG.duplicateListener( listenerClassName );
continue;
}
throw new IllegalStateException("Duplicate XML entry for " + listenerClassName);
}
localAddedClasses.add( listenerClassName );
classOverriding.put( listenerClassName, listener );
}
}
LOG.debugf( "Adding XML overriding information for listeners: %s", localAddedClasses );
addedClasses.addAll( localAddedClasses );
return localAddedClasses;
}
@SuppressWarnings("unchecked")
private void setLocalAttributeConverterDefinitions(List<Element> converterElements) {
for ( Element converterElement : converterElements ) {
final String className = converterElement.attributeValue( "class" );
final String autoApplyAttribute = converterElement.attributeValue( "auto-apply" );
final boolean autoApply = Boolean.parseBoolean( autoApplyAttribute );
try {
final Class<? extends AttributeConverter> attributeConverterClass = classLoaderAccess.classForName(
className
);
attributeConverterInfoList.add(
new AttributeConverterDefinition( attributeConverterClass.newInstance(), autoApply )
);
}
catch (ClassLoadingException e) {
throw new AnnotationException( "Unable to locate specified AttributeConverter implementation class : " + className, e );
}
catch (Exception e) {
throw new AnnotationException( "Unable to instantiate specified AttributeConverter implementation class : " + className, e );
}
}
}
public static String buildSafeClassName(String className, String defaultPackageName) {
if ( className.indexOf( '.' ) < 0 && StringHelper.isNotEmpty( defaultPackageName ) ) {
className = StringHelper.qualify( defaultPackageName, className );
}
return className;
}
public static String buildSafeClassName(String className, Default defaults) {
return buildSafeClassName( className, defaults.getPackageName() );
}
public Default getDefault(String className) {
Default xmlDefault = new Default();
xmlDefault.override( globalDefaults );
if ( className != null ) {
Default entityMappingOverriding = defaultsOverriding.get( className );
xmlDefault.override( entityMappingOverriding );
}
return xmlDefault;
}
public Element getXMLTree(String className ) {
return classOverriding.get( className );
}
public List<Element> getAllDocuments() {
return defaultElements;
}
public boolean hasContext() {
return hasContext;
}
private List<AttributeConverterInfo> attributeConverterInfoList = new ArrayList<>();
public void applyDiscoveredAttributeConverters(AttributeConverterDefinitionCollector collector) {
for ( AttributeConverterInfo info : attributeConverterInfoList ) {
collector.addAttributeConverter( info );
}
attributeConverterInfoList.clear();
}
public static class Default implements Serializable {
private AccessType access;
private String packageName;
private String schema;
private String catalog;
private Boolean metadataComplete;
private Boolean cascadePersist;
private Boolean delimitedIdentifier;
public AccessType getAccess() {
return access;
}
protected void setAccess(AccessType access) {
this.access = access;
}
public String getCatalog() {
return catalog;
}
protected void setCatalog(String catalog) {
this.catalog = catalog;
}
public String getPackageName() {
return packageName;
}
protected void setPackageName(String packageName) {
this.packageName = packageName;
}
public String getSchema() {
return schema;
}
protected void setSchema(String schema) {
this.schema = schema;
}
public Boolean getMetadataComplete() {
return metadataComplete;
}
public boolean canUseJavaAnnotations() {
return metadataComplete == null || !metadataComplete;
}
protected void setMetadataComplete(Boolean metadataComplete) {
this.metadataComplete = metadataComplete;
}
public Boolean getCascadePersist() {
return cascadePersist;
}
void setCascadePersist(Boolean cascadePersist) {
this.cascadePersist = cascadePersist;
}
public void override(Default globalDefault) {
if ( globalDefault != null ) {
if ( globalDefault.getAccess() != null ) {
access = globalDefault.getAccess();
}
if ( globalDefault.getPackageName() != null ) {
packageName = globalDefault.getPackageName();
}
if ( globalDefault.getSchema() != null ) {
schema = globalDefault.getSchema();
}
if ( globalDefault.getCatalog() != null ) {
catalog = globalDefault.getCatalog();
}
if ( globalDefault.getDelimitedIdentifier() != null ) {
delimitedIdentifier = globalDefault.getDelimitedIdentifier();
}
if ( globalDefault.getMetadataComplete() != null ) {
metadataComplete = globalDefault.getMetadataComplete();
}
//TODO fix that in stone if cascade-persist is set already?
if ( globalDefault.getCascadePersist() != null ) cascadePersist = globalDefault.getCascadePersist();
}
}
public void setDelimitedIdentifiers(Boolean delimitedIdentifier) {
this.delimitedIdentifier = delimitedIdentifier;
}
public Boolean getDelimitedIdentifier() {
return delimitedIdentifier;
}
}
public List<String> getDefaultEntityListeners() {
return defaultEntityListeners;
}
}

2
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/internal/JPAXMLOverriddenAnnotationReader.java
View File

@ -2063,7 +2063,7 @@ public class JPAXMLOverriddenAnnotationReader implements AnnotationReader {
bindNamedAttributeNodes( element.getNamedAttributeNode(), ann );
bindNamedSubgraph( defaults, ann, "subgraphs", element.getSubgraph(), classLoaderAccess );
bindNamedSubgraph( defaults, ann, "subclass-subgraph", element.getSubclassSubgraph(), classLoaderAccess );
bindNamedSubgraph( defaults, ann, "subclassSubgraphs", element.getSubclassSubgraph(), classLoaderAccess );
namedEntityGraphList.add( AnnotationFactory.create( ann ) );
}
//TODO

7
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/internal/JPAXMLOverriddenMetadataProvider.java
View File

@ -26,7 +26,6 @@ import org.hibernate.annotations.common.reflection.java.JavaMetadataProvider;
import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
import org.hibernate.boot.jaxb.mapping.spi.JaxbSequenceGenerator;
import org.hibernate.boot.jaxb.mapping.spi.JaxbTableGenerator;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.registry.classloading.spi.ClassLoadingException;
import org.hibernate.boot.spi.BootstrapContext;
import org.hibernate.boot.spi.ClassLoaderAccess;
@ -48,7 +47,7 @@ public final class JPAXMLOverriddenMetadataProvider implements MetadataProvider
* We allow fully disabling XML sources so to improve the efficiency of
* the boot process for those not using it.
*/
private final XmlMappingOptions xmlMappingOptions;
private final boolean xmlMappingEnabled;
private Map<Object, Object> defaults;
private Map<AnnotatedElement, AnnotationReader> cache;
@ -56,7 +55,7 @@ public final class JPAXMLOverriddenMetadataProvider implements MetadataProvider
public JPAXMLOverriddenMetadataProvider(BootstrapContext bootstrapContext) {
this.classLoaderAccess = bootstrapContext.getClassLoaderAccess();
this.xmlContext = new XMLContext( classLoaderAccess );
this.xmlMappingOptions = bootstrapContext.getMetadataBuildingOptions().getXmlMappingOptions();
this.xmlMappingEnabled = bootstrapContext.getMetadataBuildingOptions().isXmlMappingEnabled();
}
//all of the above can be safely rebuilt from XMLContext: only XMLContext this object is serialized
@ -89,7 +88,7 @@ public final class JPAXMLOverriddenMetadataProvider implements MetadataProvider
@Override
public Map<Object, Object> getDefaults() {
if ( !xmlMappingOptions.isEnabled() ) {
if ( !xmlMappingEnabled ) {
return Collections.emptyMap();
}
else {

17
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/internal/XMLContext.java
View File

@ -54,7 +54,7 @@ public class XMLContext implements Serializable {
private boolean hasContext = false;
/**
* @deprecated Use {@link org.hibernate.cfg.annotations.reflection.XMLContext#XMLContext(BootstrapContext)} instead.
* @deprecated Use {@link #XMLContext(BootstrapContext)} instead.
*/
@Deprecated
public XMLContext(ClassLoaderAccess classLoaderAccess) {
@ -127,11 +127,16 @@ public class XMLContext implements Serializable {
}
addedClasses.add( className );
managedTypeOverride.put( className, element );
Default localDefault = new Default();
localDefault.override( defaults );
localDefault.setMetadataComplete( element.isMetadataComplete() );
localDefault.setAccess( element.getAccess() );
defaultsOverride.put( className, localDefault );
Default mergedDefaults = new Default();
// Apply entity mapping defaults
mergedDefaults.override( defaults );
// ... then apply entity settings
Default fileDefaults = new Default();
fileDefaults.setMetadataComplete( element.isMetadataComplete() );
fileDefaults.setAccess( element.getAccess() );
mergedDefaults.override( fileDefaults );
// ... and we get the merged defaults for that entity
defaultsOverride.put( className, mergedDefaults );
LOG.debugf( "Adding XML overriding information for %s", className );
if ( element instanceof JaxbEntity ) {

7
hibernate-core/src/main/java/org/hibernate/event/internal/DefaultFlushEntityEventListener.java
View File

@ -133,7 +133,8 @@ public class DefaultFlushEntityEventListener implements FlushEntityEventListener
event.setPropertyValues( values );
//TODO: avoid this for non-new instances where mightBeDirty==false
boolean substitute = wrapCollections( session, persister, types, values );
boolean substitute = wrapCollections( session, persister, entity, entry.getId(), types, values );
if ( isUpdateNecessary( event, mightBeDirty ) ) {
substitute = scheduleUpdate( event ) || substitute;
@ -181,6 +182,8 @@ public class DefaultFlushEntityEventListener implements FlushEntityEventListener
private boolean wrapCollections(
EventSource session,
EntityPersister persister,
Object entity,
Object id,
Type[] types,
Object[] values
) {
@ -194,7 +197,7 @@ public class DefaultFlushEntityEventListener implements FlushEntityEventListener
// don't dirty the container. Also, for versioned data, we
// need to wrap before calling searchForDirtyCollections
WrapVisitor visitor = new WrapVisitor( session );
WrapVisitor visitor = new WrapVisitor( entity, id ,session );
// substitutes into values by side-effect
visitor.processEntityPropertyValues( values, types );
return visitor.isSubstitutionRequired();

5
hibernate-core/src/main/java/org/hibernate/event/internal/FlushVisitor.java
View File

@ -43,9 +43,12 @@ public class FlushVisitor extends AbstractVisitor {
else if ( collection == LazyPropertyInitializer.UNFETCHED_PROPERTY ) {
coll = (PersistentCollection) type.resolve( collection, session, owner );
}
else {
else if ( collection instanceof PersistentCollection ) {
coll = (PersistentCollection) collection;
}
else {
return null;
}
Collections.processReachableCollection( coll, type, owner, session);
}

21
hibernate-core/src/main/java/org/hibernate/event/internal/WrapVisitor.java
View File

@ -9,8 +9,11 @@ package org.hibernate.event.internal;
import org.hibernate.EntityMode;
import org.hibernate.HibernateException;
import org.hibernate.bytecode.enhance.spi.LazyPropertyInitializer;
import org.hibernate.bytecode.enhance.spi.interceptor.EnhancementAsProxyLazinessInterceptor;
import org.hibernate.collection.spi.PersistentCollection;
import org.hibernate.engine.spi.PersistenceContext;
import org.hibernate.engine.spi.PersistentAttributeInterceptable;
import org.hibernate.engine.spi.PersistentAttributeInterceptor;
import org.hibernate.engine.spi.SessionImplementor;
import org.hibernate.event.spi.EventSource;
import org.hibernate.internal.CoreLogging;
@ -29,8 +32,8 @@ import org.hibernate.type.Type;
@SuppressWarnings("WeakerAccess")
public class WrapVisitor extends ProxyVisitor {
private static final CoreMessageLogger LOG = CoreLogging.messageLogger( WrapVisitor.class );
private Object entity;
private Object id;
protected Object entity;
protected Object id;
private boolean substitute;
@ -103,8 +106,17 @@ public class WrapVisitor extends ProxyVisitor {
return null;
}
else {
if ( entity instanceof PersistentAttributeInterceptable ) {
final PersistentAttributeInterceptor interceptor = ( (PersistentAttributeInterceptable) entity ).$$_hibernate_getInterceptor();
if ( interceptor instanceof EnhancementAsProxyLazinessInterceptor ) {
if ( !( (EnhancementAsProxyLazinessInterceptor) interceptor ).isInitialized() ) {
return null;
}
}
}
final PersistentCollection persistentCollection = collectionType.wrap( session, collection );
PersistentCollection persistentCollection = collectionType.wrap( session, collection );
persistenceContext.addNewCollection( persister, persistentCollection );
if ( LOG.isTraceEnabled() ) {
@ -112,11 +124,8 @@ public class WrapVisitor extends ProxyVisitor {
}
return persistentCollection; //Force a substitution!
}
}
}
@Override

3
hibernate-core/src/main/java/org/hibernate/internal/log/DeprecationLogger.java
View File

@ -53,7 +53,8 @@ public interface DeprecationLogger extends BasicLogger {
public void logDeprecationOfMultipleEntityModeSupport();
/**
* Log message indicating the use of DOM4J EntityMode.
* Log message indicating the use of features that were only useful for DOM4J EntityMode,
* which was removed a long time ago.
*/
@LogMessage( level = WARN )
@Message(

4
hibernate-core/src/main/java/org/hibernate/tuple/Tuplizer.java
View File

@ -27,10 +27,6 @@ import org.hibernate.property.access.spi.Getter;
* <li>extract and inject values through getters/setter, or by direct field access, etc
* </ul>
* </p>
* That same piece of data might also be represented as a DOM structure, using
* the tuplizer associated with the DOM4J entity-mode, which would generate instances
* of {@link org.dom4j.Element} as the data structure and know how to access the
* values as either nested {@link org.dom4j.Element}s or as {@link org.dom4j.Attribute}s.
*
* @see org.hibernate.tuple.entity.EntityTuplizer
* @see org.hibernate.tuple.component.ComponentTuplizer

1
hibernate-core/src/main/java/org/hibernate/type/CollectionType.java
View File

@ -571,7 +571,6 @@ public abstract class CollectionType extends AbstractType implements Association
Object owner,
Map copyCache,
SharedSessionContractImplementor session) {
// TODO: does not work for EntityMode.DOM4J yet!
java.util.Collection result = ( java.util.Collection ) target;
result.clear();

78
hibernate-core/src/test/java/org/hibernate/internal/util/xml/XMLHelper.java
View File

@ -1,78 +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.internal.util.xml;
import java.security.AccessController;
import java.security.PrivilegedAction;
import org.dom4j.DocumentFactory;
import org.dom4j.io.SAXReader;
import org.xml.sax.EntityResolver;
/**
* Small helper class that lazily loads DOM and SAX reader and keep them for fast use afterwards.
*
* This was part of Hibernate ORM core, but moved into the testsuite helpers to not expose
* access to the dom4j types. It's also used by Hibernate Envers, so we will need two copies
* until Envers is able to remove its reliance on dom4j.
* The rest of Hibernate uses StAX now for XML processing. See {@link org.hibernate.boot.jaxb.internal.stax}
*/
public final class XMLHelper {
private final DocumentFactory documentFactory;
public XMLHelper() {
PrivilegedAction<DocumentFactory> action = new PrivilegedAction<DocumentFactory>() {
public DocumentFactory run() {
final ClassLoader originalTccl = Thread.currentThread().getContextClassLoader();
try {
// We need to make sure we get DocumentFactory
// loaded from the same ClassLoader that loads
// Hibernate classes, to make sure we get the
// proper version of DocumentFactory, This class
// is "internal", and should only be used for XML
// files generated by Envers.
// Using the (Hibernate) ClassLoader that loads
// this Class will avoid collisions in the case
// that DocumentFactory can be loaded from,
// for example, the application ClassLoader.
Thread.currentThread().setContextClassLoader( this.getClass().getClassLoader() );
return DocumentFactory.getInstance();
}
finally {
Thread.currentThread().setContextClassLoader( originalTccl );
}
}
};
this.documentFactory = System.getSecurityManager() != null
? AccessController.doPrivileged( action )
: action.run();
}
public DocumentFactory getDocumentFactory() {
return documentFactory;
}
public SAXReader createSAXReader(ErrorLogger errorLogger, EntityResolver entityResolver) {
SAXReader saxReader = new SAXReader();
try {
saxReader.setFeature( "http://apache.org/xml/features/nonvalidating/load-external-dtd", false );
saxReader.setFeature( "http://xml.org/sax/features/external-general-entities", false );
saxReader.setFeature( "http://xml.org/sax/features/external-parameter-entities", false );
}
catch (Exception e) {
throw new RuntimeException( e );
}
saxReader.setMergeAdjacentText( true );
saxReader.setValidation( true );
saxReader.setErrorHandler( errorLogger );
saxReader.setEntityResolver( entityResolver );
return saxReader;
}
}

8
hibernate-core/src/test/java/org/hibernate/internal/util/xml/XMLMappingHelper.java
View File

@ -14,10 +14,6 @@ import org.hibernate.boot.jaxb.SourceType;
import org.hibernate.boot.jaxb.internal.MappingBinder;
import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
import org.hibernate.boot.jaxb.spi.Binding;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.registry.BootstrapServiceRegistry;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.service.spi.ServiceRegistryImplementor;
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
import org.junit.Assert;
@ -28,8 +24,8 @@ import org.junit.Assert;
public final class XMLMappingHelper {
private final MappingBinder binder;
public XMLMappingHelper(XmlMappingOptions xmlMappingOptions) {
binder = new MappingBinder( ClassLoaderServiceTestingImpl.INSTANCE, true, xmlMappingOptions );
public XMLMappingHelper() {
binder = new MappingBinder( ClassLoaderServiceTestingImpl.INSTANCE, true );
}
public JaxbEntityMappings readOrmXmlMappings(String name) throws IOException {

66
hibernate-core/src/test/java/org/hibernate/internal/util/xml/XmlMappingOptionsStrategyRegistrationProvider.java
View File

@ -1,66 +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.internal.util.xml;
import java.util.Collections;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.boot.registry.selector.SimpleStrategyRegistrationImpl;
import org.hibernate.boot.registry.selector.StrategyRegistration;
import org.hibernate.boot.registry.selector.StrategyRegistrationProvider;
import org.jboss.logging.Logger;
/**
* A strategy registration provider that allows running the whole test suite with different XML mapping options.
* <p>
* By default, this provider does nothing.
* In some CI jobs, we set the system property {@value STRATEGY_PROPERTY_KEY}
* to re-run the whole test suite using JAXB for orm.xml parsing instead of dom4j.
*/
public class XmlMappingOptionsStrategyRegistrationProvider implements StrategyRegistrationProvider {
protected final Logger log = Logger.getLogger( getClass() );
private static final String STRATEGY_PROPERTY_KEY = "testing.mapping.xml.strategy";
public static void applyJaxbStrategy(BootstrapServiceRegistryBuilder builder) {
builder.applyStrategySelector( XmlMappingOptions.class, XmlMappingOptions.DEFAULT_NAME,
PreferJaxbXmlMappingOptions.class
);
}
@Override
public Iterable<StrategyRegistration> getStrategyRegistrations() {
switch ( getStrategyFromSystemProperties() ) {
case "jaxb":
log.warn( "Overriding the default configuration because of a test system property:"
+ " will favor jaxb when parsing XML mapping." );
return Collections.singleton(
new SimpleStrategyRegistrationImpl<>( XmlMappingOptions.class,
PreferJaxbXmlMappingOptions.class,
XmlMappingOptions.DEFAULT_NAME )
);
case "default":
default:
return Collections.emptyList();
}
}
private static String getStrategyFromSystemProperties() {
String strategy = System.getProperty( STRATEGY_PROPERTY_KEY );
return strategy == null || strategy.isEmpty() ? "default" : strategy;
}
public static class PreferJaxbXmlMappingOptions implements XmlMappingOptions {
@Override
public boolean isPreferJaxb() {
return true;
}
}
}

6
hibernate-core/src/test/java/org/hibernate/orm/test/entitygraph/named/subgraph/orm.xml
View File

@ -35,12 +35,12 @@
<id name="id"/>
<basic name="isbn"/>
<basic name="title"/>
<many-to-many name="authors">
<join-table name="book_author"/>
</many-to-many>
<one-to-many name="prizes">
<join-table name="book_prize"/>
</one-to-many>
<many-to-many name="authors">
<join-table name="book_author"/>
</many-to-many>
</attributes>
</entity>

17
hibernate-core/src/test/java/org/hibernate/orm/test/filter/DynamicFilterTest.java
View File

@ -39,6 +39,7 @@ import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
@ -251,6 +252,22 @@ public class DynamicFilterTest extends BaseNonConfigCoreFunctionalTestCase {
);
}
@Test
@TestForIssue(jiraKey = "HHH-14567")
public void testHqlFiltersAppliedAfterQueryCreation() {
inTransaction( session -> {
Query<Salesperson> query = session.createQuery(
"select s from Salesperson s",
Salesperson.class
);
List<Salesperson> list = query.list();
assertThat( list ).hasSize( 2 );
session.enableFilter( "region" ).setParameter( "region", "APAC" );
assertThat( query.list() ).hasSize( 1 );
} );
}
@Test
public void testFiltersWithCustomerReadAndWrite() {
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

7
hibernate-core/src/test/java/org/hibernate/orm/test/filter/Salesperson.java
View File

@ -24,6 +24,13 @@ public class Salesperson {
private Department department;
private Set orders = new HashSet();
@Override
public String toString() {
return "Salesperson#" + id + "{"
+ ", name='" + name + '\'' +
'}';
}
public Long getId() {
return id;
}

2
hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/ElementCollectionConverterTest.java
View File

@ -7,7 +7,6 @@
package org.hibernate.test.annotations.reflection;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
@ -22,7 +21,6 @@ public class ElementCollectionConverterTest extends BaseCoreFunctionalTestCase {
@Override
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
super.prepareBootstrapRegistryBuilder( builder );
XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
}
@Override

27
hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/JPAXMLOverriddenAnnotationReaderTest.java
View File

@ -6,45 +6,25 @@
*/
package org.hibernate.test.annotations.reflection;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import org.hibernate.annotations.Columns;
import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.cfg.EJB3DTDEntityResolver;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader;
import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
import org.hibernate.internal.util.xml.ErrorLogger;
import org.hibernate.internal.util.xml.XMLHelper;
import org.hibernate.internal.util.xml.XMLMappingHelper;
import org.hibernate.testing.boot.BootstrapContextImpl;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
import org.junit.Test;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotSupportedException;
import javax.persistence.*;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import static org.junit.Assert.*;
/**
* Tests the new {@link JPAXMLOverriddenAnnotationReader},
* which will be replacing {@link JPAOverriddenAnnotationReader}.
* {@link JPAOverriddenAnnotationReader} is still the default implementation,
* but we want to switch to {@link JPAXMLOverriddenAnnotationReader}
* as soon as it will be practical.
*
* @see LegacyJPAOverriddenAnnotationReaderTest
* @author Emmanuel Bernard
*/
@TestForIssue(jiraKey = "HHH-14529")
@ -405,12 +385,7 @@ public class JPAXMLOverriddenAnnotationReaderTest extends BaseUnitTestCase {
}
private XMLContext buildContext(String ormfile) throws IOException {
XMLMappingHelper xmlHelper = new XMLMappingHelper( new XmlMappingOptions() {
@Override
public boolean isPreferJaxb() {
return true;
}
} );
XMLMappingHelper xmlHelper = new XMLMappingHelper();
JaxbEntityMappings mappings = xmlHelper.readOrmXmlMappings( ormfile );
XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
context.addDocument( mappings );

71
hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/LegacyElementCollectionConverterTest.java
View File

@ -1,71 +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.test.annotations.reflection;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Test;
import static org.hibernate.testing.transaction.TransactionUtil.doInHibernate;
import static org.junit.Assert.assertEquals;
/**
* Tests the legacy {@link JPAOverriddenAnnotationReader},
* which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}.
* {@link JPAOverriddenAnnotationReader} is still the default implementation,
* but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}
* as soon as it will be practical.
*
* @see JPAXMLOverriddenAnnotationReaderTest
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
@TestForIssue( jiraKey = "HHH-11924")
public class LegacyElementCollectionConverterTest extends BaseCoreFunctionalTestCase {
@Override
protected Class[] getAnnotatedClasses() {
return new Class[] {
Company.class,
};
}
@Override
protected String[] getOrmXmlFiles() {
return new String[] { "org/hibernate/test/annotations/reflection/element-collection-converter-orm.xml" };
}
@Test
public void testConverterIsAppliedToElementCollection() {
doInHibernate( this::sessionFactory, session -> {
Company company = new Company();
company.setId( 1L );
Organization org1 = new Organization();
org1.setOrganizationId( "ACME" );
company.getOrganizations().add( org1 );
session.persist( company );
} );
doInHibernate( this::sessionFactory, session -> {
String organizationId = (String) session
.createNativeQuery( "select organizations from Company_organizations" )
.getSingleResult();
assertEquals( "ORG-ACME", organizationId );
Company company = session.find( Company.class, 1L );
assertEquals( 1, company.getOrganizations().size() );
assertEquals( "ACME" , company.getOrganizations().get( 0 ).getOrganizationId());
} );
}
}

485
hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/LegacyJPAOverriddenAnnotationReaderTest.java
View File

@ -1,485 +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.test.annotations.reflection;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import javax.persistence.AssociationOverrides;
import javax.persistence.AttributeOverrides;
import javax.persistence.Basic;
import javax.persistence.Column;
import javax.persistence.Converts;
import javax.persistence.DiscriminatorColumn;
import javax.persistence.DiscriminatorValue;
import javax.persistence.ElementCollection;
import javax.persistence.Embedded;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.EntityListeners;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.ExcludeDefaultListeners;
import javax.persistence.ExcludeSuperclassListeners;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.Lob;
import javax.persistence.ManyToMany;
import javax.persistence.MapKey;
import javax.persistence.MappedSuperclass;
import javax.persistence.NamedNativeQueries;
import javax.persistence.NamedQueries;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import javax.persistence.OrderBy;
import javax.persistence.PostLoad;
import javax.persistence.PostPersist;
import javax.persistence.PrePersist;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.PrimaryKeyJoinColumns;
import javax.persistence.SecondaryTable;
import javax.persistence.SecondaryTables;
import javax.persistence.SequenceGenerator;
import javax.persistence.SqlResultSetMappings;
import javax.persistence.Table;
import javax.persistence.TableGenerator;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;
import javax.persistence.Version;
import org.hibernate.annotations.Columns;
import org.hibernate.cfg.EJB3DTDEntityResolver;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.cfg.annotations.reflection.XMLContext;
import org.hibernate.internal.util.xml.ErrorLogger;
import org.hibernate.internal.util.xml.XMLHelper;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.boot.BootstrapContextImpl;
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.junit.Test;
import org.dom4j.DocumentException;
import org.dom4j.io.SAXReader;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotSupportedException;
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;
/**
* Tests the legacy {@link JPAOverriddenAnnotationReader},
* which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}.
* {@link JPAOverriddenAnnotationReader} is still the default implementation,
* but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader}
* as soon as it will be practical.
*
* @see JPAXMLOverriddenAnnotationReaderTest
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
public class LegacyJPAOverriddenAnnotationReaderTest extends BaseUnitTestCase {
@Test
public void testMappedSuperclassAnnotations() throws Exception {
XMLContext context = buildContext(
"org/hibernate/test/annotations/reflection/metadata-complete.xml"
);
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( Organization.class, context, BootstrapContextImpl.INSTANCE );
assertTrue( reader.isAnnotationPresent( MappedSuperclass.class ) );
}
@Test
public void testEntityRelatedAnnotations() throws Exception {
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
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() );
assertEquals( "Default schema not overridden", "myschema", 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() );
assertEquals( "no schema overriding", "myschema", reader.getAnnotation( TableGenerator.class ).schema() );
reader = new JPAOverriddenAnnotationReader( Match.class, context, BootstrapContextImpl.INSTANCE );
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()
);
assertEquals( "Overriding not taken into account", "mycatalog", reader.getAnnotation( Table.class ).catalog() );
assertNotNull( "SecondaryTable swallowed", reader.getAnnotation( SecondaryTables.class ) );
assertEquals(
"Default schema not taken into account", "myschema",
reader.getAnnotation( SecondaryTables.class ).value()[0].schema()
);
assertNotNull( reader.getAnnotation( Inheritance.class ) );
assertEquals(
"inheritance strategy not overriden", InheritanceType.JOINED,
reader.getAnnotation( Inheritance.class ).strategy()
);
assertNotNull( "NamedQuery not overriden", 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 overriden", 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 JPAOverriddenAnnotationReader( Competition.class, context, BootstrapContextImpl.INSTANCE );
assertNotNull( reader.getAnnotation( MappedSuperclass.class ) );
reader = new JPAOverriddenAnnotationReader( TennisMatch.class, context, BootstrapContextImpl.INSTANCE );
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 JPAOverriddenAnnotationReader( SocialSecurityPhysicalAccount.class, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/metadata-complete.xml"
);
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
assertNotNull( reader.getAnnotation( Entity.class ) );
assertEquals(
"Metadata complete should ignore java annotations", "", reader.getAnnotation( Entity.class ).name()
);
assertNotNull( reader.getAnnotation( Table.class ) );
assertEquals( "@Table should not be used", "", reader.getAnnotation( Table.class ).name() );
assertEquals( "Default schema not overriden", "myschema", reader.getAnnotation( Table.class ).schema() );
reader = new JPAOverriddenAnnotationReader( Match.class, context, BootstrapContextImpl.INSTANCE );
assertNotNull( reader.getAnnotation( Table.class ) );
assertEquals( "@Table should not be used", "", reader.getAnnotation( Table.class ).name() );
assertEquals( "Overriding not taken into account", "myschema", reader.getAnnotation( Table.class ).schema() );
assertEquals( "Overriding not taken into account", "mycatalog", reader.getAnnotation( Table.class ).catalog() );
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 JPAOverriddenAnnotationReader( TennisMatch.class, context, BootstrapContextImpl.INSTANCE );
assertNull( reader.getAnnotation( PrimaryKeyJoinColumn.class ) );
assertNull( reader.getAnnotation( PrimaryKeyJoinColumns.class ) );
reader = new JPAOverriddenAnnotationReader( Competition.class, context, BootstrapContextImpl.INSTANCE );
assertNull( reader.getAnnotation( MappedSuperclass.class ) );
reader = new JPAOverriddenAnnotationReader( SocialSecurityMoralAccount.class, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/orm.xml" );
Method method = Administration.class.getDeclaredMethod( "getId" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
assertNull( reader.getAnnotation( Id.class ) );
assertNull( reader.getAnnotation( Column.class ) );
Field field = Administration.class.getDeclaredField( "id" );
reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/metadata-complete.xml"
);
method = Administration.class.getDeclaredMethod( "getId" );
reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
assertNotNull(
"Default access type when not defined in metadata complete should be property",
reader.getAnnotation( Id.class )
);
field = Administration.class.getDeclaredField( "id" );
reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
assertNull(
"Default access type when not defined in metadata complete should be property",
reader.getAnnotation( Id.class )
);
method = BusTrip.class.getDeclaredMethod( "getId" );
reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
assertNull( reader.getAnnotation( EmbeddedId.class ) );
field = BusTrip.class.getDeclaredField( "id" );
reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/metadata-complete.xml"
);
Field field = BusTrip.class.getDeclaredField( "status" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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 JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
assertNotNull( reader.getAnnotation( Lob.class ) );
assertEquals( "serialbytes", reader.getAnnotation( Columns.class ).columns()[0].name() );
field = BusTrip.class.getDeclaredField( "terminusTime" );
reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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 JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
assertNotNull( reader.isAnnotationPresent( Basic.class ) );
}
@Test
public void testVersionRelatedAnnotations() throws Exception {
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
Method method = Administration.class.getDeclaredMethod( "getVersion" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/orm.xml" );
Field field = Administration.class.getDeclaredField( "transientField" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
assertNotNull( reader.getAnnotation( Transient.class ) );
assertNull( reader.getAnnotation( Basic.class ) );
field = Match.class.getDeclaredField( "playerASSN" );
reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
assertNotNull( reader.getAnnotation( Embedded.class ) );
}
@Test
public void testAssociationRelatedAnnotations() throws Exception {
XMLContext context = buildContext( "org/hibernate/test/annotations/reflection/orm.xml" );
Field field = Administration.class.getDeclaredField( "defaultBusTrip" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/metadata-complete.xml"
);
field = BusTrip.class.getDeclaredField( "players" );
reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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 JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/orm.xml" );
Field field = Company.class.getDeclaredField( "organizations" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( field, context, BootstrapContextImpl.INSTANCE );
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/test/annotations/reflection/orm.xml" );
Method method = Administration.class.getDeclaredMethod( "calculate" );
JPAOverriddenAnnotationReader reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
assertTrue( reader.isAnnotationPresent( PrePersist.class ) );
reader = new JPAOverriddenAnnotationReader( Administration.class, context, BootstrapContextImpl.INSTANCE );
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 JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
assertTrue( reader.isAnnotationPresent( PostLoad.class ) );
method = LogListener.class.getDeclaredMethod( "log", Object.class );
reader = new JPAOverriddenAnnotationReader( method, context, BootstrapContextImpl.INSTANCE );
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 SAXException, DocumentException, IOException {
XMLHelper xmlHelper = new XMLHelper();
InputStream is = ClassLoaderServiceTestingImpl.INSTANCE.locateResourceStream( ormfile );
assertNotNull( "ORM.xml not found: " + ormfile, is );
XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
ErrorLogger errorLogger = new ErrorLogger();
SAXReader saxReader = xmlHelper.createSAXReader( errorLogger, EJB3DTDEntityResolver.INSTANCE );
//saxReader.setValidation( false );
try {
saxReader.setFeature( "http://apache.org/xml/features/validation/schema", true );
}
catch ( SAXNotSupportedException e ) {
saxReader.setValidation( false );
}
org.dom4j.Document doc;
try {
doc = saxReader.read( new InputSource( new BufferedInputStream( is ) ) );
}
finally {
is.close();
}
if ( errorLogger.hasErrors() ) {
System.out.println( errorLogger.getErrors().get( 0 ) );
}
assertFalse( errorLogger.hasErrors() );
context.addDocument( doc );
return context;
}
}

73
hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/LegacyXMLContextTest.java
View File

@ -1,73 +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.test.annotations.reflection;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import org.hibernate.cfg.EJB3DTDEntityResolver;
import org.hibernate.cfg.annotations.reflection.XMLContext;
import org.hibernate.internal.util.xml.ErrorLogger;
import org.hibernate.internal.util.xml.XMLHelper;
import org.hibernate.testing.boot.BootstrapContextImpl;
import org.hibernate.testing.boot.ClassLoaderServiceTestingImpl;
import org.junit.Assert;
import org.junit.Test;
import org.dom4j.io.SAXReader;
import org.xml.sax.InputSource;
import org.xml.sax.SAXNotSupportedException;
/**
* Tests the legacy {@link XMLContext},
* which will be replaced with {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext}.
* {@link XMLContext} is still the default implementation,
* but we want to switch to {@link org.hibernate.cfg.annotations.reflection.internal.XMLContext}
* as soon as it will be practical.
*
* @see XMLContextTest
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link XMLContext}.
*/
public class LegacyXMLContextTest {
@Test
public void testAll() throws Exception {
final XMLHelper xmlHelper = new XMLHelper();
final XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
InputStream is = ClassLoaderServiceTestingImpl.INSTANCE.locateResourceStream(
"org/hibernate/test/annotations/reflection/orm.xml"
);
Assert.assertNotNull( "ORM.xml not found", is );
final ErrorLogger errorLogger = new ErrorLogger();
final SAXReader saxReader = xmlHelper.createSAXReader( errorLogger, EJB3DTDEntityResolver.INSTANCE );
try {
saxReader.setFeature( "http://apache.org/xml/features/validation/schema", true );
}
catch ( SAXNotSupportedException e ) {
saxReader.setValidation( false );
}
org.dom4j.Document doc;
try {
doc = saxReader.read( new InputSource( new BufferedInputStream( is ) ) );
}
finally {
try {
is.close();
}
catch ( IOException ioe ) {
//log.warn( "Could not close input stream", ioe );
}
}
Assert.assertFalse( errorLogger.hasErrors() );
context.addDocument( doc );
}
}

14
hibernate-core/src/test/java/org/hibernate/test/annotations/reflection/XMLContextTest.java
View File

@ -7,7 +7,6 @@
package org.hibernate.test.annotations.reflection;
import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
import org.hibernate.internal.util.xml.XMLMappingHelper;
@ -16,24 +15,13 @@ import org.hibernate.testing.boot.BootstrapContextImpl;
import org.junit.Test;
/**
* Tests the new {@link XMLContext},
* which will be replacing {@link org.hibernate.cfg.annotations.reflection.XMLContext}.
* {@link org.hibernate.cfg.annotations.reflection.XMLContext} is still the default implementation,
* but we want to switch to {@link XMLContext}
* as soon as it will be practical.
*
* @author Emmanuel Bernard
*/
@TestForIssue(jiraKey = "HHH-14529")
public class XMLContextTest {
@Test
public void testAll() throws Exception {
XMLMappingHelper xmlHelper = new XMLMappingHelper( new XmlMappingOptions() {
@Override
public boolean isPreferJaxb() {
return true;
}
} );
XMLMappingHelper xmlHelper = new XMLMappingHelper();
final XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
JaxbEntityMappings mappings = xmlHelper.readOrmXmlMappings( "org/hibernate/test/annotations/reflection/orm.xml" );

2
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlTest.java
View File

@ -17,7 +17,6 @@ import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.TeradataDialect;
import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
import org.hibernate.persister.collection.BasicCollectionPersister;
import org.hibernate.testing.SkipForDialect;
@ -37,7 +36,6 @@ public class Ejb3XmlTest extends BaseCoreFunctionalTestCase {
@Override
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
super.prepareBootstrapRegistryBuilder( builder );
XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
}
@Test

8
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlTestCase.java
View File

@ -11,7 +11,6 @@ import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import org.hibernate.boot.jaxb.mapping.spi.JaxbEntityMappings;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.cfg.annotations.reflection.internal.JPAXMLOverriddenAnnotationReader;
import org.hibernate.cfg.annotations.reflection.internal.XMLContext;
import org.hibernate.internal.util.xml.XMLMappingHelper;
@ -67,12 +66,7 @@ public abstract class Ejb3XmlTestCase extends BaseUnitTestCase {
}
protected XMLContext getContext(InputStream is, String resourceName) throws Exception {
XMLMappingHelper xmlHelper = new XMLMappingHelper( new XmlMappingOptions() {
@Override
public boolean isPreferJaxb() {
return true;
}
} );
XMLMappingHelper xmlHelper = new XMLMappingHelper();
JaxbEntityMappings mappings = xmlHelper.readOrmXmlMappings( is, resourceName );
XMLContext context = new XMLContext( BootstrapContextImpl.INSTANCE );
context.addDocument( mappings );

716
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlElementCollectionTest.java
View File

@ -1,716 +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.test.annotations.xml.ejb3;
import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.AssociationOverride;
import javax.persistence.AssociationOverrides;
import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.CollectionTable;
import javax.persistence.Column;
import javax.persistence.ElementCollection;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.Lob;
import javax.persistence.MapKey;
import javax.persistence.MapKeyClass;
import javax.persistence.MapKeyColumn;
import javax.persistence.MapKeyEnumerated;
import javax.persistence.MapKeyJoinColumn;
import javax.persistence.MapKeyJoinColumns;
import javax.persistence.MapKeyTemporal;
import javax.persistence.OrderBy;
import javax.persistence.OrderColumn;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.UniqueConstraint;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlElementCollectionTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
public class LegacyEjb3XmlElementCollectionTest extends LegacyEjb3XmlTestCase {
@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()
);
}
}

508
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlManyToManyTest.java
View File

@ -1,508 +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.test.annotations.xml.ejb3;
import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.CascadeType;
import javax.persistence.EnumType;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.MapKey;
import javax.persistence.MapKeyClass;
import javax.persistence.MapKeyColumn;
import javax.persistence.MapKeyEnumerated;
import javax.persistence.MapKeyJoinColumn;
import javax.persistence.MapKeyJoinColumns;
import javax.persistence.MapKeyTemporal;
import javax.persistence.OrderBy;
import javax.persistence.OrderColumn;
import javax.persistence.TemporalType;
import javax.persistence.UniqueConstraint;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlManyToManyTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
public class LegacyEjb3XmlManyToManyTest extends LegacyEjb3XmlTestCase {
@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()
);
}
}

245
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlManyToOneTest.java
View File

@ -1,245 +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.test.annotations.xml.ejb3;
import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.CascadeType;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.ManyToOne;
import javax.persistence.MapsId;
import javax.persistence.UniqueConstraint;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlManyToOneTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
public class LegacyEjb3XmlManyToOneTest extends LegacyEjb3XmlTestCase {
@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] );
}
}

561
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlOneToManyTest.java
View File

@ -1,561 +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.test.annotations.xml.ejb3;
import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.AttributeOverride;
import javax.persistence.AttributeOverrides;
import javax.persistence.CascadeType;
import javax.persistence.EnumType;
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.MapKey;
import javax.persistence.MapKeyClass;
import javax.persistence.MapKeyColumn;
import javax.persistence.MapKeyEnumerated;
import javax.persistence.MapKeyJoinColumn;
import javax.persistence.MapKeyJoinColumns;
import javax.persistence.MapKeyTemporal;
import javax.persistence.OneToMany;
import javax.persistence.OrderBy;
import javax.persistence.OrderColumn;
import javax.persistence.TemporalType;
import javax.persistence.UniqueConstraint;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlOneToManyTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
public class LegacyEjb3XmlOneToManyTest extends LegacyEjb3XmlTestCase {
@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()
);
}
}

309
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlOneToOneTest.java
View File

@ -1,309 +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.test.annotations.xml.ejb3;
import javax.persistence.Access;
import javax.persistence.AccessType;
import javax.persistence.CascadeType;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinColumns;
import javax.persistence.JoinTable;
import javax.persistence.MapsId;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.PrimaryKeyJoinColumns;
import javax.persistence.UniqueConstraint;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlOneToOneTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
public class LegacyEjb3XmlOneToOneTest extends LegacyEjb3XmlTestCase {
@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()
);
}
}

148
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlTest.java
View File

@ -1,148 +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.test.annotations.xml.ejb3;
import java.util.Date;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.dialect.CockroachDialect;
import org.hibernate.dialect.PostgreSQL81Dialect;
import org.hibernate.dialect.PostgreSQLDialect;
import org.hibernate.dialect.TeradataDialect;
import org.hibernate.persister.collection.BasicCollectionPersister;
import org.hibernate.testing.SkipForDialect;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.junit.Test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
public class LegacyEjb3XmlTest extends BaseCoreFunctionalTestCase {
@Test
@SkipForDialect(value = {PostgreSQL81Dialect.class, PostgreSQLDialect.class, CockroachDialect.class},
comment = "postgresql jdbc driver does not implement the setQueryTimeout method")
@SkipForDialect(value = TeradataDialect.class,
jiraKey = "HHH-8190",
comment = "uses Teradata reserved word - year")
public void testEjb3Xml() throws Exception {
Session s = openSession();
Transaction tx = s.beginTransaction();
CarModel model = new CarModel();
model.setYear( new Date() );
Manufacturer manufacturer = new Manufacturer();
//s.persist( manufacturer );
model.setManufacturer( manufacturer );
manufacturer.getModels().add( model );
s.persist( model );
s.flush();
s.clear();
model.setYear( new Date() );
manufacturer = (Manufacturer) s.get( Manufacturer.class, manufacturer.getId() );
@SuppressWarnings("unchecked")
List<Model> cars = s.getNamedQuery( "allModelsPerManufacturer" )
.setParameter( "manufacturer", manufacturer )
.list();
assertEquals( 1, cars.size() );
for ( Model car : cars ) {
assertNotNull( car.getManufacturer() );
s.delete( manufacturer );
s.delete( car );
}
tx.rollback();
s.close();
}
@Test
public void testXMLEntityHandled() throws Exception {
Session s = openSession();
s.getTransaction().begin();
Lighter l = new Lighter();
l.name = "Blue";
l.power = "400F";
s.persist( l );
s.flush();
s.getTransaction().rollback();
s.close();
}
@Test
public void testXmlDefaultOverriding() throws Exception {
Session s = openSession();
Transaction tx = s.beginTransaction();
Manufacturer manufacturer = new Manufacturer();
s.persist( manufacturer );
s.flush();
s.clear();
assertEquals( 1, s.getNamedQuery( "manufacturer.findAll" ).list().size() );
tx.rollback();
s.close();
}
@Test
@SuppressWarnings("unchecked")
public void testMapXMLSupport() throws Exception {
Session s = openSession();
SessionFactory sf = s.getSessionFactory();
Transaction tx = s.beginTransaction();
// Verify that we can persist an object with a couple Map mappings
VicePresident vpSales = new VicePresident();
vpSales.name = "Dwight";
Company company = new Company();
company.conferenceRoomExtensions.put( "8932", "x1234" );
company.organization.put( "sales", vpSales );
s.persist( company );
s.flush();
s.clear();
// For the element-collection, check that the orm.xml entries are honored.
// This includes: map-key-column/column/collection-table/join-column
BasicCollectionPersister confRoomMeta = (BasicCollectionPersister) sf.getCollectionMetadata( Company.class.getName() + ".conferenceRoomExtensions" );
assertEquals( "company_id", confRoomMeta.getKeyColumnNames()[0] );
assertEquals( "phone_extension", confRoomMeta.getElementColumnNames()[0] );
assertEquals( "room_number", confRoomMeta.getIndexColumnNames()[0] );
assertEquals( "phone_extension_lookup", confRoomMeta.getTableName() );
tx.rollback();
s.close();
}
@Override
protected Class[] getAnnotatedClasses() {
return new Class[] {
CarModel.class,
Manufacturer.class,
Model.class,
Light.class
//Lighter.class xml only entuty
};
}
@Override
protected String[] getOrmXmlFiles() {
return new String[] {
"org/hibernate/test/annotations/xml/ejb3/orm.xml",
"org/hibernate/test/annotations/xml/ejb3/orm2.xml",
"org/hibernate/test/annotations/xml/ejb3/orm3.xml",
"org/hibernate/test/annotations/xml/ejb3/orm4.xml"
};
}
}

82
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyEjb3XmlTestCase.java
View File

@ -1,82 +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.test.annotations.xml.ejb3;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.cfg.annotations.reflection.XMLContext;
import org.hibernate.testing.boot.BootstrapContextImpl;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.dom4j.Document;
import org.dom4j.io.SAXReader;
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.
* <p>
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.Ejb3XmlTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@Deprecated
abstract class LegacyEjb3XmlTestCase extends BaseUnitTestCase {
protected JPAOverriddenAnnotationReader reader;
protected void assertAnnotationPresent(Class<? extends Annotation> annotationType) {
assertTrue(
"Expected annotation " + annotationType.getSimpleName() + " was not present",
reader.isAnnotationPresent( annotationType )
);
}
protected void assertAnnotationNotPresent(Class<? extends Annotation> annotationType) {
assertFalse(
"Unexpected annotation " + annotationType.getSimpleName() + " was present",
reader.isAnnotationPresent( annotationType )
);
}
protected JPAOverriddenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName)
throws Exception {
AnnotatedElement el = getAnnotatedElement( entityClass, fieldName );
XMLContext xmlContext = getContext( ormResourceName );
return new JPAOverriddenAnnotationReader( el, xmlContext, BootstrapContextImpl.INSTANCE );
}
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 );
}
protected XMLContext getContext(InputStream is) throws Exception {
XMLContext xmlContext = new XMLContext( BootstrapContextImpl.INSTANCE );
SAXReader reader = new SAXReader();
reader.setFeature( "http://apache.org/xml/features/nonvalidating/load-external-dtd", false );
reader.setFeature( "http://xml.org/sax/features/external-general-entities", false );
reader.setFeature( "http://xml.org/sax/features/external-parameter-entities", false );
Document doc = reader.read( is );
xmlContext.addDocument( doc );
return xmlContext;
}
}

42
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyNonExistentOrmVersionTest.java
View File

@ -1,42 +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.test.annotations.xml.ejb3;
import org.hibernate.InvalidMappingException;
import org.hibernate.boot.MetadataSources;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.internal.util.xml.UnsupportedOrmXsdVersionException;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import org.junit.Test;
import static org.junit.Assert.fail;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.NonExistentOrmVersionTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@TestForIssue(jiraKey = "HHH-6271")
public class LegacyNonExistentOrmVersionTest extends BaseUnitTestCase {
@Test
public void testNonExistentOrmVersion() {
try {
new MetadataSources()
.addResource( "org/hibernate/test/annotations/xml/ejb3/orm5.xml" )
.buildMetadata();
fail( "Expecting failure due to unsupported xsd version" );
}
catch ( InvalidMappingException expected ) {
}
catch ( UnsupportedOrmXsdVersionException expected ) {
}
}
}

68
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyOrmVersion1SupportedTest.java
View File

@ -1,68 +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.test.annotations.xml.ejb3;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.internal.util.xml.ErrorLogger;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.hibernate.testing.logger.LoggerInspectionRule;
import org.hibernate.testing.logger.Triggerable;
import org.junit.Rule;
import org.junit.Test;
import org.jboss.logging.Logger;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.OrmVersion1SupportedTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@TestForIssue(jiraKey = "HHH-6271")
public class LegacyOrmVersion1SupportedTest extends BaseCoreFunctionalTestCase {
@Rule
public LoggerInspectionRule logInspection = new LoggerInspectionRule(
Logger.getMessageLogger(
CoreMessageLogger.class,
ErrorLogger.class.getName()
)
);
@Test
public void testOrm1Support() {
Triggerable triggerable = logInspection.watchForLogMessages( "HHH00196" );
Session s = openSession();
Transaction tx = s.beginTransaction();
Light light = new Light();
light.name = "the light at the end of the tunnel";
s.persist( light );
s.flush();
s.clear();
assertEquals( 1, s.getNamedQuery( "find.the.light" ).list().size() );
tx.rollback();
s.close();
assertFalse( triggerable.wasTriggered() );
}
@Override
protected String[] getOrmXmlFiles() {
return new String[] { "org/hibernate/test/annotations/xml/ejb3/orm2.xml" };
}
}

58
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/LegacyPreParsedOrmXmlTest.java
View File

@ -1,58 +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.test.annotations.xml.ejb3;
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import org.hibernate.boot.jaxb.spi.Binding;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.annotations.reflection.JPAOverriddenAnnotationReader;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
import org.hibernate.test.annotations.xml.ejb3.PreParsedOrmXmlTest.NonAnnotatedEntity;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Equivalent to {@link org.hibernate.test.annotations.xml.ejb3.PreParsedOrmXmlTest}
* for the legacy {@link JPAOverriddenAnnotationReader}.
*
* @author Emmanuel Bernard
* @deprecated This test will be removed in Hibernate ORM 6, along with the legacy {@link JPAOverriddenAnnotationReader}.
*/
@TestForIssue(jiraKey = "HHH-14530")
public class LegacyPreParsedOrmXmlTest extends BaseCoreFunctionalTestCase {
@Override
protected void addMappings(Configuration configuration) {
super.addMappings( configuration );
try (InputStream xmlStream = Thread.currentThread().getContextClassLoader()
.getResourceAsStream( "org/hibernate/test/annotations/xml/ejb3/pre-parsed-orm.xml" )) {
Binding<?> parsed = configuration.getXmlMappingBinderAccess().bind( xmlStream );
configuration.addXmlMapping( parsed );
}
catch (IOException e) {
throw new UncheckedIOException( e );
}
}
@Test
public void testPreParsedOrmXml() {
// Just check that the entity can be persisted, which means the mapping file was taken into account
NonAnnotatedEntity persistedEntity = new NonAnnotatedEntity( "someName" );
inTransaction( s -> s.persist( persistedEntity ) );
inTransaction( s -> {
NonAnnotatedEntity retrievedEntity = s.find( NonAnnotatedEntity.class, persistedEntity.getId() );
assertThat( retrievedEntity ).extracting( NonAnnotatedEntity::getName )
.isEqualTo( persistedEntity.getName() );
} );
}
}

2
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/NonExistentOrmVersionTest.java
View File

@ -10,7 +10,6 @@ import org.hibernate.InvalidMappingException;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.internal.util.xml.UnsupportedOrmXsdVersionException;
import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseUnitTestCase;
@ -24,7 +23,6 @@ public class NonExistentOrmVersionTest extends BaseUnitTestCase {
public void testNonExistentOrmVersion() {
try {
BootstrapServiceRegistryBuilder builder = new BootstrapServiceRegistryBuilder();
XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
new MetadataSources( builder.build() )
.addResource( "org/hibernate/test/annotations/xml/ejb3/orm5.xml" )
.buildMetadata();

2
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/OrmVersion1SupportedTest.java
View File

@ -11,7 +11,6 @@ import org.hibernate.Transaction;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.internal.util.xml.ErrorLogger;
import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
@ -31,7 +30,6 @@ public class OrmVersion1SupportedTest extends BaseCoreFunctionalTestCase {
@Override
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
super.prepareBootstrapRegistryBuilder( builder );
XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
}
@Rule

2
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/PreParsedOrmXmlTest.java
View File

@ -13,7 +13,6 @@ import java.io.UncheckedIOException;
import org.hibernate.boot.jaxb.spi.Binding;
import org.hibernate.boot.registry.BootstrapServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;
import org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.junit4.BaseCoreFunctionalTestCase;
@ -27,7 +26,6 @@ public class PreParsedOrmXmlTest extends BaseCoreFunctionalTestCase {
@Override
protected void prepareBootstrapRegistryBuilder(BootstrapServiceRegistryBuilder builder) {
super.prepareBootstrapRegistryBuilder( builder );
XmlMappingOptionsStrategyRegistrationProvider.applyJaxbStrategy( builder );
}
@Override

232
hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/lazy/proxy/inlinedirtychecking/LoadUninitializedCollectionTest.java Normal file
View File

@ -0,0 +1,232 @@
/*
* 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.test.bytecode.enhancement.lazy.proxy.inlinedirtychecking;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;
import javax.persistence.Query;
import javax.persistence.Table;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.cfg.Environment;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.bytecode.enhancement.BytecodeEnhancerRunner;
import org.hibernate.testing.bytecode.enhancement.CustomEnhancementContext;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
@TestForIssue(jiraKey = "HHH-14549")
@RunWith(BytecodeEnhancerRunner.class)
@CustomEnhancementContext({ DirtyCheckEnhancementContext.class, NoDirtyCheckEnhancementContext.class })
public class LoadUninitializedCollectionTest extends BaseEntityManagerFunctionalTestCase {
boolean skipTest;
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class[] {
Bank.class,
BankAccount.class,
BankDepartment.class
};
}
@Override
protected void addMappings(Map settings) {
String byteCodeProvider = Environment.getProperties().getProperty( AvailableSettings.BYTECODE_PROVIDER );
if ( byteCodeProvider != null && !Environment.BYTECODE_PROVIDER_NAME_BYTEBUDDY.equals( byteCodeProvider ) ) {
// skip the test if the bytecode provider is Javassist
skipTest = true;
}
}
@Before
public void setUp() {
if ( skipTest ) {
return;
}
doInJPA(
this::entityManagerFactory, entityManager -> {
Bank bank = new Bank( 1L, "International" );
BankAccount bankAccount = new BankAccount( 1L, bank, "1234567890" );
BankDepartment bankDepartmentA = new BankDepartment( 1L, "A" );
BankDepartment bankDepartmentB = new BankDepartment( 2L, "B" );
BankDepartment bankDepartmentC = new BankDepartment( 3L, "C" );
bank.addDepartment( bankDepartmentA );
bank.addDepartment( bankDepartmentB );
bank.addDepartment( bankDepartmentC );
entityManager.persist( bank );
entityManager.persist( bankAccount );
entityManager.persist( bankDepartmentA );
entityManager.persist( bankDepartmentB );
entityManager.persist( bankDepartmentC );
}
);
}
@Test
public void testLoadAfterNativeQueryExecution() {
if ( skipTest ) {
return;
}
doInJPA( this::entityManagerFactory, entityManager -> {
BankAccount account = entityManager.find( BankAccount.class, 1L );
Query nativeQuery = entityManager.createNativeQuery( "SELECT ID FROM BANK" );
nativeQuery.getResultList();
Bank bank = account.getBank();
List<BankDepartment> deps = bank.getDepartments();
assertEquals( deps.size(), 3 );
}
);
}
@Test
public void testLoadAfterFlush() {
if ( skipTest ) {
return;
}
doInJPA( this::entityManagerFactory, entityManager -> {
BankAccount account = entityManager.find( BankAccount.class, 1L );
entityManager.flush();
Bank bank = account.getBank();
List<BankDepartment> deps = bank.getDepartments();
assertEquals( deps.size(), 3 );
}
);
}
@After
public void tearDown() {
if ( skipTest ) {
return;
}
doInJPA( this::entityManagerFactory, entityManager -> {
Bank bank = entityManager.find( Bank.class, 1L );
bank.getDepartments().forEach(
department -> entityManager.remove( department )
);
List<BankAccount> accounts = entityManager.createQuery( "from BankAccount" ).getResultList();
accounts.forEach(
account -> entityManager.remove( account )
);
entityManager.remove( bank );
}
);
}
@Entity(name = "Bank")
@Table(name = "BANK")
public static class Bank {
@Id
@Column(name = "ID")
private Long id;
private String name;
public Bank() {
}
public Bank(Long id, String name) {
this.id = id;
this.name = name;
}
@OneToMany
private List<BankDepartment> departments = new ArrayList<>();
public List<BankDepartment> getDepartments() {
return departments;
}
public void addDepartment(BankDepartment department) {
this.departments.add( department );
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
@Entity(name = "BankAccount")
public static class BankAccount {
@Id
private Long id;
@ManyToOne(fetch = FetchType.LAZY)
private Bank bank;
private String serialNumber;
public BankAccount() {
}
public BankAccount(Long id, Bank bank, String serialNumber) {
this.id = id;
this.bank = bank;
this.serialNumber = serialNumber;
}
public Bank getBank() {
return bank;
}
public String getSerialNumber() {
return serialNumber;
}
}
@Entity(name = "BankDepartment")
public static class BankDepartment {
@Id
private Long id;
private String name;
public BankDepartment() {
}
public BankDepartment(Long id, String name) {
this.id = id;
}
}
}

188
hibernate-core/src/test/java/org/hibernate/test/bytecode/enhancement/lazy/proxy/inlinedirtychecking/LoadingLazyCollectionAfterQueryExecutionWithFlushModeAlwaysTest.java Normal file
View File

@ -0,0 +1,188 @@
package org.hibernate.test.bytecode.enhancement.lazy.proxy.inlinedirtychecking;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;
import org.hibernate.FlushMode;
import org.hibernate.cfg.AvailableSettings;
import org.hibernate.cfg.Environment;
import org.hibernate.jpa.test.BaseEntityManagerFunctionalTestCase;
import org.hibernate.testing.TestForIssue;
import org.hibernate.testing.bytecode.enhancement.BytecodeEnhancerRunner;
import org.hibernate.testing.bytecode.enhancement.CustomEnhancementContext;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import static org.hibernate.testing.transaction.TransactionUtil.doInJPA;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
@TestForIssue( jiraKey = "HHH-14549")
@RunWith(BytecodeEnhancerRunner.class)
@CustomEnhancementContext({ DirtyCheckEnhancementContext.class, NoDirtyCheckEnhancementContext.class })
public class LoadingLazyCollectionAfterQueryExecutionWithFlushModeAlwaysTest
extends BaseEntityManagerFunctionalTestCase {
boolean skipTest;
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class[] {
Customer.class,
ProductOrder.class,
Product.class,
City.class
};
}
@Override
protected void addMappings(Map settings) {
String byteCodeProvider = Environment.getProperties().getProperty( AvailableSettings.BYTECODE_PROVIDER );
settings.put( AvailableSettings.FLUSH_MODE, FlushMode.ALWAYS );
if ( byteCodeProvider != null && !Environment.BYTECODE_PROVIDER_NAME_BYTEBUDDY.equals( byteCodeProvider ) ) {
// skip the test if the bytecode provider is Javassist
skipTest = true;
}
}
@Before
public void setUp() {
if ( skipTest ) {
return;
}
doInJPA(
this::entityManagerFactory, entityManager -> {
ProductOrder order = new ProductOrder();
order.setOrderNumber( "12345" );
Customer customer = new Customer();
customer.setProductOrder( order );
customer.setName( "Fab" );
Product product = new Product();
product.setName( "gloves" );
order.addProduct( product );
entityManager.persist( order );
entityManager.persist( product );
entityManager.persist( customer );
}
);
}
@Test
public void reproducer_Case1() {
if ( skipTest ) {
return;
}
doInJPA(
this::entityManagerFactory, entityManager -> {
List<Customer> customers = entityManager.createQuery( "select c from Customer c" ).getResultList();
assertEquals( 1, customers.size() );
Customer customer = customers.get( 0 );
ProductOrder order = customer.getProductOrder();
assertNotNull( order );
entityManager.createQuery( "select c from City c" ).getResultList();
assertEquals( 1, order.getProducts().size() );
} );
}
@MappedSuperclass
public static abstract class Base {
@Id
@GeneratedValue
public Long id;
public Long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
}
@Entity(name = "Customer")
public static class Customer extends Base {
private String name;
@OneToOne(fetch = FetchType.LAZY)
ProductOrder order;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public ProductOrder getProductOrder() {
return order;
}
public void setProductOrder(ProductOrder order) {
this.order = order;
}
}
@Entity(name = "ProductOrder")
public static class ProductOrder extends Base {
private String orderNumber;
@OneToMany
private List<Product> products = new ArrayList<>();
public String getOrderNumber() {
return orderNumber;
}
public void setOrderNumber(String orderNumber) {
this.orderNumber = orderNumber;
}
public List<Product> getProducts() {
return products;
}
public void addProduct(Product product) {
products.add( product );
}
}
@Entity(name = "Product")
public static class Product extends Base {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
@Entity(name = "City")
public static class City extends Base {
private String name;
}
}

1
hibernate-core/src/test/resources/META-INF/services/org.hibernate.boot.registry.selector.StrategyRegistrationProvider
View File

@ -1 +0,0 @@
org.hibernate.internal.util.xml.XmlMappingOptionsStrategyRegistrationProvider

18
hibernate-core/src/test/resources/org/hibernate/orm/test/annotations/embeddables/collection/orm.xml
View File

@ -23,6 +23,15 @@
</element-collection>
</attributes>
</entity>
<entity class="ContactType">
<attributes>
<id name="id">
<generated-value strategy="AUTO"/>
</id>
<basic name="type"/>
<version name="version"/>
</attributes>
</entity>
<embeddable class="ContactInformation">
<attributes>
<basic name="name"/>
@ -34,13 +43,4 @@
</one-to-many>
</attributes>
</embeddable>
<entity class="ContactType">
<attributes>
<id name="id">
<generated-value strategy="AUTO"/>
</id>
<version name="version"/>
<basic name="type"/>
</attributes>
</entity>
</entity-mappings>

1
hibernate-entitymanager/hibernate-entitymanager.gradle
View File

@ -4,7 +4,6 @@ apply from: rootProject.file( 'gradle/published-java-module.gradle' )
dependencies {
compile( project( ':hibernate-core' ) )
compile( libraries.dom4j )
compile( libraries.commons_annotations )
compile( libraries.jpa )
compile( libraries.byteBuddy )

3
hibernate-envers/hibernate-envers.gradle
View File

@ -16,6 +16,9 @@ dependencies {
exclude group: "org.javassist", module: "javassist"
}
// TODO HHH-13703: get rid of this dependency
compile( libraries.dom4j )
provided( libraries.ant )
annotationProcessor( project( ':hibernate-jpamodelgen' ) )

5
hibernate-envers/src/main/java/org/hibernate/envers/boot/internal/AdditionalJaxbMappingProducerImpl.java
View File

@ -24,7 +24,6 @@ import org.hibernate.boot.jaxb.SourceType;
import org.hibernate.boot.jaxb.hbm.spi.JaxbHbmHibernateMapping;
import org.hibernate.boot.jaxb.internal.MappingBinder;
import org.hibernate.boot.jaxb.spi.Binding;
import org.hibernate.boot.jaxb.spi.XmlMappingOptions;
import org.hibernate.boot.model.source.internal.hbm.MappingDocument;
import org.hibernate.boot.spi.AdditionalJaxbMappingProducer;
import org.hibernate.boot.spi.MetadataBuildingContext;
@ -32,14 +31,12 @@ import org.hibernate.boot.spi.MetadataBuildingOptions;
import org.hibernate.boot.spi.MetadataImplementor;
import org.hibernate.envers.boot.EnversBootLogger;
import org.hibernate.envers.configuration.internal.MappingCollector;
import org.hibernate.internal.util.config.ConfigurationHelper;
import org.hibernate.service.ServiceRegistry;
import org.jboss.jandex.IndexView;
import org.jboss.logging.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
@ -66,7 +63,7 @@ public class AdditionalJaxbMappingProducerImpl implements AdditionalJaxbMappingP
return Collections.emptyList();
}
if ( !metadataBuildingOptions.getXmlMappingOptions().isEnabled() ) {
if ( !metadataBuildingOptions.isXmlMappingEnabled() ) {
throw new HibernateException( "Hibernate Envers currently requires XML mapping to be enabled."
+ " Please don't disable setting `" + XML_MAPPING_ENABLED
+ "`; alternatively disable Hibernate Envers." );

4
hibernate-osgi/hibernate-osgi.gradle
View File

@ -96,6 +96,7 @@ dependencies {
karafDistro "org.apache.karaf:apache-karaf:${project.karafVersion}@tar.gz"
hibernateEnvers( project( ':hibernate-envers' ) )
hibernateEnvers( libraries.dom4j )
}
jar {
@ -161,6 +162,9 @@ karaf {
name = 'hibernate-envers'
description = 'Feature for easily adding Envers support to hibernate-orm'
includeProject = false
feature ('wrap') {
prerequisite = true
}
configurations 'hibernateEnvers'
feature('hibernate-orm') {
version = project.version

7
hibernate-spatial/hibernate-spatial.gradle
View File

@ -19,10 +19,6 @@ dependencies {
compile( libraries.postgresql )
compile(libraries.dom4j) {
transitive = false
}
testCompile(libraries.junit)
testCompile(project(':hibernate-testing'))
testCompile( project( path: ':hibernate-core', configuration: 'tests' ) )
@ -34,6 +30,9 @@ dependencies {
// for test runtime
transitive = true
}
testCompile(libraries.dom4j) {
transitive = false
}
testRuntime( libraries.expression_language )

1
tooling/hibernate-enhance-maven-plugin/hibernate-enhance-maven-plugin.gradle
View File

@ -55,7 +55,6 @@ task processPluginXml(type: Copy) {
filter(ReplaceTokens, tokens: ['version' : project.version, 'generated-dependencies' :\
generateMavenDependency(libraries.jpa)\
+ generateMavenDependency(libraries.antlr)\
+ generateMavenDependency(libraries.dom4j)\
+ generateMavenDependency(libraries.jta)\
+ generateMavenDependency(libraries.commons_annotations)\
+ generateMavenDependency(libraries.javassist)\