diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/binding/InheritanceType.java b/hibernate-core/src/main/java/org/hibernate/metamodel/binding/InheritanceType.java index 97e317e09f..9bcd4792cd 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/binding/InheritanceType.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/binding/InheritanceType.java @@ -35,7 +35,8 @@ import org.hibernate.MappingException; public enum InheritanceType { JOINED, SINGLE_TABLE, - TABLE_PER_CLASS; + TABLE_PER_CLASS, + NO_INHERITANCE; /** * @param jpaType The JPA inheritance type diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClass.java b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClass.java index abef08f350..4c022f6376 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClass.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClass.java @@ -35,7 +35,6 @@ import java.util.List; import java.util.Map; import java.util.Set; import javax.persistence.AccessType; -import javax.persistence.InheritanceType; import com.fasterxml.classmate.ResolvedTypeWithMembers; import com.fasterxml.classmate.members.HierarchicType; @@ -52,6 +51,7 @@ import org.hibernate.AnnotationException; import org.hibernate.AssertionFailure; import org.hibernate.HibernateException; import org.hibernate.MappingException; +import org.hibernate.metamodel.binding.InheritanceType; import org.hibernate.metamodel.source.annotations.util.JandexHelper; import org.hibernate.metamodel.source.annotations.util.ReflectionHelper; import org.hibernate.service.ServiceRegistry; @@ -117,6 +117,10 @@ public class ConfiguredClass { return clazz.getName(); } + public String getSimpleName() { + return clazz.getSimpleName(); + } + public ClassInfo getClassInfo() { return classInfo; } @@ -375,7 +379,7 @@ public class ConfiguredClass { final Map> annotations = JandexHelper.getMemberAnnotations( classInfo, member.getName() ); - return new MappedAttribute( name, (Class) type, annotations ); + return MappedAttribute.createMappedAttribute( name, (Class) type, annotations ); } private Type findResolvedType(String name, ResolvedMember[] resolvedMembers) { diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClassHierarchy.java b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClassHierarchy.java index 6258af187d..c2e3630ee7 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClassHierarchy.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/ConfiguredClassHierarchy.java @@ -27,7 +27,6 @@ import java.util.ArrayList; import java.util.Iterator; import java.util.List; import javax.persistence.AccessType; -import javax.persistence.InheritanceType; import com.fasterxml.classmate.ResolvedTypeWithMembers; import org.jboss.jandex.AnnotationInstance; @@ -36,6 +35,7 @@ import org.jboss.jandex.FieldInfo; import org.jboss.jandex.MethodInfo; import org.hibernate.AnnotationException; +import org.hibernate.metamodel.binding.InheritanceType; import org.hibernate.metamodel.source.annotations.util.JandexHelper; import org.hibernate.metamodel.source.annotations.util.ReflectionHelper; import org.hibernate.service.ServiceRegistry; @@ -150,6 +150,10 @@ public class ConfiguredClassHierarchy implements Iterable { } private InheritanceType determineInheritanceType(List classes) { + if ( classes.size() == 1 ) { + return InheritanceType.NO_INHERITANCE; + } + InheritanceType inheritanceType = null; for ( ClassInfo info : classes ) { AnnotationInstance inheritanceAnnotation = JandexHelper.getSingleAnnotation( @@ -159,9 +163,10 @@ public class ConfiguredClassHierarchy implements Iterable { continue; } - InheritanceType tmpInheritanceType = Enum.valueOf( - InheritanceType.class, inheritanceAnnotation.value( "strategy" ).asEnum() + javax.persistence.InheritanceType jpaInheritanceType = Enum.valueOf( + javax.persistence.InheritanceType.class, inheritanceAnnotation.value( "strategy" ).asEnum() ); + InheritanceType tmpInheritanceType = InheritanceType.get( jpaInheritanceType ); if ( tmpInheritanceType == null ) { // default inheritance type is single table inheritanceType = InheritanceType.SINGLE_TABLE; diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/DiscriminatorColumnValues.java b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/DiscriminatorColumnValues.java index bd455e43fe..0e9f40b66e 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/DiscriminatorColumnValues.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/DiscriminatorColumnValues.java @@ -23,25 +23,90 @@ */ package org.hibernate.metamodel.source.annotations; +import java.util.List; +import java.util.Map; + +import org.jboss.jandex.AnnotationInstance; +import org.jboss.jandex.DotName; + +import org.hibernate.metamodel.source.annotations.util.JandexHelper; + /** * Container for the properties of a discriminator column. * * @author Hardy Ferentschik */ public class DiscriminatorColumnValues extends ColumnValues { - private static final String DEFAULT_DISCRIMINATOR_COLUMN_NAME = "DTYPE"; - private static final String DEFAULT_DISCRIMINATOR_TYPE = "string"; + public static final String DEFAULT_DISCRIMINATOR_COLUMN_NAME = "DTYPE"; private static final int DEFAULT_DISCRIMINATOR_LENGTH = 31; - public DiscriminatorColumnValues() { + private boolean isForced = true; + private boolean isIncludedInSql = true; + private String discriminatorValue = null; + + public DiscriminatorColumnValues(Map> annotations) { super(); - setName( DEFAULT_DISCRIMINATOR_COLUMN_NAME ); - setLength( DEFAULT_DISCRIMINATOR_LENGTH ); + + AnnotationInstance discriminatorOptionsAnnotation = JandexHelper.getSingleAnnotation( + annotations, JPADotNames.DISCRIMINATOR_COLUMN + ); + + if ( discriminatorOptionsAnnotation != null ) { + setName( discriminatorOptionsAnnotation.value( "name" ).asString() ); + setLength( discriminatorOptionsAnnotation.value( "length" ).asInt() ); + if ( discriminatorOptionsAnnotation.value( "columnDefinition" ) != null ) { + setColumnDefinition( discriminatorOptionsAnnotation.value( "columnDefinition" ).asString() ); + } + } + else { + setName( DEFAULT_DISCRIMINATOR_COLUMN_NAME ); + setLength( DEFAULT_DISCRIMINATOR_LENGTH ); + } + setNullable( false ); -// if ( columnAnnotation != null && !JPADotNames.COLUMN.equals( columnAnnotation.name() ) ) { -// throw new AssertionFailure( "A @Column annotation needs to be passed to the constructor" ); -// } -// applyColumnValues( columnAnnotation, isId ); + setDiscriminatorValue( annotations ); + setDiscriminatorOptions( annotations ); + setDiscriminatorFormula( annotations ); + } + + private void setDiscriminatorValue(Map> annotations) { + AnnotationInstance discriminatorValueAnnotation = JandexHelper.getSingleAnnotation( + annotations, JPADotNames.DISCRIMINATOR_VALUE + ); + if ( discriminatorValueAnnotation != null ) { + discriminatorValue = discriminatorValueAnnotation.value().asString(); + } + } + + private void setDiscriminatorFormula(Map> annotations) { + AnnotationInstance discriminatorFormulaAnnotation = JandexHelper.getSingleAnnotation( + annotations, HibernateDotNames.DISCRIMINATOR_FORMULA + ); + if ( discriminatorFormulaAnnotation != null ) { + // todo + } + } + + public boolean isForced() { + return isForced; + } + + public boolean isIncludedInSql() { + return isIncludedInSql; + } + + public String getDiscriminatorValue() { + return discriminatorValue; + } + + private void setDiscriminatorOptions(Map> annotations) { + AnnotationInstance discriminatorOptionsAnnotation = JandexHelper.getSingleAnnotation( + annotations, HibernateDotNames.DISCRIMINATOR_OPTIONS + ); + if ( discriminatorOptionsAnnotation != null ) { + isForced = discriminatorOptionsAnnotation.value( "force" ).asBoolean(); + isIncludedInSql = discriminatorOptionsAnnotation.value( "insert" ).asBoolean(); + } } } diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/EntityBinder.java b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/EntityBinder.java index 6bd580b31e..e7e5f1f92a 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/EntityBinder.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/EntityBinder.java @@ -36,7 +36,6 @@ import org.hibernate.cache.spi.access.AccessType; import org.hibernate.internal.util.StringHelper; import org.hibernate.metamodel.binding.Caching; import org.hibernate.metamodel.binding.EntityBinding; -import org.hibernate.metamodel.binding.InheritanceType; import org.hibernate.metamodel.binding.SimpleAttributeBinding; import org.hibernate.metamodel.domain.Entity; import org.hibernate.metamodel.domain.Hierarchical; @@ -67,20 +66,21 @@ public class EntityBinder { public void bind() { EntityBinding entityBinding = new EntityBinding(); - entityBinding.setInheritanceType( InheritanceType.get( configuredClass.getInheritanceType() ) ); - bindInheritance( entityBinding ); bindJpaEntityAnnotation( entityBinding ); bindHibernateEntityAnnotation( entityBinding ); // optional hibernate specific @org.hibernate.annotations.Entity + schemaName = createSchemaName(); + bindTable( entityBinding ); + + entityBinding.setInheritanceType( configuredClass.getInheritanceType() ); + bindInheritance( entityBinding ); + bindWhereFilter( entityBinding ); bindJpaCaching( entityBinding ); bindHibernateCaching( entityBinding ); - schemaName = createSchemaName(); - bindTable( entityBinding ); - if ( configuredClass.isRoot() ) { bindId( entityBinding ); } @@ -93,21 +93,36 @@ public class EntityBinder { switch ( configuredClass.getInheritanceType() ) { case SINGLE_TABLE: { bindDiscriminatorColumn( entityBinding ); + break; } case JOINED: { // todo + break; } case TABLE_PER_CLASS: { // todo + break; } default: { - throw new AnnotationException( "Invalid inheritance type " + configuredClass.getInheritanceType() ); + // do nothing } } } private void bindDiscriminatorColumn(EntityBinding entityBinding) { + MappedAttribute discriminatorAttribute = MappedAttribute.createDiscriminatorAttribute( + configuredClass.getClassInfo().annotations() + ); + bindSingleMappedAttribute( entityBinding, discriminatorAttribute ); + + if ( !( discriminatorAttribute.getColumnValues() instanceof DiscriminatorColumnValues ) ) { + throw new AssertionFailure( "Expected discriminator column values" ); + } + DiscriminatorColumnValues discriminatorColumnvalues = (DiscriminatorColumnValues) discriminatorAttribute.getColumnValues(); + entityBinding.getEntityDiscriminator().setForced( discriminatorColumnvalues.isForced() ); + entityBinding.getEntityDiscriminator().setInserted( discriminatorColumnvalues.isIncludedInSql() ); + entityBinding.setDiscriminatorValue( discriminatorColumnvalues.getDiscriminatorValue() ); } private void bindWhereFilter(EntityBinding entityBinding) { @@ -295,24 +310,33 @@ public class EntityBinder { private void bindAttributes(EntityBinding entityBinding) { for ( MappedAttribute mappedAttribute : configuredClass.getMappedAttributes() ) { - if ( mappedAttribute.isId() ) { - continue; - } + bindSingleMappedAttribute( entityBinding, mappedAttribute ); + } + } - String attributeName = mappedAttribute.getName(); - entityBinding.getEntity().getOrCreateSingularAttribute( attributeName ); - SimpleAttributeBinding attributeBinding; + private void bindSingleMappedAttribute(EntityBinding entityBinding, MappedAttribute mappedAttribute) { + if ( mappedAttribute.isId() ) { + return; + } - if ( mappedAttribute.isVersioned() ) { - attributeBinding = entityBinding.makeVersionBinding( attributeName ); - } - else { - attributeBinding = entityBinding.makeSimpleAttributeBinding( attributeName ); - } + String attributeName = mappedAttribute.getName(); + entityBinding.getEntity().getOrCreateSingularAttribute( attributeName ); + SimpleAttributeBinding attributeBinding; - AttributeDomainState domainState = new AttributeDomainState( entityBinding, mappedAttribute ); - attributeBinding.initialize( domainState ); + if ( mappedAttribute.isVersioned() ) { + attributeBinding = entityBinding.makeVersionBinding( attributeName ); + } + else if ( mappedAttribute.isDiscriminator() ) { + attributeBinding = entityBinding.makeEntityDiscriminatorBinding( attributeName ); + } + else { + attributeBinding = entityBinding.makeSimpleAttributeBinding( attributeName ); + } + AttributeDomainState domainState = new AttributeDomainState( entityBinding, mappedAttribute ); + attributeBinding.initialize( domainState ); + + if ( configuredClass.hasOwnTable() ) { AttributeColumnRelationalState columnRelationsState = new AttributeColumnRelationalState( mappedAttribute, meta ); @@ -393,10 +417,10 @@ public class EntityBinder { return null; } - EntityBinding parentBinding = meta.getEntityBinding( parent.getName() ); + EntityBinding parentBinding = meta.getEntityBinding( parent.getSimpleName() ); if ( parentBinding == null ) { throw new AssertionFailure( - "Parent entity " + parent.getName() + " of entity " + configuredClass.getName() + "not yet created!" + "Parent entity " + parent.getName() + " of entity " + configuredClass.getName() + " not yet created!" ); } @@ -404,5 +428,3 @@ public class EntityBinder { } } - - diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/MappedAttribute.java b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/MappedAttribute.java index 299548df36..b873512617 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/MappedAttribute.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/MappedAttribute.java @@ -25,14 +25,19 @@ package org.hibernate.metamodel.source.annotations; import java.util.List; import java.util.Map; +import javax.persistence.DiscriminatorType; import org.jboss.jandex.AnnotationInstance; import org.jboss.jandex.DotName; +import org.hibernate.AnnotationException; import org.hibernate.AssertionFailure; +import org.hibernate.metamodel.source.annotations.util.JandexHelper; + /** - * Represent a mapped attribute (explicitly or implicitly mapped). + * Represent a mapped attribute (explicitly or implicitly mapped). Also used for synthetic attributes likes a + * discriminator column. * * @author Hardy Ferentschik */ @@ -43,24 +48,73 @@ public class MappedAttribute implements Comparable { private final ColumnValues columnValues; private final boolean isId; private final boolean isVersioned; + private final boolean isDiscriminator; - MappedAttribute(String name, Class type, Map> annotations) { + static MappedAttribute createMappedAttribute(String name, Class type, Map> annotations) { + return new MappedAttribute( name, type, annotations, false ); + } + + static MappedAttribute createDiscriminatorAttribute(Map> annotations) { + Map> discriminatorAnnotations = JandexHelper.filterAnnotations( + annotations, + JPADotNames.DISCRIMINATOR_COLUMN, + JPADotNames.DISCRIMINATOR_VALUE, + HibernateDotNames.DISCRIMINATOR_FORMULA, + HibernateDotNames.DISCRIMINATOR_OPTIONS + ); + + AnnotationInstance discriminatorOptionsAnnotation = JandexHelper.getSingleAnnotation( + annotations, JPADotNames.DISCRIMINATOR_COLUMN + ); + String name = DiscriminatorColumnValues.DEFAULT_DISCRIMINATOR_COLUMN_NAME; + Class type = String.class; // string is the discriminator default + if ( discriminatorOptionsAnnotation != null ) { + name = discriminatorOptionsAnnotation.value( "name" ).asString(); + + DiscriminatorType discriminatorType = Enum.valueOf( + DiscriminatorType.class, discriminatorOptionsAnnotation.value( "discriminatorType" ).asEnum() + ); + switch ( discriminatorType ) { + case STRING: { + type = String.class; + break; + } + case CHAR: { + type = Character.class; + break; + } + case INTEGER: { + type = Integer.class; + break; + } + default: { + throw new AnnotationException( "Unsupported discriminator type: " + discriminatorType ); + } + } + } + return new MappedAttribute( name, type, discriminatorAnnotations, true ); + } + + private MappedAttribute(String name, Class type, Map> annotations, boolean isDiscriminator) { this.name = name; this.type = type; this.annotations = annotations; + this.isDiscriminator = isDiscriminator; - List idAnnotations = annotations.get( JPADotNames.ID ); - isId = idAnnotations != null && !idAnnotations.isEmpty(); + AnnotationInstance idAnnotation = JandexHelper.getSingleAnnotation( annotations, JPADotNames.ID ); + isId = idAnnotation != null; - List versionAnnotations = annotations.get( JPADotNames.VERSION ); - isVersioned = versionAnnotations != null && !versionAnnotations.isEmpty(); + AnnotationInstance versionAnnotation = JandexHelper.getSingleAnnotation( annotations, JPADotNames.VERSION ); + isVersioned = versionAnnotation != null; - List columnAnnotations = annotations.get( JPADotNames.COLUMN ); - if ( columnAnnotations != null && columnAnnotations.size() > 1 ) { - throw new AssertionFailure( "There can only be one @Column annotation per mapped attribute" ); + if ( isDiscriminator ) { + columnValues = new DiscriminatorColumnValues( annotations ); } - AnnotationInstance columnAnnotation = columnAnnotations == null ? null : columnAnnotations.get( 0 ); - columnValues = new ColumnValues( columnAnnotation ); + else { + AnnotationInstance columnAnnotation = JandexHelper.getSingleAnnotation( annotations, JPADotNames.COLUMN ); + columnValues = new ColumnValues( columnAnnotation ); + } + if ( isId ) { // an id must be unique and cannot be nullable columnValues.setUnique( true ); @@ -88,6 +142,10 @@ public class MappedAttribute implements Comparable { return isVersioned; } + public boolean isDiscriminator() { + return isDiscriminator; + } + /** * Returns the annotation with the specified name or {@code null} * diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/AbstractEntityBinder.java b/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/AbstractEntityBinder.java index 7060f0043e..349e73ea58 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/AbstractEntityBinder.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/AbstractEntityBinder.java @@ -480,7 +480,6 @@ PrimitiveArray hibernateMappingBinder.getHibernateXmlBinder().getMetadata(), hibernateMappingBinder, entityBinding.getEntity().getOrCreateSingularAttribute( attributeName ), - entityBinding.getMetaAttributes(), discriminator ) ); diff --git a/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/domain/HbmSimpleAttributeDomainState.java b/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/domain/HbmSimpleAttributeDomainState.java index 3e5f398768..c15b442b0a 100644 --- a/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/domain/HbmSimpleAttributeDomainState.java +++ b/hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/domain/HbmSimpleAttributeDomainState.java @@ -83,7 +83,6 @@ public class HbmSimpleAttributeDomainState extends AbstractHbmAttributeDomainSta MetadataImpl metadata, MappingDefaults defaults, org.hibernate.metamodel.domain.Attribute attribute, - Map entityMetaAttributes, XMLDiscriminator discriminator) { super( metadata, defaults, attribute, null, null, null, true diff --git a/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/InheritanceTypeTest.java b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/InheritanceTypeTest.java new file mode 100644 index 0000000000..90ec00efd4 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/InheritanceTypeTest.java @@ -0,0 +1,79 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2011, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.metamodel.source.annotations; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; + +import org.junit.Test; + +import org.hibernate.metamodel.MetadataSources; +import org.hibernate.metamodel.binding.EntityBinding; +import org.hibernate.metamodel.source.internal.MetadataImpl; +import org.hibernate.service.ServiceRegistryBuilder; +import org.hibernate.testing.junit4.BaseUnitTestCase; + +import static junit.framework.Assert.assertEquals; +import static junit.framework.Assert.assertNull; + +/** + * @author Hardy Ferentschik + */ +public class InheritanceTypeTest extends BaseUnitTestCase { + @Test + public void testNoInheritance() { + MetadataImpl meta = buildMetadata( SingleEntity.class ); + EntityBinding entityBinding = getEntityBindingForInnerClass( meta, SingleEntity.class ); + assertNull( entityBinding.getEntityDiscriminator() ); + } + + @Test + public void testDiscriminatorValue() { + MetadataImpl meta = buildMetadata( RootOfSingleTableInheritance.class, SubclassOfSingleTableInheritance.class ); + EntityBinding entityBinding = meta.getEntityBinding( SubclassOfSingleTableInheritance.class.getSimpleName() ); + assertEquals( "Wrong discriminator value", "foo", entityBinding.getDiscriminatorValue() ); + } + + private MetadataImpl buildMetadata(Class... classes) { + MetadataSources sources = new MetadataSources( new ServiceRegistryBuilder().buildServiceRegistry() ); + for ( Class clazz : classes ) { + sources.addAnnotatedClass( clazz ); + } + return (MetadataImpl) sources.buildMetadata(); + } + + private EntityBinding getEntityBindingForInnerClass(MetadataImpl meta, Class clazz) { + return meta.getEntityBinding( this.getClass().getSimpleName() + "$" + clazz.getSimpleName() ); + } + + @Entity + class SingleEntity { + @Id + @GeneratedValue + private int id; + } +} + + diff --git a/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/RootOfSingleTableInheritance.java b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/RootOfSingleTableInheritance.java new file mode 100644 index 0000000000..ef78455cd6 --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/RootOfSingleTableInheritance.java @@ -0,0 +1,41 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2010, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.metamodel.source.annotations; + +import javax.persistence.Entity; +import javax.persistence.GeneratedValue; +import javax.persistence.Id; + +/** + * @author Hardy Ferentschik + */ +@Entity +class RootOfSingleTableInheritance { + @Id + @GeneratedValue + private int id; +} + + + diff --git a/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/SubclassOfSingleTableInheritance.java b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/SubclassOfSingleTableInheritance.java new file mode 100644 index 0000000000..e7a76529ef --- /dev/null +++ b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/SubclassOfSingleTableInheritance.java @@ -0,0 +1,37 @@ +/* + * Hibernate, Relational Persistence for Idiomatic Java + * + * Copyright (c) 2010, Red Hat Inc. or third-party contributors as + * indicated by the @author tags or express copyright attribution + * statements applied by the authors. All third-party contributions are + * distributed under license by Red Hat Inc. + * + * This copyrighted material is made available to anyone wishing to use, modify, + * copy, or redistribute it subject to the terms and conditions of the GNU + * Lesser General Public License, as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY + * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License + * for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with this distribution; if not, write to: + * Free Software Foundation, Inc. + * 51 Franklin Street, Fifth Floor + * Boston, MA 02110-1301 USA + */ +package org.hibernate.metamodel.source.annotations; + +import javax.persistence.DiscriminatorValue; +import javax.persistence.Entity; + +/** + * @author Hardy Ferentschik + */ +@Entity +@DiscriminatorValue( "foo" ) +public class SubclassOfSingleTableInheritance extends RootOfSingleTableInheritance { +} + + diff --git a/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/TableNameTest.java b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/TableNameTest.java index d3adf78fba..9544412ac2 100644 --- a/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/TableNameTest.java +++ b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/TableNameTest.java @@ -29,7 +29,6 @@ import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Inheritance; -import javax.persistence.InheritanceType; import javax.persistence.Table; import org.jboss.jandex.ClassInfo; @@ -40,6 +39,7 @@ import org.junit.Assert; import org.junit.Before; import org.junit.Test; +import org.hibernate.metamodel.binding.InheritanceType; import org.hibernate.metamodel.source.annotations.util.ConfiguredClassHierarchyBuilder; import org.hibernate.metamodel.source.annotations.util.JandexHelper; import org.hibernate.service.ServiceRegistryBuilder; @@ -119,7 +119,7 @@ public class TableNameTest extends BaseUnitTestCase { @Test public void testTablePerClassDefaultTableName() { @Entity - @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) + @Inheritance(strategy = javax.persistence.InheritanceType.TABLE_PER_CLASS) class A { @Id @GeneratedValue @@ -166,7 +166,7 @@ public class TableNameTest extends BaseUnitTestCase { @Test public void testJoinedSubclassDefaultTableName() { @Entity - @Inheritance(strategy = InheritanceType.JOINED) + @Inheritance(strategy = javax.persistence.InheritanceType.JOINED) @Table(name = "FOO") class A { @Id diff --git a/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/util/ConfiguredClassHierarchyBuilderTest.java b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/util/ConfiguredClassHierarchyBuilderTest.java index a1b316b0af..15977204d4 100644 --- a/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/util/ConfiguredClassHierarchyBuilderTest.java +++ b/hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/util/ConfiguredClassHierarchyBuilderTest.java @@ -31,7 +31,6 @@ import javax.persistence.Entity; import javax.persistence.GeneratedValue; import javax.persistence.Id; import javax.persistence.Inheritance; -import javax.persistence.InheritanceType; import javax.persistence.MappedSuperclass; import org.jboss.jandex.ClassInfo; @@ -42,6 +41,7 @@ import org.junit.Before; import org.junit.Test; import org.hibernate.AnnotationException; +import org.hibernate.metamodel.binding.InheritanceType; import org.hibernate.metamodel.source.annotations.ConfiguredClass; import org.hibernate.metamodel.source.annotations.ConfiguredClassHierarchy; import org.hibernate.service.ServiceRegistryBuilder; @@ -265,7 +265,7 @@ public class ConfiguredClassHierarchyBuilderTest extends BaseUnitTestCase { } @Entity - @Inheritance(strategy = InheritanceType.JOINED) + @Inheritance(strategy = javax.persistence.InheritanceType.JOINED) class A extends MappedSuperClass { @Id String id; @@ -281,20 +281,22 @@ public class ConfiguredClassHierarchyBuilderTest extends BaseUnitTestCase { ); assertTrue( hierarchies.size() == 1 ); ConfiguredClassHierarchy hierarchy = hierarchies.iterator().next(); - assertEquals( "Wrong inheritance type", InheritanceType.JOINED, hierarchy.getInheritanceType() ); + assertEquals( + "Wrong inheritance type", InheritanceType.JOINED, hierarchy.getInheritanceType() + ); } @Test(expected = AnnotationException.class) public void testMultipleConflictingInheritanceDefinitions() { @Entity - @Inheritance(strategy = InheritanceType.JOINED) + @Inheritance(strategy = javax.persistence.InheritanceType.JOINED) class A { String id; } @Entity - @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) + @Inheritance(strategy = javax.persistence.InheritanceType.TABLE_PER_CLASS) class B extends A { }