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

HHH-16125 final cleanup of legacy enum converters stuff

This commit is contained in:
Gavin 2023-04-29 13:54:07 +02:00 committed by Gavin King
parent 15d20113e7
commit 20b157000c
7 changed files with 23 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
hibernate-core/src/main/java/org/hibernate/type/EnumType.java
View File

@ -23,7 +23,6 @@ import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.internal.CoreLogging;
import org.hibernate.internal.util.ReflectHelper;
import org.hibernate.type.descriptor.converter.spi.BasicValueConverter;
import org.hibernate.type.descriptor.java.EnumJavaType;
import org.hibernate.type.descriptor.java.JavaType;
import org.hibernate.type.descriptor.jdbc.JdbcType;
@ -68,14 +67,13 @@ public class EnumType<T extends Enum<T>>
public EnumType() {
}
@Override
public JdbcType getJdbcType(TypeConfiguration typeConfiguration) {
return jdbcType;
public Class<T> getEnumClass() {
return enumClass;
}
@Override
public BasicValueConverter<T, Object> getValueConverter() {
return null;
public JdbcType getJdbcType(TypeConfiguration typeConfiguration) {
return jdbcType;
}
/**
@ -126,9 +124,6 @@ public class EnumType<T extends Enum<T>>
else if ( reader != null ) {
enumClass = (Class<T>) reader.getReturnedClass().asSubclass( Enum.class );
}
else {
throw new AssertionFailure( "No enum class" );
}
final JavaType<T> descriptor = typeConfiguration.getJavaTypeRegistry().getDescriptor( enumClass );
enumJavaType = (EnumJavaType<T>) descriptor;
@ -185,7 +180,7 @@ public class EnumType<T extends Enum<T>>
private boolean isNationalized(ParameterType reader) {
return typeConfiguration.getCurrentBaseSqlTypeIndicators().isNationalized()
|| getAnnotation( reader.getAnnotationsMethod(), Nationalized.class ) != null;
|| reader!=null && getAnnotation( reader.getAnnotationsMethod(), Nationalized.class ) != null;
}
@SuppressWarnings("unchecked")

68
hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/NamedEnumValueConverter.java
View File

@ -1,68 +0,0 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
*/
package org.hibernate.type.descriptor.converter.internal;
import java.io.Serializable;
import org.hibernate.type.descriptor.converter.spi.EnumValueConverter;
import org.hibernate.type.descriptor.java.EnumJavaType;
import org.hibernate.type.descriptor.java.JavaType;
import org.hibernate.type.descriptor.jdbc.JdbcType;
/**
* BasicValueConverter handling the conversion of an enum based on
* JPA {@link jakarta.persistence.EnumType#STRING} strategy (storing the name)
*
* @author Steve Ebersole
*
* @deprecated we no longer use converters to handle enum mappings
*/
@Deprecated(since="6.3", forRemoval=true)
public class NamedEnumValueConverter<E extends Enum<E>> implements EnumValueConverter<E,String>, Serializable {
private final EnumJavaType<E> domainTypeDescriptor;
private final JdbcType jdbcType;
private final JavaType<String> relationalTypeDescriptor;
public NamedEnumValueConverter(
EnumJavaType<E> domainTypeDescriptor,
JdbcType jdbcType,
JavaType<String> relationalTypeDescriptor) {
this.domainTypeDescriptor = domainTypeDescriptor;
this.jdbcType = jdbcType;
this.relationalTypeDescriptor = relationalTypeDescriptor;
}
@Override
public EnumJavaType<E> getDomainJavaType() {
return domainTypeDescriptor;
}
@Override
public JavaType<String> getRelationalJavaType() {
return relationalTypeDescriptor;
}
@Override
public E toDomainValue(String relationalForm) {
return domainTypeDescriptor.fromName( relationalForm );
}
@Override
public String toRelationalValue(E domainForm) {
return domainTypeDescriptor.toName( domainForm );
}
@Override
public int getJdbcTypeCode() {
return jdbcType.getDefaultSqlTypeCode();
}
@Override
public String toSqlLiteral(Object value) {
return "'" + ( (Enum<?>) value ).name() + "'";
}
}

69
hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/internal/OrdinalEnumValueConverter.java
View File

@ -1,69 +0,0 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
*/
package org.hibernate.type.descriptor.converter.internal;
import java.io.Serializable;
import org.hibernate.type.descriptor.converter.spi.EnumValueConverter;
import org.hibernate.type.descriptor.java.EnumJavaType;
import org.hibernate.type.descriptor.java.JavaType;
import org.hibernate.type.descriptor.jdbc.JdbcType;
/**
* BasicValueConverter handling the conversion of an enum based on
* JPA {@link jakarta.persistence.EnumType#ORDINAL} strategy (storing the ordinal)
*
* @author Steve Ebersole
*
* @deprecated we no longer use converters to handle enum mappings
*/
@Deprecated(since="6.3", forRemoval=true)
public class OrdinalEnumValueConverter<E extends Enum<E>, N extends Number> implements EnumValueConverter<E, N>, Serializable {
private final EnumJavaType<E> enumJavaType;
private final JdbcType jdbcType;
private final JavaType<N> relationalJavaType;
public OrdinalEnumValueConverter(
EnumJavaType<E> enumJavaType,
JdbcType jdbcType,
JavaType<N> relationalJavaType) {
this.enumJavaType = enumJavaType;
this.jdbcType = jdbcType;
this.relationalJavaType = relationalJavaType;
}
@Override
public E toDomainValue(Number relationalForm) {
return enumJavaType.fromOrdinal( relationalForm == null ? null : relationalForm.intValue() );
}
@Override
public N toRelationalValue(E domainForm) {
return relationalJavaType.wrap( enumJavaType.toOrdinal( domainForm ), null );
}
@Override
public int getJdbcTypeCode() {
return jdbcType.getDefaultSqlTypeCode();
}
@Override
public EnumJavaType<E> getDomainJavaType() {
return enumJavaType;
}
@Override
public JavaType<N> getRelationalJavaType() {
return relationalJavaType;
}
@Override
public String toSqlLiteral(Object value) {
return Integer.toString( ( (Enum<?>) value ).ordinal() );
}
}

11
hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/package-info.java
View File

@ -11,14 +11,9 @@
* Hibernate {@link org.hibernate.type.Type} system. The main contract is
* {@link org.hibernate.type.descriptor.converter.spi.BasicValueConverter}.
* <p>
* All basic value conversions are defined by this namespace, including:
* <ul>
* <li>Java {@code enum} conversions via
* {@link org.hibernate.type.descriptor.converter.spi.EnumValueConverter},
* and
* <li>support for {@link jakarta.persistence.AttributeConverter} via
* {@link org.hibernate.type.descriptor.converter.spi.JpaAttributeConverter}.
* </ul>
* All basic value conversions are defined by this namespace, including
* support for {@link jakarta.persistence.AttributeConverter} via
* {@link org.hibernate.type.descriptor.converter.spi.JpaAttributeConverter}.
*
* @see org.hibernate.type.descriptor.converter.spi.BasicValueConverter
*/

26
hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/spi/EnumValueConverter.java
View File

@ -1,26 +0,0 @@
/*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later
* See the lgpl.txt file in the root directory or http://www.gnu.org/licenses/lgpl-2.1.html
*/
package org.hibernate.type.descriptor.converter.spi;
import org.hibernate.Incubating;
import org.hibernate.type.descriptor.java.EnumJavaType;
/**
* {@link BasicValueConverter} extension for enum-specific support
*
* @author Steve Ebersole
*/
@Incubating
public interface EnumValueConverter<O extends Enum<O>, R> extends BasicValueConverter<O,R> {
@Override
EnumJavaType<O> getDomainJavaType();
int getJdbcTypeCode();
String toSqlLiteral(Object value);
}

10
hibernate-core/src/main/java/org/hibernate/type/descriptor/converter/spi/package-info.java
View File

@ -12,13 +12,9 @@
* <p>
* The main contract is
* {@link org.hibernate.type.descriptor.converter.spi.BasicValueConverter},
* with specializations:
* <ul>
* <li>{@link org.hibernate.type.descriptor.converter.spi.EnumValueConverter}
* for Java {@code enum} conversions, and
* <li>{@link org.hibernate.type.descriptor.converter.spi.JpaAttributeConverter}
* for adapting for JPA {@link jakarta.persistence.AttributeConverter}.
* </ul>
* which is specialized by
* {@link org.hibernate.type.descriptor.converter.spi.JpaAttributeConverter}
* for adapting for JPA {@link jakarta.persistence.AttributeConverter}s.
*
* @see org.hibernate.type.descriptor.converter.spi.BasicValueConverter
*/

35
hibernate-envers/src/main/java/org/hibernate/envers/configuration/internal/metadata/BasicMetadataGenerator.java
View File

@ -16,11 +16,9 @@ import org.hibernate.envers.internal.entities.mapper.SimpleMapperBuilder;
import org.hibernate.mapping.SimpleValue;
import org.hibernate.mapping.Value;
import org.hibernate.type.BasicType;
import org.hibernate.type.ConvertedBasicType;
import org.hibernate.type.CustomType;
import org.hibernate.type.EnumType;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.converter.internal.NamedEnumValueConverter;
import org.hibernate.type.descriptor.converter.spi.EnumValueConverter;
/**
* Generates metadata for basic properties: immutable types (including enums).
@ -42,7 +40,7 @@ public final class BasicMetadataGenerator {
boolean key) {
if ( value.getType() instanceof BasicType ) {
if ( attributeContainer != null ) {
BasicAttribute attribute = buildProperty(propertyAuditingData, value, insertable, key );
BasicAttribute attribute = buildProperty( propertyAuditingData, value, insertable, key );
attributeContainer.addAttribute( attribute );
if ( isAddNestedType( value ) ) {
@ -62,21 +60,18 @@ public final class BasicMetadataGenerator {
return false;
}
private void mapEnumerationType(TypeSpecification typeDefinition, Type type, Properties parameters) {
private void mapEnumerationType(TypeSpecification typeDefinition, EnumType type, Properties parameters) {
if ( parameters.getProperty( EnumType.ENUM ) != null ) {
typeDefinition.setParameter( EnumType.ENUM, parameters.getProperty( EnumType.ENUM ) );
}
else {
typeDefinition.setParameter( EnumType.ENUM, type.getReturnedClass().getName() );
typeDefinition.setParameter( EnumType.ENUM, type.getEnumClass().getName() );
}
if ( parameters.getProperty( EnumType.NAMED ) != null ) {
typeDefinition.setParameter( EnumType.NAMED, parameters.getProperty( EnumType.NAMED ) );
}
else {
final ConvertedBasicType<?> convertedType = (ConvertedBasicType<?>) type;
final EnumValueConverter<?, ?> valueConverter = (EnumValueConverter<?, ?>) convertedType.getValueConverter();
final boolean isNamed = valueConverter instanceof NamedEnumValueConverter;
typeDefinition.setParameter( EnumType.NAMED, Boolean.toString( isNamed ) );
typeDefinition.setParameter( EnumType.NAMED, Boolean.toString( !type.isOrdinal() ) );
}
}
@ -103,12 +98,13 @@ public final class BasicMetadataGenerator {
final Properties typeParameters = value.getTypeParameters();
final String typeName = getBasicTypeName( value.getType() );
final TypeSpecification type = new TypeSpecification(typeName );
attribute.setType( type );
final TypeSpecification typeSpecification = new TypeSpecification( typeName );
attribute.setType( typeSpecification );
if ( isEnumType( value.getType(), typeName ) ) {
// Proper handling of enumeration type
mapEnumerationType( type, value.getType(), typeParameters );
Type type = value.getType();
if ( type instanceof CustomType && ((CustomType<?>) type).getUserType() instanceof EnumType ) {
// Proper handling of nasty legacy EnumType
mapEnumerationType( typeSpecification, (EnumType) ((CustomType<?>) type).getUserType(), typeParameters );
}
else {
// By default, copying all Hibernate properties
@ -116,7 +112,7 @@ public final class BasicMetadataGenerator {
final String keyType = (String) object;
final String property = typeParameters.getProperty( keyType );
if ( property != null ) {
type.setParameter( keyType, property );
typeSpecification.setParameter( keyType, property );
}
}
}
@ -130,11 +126,4 @@ public final class BasicMetadataGenerator {
return typeName;
}
private boolean isEnumType(Type type, String typeName) {
if ( type instanceof ConvertedBasicType ) {
final ConvertedBasicType<?> convertedType = (ConvertedBasicType<?>) type;
return convertedType.getValueConverter() instanceof EnumValueConverter;
}
return false;
}
}