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

Attempt to match Hibernate code conventions

This commit is contained in:
davidmc24 2010-12-22 00:45:34 -05:00
parent 6de52c2db3
commit e0b06e8a57
36 changed files with 765 additions and 768 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

134
hibernate-core/src/main/java/org/hibernate/cfg/annotations/reflection/JPAOverridenAnnotationReader.java
View File

@ -484,7 +484,6 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
}
}
private Annotation getSequenceGenerator(List<Element> elementsForProperty, XMLContext.Default defaults) {
for (Element element : elementsForProperty) {
Element subelement = element != null ? element.element( annotationToXml.get( SequenceGenerator.class ) ) : null;
@ -673,7 +672,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
getFetchType( ad, element );
getCascades( ad, element, defaults );
getJoinTable( annotationList, element, defaults );
buildJoinColumns( annotationList, element);
buildJoinColumns( annotationList, element );
Annotation annotation = getPrimaryKeyJoinColumns( element, defaults );
addIfNotNull( annotationList, annotation );
copyBooleanAttribute( ad, element, "optional" );
@ -682,15 +681,15 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
getOrderBy( annotationList, element );
getMapKey( annotationList, element );
getMapKeyClass( annotationList, element, defaults );
getMapKeyColumn(annotationList, element);
getOrderColumn(annotationList, element);
getMapKeyTemporal(annotationList, element);
getMapKeyEnumerated(annotationList, element);
getMapKeyColumn( annotationList, element );
getOrderColumn( annotationList, element );
getMapKeyTemporal( annotationList, element );
getMapKeyEnumerated( annotationList, element );
annotation = getMapKeyAttributeOverrides( element, defaults );
addIfNotNull( annotationList, annotation );
buildMapKeyJoinColumns( annotationList, element);
getAssociationId(annotationList, element);
getMapsId(annotationList, element);
buildMapKeyJoinColumns( annotationList, element );
getAssociationId( annotationList, element );
getMapsId( annotationList, element );
annotationList.add( AnnotationFactory.create( ad ) );
getAccessType( annotationList, element );
}
@ -825,8 +824,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
}
}
private void buildMapKeyJoinColumns(List<Annotation> annotationList,
Element element) {
private void buildMapKeyJoinColumns(List<Annotation> annotationList, Element element) {
MapKeyJoinColumn[] joinColumns = getMapKeyJoinColumns( element );
if ( joinColumns.length > 0 ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyJoinColumns.class );
@ -834,11 +832,9 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
annotationList.add( AnnotationFactory.create( ad ) );
}
}
private MapKeyJoinColumn[] getMapKeyJoinColumns(Element element) {
List<Element> subelements = element != null ?
element.elements( "map-key-join-column" ) :
null;
List<Element> subelements = element != null ? element.elements( "map-key-join-column" ) : null;
List<MapKeyJoinColumn> joinColumns = new ArrayList<MapKeyJoinColumn>();
if ( subelements != null ) {
for (Element subelement : subelements) {
@ -857,17 +853,16 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
return joinColumns.toArray( new MapKeyJoinColumn[joinColumns.size()] );
}
private Annotation getMapKeyAttributeOverrides(Element tree,
Default defaults) {
private Annotation getMapKeyAttributeOverrides(Element tree, Default defaults) {
List<AttributeOverride> attributes = buildMapKeyAttributeOverrides( tree );
return mergeAttributeOverrides( defaults, attributes );
}
private List<AttributeOverride> buildMapKeyAttributeOverrides(Element element) {
List<Element> subelements = element == null ? null : element.elements( "map-key-attribute-override" );
return buildMapKeyAttributeOverrides( subelements );
}
private List<AttributeOverride> buildMapKeyAttributeOverrides(List<Element> subelements) {
List<AttributeOverride> overrides = new ArrayList<AttributeOverride>();
if ( subelements != null && subelements.size() > 0 ) {
@ -884,48 +879,42 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
}
/**
* Adds a @MapKeyEnumerated annotation to the specified annotationList if
* the specified element contains a map-key-enumerated sub-element. This
* should only be the case for element-collection, many-to-many, or
* one-to-many associations.
* Adds a @MapKeyEnumerated annotation to the specified annotationList if the specified element
* contains a map-key-enumerated sub-element. This should only be the case for
* element-collection, many-to-many, or one-to-many associations.
*/
private void getMapKeyEnumerated(List<Annotation> annotationList,
Element element) {
private void getMapKeyEnumerated(List<Annotation> annotationList, Element element) {
Element subelement = element != null ? element.element( "map-key-enumerated" ) : null;
if ( subelement != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyEnumerated.class );
EnumType value = EnumType.valueOf(subelement.getTextTrim());
ad.setValue("value", value);
EnumType value = EnumType.valueOf( subelement.getTextTrim() );
ad.setValue( "value", value );
annotationList.add( AnnotationFactory.create( ad ) );
}
}
/**
* Adds a @MapKeyTemporal annotation to the specified annotationList if the
* specified element contains a map-key-temporal sub-element. This should
* only be the case for element-collection, many-to-many, or one-to-many
* associations.
* Adds a @MapKeyTemporal annotation to the specified annotationList if the specified element
* contains a map-key-temporal sub-element. This should only be the case for element-collection,
* many-to-many, or one-to-many associations.
*/
private void getMapKeyTemporal(List<Annotation> annotationList,
Element element) {
private void getMapKeyTemporal(List<Annotation> annotationList, Element element) {
Element subelement = element != null ? element.element( "map-key-temporal" ) : null;
if ( subelement != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapKeyTemporal.class );
TemporalType value = TemporalType.valueOf(subelement.getTextTrim());
ad.setValue("value", value);
TemporalType value = TemporalType.valueOf( subelement.getTextTrim() );
ad.setValue( "value", value );
annotationList.add( AnnotationFactory.create( ad ) );
}
}
/**
* Adds an @OrderColumn annotation to the specified annotationList if the
* specified element contains an order-column sub-element. This should only
* be the case for element-collection, many-to-many, or one-to-many
* associations.
* Adds an @OrderColumn annotation to the specified annotationList if the specified element
* contains an order-column sub-element. This should only be the case for element-collection,
* many-to-many, or one-to-many associations.
*/
private void getOrderColumn(List<Annotation> annotationList,
Element element) {
private void getOrderColumn(List<Annotation> annotationList, Element element) {
Element subelement = element != null ? element.element( "order-column" ) : null;
if ( subelement != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( OrderColumn.class );
@ -939,28 +928,27 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
}
/**
* Adds a @MapsId annotation to the specified annotationList if the
* specified element has the maps-id attribute set. This should only be the
* case for many-to-one or one-to-one associations.
* Adds a @MapsId annotation to the specified annotationList if the specified element has the
* maps-id attribute set. This should only be the case for many-to-one or one-to-one
* associations.
*/
private void getMapsId(List<Annotation> annotationList, Element element) {
String attrVal = element.attributeValue("maps-id");
if(attrVal != null) {
String attrVal = element.attributeValue( "maps-id" );
if ( attrVal != null ) {
AnnotationDescriptor ad = new AnnotationDescriptor( MapsId.class );
ad.setValue("value", attrVal);
ad.setValue( "value", attrVal );
annotationList.add( AnnotationFactory.create( ad ) );
}
}
/**
* Adds an @Id annotation to the specified annotationList if the specified
* element has the id attribute set to true. This should only be the case
* for many-to-one or one-to-one associations.
* Adds an @Id annotation to the specified annotationList if the specified element has the id
* attribute set to true. This should only be the case for many-to-one or one-to-one
* associations.
*/
private void getAssociationId(List<Annotation> annotationList,
Element element) {
String attrVal = element.attributeValue("id");
if("true".equals(attrVal)) {
private void getAssociationId(List<Annotation> annotationList, Element element) {
String attrVal = element.attributeValue( "id" );
if ( "true".equals( attrVal ) ) {
AnnotationDescriptor ad = new AnnotationDescriptor( Id.class );
annotationList.add( AnnotationFactory.create( ad ) );
}
@ -972,8 +960,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
Class clazz;
try {
clazz = ReflectHelper.classForName(
XMLContext.buildSafeClassName( className, defaults ),
this.getClass()
XMLContext.buildSafeClassName( className, defaults ), this.getClass()
);
}
catch (ClassNotFoundException e) {
@ -981,11 +968,11 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
"Unable to find " + element.getPath() + " " + nodeName + ": " + className, e
);
}
ad.setValue( getJavaAttributeNameFromXMLOne(nodeName), clazz );
ad.setValue( getJavaAttributeNameFromXMLOne( nodeName ), clazz );
}
}
// TODO: Complete parsing of all element-collection related xml
//TODO: Complete parsing of all element-collection related xml
private void getElementCollection(List<Annotation> annotationList, XMLContext.Default defaults) {
for ( Element element : elementsForProperty ) {
if ( "element-collection".equals( element.getName() ) ) {
@ -999,24 +986,24 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
//TODO: support map-key-temporal
//TODO: support map-key-enumerated
//TODO: support map-key-attribute-override
getMapKeyColumn(annotationList, element);
getMapKeyColumn( annotationList, element );
//TODO: support map-key-join-column
Annotation annotation = getColumn(element.element( "column" ), false, element);
addIfNotNull(annotationList, annotation);
getTemporal(annotationList, element);
getEnumerated(annotationList, element);
getLob(annotationList, element);
Annotation annotation = getColumn( element.element( "column" ), false, element );
addIfNotNull( annotationList, annotation );
getTemporal( annotationList, element );
getEnumerated( annotationList, element );
getLob( annotationList, element );
annotation = getAttributeOverrides( element, defaults );
addIfNotNull( annotationList, annotation );
annotation = getAssociationOverrides( element, defaults );
addIfNotNull( annotationList, annotation );
getCollectionTable(annotationList, element, defaults);
getCollectionTable( annotationList, element, defaults );
annotationList.add( AnnotationFactory.create( ad ) );
getAccessType( annotationList, element );
}
}
}
private void getOrderBy(List<Annotation> annotationList, Element element) {
Element subelement = element != null ? element.element( "order-by" ) : null;
if ( subelement != null ) {
@ -1036,7 +1023,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
annotationList.add( AnnotationFactory.create( ad ) );
}
}
private void getMapKeyColumn(List<Annotation> annotationList, Element element) {
Element subelement = element != null ? element.element( "map-key-column" ) : null;
if ( subelement != null ) {
@ -1054,7 +1041,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
annotationList.add( AnnotationFactory.create( ad ) );
}
}
private void getMapKeyClass(List<Annotation> annotationList, Element element, XMLContext.Default defaults) {
String nodeName = "map-key-class";
Element subelement = element != null ? element.element( nodeName ) : null;
@ -1065,7 +1052,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
Class clazz;
try {
clazz = ReflectHelper.classForName(
XMLContext.buildSafeClassName( mapKeyClassName, defaults ),
XMLContext.buildSafeClassName(mapKeyClassName, defaults ),
this.getClass()
);
}
@ -1079,7 +1066,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
annotationList.add( AnnotationFactory.create( ad ) );
}
}
private void getCollectionTable(List<Annotation> annotationList, Element element, XMLContext.Default defaults) {
Element subelement = element != null ? element.element( "collection-table" ) : null;
if ( subelement != null ) {
@ -1579,8 +1566,7 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
return mergeAttributeOverrides( defaults, attributes );
}
private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults,
List<AttributeOverride> attributes) {
private AttributeOverrides mergeAttributeOverrides(XMLContext.Default defaults, List<AttributeOverride> attributes) {
if ( defaults.canUseJavaAnnotations() ) {
AttributeOverride annotation = getJavaAnnotation( AttributeOverride.class );
addAttributeOverrideIfNeeded( annotation, attributes );
@ -1789,8 +1775,8 @@ public class JPAOverridenAnnotationReader implements AnnotationReader {
Class clazz;
try {
clazz = ReflectHelper.classForName(
XMLContext.buildSafeClassName( clazzName, defaults ),
JPAOverridenAnnotationReader.class
XMLContext.buildSafeClassName( clazzName, defaults ),
JPAOverridenAnnotationReader.class
);
}
catch (ClassNotFoundException e) {

322
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlManyToOneTest.java
View File

@ -37,198 +37,200 @@ import javax.persistence.MapsId;
import javax.persistence.UniqueConstraint;
public class Ejb3XmlManyToOneTest extends Ejb3XmlTestCase {
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());
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.
*/
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);
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());
assertEquals( 1, joinColumns.length );
assertEquals( "col1", joinColumns[0].name() );
assertEquals( "col2", joinColumns[0].referencedColumnName() );
assertEquals( "table1", joinColumns[0].table() );
}
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);
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());
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() );
}
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);
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 );
}
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());
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
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(1, uniqueConstraints[0].columnNames().length);
assertEquals("col5", uniqueConstraints[0].columnNames()[0]);
assertEquals(2, uniqueConstraints[1].columnNames().length);
assertEquals("col6", uniqueConstraints[1].columnNames()[0]);
assertEquals("col7", uniqueConstraints[1].columnNames()[1]);
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( 1, uniqueConstraints[0].columnNames().length );
assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
assertEquals( 2, uniqueConstraints[1].columnNames().length );
assertEquals( "col6", uniqueConstraints[1].columnNames()[0] );
assertEquals( "col7", uniqueConstraints[1].columnNames()[1] );
}
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());
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() );
}
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]);
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] );
}
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]);
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.
*/
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]);
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] );
}
//TODO: tests for merging/overriding
}

