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

HHH-6371 - Develop metamodel binding creation using a push approach

This commit is contained in:
Steve Ebersole 2011-07-13 08:43:27 -05:00
parent 24edf42c04
commit c97075c3c8
34 changed files with 351 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
hibernate-core/src/main/java/org/hibernate/annotations/CacheConcurrencyStrategy.java
View File

@ -43,6 +43,11 @@ public enum CacheConcurrencyStrategy {
this.accessType = accessType;
}
private boolean isMatch(String name) {
return ( accessType != null && accessType.getExternalName().equalsIgnoreCase( name ) )
|| name().equalsIgnoreCase( name );
}
public static CacheConcurrencyStrategy fromAccessType(AccessType accessType) {
switch ( accessType ) {
case READ_ONLY: {
@ -64,19 +69,19 @@ public enum CacheConcurrencyStrategy {
}
public static CacheConcurrencyStrategy parse(String name) {
if ( READ_ONLY.accessType.getExternalName().equalsIgnoreCase( name ) ) {
if ( READ_ONLY.isMatch( name ) ) {
return READ_ONLY;
}
else if ( READ_WRITE.accessType.getExternalName().equalsIgnoreCase( name ) ) {
else if ( READ_WRITE.isMatch( name ) ) {
return READ_WRITE;
}
else if ( NONSTRICT_READ_WRITE.accessType.getExternalName().equalsIgnoreCase( name ) ) {
else if ( NONSTRICT_READ_WRITE.isMatch( name ) ) {
return NONSTRICT_READ_WRITE;
}
else if ( TRANSACTIONAL.accessType.getExternalName().equalsIgnoreCase( name ) ) {
else if ( TRANSACTIONAL.isMatch( name ) ) {
return TRANSACTIONAL;
}
else if ( "none".equalsIgnoreCase( name ) ) {
else if ( NONE.isMatch( name ) ) {
return NONE;
}
else {

2
hibernate-core/src/main/java/org/hibernate/dialect/function/CastFunction.java
View File

@ -57,7 +57,7 @@ public class CastFunction implements SQLFunction {
}
String sqlType = factory.getDialect().getCastTypeName( sqlTypeCodes[0] );
if (sqlType==null) {
//TODO: never reached, since getTypeName() actually throws an exception!
//TODO: never reached, since getExplicitHibernateTypeName() actually throws an exception!
sqlType = type;
}
/*else {

5
hibernate-core/src/main/java/org/hibernate/metamodel/binding/AbstractAttributeBinding.java
View File

@ -70,8 +70,9 @@ public abstract class AbstractAttributeBinding implements AttributeBinding {
}
protected void initialize(AttributeBindingState state) {
hibernateTypeDescriptor.setExplicitTypeName( state.getTypeName() );
hibernateTypeDescriptor.setTypeParameters( state.getTypeParameters() );
hibernateTypeDescriptor.setExplicitTypeName( state.getExplicitHibernateTypeName() );
hibernateTypeDescriptor.setTypeParameters( state.getExplicitHibernateTypeParameters() );
hibernateTypeDescriptor.setJavaTypeName( state.getJavaTypeName() );
isLazy = state.isLazy();
propertyAccessorName = state.getPropertyAccessorName();
isAlternateUniqueKey = state.isAlternateUniqueKey();

1
hibernate-core/src/main/java/org/hibernate/metamodel/binding/SimpleAttributeBinding.java
View File

@ -24,6 +24,7 @@
package org.hibernate.metamodel.binding;
import org.hibernate.mapping.PropertyGeneration;
import org.hibernate.metamodel.domain.AbstractAttributeContainer;
import org.hibernate.metamodel.source.MetaAttributeContext;
import org.hibernate.metamodel.binding.state.SimpleAttributeBindingState;
import org.hibernate.metamodel.domain.SingularAttribute;

6
hibernate-core/src/main/java/org/hibernate/metamodel/binding/state/AttributeBindingState.java
View File

@ -35,9 +35,11 @@ import org.hibernate.metamodel.binding.CascadeType;
public interface AttributeBindingState {
String getAttributeName();
String getTypeName();
String getJavaTypeName();
Map<String, String> getTypeParameters();
String getExplicitHibernateTypeName();
Map<String, String> getExplicitHibernateTypeParameters();
boolean isLazy();

1
hibernate-core/src/main/java/org/hibernate/metamodel/domain/AttributeContainer.java
View File

@ -49,6 +49,7 @@ public interface AttributeContainer extends Type {
public Set<Attribute> getAttributes();
public SingularAttribute locateOrCreateSingularAttribute(String name);
public PluralAttribute locateOrCreatePluralAttribute(String name, PluralAttributeNature nature);
public PluralAttribute locateOrCreateBag(String name);
public PluralAttribute locateOrCreateSet(String name);

4
hibernate-core/src/main/java/org/hibernate/metamodel/domain/SingularAttribute.java
View File

@ -35,4 +35,8 @@ public interface SingularAttribute extends Attribute {
* @return THe attribute type.
*/
public Type getSingularAttributeType();
public boolean isTypeResolved();
public void resolveType(Type type);
}

2
hibernate-core/src/main/java/org/hibernate/metamodel/relational/Identifier.java
View File

@ -57,7 +57,7 @@ public class Identifier {
}
}
private static boolean isQuoted(String name) {
public static boolean isQuoted(String name) {
return name.startsWith( "`" ) && name.endsWith( "`" );
}

3
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/AnnotationsSourceProcessor.java
View File

@ -128,8 +128,9 @@ public class AnnotationsSourceProcessor implements SourceProcessor, AnnotationsB
index = parseAndUpdateIndex( mappings, index );
}
if( index.getAnnotations( PseudoJpaDotNames.DEFAULT_DELIMITED_IDENTIFIERS ) != null ) {
if ( index.getAnnotations( PseudoJpaDotNames.DEFAULT_DELIMITED_IDENTIFIERS ) != null ) {
// todo : this needs to move to AnnotationBindingContext
// what happens right now is that specifying this in an orm.xml causes it to effect all orm.xmls
metadata.setGloballyQuotedIdentifiers( true );
}
}

10
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/attribute/AssociationAttribute.java
View File

@ -46,12 +46,12 @@ public class AssociationAttribute extends SimpleAttribute {
private final String referencedEntityType;
private final Set<CascadeType> cascadeTypes;
public static AssociationAttribute createAssociationAttribute(String name, String type, AttributeType associationType, Map<DotName, List<AnnotationInstance>> annotations) {
return new AssociationAttribute( name, type, associationType, annotations );
public static AssociationAttribute createAssociationAttribute(String name, Class<?> javaType, AttributeType associationType, Map<DotName, List<AnnotationInstance>> annotations) {
return new AssociationAttribute( name, javaType, associationType, annotations );
}
private AssociationAttribute(String name, String type, AttributeType associationType, Map<DotName, List<AnnotationInstance>> annotations) {
super( name, type, annotations, false );
private AssociationAttribute(String name, Class<?> javaType, AttributeType associationType, Map<DotName, List<AnnotationInstance>> annotations) {
super( name, javaType, annotations, false );
this.associationType = associationType;
this.ignoreNotFound = ignoreNotFound();
@ -94,7 +94,7 @@ public class AssociationAttribute extends SimpleAttribute {
}
private String determineReferencedEntityType(AnnotationInstance associationAnnotation) {
String targetTypeName = getType();
String targetTypeName = getJavaType().getName();
AnnotationInstance targetAnnotation = getIfExists( HibernateDotNames.TARGET );
if ( targetAnnotation != null ) {

2
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/attribute/AttributeOverride.java
View File

@ -5,7 +5,7 @@ import org.jboss.jandex.AnnotationInstance;
import org.hibernate.AssertionFailure;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.metamodel.source.annotations.JPADotNames;
import org.hibernate.metamodel.source.annotations.util.JandexHelper;
import org.hibernate.metamodel.source.annotations.JandexHelper;
/**
* Contains the information about a single {@link javax.persistence.AttributeOverride}. Instances of this class

91
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/attribute/MappedAttribute.java
View File

@ -50,34 +50,58 @@ public abstract class MappedAttribute implements Comparable<MappedAttribute> {
*/
private final String name;
/**
* Optional type parameters for custom types.
*/
private final Map<String, String> typeParameters;
private final Class<?> javaType;
/**
* The property type as string.
*/
private final String type;
private final String explicitHibernateTypeName;
MappedAttribute(String name, String type, Map<DotName, List<AnnotationInstance>> annotations) {
private final Map<String, String> explicitHibernateTypeParameters;
MappedAttribute(String name, Class<?> javaType, Map<DotName, List<AnnotationInstance>> annotations) {
this.annotations = annotations;
this.name = name;
this.typeParameters = new HashMap<String, String>();
this.type = determineType( type, typeParameters );
this.javaType = javaType;
final AnnotationInstance typeAnnotation = getIfExists( HibernateDotNames.TYPE );
if ( typeAnnotation != null ) {
this.explicitHibernateTypeName = typeAnnotation.value( "type" ).asString();
this.explicitHibernateTypeParameters = extractTypeParameters( typeAnnotation );
}
else {
this.explicitHibernateTypeName = null;
this.explicitHibernateTypeParameters = new HashMap<String, String>();
}
}
private Map<String, String> extractTypeParameters(AnnotationInstance typeAnnotation) {
HashMap<String,String> typeParameters = new HashMap<String, String>();
AnnotationValue parameterAnnotationValue = typeAnnotation.value( "parameters" );
if ( parameterAnnotationValue != null ) {
AnnotationInstance[] parameterAnnotations = parameterAnnotationValue.asNestedArray();
for ( AnnotationInstance parameterAnnotationInstance : parameterAnnotations ) {
typeParameters.put(
parameterAnnotationInstance.value( "name" ).asString(),
parameterAnnotationInstance.value( "value" ).asString()
);
}
}
return typeParameters;
}
public String getName() {
return name;
}
public final String getType() {
return type;
public final Class<?> getJavaType() {
return javaType;
}
public Map<String, String> getTypeParameters() {
return typeParameters;
public String getExplicitHibernateTypeName() {
return explicitHibernateTypeName;
}
public Map<String, String> getExplicitHibernateTypeParameters() {
return explicitHibernateTypeParameters;
}
/**
@ -101,6 +125,10 @@ public abstract class MappedAttribute implements Comparable<MappedAttribute> {
}
}
Map<DotName, List<AnnotationInstance>> annotations() {
return annotations;
}
@Override
public int compareTo(MappedAttribute mappedProperty) {
return name.compareTo( mappedProperty.getName() );
@ -114,39 +142,6 @@ public abstract class MappedAttribute implements Comparable<MappedAttribute> {
sb.append( '}' );
return sb.toString();
}
Map<DotName, List<AnnotationInstance>> annotations() {
return annotations;
}
/**
* We need to check whether the is an explicit type specified via {@link org.hibernate.annotations.Type}.
*
* @param type the type specified via the constructor
* @param typeParameters map for type parameters in case there are any
*
* @return the final type for this mapped attribute
*/
private String determineType(String type, Map<String, String> typeParameters) {
AnnotationInstance typeAnnotation = getIfExists( HibernateDotNames.TYPE );
if ( typeAnnotation == null ) {
// return discovered type
return type;
}
AnnotationValue parameterAnnotationValue = typeAnnotation.value( "parameters" );
if ( parameterAnnotationValue != null ) {
AnnotationInstance[] parameterAnnotations = parameterAnnotationValue.asNestedArray();
for ( AnnotationInstance parameterAnnotationInstance : parameterAnnotations ) {
typeParameters.put(
parameterAnnotationInstance.value( "name" ).asString(),
parameterAnnotationInstance.value( "value" ).asString()
);
}
}
return typeAnnotation.value( "type" ).asString();
}
}

14
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/attribute/SimpleAttribute.java
View File

@ -86,12 +86,12 @@ public class SimpleAttribute extends MappedAttribute {
*/
private ColumnValues columnValues;
public static SimpleAttribute createSimpleAttribute(String name, String type, Map<DotName, List<AnnotationInstance>> annotations) {
public static SimpleAttribute createSimpleAttribute(String name, Class<?> type, Map<DotName, List<AnnotationInstance>> annotations) {
return new SimpleAttribute( name, type, annotations, false );
}
public static SimpleAttribute createSimpleAttribute(SimpleAttribute simpleAttribute, ColumnValues columnValues) {
SimpleAttribute attribute = new SimpleAttribute( simpleAttribute.getName(), simpleAttribute.getType(), simpleAttribute.annotations(), false );
SimpleAttribute attribute = new SimpleAttribute( simpleAttribute.getName(), simpleAttribute.getJavaType(), simpleAttribute.annotations(), false );
attribute.columnValues = columnValues;
return attribute;
}
@ -101,7 +101,7 @@ public class SimpleAttribute extends MappedAttribute {
annotations, JPADotNames.DISCRIMINATOR_COLUMN
);
String name = DiscriminatorColumnValues.DEFAULT_DISCRIMINATOR_COLUMN_NAME;
String type = String.class.toString(); // string is the discriminator default
Class<?> type = String.class; // string is the discriminator default
if ( discriminatorOptionsAnnotation != null ) {
name = discriminatorOptionsAnnotation.value( "name" ).asString();
@ -110,15 +110,15 @@ public class SimpleAttribute extends MappedAttribute {
);
switch ( discriminatorType ) {
case STRING: {
type = String.class.toString();
type = String.class;
break;
}
case CHAR: {
type = Character.class.toString();
type = Character.class;
break;
}
case INTEGER: {
type = Integer.class.toString();
type = Integer.class;
break;
}
default: {
@ -129,7 +129,7 @@ public class SimpleAttribute extends MappedAttribute {
return new SimpleAttribute( name, type, annotations, true );
}
SimpleAttribute(String name, String type, Map<DotName, List<AnnotationInstance>> annotations, boolean isDiscriminator) {
SimpleAttribute(String name, Class<?> type, Map<DotName, List<AnnotationInstance>> annotations, boolean isDiscriminator) {
super( name, type, annotations );
this.isDiscriminator = isDiscriminator;

13
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/attribute/state/binding/AttributeBindingStateImpl.java
View File

@ -67,13 +67,18 @@ public class AttributeBindingStateImpl implements SimpleAttributeBindingState {
}
@Override
public String getTypeName() {
return mappedAttribute.getType();
public String getJavaTypeName() {
return mappedAttribute.getJavaType().getName();
}
@Override
public Map<String, String> getTypeParameters() {
return mappedAttribute.getTypeParameters();
public String getExplicitHibernateTypeName() {
return mappedAttribute.getJavaType().getName();
}
@Override
public Map<String, String> getExplicitHibernateTypeParameters() {
return mappedAttribute.getExplicitHibernateTypeParameters();
}
@Override

8
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/entity/ConfiguredClass.java
View File

@ -430,11 +430,7 @@ public class ConfiguredClass {
AttributeType attributeType = determineAttributeType( annotations );
switch ( attributeType ) {
case BASIC: {
SimpleAttribute attribute = SimpleAttribute.createSimpleAttribute(
attributeName,
type.getName(),
annotations
);
SimpleAttribute attribute = SimpleAttribute.createSimpleAttribute( attributeName, type, annotations );
if ( attribute.isId() ) {
idAttributeMap.put( attributeName, attribute );
}
@ -452,7 +448,7 @@ public class ConfiguredClass {
// TODO handle the different association types
default: {
AssociationAttribute attribute = AssociationAttribute.createAssociationAttribute(
attributeName, type.getName(), attributeType, annotations
attributeName, type, attributeType, annotations
);
associationAttributeMap.put( attributeName, attribute );
}

100
hibernate-core/src/main/java/org/hibernate/metamodel/source/annotations/entity/EntityBinder.java
View File

@ -125,6 +125,10 @@ public class EntityBinder {
}
}
if ( bindingContext.isGloballyQuotedIdentifiers() ) {
schema = StringHelper.quote( schema );
catalog = StringHelper.quote( catalog );
}
return new Schema.Name( schema, catalog );
}
@ -400,13 +404,13 @@ public class EntityBinder {
final AnnotationInstance sqlUpdateAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(), HibernateDotNames.SQL_UPDATE
);
entityBinding.setCustomInsert( createCustomSQL( sqlUpdateAnnotation ) );
entityBinding.setCustomUpdate( createCustomSQL( sqlUpdateAnnotation ) );
// Custom sql delete
final AnnotationInstance sqlDeleteAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(), HibernateDotNames.SQL_DELETE
);
entityBinding.setCustomInsert( createCustomSQL( sqlDeleteAnnotation ) );
entityBinding.setCustomDelete( createCustomSQL( sqlDeleteAnnotation ) );
// Batch size
final AnnotationInstance batchSizeAnnotation = JandexHelper.getSingleAnnotation(
@ -423,12 +427,17 @@ public class EntityBinder {
if ( hibernateProxyAnnotation != null ) {
lazy = hibernateProxyAnnotation.value( "lazy" ) == null
|| hibernateProxyAnnotation.value( "lazy" ).asBoolean();
final AnnotationValue proxyClassValue = hibernateProxyAnnotation.value( "proxyClass" );
if ( proxyClassValue == null ) {
proxyInterfaceType = entity.getClassReferenceUnresolved();
if ( lazy ) {
final AnnotationValue proxyClassValue = hibernateProxyAnnotation.value( "proxyClass" );
if ( proxyClassValue == null ) {
proxyInterfaceType = entity.getClassReferenceUnresolved();
}
else {
proxyInterfaceType = bindingContext.makeClassReference( proxyClassValue.asString() );
}
}
else {
proxyInterfaceType = bindingContext.makeClassReference( proxyClassValue.asString() );
proxyInterfaceType = null;
}
}
else {
@ -495,9 +504,44 @@ public class EntityBinder {
return new CustomSQL( sql, isCallable, checkStyle );
}
private void bindPrimaryTable(EntityBinding entityBinding) {
final Schema schema = bindingContext.getMetadataImplementor().getDatabase().getSchema( schemaName );
AnnotationInstance tableAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(),
JPADotNames.TABLE
);
String tableName = null;
if ( tableAnnotation != null ) {
String explicitTableName = JandexHelper.getValue( tableAnnotation, "name", String.class );
if ( StringHelper.isNotEmpty( explicitTableName ) ) {
tableName = bindingContext.getNamingStrategy().tableName( explicitTableName );
}
}
// no explicit table name given, let's use the entity name as table name (taking inheritance into consideration
if ( StringHelper.isEmpty( tableName ) ) {
tableName = bindingContext.getNamingStrategy().classToTableName( entityClass.getClassNameForTable() );
}
if ( bindingContext.isGloballyQuotedIdentifiers() && ! Identifier.isQuoted( tableName ) ) {
tableName = StringHelper.quote( tableName );
}
org.hibernate.metamodel.relational.Table table = schema.locateOrCreateTable( Identifier.toIdentifier( tableName ) );
entityBinding.setBaseTable( table );
AnnotationInstance checkAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(), HibernateDotNames.CHECK
);
if ( checkAnnotation != null ) {
table.addCheckConstraint( checkAnnotation.value( "constraints" ).asString() );
}
}
private AnnotationInstance locatePojoTuplizerAnnotation() {
final AnnotationInstance tuplizersAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(), HibernateDotNames.SYNCHRONIZE
entityClass.getClassInfo(), HibernateDotNames.TUPLIZERS
);
if ( tuplizersAnnotation == null ) {
return null;
@ -524,38 +568,6 @@ public class EntityBinder {
}
}
private void bindPrimaryTable(EntityBinding entityBinding) {
final Schema schema = bindingContext.getMetadataImplementor().getDatabase().getSchema( schemaName );
AnnotationInstance tableAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(),
JPADotNames.TABLE
);
String tableName = null;
if ( tableAnnotation != null ) {
String explicitTableName = JandexHelper.getValue( tableAnnotation, "name", String.class );
if ( StringHelper.isNotEmpty( explicitTableName ) ) {
tableName = bindingContext.getNamingStrategy().tableName( explicitTableName );
}
}
// no explicit table name given, let's use the entity name as table name (taking inheritance into consideration
if ( StringHelper.isEmpty( tableName ) ) {
tableName = bindingContext.getNamingStrategy().classToTableName( entityClass.getClassNameForTable() );
}
org.hibernate.metamodel.relational.Table table = schema.locateOrCreateTable( Identifier.toIdentifier( tableName ) );
entityBinding.setBaseTable( table );
AnnotationInstance checkAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(), HibernateDotNames.CHECK
);
if ( checkAnnotation != null ) {
table.addCheckConstraint( checkAnnotation.value( "constraints" ).asString() );
}
}
private void bindTableUniqueConstraints(EntityBinding entityBinding) {
AnnotationInstance tableAnnotation = JandexHelper.getSingleAnnotation(
entityClass.getClassInfo(),
@ -665,12 +677,16 @@ public class EntityBinder {
// now that we have the id attribute we can create the attribute and binding
MappedAttribute idAttribute = iter.next();
Attribute attribute = container.locateOrCreateSingularAttribute( idAttribute.getName() );
SingularAttribute attribute = container.locateOrCreateSingularAttribute( idAttribute.getName() );
SimpleAttributeBinding attributeBinding = entityBinding.makeSimpleIdAttributeBinding( attribute );
attributeBinding.initialize( new AttributeBindingStateImpl( (SimpleAttribute) idAttribute ) );
attributeBinding.initialize( new ColumnRelationalStateImpl( (SimpleAttribute) idAttribute, bindingContext.getMetadataImplementor() ) );
bindSingleIdGeneratedValue( entityBinding, idAttribute.getName() );
if ( ! attribute.isTypeResolved() ) {
attribute.resolveType( bindingContext.makeJavaType( attributeBinding.getHibernateTypeDescriptor().getJavaTypeName() ) );
}
}
private void bindSingleIdGeneratedValue(EntityBinding entityBinding, String idPropertyName) {
@ -903,6 +919,10 @@ public class EntityBinder {
attributeBinding.initialize( relationalState );
}
if ( ! attribute.isTypeResolved() ) {
attribute.resolveType( bindingContext.makeJavaType( attributeBinding.getHibernateTypeDescriptor().getJavaTypeName() ) );
}
}
}

4
hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/BindingCreator.java
View File

@ -738,9 +738,7 @@ public class BindingCreator {
final Class<?> attributeJavaType = determineJavaType( attributeBinding.getAttribute() );
if ( attributeJavaType != null ) {
attributeBinding.getHibernateTypeDescriptor().setJavaTypeName( attributeJavaType.getName() );
( (AbstractAttributeContainer.SingularAttributeImpl) attributeBinding.getAttribute() ).resolveType(
currentBindingContext.makeJavaType( attributeJavaType.getName() )
);
attributeBinding.getAttribute().resolveType( currentBindingContext.makeJavaType( attributeJavaType.getName() ) );
}
// prefer type attribute over nested <type/> element

2
hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/binding/AbstractHbmAttributeBindingState.java
View File

@ -152,7 +152,7 @@ public abstract class AbstractHbmAttributeBindingState implements AttributeBindi
return null;
}
public Map<String, String> getTypeParameters() {
public Map<String, String> getExplicitHibernateTypeParameters() {
return null;
}
}

18
hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/binding/HbmDiscriminatorBindingState.java
View File

@ -25,10 +25,10 @@ package org.hibernate.metamodel.source.hbm.state.binding;
import java.util.Set;
import org.hibernate.metamodel.source.BindingContext;
import org.hibernate.metamodel.source.hbm.Helper;
import org.hibernate.metamodel.binding.CascadeType;
import org.hibernate.metamodel.binding.state.DiscriminatorBindingState;
import org.hibernate.metamodel.source.BindingContext;
import org.hibernate.metamodel.source.hbm.Helper;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLHibernateMapping;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLHibernateMapping.XMLClass.XMLDiscriminator;
@ -41,7 +41,8 @@ public class HbmDiscriminatorBindingState
private final String discriminatorValue;
private final boolean isForced;
private final boolean isInserted;
private final String typeName;
private final String explicitHibernateTypeName;
public HbmDiscriminatorBindingState(
String entityName,
@ -63,7 +64,7 @@ public class HbmDiscriminatorBindingState
);
this.isForced = xmlEntityClazz.getDiscriminator().isForce();
this.isInserted = discriminator.isInsert();
this.typeName = discriminator.getType() == null ? "string" : discriminator.getType();
this.explicitHibernateTypeName = discriminator.getType() == null ? "string" : discriminator.getType();
}
public Set<CascadeType> getCascadeTypes() {
@ -74,8 +75,13 @@ public class HbmDiscriminatorBindingState
return false;
}
public String getTypeName() {
return typeName;
public String getExplicitHibernateTypeName() {
return explicitHibernateTypeName;
}
@Override
public String getJavaTypeName() {
return null;
}
@Override

7
hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/binding/HbmManyToOneAttributeBindingState.java
View File

@ -131,7 +131,12 @@ public class HbmManyToOneAttributeBindingState
return fetchMode;
}
public String getTypeName() {
public String getExplicitHibernateTypeName() {
return null;
}
@Override
public String getJavaTypeName() {
return referencedEntityName;
}

22
hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/binding/HbmPluralAttributeBindingState.java
View File

@ -29,12 +29,12 @@ import java.util.HashSet;
import java.util.Set;
import org.hibernate.FetchMode;
import org.hibernate.metamodel.source.BindingContext;
import org.hibernate.metamodel.source.MetaAttributeContext;
import org.hibernate.metamodel.source.hbm.Helper;
import org.hibernate.metamodel.binding.CascadeType;
import org.hibernate.metamodel.binding.CustomSQL;
import org.hibernate.metamodel.binding.state.PluralAttributeBindingState;
import org.hibernate.metamodel.source.BindingContext;
import org.hibernate.metamodel.source.MetaAttributeContext;
import org.hibernate.metamodel.source.hbm.Helper;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLBagElement;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLSqlDeleteAllElement;
import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLSqlDeleteElement;
@ -49,9 +49,11 @@ public class HbmPluralAttributeBindingState extends AbstractHbmAttributeBindingS
implements PluralAttributeBindingState {
private final XMLBagElement collection;
private final Class collectionPersisterClass;
private final String typeName;
private final Set<CascadeType> cascadeTypes;
private final String explicitHibernateCollectionTypeName;
private final Class javaType;
public HbmPluralAttributeBindingState(
String ownerClassName,
BindingContext bindingContext,
@ -91,7 +93,8 @@ public class HbmPluralAttributeBindingState extends AbstractHbmAttributeBindingS
}
*/
//}
typeName = collection.getCollectionType();
this.explicitHibernateCollectionTypeName = collection.getCollectionType();
this.javaType = java.util.Collection.class;
}
public FetchMode getFetchMode() {
@ -277,7 +280,12 @@ public class HbmPluralAttributeBindingState extends AbstractHbmAttributeBindingS
return null;
}
public String getTypeName() {
return typeName;
public String getExplicitHibernateTypeName() {
return explicitHibernateCollectionTypeName;
}
@Override
public String getJavaTypeName() {
return javaType.getName();
}
}

75
hibernate-core/src/main/java/org/hibernate/metamodel/source/hbm/state/binding/HbmSimpleAttributeBindingState.java
View File

@ -23,11 +23,14 @@
*/
package org.hibernate.metamodel.source.hbm.state.binding;
import java.beans.BeanInfo;
import java.beans.PropertyDescriptor;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import org.hibernate.MappingException;
import org.hibernate.internal.util.beans.BeanInfoHelper;
import org.hibernate.mapping.PropertyGeneration;
import org.hibernate.metamodel.source.BindingContext;
import org.hibernate.metamodel.source.MappingDefaults;
@ -46,8 +49,9 @@ import org.hibernate.metamodel.source.hbm.jaxb.mapping.XMLPropertyElement;
*/
public class HbmSimpleAttributeBindingState extends AbstractHbmAttributeBindingState
implements SimpleAttributeBindingState {
private final String typeName;
private final Map<String, String> typeParameters = new HashMap<String, String>();
private final String explicitHibernateTypeName;
private final Map<String, String> explicitHibernateTypeParameters = new HashMap<String, String>();
private final boolean isLazy;
private final PropertyGeneration propertyGeneration;
@ -75,13 +79,13 @@ public class HbmSimpleAttributeBindingState extends AbstractHbmAttributeBindingS
this.isLazy = false;
if ( id.getTypeAttribute() != null ) {
typeName = maybeConvertToTypeDefName( id.getTypeAttribute(), bindingContext.getMappingDefaults() );
explicitHibernateTypeName = maybeConvertToTypeDefName( id.getTypeAttribute(), bindingContext.getMappingDefaults() );
}
else if ( id.getType() != null ) {
typeName = maybeConvertToTypeDefName( id.getType().getName(), bindingContext.getMappingDefaults() );
explicitHibernateTypeName = maybeConvertToTypeDefName( id.getType().getName(), bindingContext.getMappingDefaults() );
}
else {
typeName = getTypeNameByReflection();
explicitHibernateTypeName = getTypeNameByReflection();
}
// TODO: how should these be set???
@ -119,7 +123,7 @@ public class HbmSimpleAttributeBindingState extends AbstractHbmAttributeBindingS
),
true
);
this.typeName = version.getType() == null ? "integer" : version.getType();
this.explicitHibernateTypeName = version.getType() == null ? "integer" : version.getType();
this.isLazy = false;
@ -155,7 +159,7 @@ public class HbmSimpleAttributeBindingState extends AbstractHbmAttributeBindingS
);
// Timestamp.getType() is not defined
this.typeName = "db".equals( timestamp.getSource() ) ? "dbtimestamp" : "timestamp";
this.explicitHibernateTypeName = "db".equals( timestamp.getSource() ) ? "dbtimestamp" : "timestamp";
this.isLazy = false;
// for version properties marked as being generated, make sure they are "always"
@ -222,17 +226,17 @@ public class HbmSimpleAttributeBindingState extends AbstractHbmAttributeBindingS
}
if ( property.getTypeAttribute() != null ) {
typeName = maybeConvertToTypeDefName( property.getTypeAttribute(), bindingContext.getMappingDefaults() );
explicitHibernateTypeName = maybeConvertToTypeDefName( property.getTypeAttribute(), bindingContext.getMappingDefaults() );
}
else if ( property.getType() != null ) {
typeName = maybeConvertToTypeDefName( property.getType().getName(), bindingContext.getMappingDefaults() );
explicitHibernateTypeName = maybeConvertToTypeDefName( property.getType().getName(), bindingContext.getMappingDefaults() );
for ( XMLParamElement typeParameter : property.getType().getParam() ) {
//TODO: add parameters from typedef
typeParameters.put( typeParameter.getName(), typeParameter.getValue().trim() );
explicitHibernateTypeParameters.put( typeParameter.getName(), typeParameter.getValue().trim() );
}
}
else {
typeName = getTypeNameByReflection();
explicitHibernateTypeName = getTypeNameByReflection();
}
@ -255,12 +259,53 @@ public class HbmSimpleAttributeBindingState extends AbstractHbmAttributeBindingS
return false;
}
public String getTypeName() {
return typeName;
private String javaType;
@Override
public String getJavaTypeName() {
if ( javaType == null ) {
javaType = tryToResolveAttributeJavaType();
}
return javaType;
}
public Map<String, String> getTypeParameters() {
return typeParameters;
private String tryToResolveAttributeJavaType() {
try {
Class ownerClass = getBindingContext().locateClassByName( super.getOwnerClassName() );
AttributeLocatorDelegate delegate = new AttributeLocatorDelegate( getAttributeName() );
BeanInfoHelper.visitBeanInfo( ownerClass, delegate );
return delegate.attributeTypeName;
}
catch (Exception ignore) {
}
return null;
}
private static class AttributeLocatorDelegate implements BeanInfoHelper.BeanInfoDelegate {
private final String attributeName;
private String attributeTypeName;
private AttributeLocatorDelegate(String attributeName) {
this.attributeName = attributeName;
}
@Override
public void processBeanInfo(BeanInfo beanInfo) throws Exception {
for ( PropertyDescriptor propertyDescriptor : beanInfo.getPropertyDescriptors() ) {
if ( propertyDescriptor.getName().equals( attributeName ) ) {
attributeTypeName = propertyDescriptor.getPropertyType().getName();
break;
}
}
}
}
public String getExplicitHibernateTypeName() {
return explicitHibernateTypeName;
}
public Map<String, String> getExplicitHibernateTypeParameters() {
return explicitHibernateTypeParameters;
}
public boolean isLazy() {

155
hibernate-core/src/main/java/org/hibernate/metamodel/source/internal/AttributeTypeResolver.java
View File

@ -25,16 +25,14 @@ package org.hibernate.metamodel.source.internal;
import java.util.Properties;
import org.hibernate.MappingException;
import org.hibernate.metamodel.binding.AttributeBinding;
import org.hibernate.metamodel.binding.EntityBinding;
import org.hibernate.metamodel.binding.HibernateTypeDescriptor;
import org.hibernate.metamodel.domain.Attribute;
import org.hibernate.metamodel.domain.SingularAttribute;
import org.hibernate.metamodel.relational.Datatype;
import org.hibernate.metamodel.relational.SimpleValue;
import org.hibernate.metamodel.relational.Value;
import org.hibernate.metamodel.source.MetadataImplementor;
import org.hibernate.type.AbstractStandardBasicType;
import org.hibernate.type.Type;
/**
@ -54,83 +52,102 @@ class AttributeTypeResolver {
void resolve() {
for ( EntityBinding entityBinding : metadata.getEntityBindings() ) {
for ( AttributeBinding attributeBinding : entityBinding.getAttributeBindings() ) {
Type type = resolveHibernateType( attributeBinding );
if ( type != null && ! type.isAssociationType() && ! type.isCollectionType() && ! type.isComponentType() ) {
resolveJavaType( attributeBinding.getAttribute(), type );
for ( Value value : attributeBinding.getValues() ) {
resolveSqlType( value, type );
resolveTypeInformation( attributeBinding );
}
}
}
private void resolveTypeInformation(AttributeBinding attributeBinding) {
// perform any needed type resolutions
final HibernateTypeDescriptor hibernateTypeDescriptor = attributeBinding.getHibernateTypeDescriptor();
Type resolvedHibernateType = attributeBinding.getHibernateTypeDescriptor().getResolvedTypeMapping();
if ( resolvedHibernateType == null ) {
resolvedHibernateType = determineHibernateType( attributeBinding );
if ( resolvedHibernateType != null ) {
hibernateTypeDescriptor.setResolvedTypeMapping( resolvedHibernateType );
}
}
if ( resolvedHibernateType != null ) {
pushHibernateTypeInformationDownIfNeeded( attributeBinding, resolvedHibernateType );
}
}
private Type determineHibernateType(AttributeBinding attributeBinding) {
String typeName = null;
Properties typeParameters = new Properties();
// we can determine the Hibernate Type if either:
// 1) the user explicitly named a Type
// 2) we know the java type of the attribute
if ( attributeBinding.getHibernateTypeDescriptor().getExplicitTypeName() != null ) {
typeName = attributeBinding.getHibernateTypeDescriptor().getExplicitTypeName();
if ( attributeBinding.getHibernateTypeDescriptor().getTypeParameters() != null ) {
typeParameters.putAll( attributeBinding.getHibernateTypeDescriptor().getTypeParameters() );
}
}
else {
typeName = attributeBinding.getHibernateTypeDescriptor().getJavaTypeName();
if ( typeName == null ) {
if ( attributeBinding.getAttribute().isSingular() ) {
SingularAttribute singularAttribute = (SingularAttribute) attributeBinding.getAttribute();
if ( singularAttribute.getSingularAttributeType() != null ) {
typeName = singularAttribute.getSingularAttributeType().getClassName();
}
}
}
}
}
private Type resolveHibernateType(AttributeBinding attributeBinding) {
if ( attributeBinding.getHibernateTypeDescriptor().getResolvedTypeMapping() != null ) {
return attributeBinding.getHibernateTypeDescriptor().getResolvedTypeMapping(); // already resolved
}
// this only works for "basic" attribute types
HibernateTypeDescriptor typeDescriptor = attributeBinding.getHibernateTypeDescriptor();
if ( typeDescriptor == null || typeDescriptor.getExplicitTypeName() == null) {
throw new MappingException( "Hibernate type name has not been defined for attribute: " +
getQualifiedAttributeName( attributeBinding )
);
}
Type type = null;
if ( typeDescriptor.getExplicitTypeName() != null ) {
Properties typeParameters = null;
if ( typeDescriptor.getTypeParameters() != null ) {
typeParameters = new Properties();
typeParameters.putAll( typeDescriptor.getTypeParameters() );
if ( typeName != null ) {
try {
return metadata.getTypeResolver().heuristicType( typeName, typeParameters );
}
catch (Exception ignore) {
}
type = metadata.getTypeResolver().heuristicType(
typeDescriptor.getExplicitTypeName(),
typeParameters
);
typeDescriptor.setResolvedTypeMapping( type );
}
return type;
return null;
}
// this only works for singular basic types
private void resolveJavaType(Attribute attribute, Type type) {
// if ( ! ( type instanceof AbstractStandardBasicType ) || ! attribute.isSingular() ) {
// return;
// }
// // Converting to SingularAttributeImpl is bad, but this resolver is TEMPORARY!
// AbstractAttributeContainer.SingularAttributeImpl singularAttribute =
// ( AbstractAttributeContainer.SingularAttributeImpl ) attribute;
// if ( ! singularAttribute.isTypeResolved() ) {
// singularAttribute.resolveType(
// new BasicType(
// new JavaType( ( ( AbstractStandardBasicType) type ).getJavaTypeDescriptor().getJavaTypeClass() )
// )
// );
// }
}
private void pushHibernateTypeInformationDownIfNeeded(AttributeBinding attributeBinding, Type resolvedHibernateType) {
final HibernateTypeDescriptor hibernateTypeDescriptor = attributeBinding.getHibernateTypeDescriptor();
// this only works for singular basic types
private void resolveSqlType(Value value, Type type) {
if ( value == null || ! ( value instanceof SimpleValue ) || ! ( type instanceof AbstractStandardBasicType ) ) {
return;
// java type information ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
if ( hibernateTypeDescriptor.getJavaTypeName() == null ) {
hibernateTypeDescriptor.setJavaTypeName( resolvedHibernateType.getReturnedClass().getName() );
}
if ( SingularAttribute.class.isInstance( attributeBinding.getAttribute() ) ) {
final SingularAttribute singularAttribute = (SingularAttribute) attributeBinding.getAttribute();
if ( ! singularAttribute.isTypeResolved() ) {
if ( hibernateTypeDescriptor.getJavaTypeName() != null ) {
singularAttribute.resolveType( metadata.makeJavaType( hibernateTypeDescriptor.getJavaTypeName() ) );
}
}
}
// sql type information ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// todo : this can be made a lot smarter, but for now this will suffice. currently we only handle single value bindings
Value value = attributeBinding.getValue();
if ( SimpleValue.class.isInstance( value ) ) {
SimpleValue simpleValue = (SimpleValue) value;
if ( simpleValue.getDatatype() == null ) {
simpleValue.setDatatype(
new Datatype(
resolvedHibernateType.sqlTypes( metadata )[0],
resolvedHibernateType.getName(),
resolvedHibernateType.getReturnedClass()
)
);
}
}
// Converting to AbstractStandardBasicType is bad, but this resolver is TEMPORARY!
AbstractStandardBasicType basicType = ( AbstractStandardBasicType ) type;
Datatype dataType = new Datatype(
basicType.getSqlTypeDescriptor().getSqlType(),
basicType.getName(),
basicType.getReturnedClass()
);
( (SimpleValue) value ).setDatatype( dataType );
}
// TODO: this does not work for components
private static String getQualifiedAttributeName(AttributeBinding attributebinding) {
return new StringBuilder()
.append( attributebinding.getEntityBinding().getEntity().getName() )
.append( "." )
.append( attributebinding.getAttribute().getName() )
.toString();
}
}

2
hibernate-core/src/main/java/org/hibernate/metamodel/source/internal/MetadataImpl.java
View File

@ -1,7 +1,7 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* Copyright (c) 2010, Red Hat Inc. or third-party contributors as
* Copyright (c) 2011, Red Hat Inc. or third-party contributors as
* indicated by the @author tags or express copyright attribution
* statements applied by the authors. All third-party contributions are
* distributed under license by Red Hat Inc.

13
hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/entity/CustomSQLBindingTests.java
View File

@ -71,12 +71,13 @@ public class CustomSQLBindingTests extends BaseAnnotationBindingTestCase {
assertCustomSql( customSql, "UPDATE FOO", false, ExecuteUpdateResultCheckStyle.PARAM );
}
@Test
public void testDeleteAllWins() {
buildMetadataSources( CustomDeleteAllEntity.class );
EntityBinding binding = getEntityBinding( CustomDeleteAllEntity.class );
assertEquals( "Wrong sql", "DELETE ALL", binding.getCustomDelete().getSql() );
}
// not so sure about the validity of this one
// @Test
// public void testDeleteAllWins() {
// buildMetadataSources( CustomDeleteAllEntity.class );
// EntityBinding binding = getEntityBinding( CustomDeleteAllEntity.class );
// assertEquals( "Wrong sql", "DELETE ALL", binding.getCustomDelete().getSql() );
// }
private void assertCustomSql(CustomSQL customSql, String sql, boolean isCallable, ExecuteUpdateResultCheckStyle style) {
assertNotNull( customSql );

6
hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/util/GenericTypeDiscoveryTest.java
View File

@ -64,7 +64,7 @@ public class GenericTypeDiscoveryTest extends BaseAnnotationIndexTestCase {
ClassInfo info = configuredClass.getClassInfo();
assertEquals( "wrong class", DotName.createSimple( Stuff.class.getName() ), info.name() );
MappedAttribute property = configuredClass.getMappedAttribute( "value" );
assertEquals( Price.class.getName(), property.getType() );
assertEquals( Price.class, property.getJavaType() );
assertTrue( iter.hasNext() );
configuredClass = iter.next();
@ -80,9 +80,9 @@ public class GenericTypeDiscoveryTest extends BaseAnnotationIndexTestCase {
assertEquals( "wrong class", DotName.createSimple( Item.class.getName() ), info.name() );
// properties are alphabetically ordered!
property = configuredClass.getMappedAttribute( "owner" );
assertEquals( SomeGuy.class.getName(), property.getType() );
assertEquals( SomeGuy.class, property.getJavaType() );
property = configuredClass.getMappedAttribute( "type" );
assertEquals( PaperType.class.getName(), property.getType() );
assertEquals( PaperType.class, property.getJavaType() );
assertTrue( iter.hasNext() );
configuredClass = iter.next();

8
hibernate-core/src/test/java/org/hibernate/metamodel/source/annotations/util/TypeDiscoveryTest.java
View File

@ -53,15 +53,15 @@ public class TypeDiscoveryTest extends BaseAnnotationIndexTestCase {
ConfiguredClass configuredClass = iter.next();
MappedAttribute property = configuredClass.getMappedAttribute( "id" );
assertEquals( "Unexpected property type", "int", property.getType() );
assertEquals( "Unexpected property type", int.class, property.getJavaType() );
property = configuredClass.getMappedAttribute( "string" );
assertEquals( "Unexpected property type", String.class.getName(), property.getType() );
assertEquals( "Unexpected property type", String.class, property.getJavaType() );
property = configuredClass.getMappedAttribute( "customString" );
assertEquals( "Unexpected property type", "my.custom.Type", property.getType() );
assertEquals( "Unexpected property type", "my.custom.Type", property.getExplicitHibernateTypeName() );
Map<String, String> typeParameters = property.getTypeParameters();
Map<String, String> typeParameters = property.getExplicitHibernateTypeParameters();
assertEquals( "There should be a type parameter", "bar", typeParameters.get( "foo" ) );
}

0
hibernate-core/src/test/resources/org/hibernate/metamodel/binder/source/annotations/xml/mocker/AttributeOverride.xml → hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/xml/mocker/AttributeOverride.xml
View File

0
hibernate-core/src/test/resources/org/hibernate/metamodel/binder/source/annotations/xml/mocker/default-schema.xml → hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/xml/mocker/default-schema.xml
View File

0
hibernate-core/src/test/resources/org/hibernate/metamodel/binder/source/annotations/xml/mocker/default-schema2.xml → hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/xml/mocker/default-schema2.xml
View File

0
hibernate-core/src/test/resources/org/hibernate/metamodel/binder/source/annotations/xml/mocker/entity-metadata-complete.xml → hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/xml/mocker/entity-metadata-complete.xml
View File

2
hibernate-core/src/test/resources/org/hibernate/metamodel/binder/source/annotations/xml/mocker/listener.xml → hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/xml/mocker/listener.xml
View File

@ -15,7 +15,7 @@
</entity-listeners>
</persistence-unit-defaults>
</persistence-unit-metadata>
<package>org.hibernate.metamodel.binder.source.annotations.xml.mocker</package>
<package>org.hibernate.metamodel.source.annotations.xml.mocker</package>
<entity class="Item">
<entity-listeners>
<entity-listener class="org.hibernate.metamodel.source.annotations.xml.mocker.ItemListener">

0
hibernate-core/src/test/resources/org/hibernate/metamodel/binder/source/annotations/xml/mocker/override-to-mappedsuperclass.xml → hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/xml/mocker/override-to-mappedsuperclass.xml
View File

0
hibernate-core/src/test/resources/org/hibernate/metamodel/binder/source/annotations/xml/mocker/persistence-metadata.xml → hibernate-core/src/test/resources/org/hibernate/metamodel/source/annotations/xml/mocker/persistence-metadata.xml
View File