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

HHH-6109 Starting work for annotation binding against the new metamodel. Enabling JAXB for parsing of orm.xml

This commit is contained in:
Hardy Ferentschik 2011-03-29 13:58:17 +02:00
parent 72a2862ea9
commit 42502e696b
22 changed files with 976 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
build.gradle
View File

@ -46,6 +46,7 @@ libraries = [
// Annotations
commons_annotations:
'org.hibernate:hibernate-commons-annotations:3.2.0.Final',
jandex: 'org.jboss:jandex:1.0.0.Beta6',
// Jakarta commons-collections todo : get rid of commons-collections dependency
commons_collections:
@ -53,6 +54,7 @@ libraries = [
// Dom4J
dom4j: 'dom4j:dom4j:1.6.1@jar',
jaxb: 'com.sun.xml.bind:jaxb-xjc:2.1.6',
// h2
h2: 'com.h2database:h2:1.2.145',
@ -114,6 +116,9 @@ subprojects { subProject ->
deployerJars {
description = 'Jars needed for doing deployment to JBoss Nexus repo'
}
jaxb {
description = 'Dependencies for running ant xjc (jaxb class generation)'
}
}
// appropriately inject the common dependencies into each sub-project
@ -129,6 +134,7 @@ subprojects { subProject ->
testRuntime( libraries.h2 )
jbossLoggingTool( libraries.logging_tools )
hibernateJpaModelGenTool( libraries.jpa_modelgen )
jaxb( libraries.jaxb )
deployerJars "org.apache.maven.wagon:wagon-http:1.0-beta-6"
}

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

@ -9,6 +9,7 @@ dependencies {
transitive = false
}
compile( libraries.commons_annotations )
compile( libraries.jandex )
compile( libraries.jpa )
compile( libraries.javassist )
antlr( libraries.antlr )
@ -43,3 +44,16 @@ ideaModule {
}
task jaxb << {
jaxbTargetDir = file( "${buildDir}/generated-src/jaxb" )
jaxbTargetDir.mkdirs()
ant.taskdef(name: 'xjc', classname: 'com.sun.tools.xjc.XJCTask', classpath: configurations.jaxb.asPath)
ant.jaxbTargetDir = jaxbTargetDir
ant.xjc(destdir: '${jaxbTargetDir}', package: 'org.hibernate.metamodel.source.xml') {
schema(dir: 'src/main/resources/org/hibernate/ejb', includes: 'orm_2_0.xsd')
}
}
compileJava.dependsOn jaxb

8
hibernate-core/src/main/java/org/hibernate/metamodel/binding/EntityIdentifier.java
View File

@ -28,7 +28,7 @@ import org.hibernate.internal.CoreMessageLogger;
import org.jboss.logging.Logger;
/**
* TODO : javadoc
* Binds the entity identifier.
*
* @author Steve Ebersole
*/
@ -42,7 +42,8 @@ public class EntityIdentifier {
/**
* Create an identifier
* @param entityBinding
*
* @param entityBinding the entity binding for which this instance is the id
*/
public EntityIdentifier(EntityBinding entityBinding) {
this.entityBinding = entityBinding;
@ -54,7 +55,8 @@ public class EntityIdentifier {
public void setValueBinding(AttributeBinding attributeBinding) {
if ( this.attributeBinding != null ) {
// todo : error? or just log? for now just log
// todo : error? or just log? For now throw exception and see what happens. Easier to see whether this
// method gets called multiple times
LOG.entityIdentifierValueBindingExists( entityBinding.getEntity().getName() );
}
this.attributeBinding = attributeBinding;

77
hibernate-core/src/main/java/org/hibernate/metamodel/source/Metadata.java
View File

@ -29,23 +29,21 @@ import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.DuplicateMappingException;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.annotations.common.reflection.MetadataProvider;
import org.hibernate.annotations.common.reflection.MetadataProviderInjector;
import org.hibernate.annotations.common.reflection.ReflectionManager;
import org.hibernate.annotations.common.reflection.java.JavaReflectionManager;
import org.hibernate.cfg.EJB3NamingStrategy;
import org.hibernate.cfg.NamingStrategy;
import org.hibernate.cfg.annotations.reflection.JPAMetadataProvider;
import org.hibernate.mapping.FetchProfile;
import org.hibernate.mapping.MetadataSource;
import org.hibernate.metamodel.binding.EntityBinding;
import org.hibernate.metamodel.binding.PluralAttributeBinding;
import org.hibernate.metamodel.relational.Database;
import org.hibernate.metamodel.source.annotations.AnnotationBinder;
import org.hibernate.metamodel.source.hbm.HibernateXmlBinder;
import org.jboss.logging.Logger;
/**
* TODO : javadoc
@ -53,19 +51,36 @@ import org.jboss.logging.Logger;
* @author Steve Ebersole
*/
public class Metadata implements Serializable {
private static final Logger log = LoggerFactory.getLogger( Metadata.class );
private static final CoreMessageLogger LOG = Logger.getMessageLogger(CoreMessageLogger.class, Metadata.class.getName());
private static final HibernateLogger LOG = Logger.getMessageLogger(HibernateLogger.class, Metadata.class.getName());
private final AnnotationBinder annotationBinder;
private final HibernateXmlBinder hibernateXmlBinder;
private final ExtendsQueue extendsQueue;
private final MetadataSourceQueue metadataSourceQueue;
private final Database database = new Database();
private final HibernateXmlBinder hibernateXmlBinder = new HibernateXmlBinder( this );
private final ExtendsQueue extendsQueue = new ExtendsQueue( this );
private final MetadataSourceQueue metadataSourceQueue = new MetadataSourceQueue( this );
private NamingStrategy namingStrategy = EJB3NamingStrategy.INSTANCE;
private Map<String, EntityBinding> entityBindingMap = new HashMap<String, EntityBinding>();
private Map<String, PluralAttributeBinding> collectionBindingMap = new HashMap<String, PluralAttributeBinding>();
private Map<String, FetchProfile> fetchProfiles = new HashMap<String, FetchProfile>();
private Map<String, String> imports;
private transient ReflectionManager reflectionManager = createReflectionManager();
public Metadata() {
annotationBinder = new AnnotationBinder( this );
hibernateXmlBinder = new HibernateXmlBinder( this );
extendsQueue = new ExtendsQueue( this );
metadataSourceQueue = new MetadataSourceQueue( this );
}
public HibernateXmlBinder getHibernateXmlBinder() {
return hibernateXmlBinder;
}
public AnnotationBinder getAnnotationBinder() {
return annotationBinder;
}
public ExtendsQueue getExtendsQueue() {
return extendsQueue;
}
@ -74,32 +89,10 @@ public class Metadata implements Serializable {
return metadataSourceQueue;
}
public ReflectionManager getReflectionManager() {
return reflectionManager;
}
public void setReflectionManager(ReflectionManager reflectionManager) {
this.reflectionManager = reflectionManager;
}
private ReflectionManager createReflectionManager() {
return createReflectionManager( new JPAMetadataProvider() );
}
private ReflectionManager createReflectionManager(MetadataProvider metadataProvider) {
ReflectionManager reflectionManager = new JavaReflectionManager();
( (MetadataProviderInjector) reflectionManager ).setMetadataProvider( metadataProvider );
return reflectionManager;
}
private final Database database = new Database();
public Database getDatabase() {
return database;
}
private NamingStrategy namingStrategy = EJB3NamingStrategy.INSTANCE;
public NamingStrategy getNamingStrategy() {
return namingStrategy;
}
@ -108,8 +101,6 @@ public class Metadata implements Serializable {
this.namingStrategy = namingStrategy;
}
private Map<String,EntityBinding> entityBindingMap = new HashMap<String, EntityBinding>();
public EntityBinding getEntityBinding(String entityName) {
return entityBindingMap.get( entityName );
}
@ -126,8 +117,6 @@ public class Metadata implements Serializable {
entityBindingMap.put( entityName, entityBinding );
}
private Map<String,PluralAttributeBinding> collectionBindingMap = new HashMap<String, PluralAttributeBinding>();
public PluralAttributeBinding getCollection(String collectionRole) {
return collectionBindingMap.get( collectionRole );
}
@ -146,21 +135,17 @@ public class Metadata implements Serializable {
collectionBindingMap.put( collectionRole, pluralAttributeBinding );
}
private Map<String,String> imports;
public void addImport(String importName, String entityName) {
if ( imports == null ) {
imports = new HashMap<String, String>();
}
LOG.tracef( "Import: %s -> %s", importName, entityName );
log.trace( "Import: " + importName + " -> " + entityName );
String old = imports.put( importName, entityName );
if ( old != null ) {
LOG.debugf( "import name [%s] overrode previous [%s]", importName, old );
log.debug( "import name [{}] overrode previous [{}]", importName, old );
}
}
private Map<String,FetchProfile> fetchProfiles = new HashMap<String, FetchProfile>();
public Iterable<FetchProfile> getFetchProfiles() {
return fetchProfiles.values();
}
@ -175,16 +160,10 @@ public class Metadata implements Serializable {
}
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
//we need reflectionManager before reading the other components (MetadataSourceQueue in particular)
final MetadataProvider metadataProvider = (MetadataProvider) ois.readObject();
this.reflectionManager = createReflectionManager( metadataProvider );
ois.defaultReadObject();
}
private void writeObject(java.io.ObjectOutputStream out) throws IOException {
//We write MetadataProvider first as we need reflectionManager before reading the other components
final MetadataProvider metadataProvider = ( ( MetadataProviderInjector ) reflectionManager ).getMetadataProvider();
out.writeObject( metadataProvider );
out.defaultWriteObject();
}
}

121
hibernate-core/src/main/java/org/hibernate/metamodel/source/MetadataSourceQueue.java
View File

@ -34,20 +34,20 @@ import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.persistence.Entity;
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.InvalidMappingException;
import org.hibernate.MappingException;
import org.hibernate.annotations.common.reflection.XClass;
import org.hibernate.cfg.MetadataSourceType;
import org.hibernate.internal.util.collections.JoinedIterator;
import org.hibernate.internal.util.xml.XmlDocument;
import org.jboss.logging.Logger;
/**
* TODO : javadoc
@ -55,19 +55,14 @@ import org.jboss.logging.Logger;
* @author Steve Ebersole
*/
public class MetadataSourceQueue implements Serializable {
private static final Logger log = LoggerFactory.getLogger( MetadataSourceQueue.class );
private static final CoreMessageLogger LOG = Logger.getMessageLogger(CoreMessageLogger.class, MetadataSourceQueue.class.getName());
private final Metadata metadata;
private LinkedHashMap<XmlDocument, Set<String>> hbmMetadataToEntityNamesMap
= new LinkedHashMap<XmlDocument, Set<String>>();
private Map<String, XmlDocument> hbmMetadataByEntityNameXRef = new HashMap<String, XmlDocument>();
//XClass are not serializable by default
private transient List<XClass> annotatedClasses = new ArrayList<XClass>();
//only used during the secondPhaseCompile pass, hence does not need to be serialized
private transient Map<String, XClass> annotatedClassesByEntityNameMap = new HashMap<String, XClass>();
private transient List<Class> annotatedClasses = new ArrayList<Class>();
public MetadataSourceQueue(Metadata metadata) {
this.metadata = metadata;
@ -75,24 +70,10 @@ public class MetadataSourceQueue implements Serializable {
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
ois.defaultReadObject();
annotatedClassesByEntityNameMap = new HashMap<String, XClass>();
//build back annotatedClasses
@SuppressWarnings("unchecked")
List<Class> serializableAnnotatedClasses = (List<Class>) ois.readObject();
annotatedClasses = new ArrayList<XClass>( serializableAnnotatedClasses.size() );
for ( Class clazz : serializableAnnotatedClasses ) {
annotatedClasses.add( metadata.getReflectionManager().toXClass( clazz ) );
}
}
private void writeObject(java.io.ObjectOutputStream out) throws IOException {
out.defaultWriteObject();
List<Class> serializableAnnotatedClasses = new ArrayList<Class>( annotatedClasses.size() );
for ( XClass xClass : annotatedClasses ) {
serializableAnnotatedClasses.add( metadata.getReflectionManager().toClass( xClass ) );
}
out.writeObject( serializableAnnotatedClasses );
}
public void add(XmlDocument metadataXml) {
@ -143,28 +124,11 @@ public class MetadataSourceQueue implements Serializable {
return unqualifiedName;
}
public void add(XClass annotatedClass) {
public void add(Class annotatedClass) {
annotatedClasses.add( annotatedClass );
}
protected void syncAnnotatedClasses() {
final Iterator<XClass> itr = annotatedClasses.iterator();
while ( itr.hasNext() ) {
final XClass annotatedClass = itr.next();
if ( annotatedClass.isAnnotationPresent( Entity.class ) ) {
annotatedClassesByEntityNameMap.put( annotatedClass.getName(), annotatedClass );
continue;
}
if ( !annotatedClass.isAnnotationPresent( javax.persistence.MappedSuperclass.class ) ) {
itr.remove();
}
}
}
protected void processMetadata(List<MetadataSourceType> order) {
syncAnnotatedClasses();
for ( MetadataSourceType type : order ) {
if ( MetadataSourceType.HBM.equals( type ) ) {
processHbmXmlQueue();
@ -176,7 +140,7 @@ public class MetadataSourceQueue implements Serializable {
}
private void processHbmXmlQueue() {
LOG.debug( "Processing hbm.xml files" );
log.debug( "Processing hbm.xml files" );
for ( Map.Entry<XmlDocument, Set<String>> entry : hbmMetadataToEntityNamesMap.entrySet() ) {
// Unfortunately we have to create a Mappings instance for each iteration here
processHbmXml( entry.getKey(), entry.getValue() );
@ -196,83 +160,14 @@ public class MetadataSourceQueue implements Serializable {
me
);
}
for ( String entityName : entityNames ) {
if ( annotatedClassesByEntityNameMap.containsKey( entityName ) ) {
annotatedClasses.remove( annotatedClassesByEntityNameMap.get( entityName ) );
annotatedClassesByEntityNameMap.remove( entityName );
}
}
}
private void processAnnotatedClassesQueue() {
LOG.debug( "Process annotated classes" );
//bind classes in the correct order calculating some inheritance state
List<XClass> orderedClasses = orderAndFillHierarchy( annotatedClasses );
// Map<XClass, InheritanceState> inheritanceStatePerClass = AnnotationBinder.buildInheritanceStates(
// orderedClasses, mappings
// );
for ( XClass clazz : orderedClasses ) {
// todo : replace this with similar non-static code.
// AnnotationBinder.bindClass( clazz, inheritanceStatePerClass, mappings );
final String entityName = clazz.getName();
if ( hbmMetadataByEntityNameXRef.containsKey( entityName ) ) {
hbmMetadataToEntityNamesMap.remove( hbmMetadataByEntityNameXRef.get( entityName ) );
hbmMetadataByEntityNameXRef.remove( entityName );
}
}
log.debug( "Process annotated classes" );
annotatedClasses.clear();
annotatedClassesByEntityNameMap.clear();
}
private List<XClass> orderAndFillHierarchy(List<XClass> original) {
List<XClass> copy = new ArrayList<XClass>( original );
insertMappedSuperclasses( original, copy );
// order the hierarchy
List<XClass> workingCopy = new ArrayList<XClass>( copy );
List<XClass> newList = new ArrayList<XClass>( copy.size() );
while ( workingCopy.size() > 0 ) {
XClass clazz = workingCopy.get( 0 );
orderHierarchy( workingCopy, newList, copy, clazz );
}
return newList;
}
private void insertMappedSuperclasses(List<XClass> original, List<XClass> copy) {
for ( XClass clazz : original ) {
XClass superClass = clazz.getSuperclass();
while ( superClass != null
&& !metadata.getReflectionManager().equals( superClass, Object.class )
&& !copy.contains( superClass ) ) {
if ( superClass.isAnnotationPresent( Entity.class )
|| superClass.isAnnotationPresent( javax.persistence.MappedSuperclass.class ) ) {
copy.add( superClass );
}
superClass = superClass.getSuperclass();
}
}
}
private void orderHierarchy(List<XClass> copy, List<XClass> newList, List<XClass> original, XClass clazz) {
if ( clazz == null || metadata.getReflectionManager().equals( clazz, Object.class ) ) {
return;
}
//process superclass first
orderHierarchy( copy, newList, original, clazz.getSuperclass() );
if ( original.contains( clazz ) ) {
if ( !newList.contains( clazz ) ) {
newList.add( clazz );
}
copy.remove( clazz );
}
}
public boolean isEmpty() {
return hbmMetadataToEntityNamesMap.isEmpty() && annotatedClasses.isEmpty();
}
}

336
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/AnnotationBinder.java Normal file
View File

@ -0,0 +1,336 @@
/*
* 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 java.util.Iterator;
import java.util.List;
import javax.persistence.MappedSuperclass;
import org.jboss.jandex.AnnotationInstance;
import org.jboss.jandex.ClassInfo;
import org.jboss.jandex.DotName;
import org.jboss.jandex.Index;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.hibernate.AnnotationException;
import org.hibernate.AssertionFailure;
import org.hibernate.metamodel.source.Metadata;
/**
* Main class responsible to creating and binding the Hibernate meta-model from annotations.
* This binder only has to deal with annotation index. XML configuration is already processed and pseudo annotations
* are added to the annotation index.
*
* @author Hardy Ferentschik
* @todo On top of the index we probably needs to pass some sort of XMLContext for global configuration data
* @todo The annotation index should really be passed at construction time
*/
public class AnnotationBinder {
public static final DotName ENTITY = DotName.createSimple( Entity.class.getName() );
public static final DotName HIBERNATE_ENTITY = DotName.createSimple( org.hibernate.annotations.Entity.class.getName() );
public static final DotName MAPPED_SUPER_CLASS = DotName.createSimple( MappedSuperclass.class.getName() );
private static final Logger log = LoggerFactory.getLogger( AnnotationBinder.class );
private final Metadata metadata;
public AnnotationBinder(Metadata metadata) {
this.metadata = metadata;
}
public void bindMappedClasses(Index annotationIndex) {
// need to order our annotated entities into an order we can process
EntityHierarchyBuilder builder = new EntityHierarchyBuilder();
List<EntityHierarchy> hierarchies = builder.createEntityHierarchies( annotationIndex );
// now we process each hierarchy one at the time
for ( EntityHierarchy hierarchy : hierarchies ) {
Iterator<Entity> iter = hierarchy.iterator();
while ( iter.hasNext() ) {
Entity entity = iter.next();
bindEntity( entity );
}
}
}
public void bindEntity(Entity entity) {
ClassInfo classInfo = entity.getClassInfo();
//@Entity and @MappedSuperclass on the same class leads to a NPE down the road
AnnotationInstance jpaEntityAnnotation = getSingleAnnotation( classInfo, ENTITY );
AnnotationInstance mappedSuperClassAnnotation = getSingleAnnotation( classInfo, MAPPED_SUPER_CLASS );
AnnotationInstance hibernateEntityAnnotation = getSingleAnnotation( classInfo, HIBERNATE_ENTITY );
if ( jpaEntityAnnotation != null && mappedSuperClassAnnotation != null ) {
throw new AnnotationException(
"An entity cannot be annotated with both @Entity and @MappedSuperclass: "
+ classInfo.name().toString()
);
}
// //TODO: be more strict with secondarytable allowance (not for ids, not for secondary table join columns etc)
// InheritanceState inheritanceState = inheritanceStatePerClass.get( clazzToProcess );
// AnnotatedClassType classType = mappings.getClassType( clazzToProcess );
//
// //Queries declared in MappedSuperclass should be usable in Subclasses
// if ( AnnotatedClassType.EMBEDDABLE_SUPERCLASS.equals( classType ) ) {
// bindQueries( clazzToProcess, mappings );
// bindTypeDefs( clazzToProcess, mappings );
// bindFilterDefs( clazzToProcess, mappings );
// }
//
// if ( !isEntityClassType( clazzToProcess, classType ) ) {
// return;
// }
//
log.info( "Binding entity from annotated class: {}", classInfo.name() );
//
// PersistentClass superEntity = getSuperEntity(
// clazzToProcess, inheritanceStatePerClass, mappings, inheritanceState
// );
//
// PersistentClass persistentClass = makePersistentClass( inheritanceState, superEntity );
EntityBinder entityBinder = new EntityBinder(
metadata, classInfo, jpaEntityAnnotation, hibernateEntityAnnotation
);
// entityBinder.setInheritanceState( inheritanceState );
//
// bindQueries( clazzToProcess, mappings );
// bindFilterDefs( clazzToProcess, mappings );
// bindTypeDefs( clazzToProcess, mappings );
// bindFetchProfiles( clazzToProcess, mappings );
// BinderHelper.bindAnyMetaDefs( clazzToProcess, mappings );
//
// String schema = "";
// String table = ""; //might be no @Table annotation on the annotated class
// String catalog = "";
// List<UniqueConstraintHolder> uniqueConstraints = new ArrayList<UniqueConstraintHolder>();
// if ( clazzToProcess.isAnnotationPresent( javax.persistence.Table.class ) ) {
// javax.persistence.Table tabAnn = clazzToProcess.getAnnotation( javax.persistence.Table.class );
// table = tabAnn.name();
// schema = tabAnn.schema();
// catalog = tabAnn.catalog();
// uniqueConstraints = TableBinder.buildUniqueConstraintHolders( tabAnn.uniqueConstraints() );
// }
//
// Ejb3JoinColumn[] inheritanceJoinedColumns = makeInheritanceJoinColumns(
// clazzToProcess, mappings, inheritanceState, superEntity
// );
// Ejb3DiscriminatorColumn discriminatorColumn = null;
// if ( InheritanceType.SINGLE_TABLE.equals( inheritanceState.getType() ) ) {
// discriminatorColumn = processDiscriminatorProperties(
// clazzToProcess, mappings, inheritanceState, entityBinder
// );
// }
//
// entityBinder.setProxy( clazzToProcess.getAnnotation( Proxy.class ) );
// entityBinder.setBatchSize( clazzToProcess.getAnnotation( BatchSize.class ) );
// entityBinder.setWhere( clazzToProcess.getAnnotation( Where.class ) );
// entityBinder.setCache( determineCacheSettings( clazzToProcess, mappings ) );
//
// //Filters are not allowed on subclasses
// if ( !inheritanceState.hasParents() ) {
// bindFilters( clazzToProcess, entityBinder, mappings );
// }
//
// entityBinder.bindEntity();
//
// if ( inheritanceState.hasTable() ) {
// Check checkAnn = clazzToProcess.getAnnotation( Check.class );
// String constraints = checkAnn == null ?
// null :
// checkAnn.constraints();
// entityBinder.bindTable(
// schema, catalog, table, uniqueConstraints,
// constraints, inheritanceState.hasDenormalizedTable() ?
// superEntity.getTable() :
// null
// );
// }
// else {
// if ( clazzToProcess.isAnnotationPresent( Table.class ) ) {
// log.warn(
// "Illegal use of @Table in a subclass of a SINGLE_TABLE hierarchy: " + clazzToProcess
// .getName()
// );
// }
// }
//
// PropertyHolder propertyHolder = PropertyHolderBuilder.buildPropertyHolder(
// clazzToProcess,
// persistentClass,
// entityBinder, mappings, inheritanceStatePerClass
// );
//
// javax.persistence.SecondaryTable secTabAnn = clazzToProcess.getAnnotation(
// javax.persistence.SecondaryTable.class
// );
// javax.persistence.SecondaryTables secTabsAnn = clazzToProcess.getAnnotation(
// javax.persistence.SecondaryTables.class
// );
// entityBinder.firstLevelSecondaryTablesBinding( secTabAnn, secTabsAnn );
//
// OnDelete onDeleteAnn = clazzToProcess.getAnnotation( OnDelete.class );
// boolean onDeleteAppropriate = false;
// if ( InheritanceType.JOINED.equals( inheritanceState.getType() ) && inheritanceState.hasParents() ) {
// onDeleteAppropriate = true;
// final JoinedSubclass jsc = ( JoinedSubclass ) persistentClass;
// if ( persistentClass.getEntityPersisterClass() == null ) {
// persistentClass.getRootClass().setEntityPersisterClass( JoinedSubclassEntityPersister.class );
// }
// SimpleValue key = new DependantValue( mappings, jsc.getTable(), jsc.getIdentifier() );
// jsc.setKey( key );
// ForeignKey fk = clazzToProcess.getAnnotation( ForeignKey.class );
// if ( fk != null && !BinderHelper.isEmptyAnnotationValue( fk.name() ) ) {
// key.setForeignKeyName( fk.name() );
// }
// if ( onDeleteAnn != null ) {
// key.setCascadeDeleteEnabled( OnDeleteAction.CASCADE.equals( onDeleteAnn.action() ) );
// }
// else {
// key.setCascadeDeleteEnabled( false );
// }
// //we are never in a second pass at that stage, so queue it
// SecondPass sp = new JoinedSubclassFkSecondPass( jsc, inheritanceJoinedColumns, key, mappings );
// mappings.addSecondPass( sp );
// mappings.addSecondPass( new CreateKeySecondPass( jsc ) );
//
// }
// else if ( InheritanceType.SINGLE_TABLE.equals( inheritanceState.getType() ) ) {
// if ( inheritanceState.hasParents() ) {
// if ( persistentClass.getEntityPersisterClass() == null ) {
// persistentClass.getRootClass().setEntityPersisterClass( SingleTableEntityPersister.class );
// }
// }
// else {
// if ( inheritanceState.hasSiblings() || !discriminatorColumn.isImplicit() ) {
// //need a discriminator column
// bindDiscriminatorToPersistentClass(
// (RootClass) persistentClass,
// discriminatorColumn,
// entityBinder.getSecondaryTables(),
// propertyHolder,
// mappings
// );
// entityBinder.bindDiscriminatorValue();//bind it again since the type might have changed
// }
// }
// }
// else if ( InheritanceType.TABLE_PER_CLASS.equals( inheritanceState.getType() ) ) {
// if ( inheritanceState.hasParents() ) {
// if ( persistentClass.getEntityPersisterClass() == null ) {
// persistentClass.getRootClass().setEntityPersisterClass( UnionSubclassEntityPersister.class );
// }
// }
// }
// if ( onDeleteAnn != null && !onDeleteAppropriate ) {
// log.warn(
// "Inapropriate use of @OnDelete on entity, annotation ignored: {}", propertyHolder.getEntityName()
// );
// }
//
// // try to find class level generators
// HashMap<String, IdGenerator> classGenerators = buildLocalGenerators( clazzToProcess, mappings );
//
// // check properties
// final InheritanceState.ElementsToProcess elementsToProcess = inheritanceState.getElementsToProcess();
// inheritanceState.postProcess( persistentClass, entityBinder );
//
// final boolean subclassAndSingleTableStrategy = inheritanceState.getType() == InheritanceType.SINGLE_TABLE
// && inheritanceState.hasParents();
// Set<String> idPropertiesIfIdClass = new HashSet<String>();
// boolean isIdClass = mapAsIdClass(
// inheritanceStatePerClass,
// inheritanceState,
// persistentClass,
// entityBinder,
// propertyHolder,
// elementsToProcess,
// idPropertiesIfIdClass,
// mappings
// );
//
// if ( !isIdClass ) {
// entityBinder.setWrapIdsInEmbeddedComponents( elementsToProcess.getIdPropertyCount() > 1 );
// }
//
// processIdPropertiesIfNotAlready(
// inheritanceStatePerClass,
// mappings,
// persistentClass,
// entityBinder,
// propertyHolder,
// classGenerators,
// elementsToProcess,
// subclassAndSingleTableStrategy,
// idPropertiesIfIdClass
// );
//
// if ( !inheritanceState.hasParents() ) {
// final RootClass rootClass = ( RootClass ) persistentClass;
// mappings.addSecondPass( new CreateKeySecondPass( rootClass ) );
// }
// else {
// superEntity.addSubclass( (Subclass) persistentClass );
// }
//
// mappings.addClass( persistentClass );
//
// //Process secondary tables and complementary definitions (ie o.h.a.Table)
// mappings.addSecondPass( new SecondaryTableSecondPass( entityBinder, propertyHolder, clazzToProcess ) );
//
// //add process complementary Table definition (index & all)
// entityBinder.processComplementaryTableDefinitions( clazzToProcess.getAnnotation( org.hibernate.annotations.Table.class ) );
// entityBinder.processComplementaryTableDefinitions( clazzToProcess.getAnnotation( org.hibernate.annotations.Tables.class ) );
}
/**
* @param classInfo the class info from which to retrieve the annotation instance
* @param annotationName the annotation to retrieve from the class info
*
* @return the single annotation defined on the class or {@code null} in case the annotation is not specified at all
*
* @throws AssertionFailure in case there is
*/
private AnnotationInstance getSingleAnnotation(ClassInfo classInfo, DotName annotationName)
throws AssertionFailure {
List<AnnotationInstance> annotationList = classInfo.annotations().get( annotationName );
if ( annotationList == null ) {
return null;
}
else if ( annotationList.size() == 1 ) {
return annotationList.get( 0 );
}
else {
throw new AssertionFailure(
"There should be only one annotation of type " + annotationName + " defined on" + classInfo.name()
);
}
}
}

41
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/Entity.java Normal file
View File

@ -0,0 +1,41 @@
/*
* 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 org.jboss.jandex.ClassInfo;
/**
* Represents an entity or mapped superclass which needs to be mapped.
*
* @author Hardy Ferentschik
*/
public class Entity {
private ClassInfo classInfo;
public ClassInfo getClassInfo() {
return classInfo;
}
}

85
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/EntityBinder.java Normal file
View File

@ -0,0 +1,85 @@
/*
* 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 org.jboss.jandex.AnnotationInstance;
import org.jboss.jandex.ClassInfo;
import org.hibernate.AssertionFailure;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.metamodel.binding.EntityBinding;
import org.hibernate.metamodel.domain.Entity;
import org.hibernate.metamodel.source.Metadata;
/**
* @author Hardy Ferentschik
*/
public class EntityBinder {
private final ClassInfo classToBind;
public EntityBinder(Metadata metadata, ClassInfo classInfo, AnnotationInstance jpaEntityAnnotation, AnnotationInstance hibernateEntityAnnotation) {
this.classToBind = classInfo;
EntityBinding entityBinding = new EntityBinding();
bindJpaAnnotation( jpaEntityAnnotation, entityBinding );
bindHibernateAnnotation( hibernateEntityAnnotation, entityBinding );
metadata.addEntity( entityBinding );
}
private void bindHibernateAnnotation(AnnotationInstance annotation, EntityBinding entityBinding) {
// if ( hibAnn != null ) {
// dynamicInsert = hibAnn.dynamicInsert();
// dynamicUpdate = hibAnn.dynamicUpdate();
// optimisticLockType = hibAnn.optimisticLock();
// selectBeforeUpdate = hibAnn.selectBeforeUpdate();
// polymorphismType = hibAnn.polymorphism();
// explicitHibernateEntityAnnotation = true;
// //persister handled in bind
// }
// else {
// //default values when the annotation is not there
// dynamicInsert = false;
// dynamicUpdate = false;
// optimisticLockType = OptimisticLockType.VERSION;
// polymorphismType = PolymorphismType.IMPLICIT;
// selectBeforeUpdate = false;
// }
}
private void bindJpaAnnotation(AnnotationInstance annotation, EntityBinding entityBinding) {
if ( annotation == null ) {
throw new AssertionFailure( "@Entity cannot be not null when binding an entity" );
}
String name;
if ( annotation.value( "name" ) == null ) {
name = StringHelper.unqualify( classToBind.name().toString() );
}
else {
name = annotation.value( "name" ).asString();
}
entityBinding.setEntity( new Entity( name, null ) );
}
}

38
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/EntityHierarchy.java Normal file
View File

@ -0,0 +1,38 @@
/*
* 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 java.util.Iterator;
/**
* @author Hardy Ferentschik
*/
public class EntityHierarchy implements Iterable<Entity> {
@Override
public Iterator<Entity> iterator() {
return null;
}
}

22
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/EntityHierarchyBuilder.java Normal file
View File

@ -0,0 +1,22 @@
package org.hibernate.metamodel.source.annotations;
import java.util.ArrayList;
import java.util.List;
import org.jboss.jandex.Index;
/**
* Given a annotation index build a list of entity hierarchies.
*
* @author Hardy Ferentschik
*/
public class EntityHierarchyBuilder {
public List<EntityHierarchy> createEntityHierarchies(Index index) {
List<EntityHierarchy> hierarchies = new ArrayList<EntityHierarchy>();
return hierarchies;
}
}

99
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/OrmXmlParser.java Normal file
View File

@ -0,0 +1,99 @@
package org.hibernate.metamodel.source.annotations;
import java.io.InputStream;
import java.net.URL;
import java.util.HashSet;
import java.util.Set;
import javax.validation.ValidationException;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.transform.stream.StreamSource;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import org.jboss.jandex.Index;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;
import org.hibernate.metamodel.source.xml.EntityMappings;
/**
* @author Hardy Ferentschik
* @todo Need some create some XMLContext as well which can be populated w/ information which can not be expressed via annotations
*/
public class OrmXmlParser {
private static final Logger log = LoggerFactory.getLogger( OrmXmlParser.class );
private static final String ORM_MAPPING_XSD = "org/hibernate/ejb/orm_2_0.xsd";
/**
* Parses the given xml configuration files and returns a updated annotation index
*
* @param mappingFileNames the file names of the xml files to parse
* @param annotationIndex the annotation index based on scanned annotations
*
* @return a new updated annotation index, enhancing and modifying the existing ones according to the jpa xml rules
*/
public Index parseAndUpdateIndex(Set<String> mappingFileNames, Index annotationIndex) {
Set<InputStream> mappingStreams = new HashSet<InputStream>();
for ( String fileName : mappingFileNames ) {
mappingStreams.add( getInputStreamForPath( fileName ) );
}
for ( InputStream in : mappingStreams ) {
EntityMappings entityMappings = getEntityMappings( in );
// ...
}
return null;
}
private InputStream getInputStreamForPath(String path) {
// try the context class loader first
InputStream inputStream = Thread.currentThread().getContextClassLoader().getResourceAsStream( path );
// try the current class loader
if ( inputStream == null ) {
inputStream = OrmXmlParser.class.getResourceAsStream( path );
}
return inputStream;
}
private EntityMappings getEntityMappings(InputStream in) {
EntityMappings entityMappings;
Schema schema = getMappingSchema();
try {
JAXBContext jc = JAXBContext.newInstance( EntityMappings.class );
Unmarshaller unmarshaller = jc.createUnmarshaller();
unmarshaller.setSchema( schema );
StreamSource stream = new StreamSource( in );
JAXBElement<EntityMappings> root = unmarshaller.unmarshal( stream, EntityMappings.class );
entityMappings = root.getValue();
}
catch ( JAXBException e ) {
String msg = "Error parsing mapping file.";
log.error( msg );
throw new ValidationException( msg, e );
}
return entityMappings;
}
private Schema getMappingSchema() {
ClassLoader loader = OrmXmlParser.class.getClassLoader();
URL schemaUrl = loader.getResource( ORM_MAPPING_XSD );
SchemaFactory sf = SchemaFactory.newInstance( javax.xml.XMLConstants.W3C_XML_SCHEMA_NS_URI );
Schema schema = null;
try {
schema = sf.newSchema( schemaUrl );
}
catch ( SAXException e ) {
log.debug( "Unable to create schema for {}: {}", ORM_MAPPING_XSD, e.getMessage() );
}
return schema;
}
}

16
hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/AbstractEntityBinder.java
View File

@ -568,22 +568,6 @@ abstract class AbstractEntityBinder {
// return prop;
// }
protected Value processValues(Element identifierElement, TableSpecification baseTable, String propertyPath) {
// first boolean (false here) indicates that by default columns are nullable
// second boolean (true here) indicates that by default column names should be guessed

89
hibernate-core/src/test/java/org/hibernate/metamodel/binding/AbstractBasicBindingTests.java Normal file
View File

@ -0,0 +1,89 @@
/*
* 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.binding;
import org.junit.Test;
import org.hibernate.metamodel.relational.Column;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Basic tests of {@code hbm.xml} and annotation binding code
*
* @author Steve Ebersole
*/
public abstract class AbstractBasicBindingTests extends BaseUnitTestCase {
@Test
public void testSimpleEntityMapping() {
EntityBinding entityBinding = buildSimpleEntityBinding();
assertNotNull( entityBinding );
assertNotNull( entityBinding.getEntityIdentifier() );
assertNotNull( entityBinding.getEntityIdentifier().getValueBinding() );
assertNull( entityBinding.getVersioningValueBinding() );
AttributeBinding idAttributeBinding = entityBinding.getAttributeBinding( "id" );
assertNotNull( idAttributeBinding );
assertSame( idAttributeBinding, entityBinding.getEntityIdentifier().getValueBinding() );
assertNotNull( idAttributeBinding.getAttribute() );
assertNotNull( idAttributeBinding.getValue() );
assertTrue( idAttributeBinding.getValue() instanceof Column );
AttributeBinding nameBinding = entityBinding.getAttributeBinding( "name" );
assertNotNull( nameBinding );
assertNotNull( nameBinding.getAttribute() );
assertNotNull( nameBinding.getValue() );
}
@Test
public void testSimpleVersionedEntityMapping() {
EntityBinding entityBinding = buildSimpleVersionedEntityBinding();
assertNotNull( entityBinding );
assertNotNull( entityBinding.getEntityIdentifier() );
assertNotNull( entityBinding.getEntityIdentifier().getValueBinding() );
assertNotNull( entityBinding.getVersioningValueBinding() );
assertNotNull( entityBinding.getVersioningValueBinding().getAttribute() );
AttributeBinding idAttributeBinding = entityBinding.getAttributeBinding( "id" );
assertNotNull( idAttributeBinding );
assertSame( idAttributeBinding, entityBinding.getEntityIdentifier().getValueBinding() );
assertNotNull( idAttributeBinding.getAttribute() );
assertNotNull( idAttributeBinding.getValue() );
assertTrue( idAttributeBinding.getValue() instanceof Column );
AttributeBinding nameBinding = entityBinding.getAttributeBinding( "name" );
assertNotNull( nameBinding );
assertNotNull( nameBinding.getAttribute() );
assertNotNull( nameBinding.getValue() );
}
public abstract EntityBinding buildSimpleVersionedEntityBinding();
public abstract EntityBinding buildSimpleEntityBinding();
}

88
hibernate-core/src/test/java/org/hibernate/metamodel/binding/BasicAnnotationBindingTests.java Normal file
View File

@ -0,0 +1,88 @@
/*
* 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.binding;
import java.io.IOException;
import java.io.InputStream;
import org.jboss.jandex.Index;
import org.jboss.jandex.Indexer;
import org.junit.Test;
import org.hibernate.metamodel.source.Metadata;
import org.hibernate.testing.FailureExpected;
import static org.junit.Assert.fail;
/**
* Basic tests of annotation based binding code
*
* @author Hardy Ferentschik
*/
public class BasicAnnotationBindingTests extends AbstractBasicBindingTests {
//@FailureExpected(jiraKey = "HHH-5672", message = "Work in progress")
@Test
public void testSimpleEntityMapping() {
super.testSimpleEntityMapping();
}
@FailureExpected(jiraKey = "HHH-5672", message = "Work in progress")
@Test
public void testSimpleVersionedEntityMapping() {
super.testSimpleVersionedEntityMapping();
}
public EntityBinding buildSimpleEntityBinding() {
Index index = indexForClass( SimpleEntity.class );
Metadata metadata = new Metadata();
metadata.getAnnotationBinder().bindMappedClasses( index );
return metadata.getEntityBinding( SimpleEntity.class.getSimpleName() );
}
public EntityBinding buildSimpleVersionedEntityBinding() {
Index index = indexForClass( SimpleEntity.class );
Metadata metadata = new Metadata();
metadata.getAnnotationBinder().bindMappedClasses( index );
return metadata.getEntityBinding( SimpleVersionedEntity.class.getSimpleName() );
}
private Index indexForClass(Class<?>... classes) {
Indexer indexer = new Indexer();
for ( Class<?> clazz : classes ) {
InputStream stream = getClass().getClassLoader().getResourceAsStream(
clazz.getName().replace( '.', '/' ) + ".class"
);
try {
indexer.index( stream );
}
catch ( IOException e ) {
fail( "Unable to index" );
}
}
return indexer.complete();
}
}

63
hibernate-core/src/test/java/org/hibernate/metamodel/binding/BasicHbmBindingTests.java
View File

@ -30,75 +30,32 @@ import org.hibernate.internal.util.xml.MappingReader;
import org.hibernate.internal.util.xml.Origin;
import org.hibernate.internal.util.xml.XMLHelper;
import org.hibernate.internal.util.xml.XmlDocument;
import org.hibernate.metamodel.relational.Column;
import org.hibernate.metamodel.source.Metadata;
import org.junit.Test;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
/**
* Basic tests of {@code hbm.xml} beinding code
* Basic tests of {@code hbm.xml} binding code
*
* @author Steve Ebersole
*/
public class BasicHbmBindingTests extends BaseUnitTestCase {
@Test
public void testSuperSimpleMapping() {
public class BasicHbmBindingTests extends AbstractBasicBindingTests {
public EntityBinding buildSimpleEntityBinding() {
Metadata metadata = new Metadata();
{
XmlDocument xmlDocument = readResource( "/org/hibernate/metamodel/binding/SimpleEntity.hbm.xml" );
metadata.getHibernateXmlBinder().bindRoot( xmlDocument );
EntityBinding entityBinding = metadata.getEntityBinding( SimpleEntity.class.getName() );
assertNotNull( entityBinding );
assertNotNull( entityBinding.getEntityIdentifier() );
assertNotNull( entityBinding.getEntityIdentifier().getValueBinding() );
assertNull( entityBinding.getVersioningValueBinding() );
AttributeBinding idAttributeBinding = entityBinding.getAttributeBinding( "id" );
assertNotNull( idAttributeBinding );
assertSame( idAttributeBinding, entityBinding.getEntityIdentifier().getValueBinding() );
assertNotNull( idAttributeBinding.getAttribute() );
assertNotNull( idAttributeBinding.getValue() );
assertTrue( idAttributeBinding.getValue() instanceof Column );
AttributeBinding nameBinding = entityBinding.getAttributeBinding( "name" );
assertNotNull( nameBinding );
assertNotNull( nameBinding.getAttribute() );
assertNotNull( nameBinding.getValue() );
return metadata.getEntityBinding( SimpleEntity.class.getName() );
}
{
public EntityBinding buildSimpleVersionedEntityBinding() {
Metadata metadata = new Metadata();
XmlDocument xmlDocument = readResource( "/org/hibernate/metamodel/binding/SimpleVersionedEntity.hbm.xml" );
metadata.getHibernateXmlBinder().bindRoot( xmlDocument );
EntityBinding entityBinding = metadata.getEntityBinding( SimpleVersionedEntity.class.getName() );
assertNotNull( entityBinding );
assertNotNull( entityBinding.getEntityIdentifier() );
assertNotNull( entityBinding.getEntityIdentifier().getValueBinding() );
assertNotNull( entityBinding.getVersioningValueBinding() );
assertNotNull( entityBinding.getVersioningValueBinding().getAttribute() );
AttributeBinding idAttributeBinding = entityBinding.getAttributeBinding( "id" );
assertNotNull( idAttributeBinding );
assertSame( idAttributeBinding, entityBinding.getEntityIdentifier().getValueBinding() );
assertNotNull( idAttributeBinding.getAttribute() );
assertNotNull( idAttributeBinding.getValue() );
assertTrue( idAttributeBinding.getValue() instanceof Column );
AttributeBinding nameBinding = entityBinding.getAttributeBinding( "name" );
assertNotNull( nameBinding );
assertNotNull( nameBinding.getAttribute() );
assertNotNull( nameBinding.getValue() );
}
return metadata.getEntityBinding( SimpleVersionedEntity.class.getName() );
}
private XmlDocument readResource(final String name) {
final String path = "/org/hibernate/test/id/Car.hbm.xml";
Origin origin = new Origin() {
@Override
public String getType() {

5
hibernate-core/src/test/java/org/hibernate/metamodel/binding/SimpleEntity.java
View File

@ -23,10 +23,15 @@
*/
package org.hibernate.metamodel.binding;
import javax.persistence.Entity;
import javax.persistence.Id;
/**
* @author Steve Ebersole
*/
@Entity
public class SimpleEntity {
@Id
private Long id;
private String name;

36
hibernate-core/src/test/java/org/hibernate/metamodel/binding/SimpleEntitySubClass.java Normal file
View File

@ -0,0 +1,36 @@
/*
* 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.binding;
import javax.persistence.Entity;
/**
* @author Steve Ebersole
*/
@Entity
public class SimpleEntitySubClass extends SimpleEntity {
public SimpleEntitySubClass() {
}
}

5
hibernate-core/src/test/java/org/hibernate/metamodel/binding/SimpleValueBindingTests.java
View File

@ -25,6 +25,8 @@ package org.hibernate.metamodel.binding;
import java.sql.Types;
import org.junit.Test;
import org.hibernate.metamodel.domain.Entity;
import org.hibernate.metamodel.domain.SingularAttribute;
import org.hibernate.metamodel.relational.Column;
@ -32,9 +34,6 @@ import org.hibernate.metamodel.relational.Datatype;
import org.hibernate.metamodel.relational.Schema;
import org.hibernate.metamodel.relational.Size;
import org.hibernate.metamodel.relational.Table;
import org.junit.Test;
import org.hibernate.testing.junit4.BaseUnitTestCase;
import static org.junit.Assert.assertSame;

2
hibernate-core/src/test/java/org/hibernate/metamodel/binding/SimpleVersionedEntity.java
View File

@ -24,6 +24,8 @@
package org.hibernate.metamodel.binding;
/**
* TODO : javadoc
*
* @author Steve Ebersole
*/
public class SimpleVersionedEntity {

4
hibernate-core/src/test/java/org/hibernate/metamodel/binding/package-info.java Normal file
View File

@ -0,0 +1,4 @@
@GenericGenerator(name = "myGenerator", strategy = "sequence")
package org.hibernate.metamodel.binding;
import org.hibernate.annotations.GenericGenerator;

24
hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/OrmXmlParserTests.java Normal file
View File

@ -0,0 +1,24 @@
package org.hibernate.metamodel.source.annotations;
import java.util.HashSet;
import java.util.Set;
import org.junit.Test;
import org.hibernate.testing.junit4.BaseUnitTestCase;
/**
* @author Hardy Ferentschik
*/
public class OrmXmlParserTests extends BaseUnitTestCase {
@Test
public void testSingleOrmXml() {
OrmXmlParser parser = new OrmXmlParser();
Set<String> xmlFiles = new HashSet<String>();
xmlFiles.add( "org/hibernate/metamodel/source/annotations/orm.xml" );
parser.parseAndUpdateIndex( xmlFiles, null );
}
}

29
hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/orm.xml Normal file
View File

@ -0,0 +1,29 @@
<?xml version="1.0" encoding="UTF-8"?>
<entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
version="2.0">
<package>org.hibernate.test.annotations.onetoone</package>
<entity class="Father">
<attributes>
<id name="id">
<generated-value strategy="AUTO"/>
</id>
<basic name="name"/>
</attributes>
</entity>
<entity class="Son">
<attributes>
<id name="id">
<generated-value strategy="AUTO"/>
</id>
<basic name="name"/>
<one-to-one name="father">
<join-table name="father_son">
<join-column name="foo"/>
<inverse-join-column name="bar"/>
</join-table>
</one-to-one>
</attributes>
</entity>
</entity-mappings>