800
hibernate-core/src/test/java/org/hibernate/test/annotations/xml/ejb3/Ejb3XmlOneToManyTest.java
View File

@ -48,474 +48,482 @@ import javax.persistence.TemporalType;
import javax.persistence.UniqueConstraint;
public class Ejb3XmlOneToManyTest extends Ejb3XmlTestCase {
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());
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() );
}
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());
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() );
}
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());
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() );
}
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());
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() );
}
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());
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() );
}
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());
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() );
}
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());
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() );
}
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());
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() );
}
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());
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.
*/
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);
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());
assertEquals( 1, overrides.length );
assertEquals( "field1", overrides[0].name() );
assertEquals( "col1", overrides[0].column().name() );
}
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);
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());
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() );
}
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());
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() );
}
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());
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.
*/
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);
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());
assertEquals( 1, joinColumns.length );
assertEquals( "col1", joinColumns[0].name() );
}
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);
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());
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() );
}
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);
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 );
}
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());
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
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(1, uniqueConstraints[0].columnNames().length);
assertEquals("col5", uniqueConstraints[0].columnNames()[0]);
assertEquals(2, uniqueConstraints[1].columnNames().length);
assertEquals("col6", uniqueConstraints[1].columnNames()[0]);
assertEquals("col7", uniqueConstraints[1].columnNames()[1]);
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( 1, uniqueConstraints[0].columnNames().length );
assertEquals( "col5", uniqueConstraints[0].columnNames()[0] );
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.
*/
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);
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());
assertEquals( 1, joinColumns.length );
assertEquals( "col1", joinColumns[0].name() );
assertEquals( "col2", joinColumns[0].referencedColumnName() );
assertEquals( "table1", joinColumns[0].table() );
}
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);
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());
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() );
}
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]);
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] );
}
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]);
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.
*/
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]);
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] );
}
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());
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() );
}
//TODO: tests for merging/overriding
}

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

@ -36,39 +36,40 @@ import org.hibernate.test.annotations.TestCase;
abstract class Ejb3XmlTestCase extends TestCase {
protected JPAOverridenAnnotationReader reader;
protected void assertAnnotationPresent(Class<? extends Annotation> annotationType) {
assertTrue(reader.isAnnotationPresent(annotationType));
assertTrue( reader.isAnnotationPresent( annotationType ) );
}
protected void assertAnnotationNotPresent(Class<? extends Annotation> annotationType) {
assertFalse(reader.isAnnotationPresent(annotationType));
assertFalse( reader.isAnnotationPresent( annotationType ) );
}
protected JPAOverridenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName) throws Exception {
AnnotatedElement el = getAnnotatedElement(entityClass, fieldName);
XMLContext xmlContext = getContext(ormResourceName);
JPAOverridenAnnotationReader reader = new JPAOverridenAnnotationReader(el, xmlContext);
protected JPAOverridenAnnotationReader getReader(Class<?> entityClass, String fieldName, String ormResourceName)
throws Exception {
AnnotatedElement el = getAnnotatedElement( entityClass, fieldName );
XMLContext xmlContext = getContext( ormResourceName );
JPAOverridenAnnotationReader reader = new JPAOverridenAnnotationReader( el, xmlContext );
return reader;
}
protected AnnotatedElement getAnnotatedElement(Class<?> entityClass, String fieldName) throws Exception {
return entityClass.getDeclaredField(fieldName);
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);
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();
Document doc = new SAXReader().read(is);
xmlContext.addDocument(doc);
Document doc = new SAXReader().read( is );
xmlContext.addDocument( doc );
return xmlContext;
}
@Override
protected Class<?>[] getAnnotatedClasses() {
return new Class<?>[0];

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm1.xml
View File

@ -28,12 +28,12 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1">
<attributes>
<many-to-one name="field1" />
<many-to-one name="field1"/>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm2.xml
View File

@ -28,15 +28,15 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1">
<attributes>
<many-to-one name="field1">
<join-column name="col1" referenced-column-name="col2"
table="table1" />
table="table1"/>
</many-to-one>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm3.xml
View File

@ -28,17 +28,17 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1">
<attributes>
<many-to-one name="field1">
<join-column />
<join-column/>
<join-column name="col1" referenced-column-name="col2"
table="table1" insertable="false" updatable="false"
column-definition="int" nullable="false" unique="true" />
column-definition="int" nullable="false" unique="true"/>
</many-to-one>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm4.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1">
<attributes>
<many-to-one name="field1">
<join-table />
<join-table/>
</many-to-one>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm5.xml
View File

@ -28,21 +28,21 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1">
<attributes>
<many-to-one name="field1">
<join-table name="table1" catalog="cat1" schema="schema1">
<join-column />
<join-column/>
<join-column name="col1" referenced-column-name="col2"
table="table2" column-definition="int" insertable="false"
updatable="false" nullable="false" unique="true" />
<inverse-join-column />
updatable="false" nullable="false" unique="true"/>
<inverse-join-column/>
<inverse-join-column name="col3"
referenced-column-name="col4" table="table3" column-definition="int"
insertable="false" updatable="false" nullable="false" unique="true" />
insertable="false" updatable="false" nullable="false" unique="true"/>
<unique-constraint>
<column-name>col5</column-name>
</unique-constraint>
@ -54,4 +54,4 @@
</many-to-one>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm6.xml
View File

@ -28,13 +28,13 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1">
<attributes>
<many-to-one name="field1" target-entity="Entity3" fetch="LAZY"
optional="false" access="PROPERTY" maps-id="col1" id="true" />
optional="false" access="PROPERTY" maps-id="col1" id="true"/>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm7.xml
View File

@ -28,16 +28,16 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity1">
<attributes>
<many-to-one name="field1">
<cascade>
<cascade-all />
<cascade-all/>
</cascade>
</many-to-one>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm8.xml
View File

@ -28,9 +28,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
<persistence-unit-defaults>
<cascade-persist />
<cascade-persist/>
</persistence-unit-defaults>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
@ -38,11 +38,11 @@
<attributes>
<many-to-one name="field1">
<cascade>
<cascade-remove />
<cascade-refresh />
<cascade-detach />
<cascade-remove/>
<cascade-refresh/>
<cascade-detach/>
</cascade>
</many-to-one>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

18
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/many-to-one.orm9.xml
View File

@ -28,9 +28,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
<persistence-unit-defaults>
<cascade-persist />
<cascade-persist/>
</persistence-unit-defaults>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
@ -38,14 +38,14 @@
<attributes>
<many-to-one name="field1">
<cascade>
<cascade-all />
<cascade-persist />
<cascade-merge />
<cascade-remove />
<cascade-refresh />
<cascade-detach />
<cascade-all/>
<cascade-persist/>
<cascade-merge/>
<cascade-remove/>
<cascade-refresh/>
<cascade-detach/>
</cascade>
</many-to-one>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm1.xml
View File

@ -28,12 +28,12 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1" />
<one-to-many name="field1"/>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm10.xml
View File

@ -28,16 +28,16 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
<attributes>
<one-to-many name="field1">
<map-key-attribute-override name="field1">
<column name="col1" />
<column name="col1"/>
</map-key-attribute-override>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm11.xml
View File

@ -28,21 +28,21 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
<attributes>
<one-to-many name="field1">
<map-key-attribute-override name="field1">
<column />
<column/>
</map-key-attribute-override>
<map-key-attribute-override name="field2">
<column name="col1" column-definition="int" insertable="false"
nullable="false" length="50" precision="2" scale="1" table="table1"
unique="true" updatable="false" />
unique="true" updatable="false"/>
</map-key-attribute-override>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm12.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
<attributes>
<one-to-many name="field1">
<map-key-column />
<map-key-column/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm13.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
@ -36,8 +36,8 @@
<one-to-many name="field1">
<map-key-column column-definition="int" insertable="false"
length="50" name="col1" nullable="true" precision="2" scale="1"
table="table1" unique="true" updatable="false" />
table="table1" unique="true" updatable="false"/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm14.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
@ -38,4 +38,4 @@
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm15.xml
View File

@ -28,18 +28,18 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
<attributes>
<one-to-many name="field1">
<map-key-join-column />
<map-key-join-column/>
<map-key-join-column name="col1"
column-definition="int" insertable="false" nullable="true"
referenced-column-name="col2" table="table1" unique="true"
updatable="false" />
updatable="false"/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm16.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
@ -38,4 +38,4 @@
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm17.xml
View File

@ -28,21 +28,21 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1">
<join-table name="table1" catalog="cat1" schema="schema1">
<join-column />
<join-column/>
<join-column name="col1" referenced-column-name="col2"
table="table2" column-definition="int" insertable="false"
updatable="false" nullable="false" unique="true" />
<inverse-join-column />
updatable="false" nullable="false" unique="true"/>
<inverse-join-column/>
<inverse-join-column name="col3"
referenced-column-name="col4" table="table3" column-definition="int"
insertable="false" updatable="false" nullable="false" unique="true" />
insertable="false" updatable="false" nullable="false" unique="true"/>
<unique-constraint>
<column-name>col5</column-name>
</unique-constraint>
@ -54,4 +54,4 @@
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm18.xml
View File

@ -28,15 +28,15 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1">
<join-column name="col1" referenced-column-name="col2"
table="table1" />
table="table1"/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

8
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm19.xml
View File

@ -28,17 +28,17 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1">
<join-column />
<join-column/>
<join-column name="col1" referenced-column-name="col2"
table="table1" insertable="false" updatable="false"
column-definition="int" nullable="false" unique="true" />
column-definition="int" nullable="false" unique="true"/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm2.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
@ -38,4 +38,4 @@
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm20.xml
View File

@ -23,16 +23,16 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1">
<cascade>
<cascade-all />
<cascade-all/>
</cascade>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

12
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm21.xml
View File

@ -23,9 +23,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
<persistence-unit-defaults>
<cascade-persist />
<cascade-persist/>
</persistence-unit-defaults>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
@ -33,11 +33,11 @@
<attributes>
<one-to-many name="field1">
<cascade>
<cascade-remove />
<cascade-refresh />
<cascade-detach />
<cascade-remove/>
<cascade-refresh/>
<cascade-detach/>
</cascade>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

18
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm22.xml
View File

@ -23,9 +23,9 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
<persistence-unit-defaults>
<cascade-persist />
<cascade-persist/>
</persistence-unit-defaults>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
@ -33,14 +33,14 @@
<attributes>
<one-to-many name="field1">
<cascade>
<cascade-all />
<cascade-persist />
<cascade-merge />
<cascade-remove />
<cascade-refresh />
<cascade-detach />
<cascade-all/>
<cascade-persist/>
<cascade-merge/>
<cascade-remove/>
<cascade-refresh/>
<cascade-detach/>
</cascade>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm23.xml
View File

@ -23,13 +23,13 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1" access="PROPERTY" fetch="EAGER"
mapped-by="field2" orphan-removal="true" target-entity="Entity3" />
mapped-by="field2" orphan-removal="true" target-entity="Entity3"/>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm3.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1">
<order-column />
<order-column/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm4.xml
View File

@ -28,15 +28,15 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity2">
<attributes>
<one-to-many name="field1">
<order-column column-definition="int" name="col1"
insertable="false" nullable="false" updatable="false" />
insertable="false" nullable="false" updatable="false"/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm5.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
<attributes>
<one-to-many name="field1">
<map-key />
<map-key/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm6.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
<attributes>
<one-to-many name="field1">
<map-key name="field2" />
<map-key name="field2"/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

6
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm7.xml
View File

@ -28,14 +28,14 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
<attributes>
<one-to-many name="field1">
<map-key-class class="Entity2" />
<map-key-class class="Entity2"/>
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm8.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
@ -38,4 +38,4 @@
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>

4
hibernate-core/src/test/resources/org/hibernate/test/annotations/xml/ejb3/one-to-many.orm9.xml
View File

@ -28,7 +28,7 @@
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm http://java.sun.com/xml/ns/persistence/orm_2_0.xsd"
version="2.0">
<persistence-unit-metadata>
<xml-mapping-metadata-complete />
<xml-mapping-metadata-complete/>
</persistence-unit-metadata>
<package>org.hibernate.test.annotations.xml.ejb3</package>
<entity class="Entity3">
@ -38,4 +38,4 @@
</one-to-many>
</attributes>
</entity>
</entity-mappings>
</entity-mappings>