Hibernate/hibernate-orm
1
0
Fork 0
mirror of https://github.com/hibernate/hibernate-orm synced 2025-03-01 15:29:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup naming of JavaTypeDescriptor and JdbcTypeDescriptor implementations. Get rid of PrimitiveType, IdentifierType, DiscriminatorType and AllowableTemporalParameterType

Browse Source
This commit is contained in:
Christian Beikov 2021-10-05 17:34:32 +02:00
parent 653f62ac60
commit 1cb6ff8916
266 changed files with 1304 additions and 2030 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
documentation/src/test/java/org/hibernate/userguide/collections/type/CommaDelimitedStringsJavaTypeDescriptor.java
View File

@ -12,14 +12,14 @@
import java.util.stream.Collectors;
import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.descriptor.java.AbstractClassTypeDescriptor;
import org.hibernate.type.descriptor.java.AbstractClassJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.MutableMutabilityPlan;
/**
* @author Vlad Mihalcea
*/
//tag::collections-comma-delimited-collection-example[]
public class CommaDelimitedStringsJavaTypeDescriptor extends AbstractClassTypeDescriptor<List> {
public class CommaDelimitedStringsJavaTypeDescriptor extends AbstractClassJavaTypeDescriptor<List> {
public static final String DELIMITER = ",";

6
documentation/src/test/java/org/hibernate/userguide/collections/type/CommaDelimitedStringsType.java
View File

@ -9,7 +9,7 @@
import java.util.List;
import org.hibernate.type.AbstractSingleColumnStandardBasicType;
import org.hibernate.type.descriptor.jdbc.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharJdbcTypeDescriptor;
/**
* @author Vlad Mihalcea
@ -19,8 +19,8 @@ public class CommaDelimitedStringsType extends AbstractSingleColumnStandardBasic
public CommaDelimitedStringsType() {
super(
VarcharTypeDescriptor.INSTANCE,
new CommaDelimitedStringsJavaTypeDescriptor()
VarcharJdbcTypeDescriptor.INSTANCE,
new CommaDelimitedStringsJavaTypeDescriptor()
);
}

13
documentation/src/test/java/org/hibernate/userguide/collections/type/TimestampEpochType.java
View File

@ -8,10 +8,9 @@
import java.util.Date;
import org.hibernate.HibernateException;
import org.hibernate.type.AbstractSingleColumnStandardBasicType;
import org.hibernate.type.descriptor.java.JdbcTimestampTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BigIntTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcTimestampJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BigIntJdbcTypeDescriptor;
/**
* @author Vlad Mihalcea
@ -24,8 +23,8 @@ public class TimestampEpochType extends AbstractSingleColumnStandardBasicType<Da
public TimestampEpochType() {
super(
BigIntTypeDescriptor.INSTANCE,
JdbcTimestampTypeDescriptor.INSTANCE
BigIntJdbcTypeDescriptor.INSTANCE,
JdbcTimestampJavaTypeDescriptor.INSTANCE
);
}
@ -34,9 +33,5 @@ public String getName() {
return "epoch";
}
@Override
public Date fromStringValue(CharSequence xml) throws HibernateException {
return fromString( xml );
}
}
//end::collections-map-custom-key-type-mapping-example[]

4
documentation/src/test/java/org/hibernate/userguide/mapping/basic/BitSetJavaType.java
View File

@ -4,7 +4,7 @@
import java.util.BitSet;
import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.descriptor.java.AbstractClassTypeDescriptor;
import org.hibernate.type.descriptor.java.AbstractClassJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.MutabilityPlan;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptorIndicators;
@ -13,7 +13,7 @@
* @author Vlad Mihalcea
*/
//tag::basic-bitset-example-java-type[]
public class BitSetJavaType extends AbstractClassTypeDescriptor<BitSet> {
public class BitSetJavaType extends AbstractClassJavaTypeDescriptor<BitSet> {
public static final BitSetJavaType INSTANCE = new BitSetJavaType();
public BitSetJavaType() {

13
documentation/src/test/java/org/hibernate/userguide/mapping/basic/BitSetType.java
View File

@ -3,29 +3,22 @@
import java.util.BitSet;
import org.hibernate.type.AbstractSingleColumnStandardBasicType;
import org.hibernate.type.DiscriminatorType;
import org.hibernate.type.descriptor.jdbc.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharJdbcTypeDescriptor;
/**
* @author Vlad Mihalcea
*/
//tag::basic-custom-type-BitSetType-example[]
public class BitSetType
extends AbstractSingleColumnStandardBasicType<BitSet>
implements DiscriminatorType<BitSet> {
extends AbstractSingleColumnStandardBasicType<BitSet> {
public static final BitSetType INSTANCE = new BitSetType();
public BitSetType() {
super( VarcharTypeDescriptor.INSTANCE, BitSetJavaType.INSTANCE );
super( VarcharJdbcTypeDescriptor.INSTANCE, BitSetJavaType.INSTANCE );
}
@Override
public BitSet stringToObject(CharSequence sequence) throws Exception {
return fromString( sequence );
}
@Override
public String getName() {
return "bitset";
}

6
documentation/src/test/java/org/hibernate/userguide/mapping/basic/CustomBinaryJdbcType.java
View File

@ -12,7 +12,7 @@
import org.hibernate.type.descriptor.ValueExtractor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarbinaryTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarbinaryJdbcTypeDescriptor;
/**
* JdbcTypeDescriptor for documentation
@ -32,11 +32,11 @@ public boolean canBeRemapped() {
@Override
public <X> ValueBinder<X> getBinder(JavaTypeDescriptor<X> javaTypeDescriptor) {
return VarbinaryTypeDescriptor.INSTANCE.getBinder( javaTypeDescriptor );
return VarbinaryJdbcTypeDescriptor.INSTANCE.getBinder( javaTypeDescriptor );
}
@Override
public <X> ValueExtractor<X> getExtractor(JavaTypeDescriptor<X> javaTypeDescriptor) {
return VarbinaryTypeDescriptor.INSTANCE.getExtractor( javaTypeDescriptor );
return VarbinaryJdbcTypeDescriptor.INSTANCE.getExtractor( javaTypeDescriptor );
}
}

10
documentation/src/test/java/org/hibernate/userguide/mapping/basic/GenderJavaTypeDescriptor.java
View File

@ -1,14 +1,14 @@
package org.hibernate.userguide.mapping.basic;
import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.descriptor.java.AbstractClassTypeDescriptor;
import org.hibernate.type.descriptor.java.CharacterTypeDescriptor;
import org.hibernate.type.descriptor.java.AbstractClassJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.CharacterJavaTypeDescriptor;
/**
* @author Vlad Mihalcea
*/
//tag::basic-enums-custom-type-example[]
public class GenderJavaTypeDescriptor extends AbstractClassTypeDescriptor<Gender> {
public class GenderJavaTypeDescriptor extends AbstractClassJavaTypeDescriptor<Gender> {
public static final GenderJavaTypeDescriptor INSTANCE =
new GenderJavaTypeDescriptor();
@ -26,7 +26,7 @@ public Gender fromString(CharSequence string) {
}
public <X> X unwrap(Gender value, Class<X> type, WrapperOptions options) {
return CharacterTypeDescriptor.INSTANCE.unwrap(
return CharacterJavaTypeDescriptor.INSTANCE.unwrap(
value == null ? null : value.getCode(),
type,
options
@ -35,7 +35,7 @@ public <X> X unwrap(Gender value, Class<X> type, WrapperOptions options) {
public <X> Gender wrap(X value, WrapperOptions options) {
return Gender.fromCode(
CharacterTypeDescriptor.INSTANCE.wrap( value, options )
CharacterJavaTypeDescriptor.INSTANCE.wrap( value, options )
);
}
}

6
documentation/src/test/java/org/hibernate/userguide/mapping/basic/GenderType.java
View File

@ -1,7 +1,7 @@
package org.hibernate.userguide.mapping.basic;
import org.hibernate.type.AbstractSingleColumnStandardBasicType;
import org.hibernate.type.descriptor.jdbc.CharTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.CharJdbcTypeDescriptor;
/**
* @author Vlad Mihalcea
@ -13,8 +13,8 @@ public class GenderType extends AbstractSingleColumnStandardBasicType<Gender> {
public GenderType() {
super(
CharTypeDescriptor.INSTANCE,
GenderJavaTypeDescriptor.INSTANCE
CharJdbcTypeDescriptor.INSTANCE,
GenderJavaTypeDescriptor.INSTANCE
);
}

8
hibernate-community-dialects/src/main/java/org/hibernate/community/dialect/SQLiteDialect.java
View File

@ -49,8 +49,8 @@
import org.hibernate.sql.ast.tree.Statement;
import org.hibernate.sql.exec.spi.JdbcOperation;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.jdbc.BlobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import static org.hibernate.exception.spi.TemplatedViolatedConstraintNameExtractor.extractUsingTemplate;
@ -319,9 +319,9 @@ protected boolean supportsMathFunctions() {
public JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
switch (sqlCode) {
case Types.BLOB:
return BlobTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
return BlobJdbcTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
case Types.CLOB:
return ClobTypeDescriptor.STRING_BINDING;
return ClobJdbcTypeDescriptor.STRING_BINDING;
default:
return super.getSqlTypeDescriptorOverride( sqlCode );
}

4
hibernate-core/src/main/java/org/hibernate/annotations/JavaType.java
View File

@ -9,7 +9,7 @@
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.FIELD;
@ -30,5 +30,5 @@
/**
* The JavaTypeDescriptor to use
*/
Class<? extends BasicJavaDescriptor<?>> value();
Class<? extends BasicJavaTypeDescriptor<?>> value();
}

4
hibernate-core/src/main/java/org/hibernate/annotations/JavaTypeRegistration.java
View File

@ -10,7 +10,7 @@
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
import static java.lang.annotation.ElementType.PACKAGE;
@ -31,5 +31,5 @@
public @interface JavaTypeRegistration {
Class<?> javaType();
Class<? extends BasicJavaDescriptor<?>> descriptorClass();
Class<? extends BasicJavaTypeDescriptor<?>> descriptorClass();
}

4
hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinitionRegistry.java
View File

@ -8,7 +8,7 @@
import java.util.Map;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
/**
* @author Chris Cranford
@ -23,7 +23,7 @@ enum DuplicationStrategy {
}
TypeDefinition resolve(String typeName);
TypeDefinition resolveAutoApplied(BasicJavaDescriptor<?> jtd);
TypeDefinition resolveAutoApplied(BasicJavaTypeDescriptor<?> jtd);
TypeDefinitionRegistry register(TypeDefinition typeDefinition);
TypeDefinitionRegistry register(TypeDefinition typeDefinition, DuplicationStrategy duplicationStrategy);

4
hibernate-core/src/main/java/org/hibernate/boot/model/TypeDefinitionRegistryStandardImpl.java
View File

@ -11,7 +11,7 @@
import java.util.Map;
import org.hibernate.internal.util.StringHelper;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.jboss.logging.Logger;
@ -47,7 +47,7 @@ public TypeDefinition resolve(String typeName) {
}
@Override
public TypeDefinition resolveAutoApplied(BasicJavaDescriptor<?> jtd) {
public TypeDefinition resolveAutoApplied(BasicJavaTypeDescriptor<?> jtd) {
// For now, check the definition map for a entry keyed by the JTD name.
// Ultimately should maybe have TypeDefinition or the registry keep explicit track of
// auto-applied defs

49
hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/InferredBasicValueResolver.java
View File

@ -21,21 +21,20 @@
import org.hibernate.metamodel.mapping.JdbcMapping;
import org.hibernate.metamodel.model.convert.internal.NamedEnumValueConverter;
import org.hibernate.metamodel.model.convert.internal.OrdinalEnumValueConverter;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.AdjustableBasicType;
import org.hibernate.type.BasicType;
import org.hibernate.type.CustomType;
import org.hibernate.type.SerializableType;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.EnumJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.SerializableTypeDescriptor;
import org.hibernate.type.descriptor.java.SerializableJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.TemporalJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptorIndicators;
import org.hibernate.type.descriptor.jdbc.ObjectJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntJdbcTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
/**
@ -48,7 +47,7 @@ public class InferredBasicValueResolver {
*/
@SuppressWarnings({"unchecked", "rawtypes"})
public static BasicValue.Resolution from(
Function<TypeConfiguration, BasicJavaDescriptor> explicitJavaTypeAccess,
Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJavaTypeAccess,
Function<TypeConfiguration, JdbcTypeDescriptor> explicitSqlTypeAccess,
Type resolvedJavaType,
Supplier<JavaTypeDescriptor> reflectedJtdResolver,
@ -59,10 +58,10 @@ public static BasicValue.Resolution from(
String propertyName,
TypeConfiguration typeConfiguration) {
final BasicJavaDescriptor explicitJavaType = explicitJavaTypeAccess != null ? explicitJavaTypeAccess.apply( typeConfiguration ) : null;
final BasicJavaTypeDescriptor explicitJavaType = explicitJavaTypeAccess != null ? explicitJavaTypeAccess.apply( typeConfiguration ) : null;
final JdbcTypeDescriptor explicitJdbcType = explicitSqlTypeAccess != null ? explicitSqlTypeAccess.apply( typeConfiguration ) : null;
final BasicJavaDescriptor reflectedJtd = (BasicJavaDescriptor) reflectedJtdResolver.get();
final BasicJavaTypeDescriptor reflectedJtd = (BasicJavaTypeDescriptor) reflectedJtdResolver.get();
// NOTE : the distinction that is made below wrt `explicitJavaType` and `reflectedJtd` is
// needed temporarily to trigger "legacy resolution" versus "ORM6 resolution. Yes, it
@ -108,7 +107,7 @@ else if ( explicitJavaType instanceof TemporalJavaTypeDescriptor ) {
typeConfiguration
);
}
else if ( explicitJavaType instanceof SerializableTypeDescriptor || explicitJavaType.getJavaType() instanceof Serializable ) {
else if ( explicitJavaType instanceof SerializableJavaTypeDescriptor || explicitJavaType.getJavaType() instanceof Serializable ) {
legacyType = new SerializableType<>( explicitJavaType );
jdbcMapping = legacyType;
}
@ -172,7 +171,7 @@ else if ( reflectedJtd instanceof TemporalJavaTypeDescriptor ) {
legacyType = resolveSqlTypeIndicators( stdIndicators, registeredType, reflectedJtd );
jdbcMapping = legacyType;
}
else if ( reflectedJtd instanceof SerializableTypeDescriptor || reflectedJtd.getJavaType() instanceof Serializable ) {
else if ( reflectedJtd instanceof SerializableJavaTypeDescriptor || reflectedJtd.getJavaType() instanceof Serializable ) {
legacyType = new SerializableType<>( reflectedJtd );
jdbcMapping = legacyType;
}
@ -205,7 +204,7 @@ else if ( column.getLength() != null ) {
}
}
}
final BasicJavaDescriptor recommendedJtd = explicitJdbcType.getJdbcRecommendedJavaTypeMapping(
final BasicJavaTypeDescriptor recommendedJtd = explicitJdbcType.getJdbcRecommendedJavaTypeMapping(
length,
scale,
typeConfiguration
@ -269,7 +268,7 @@ public static BasicType<?> resolveSqlTypeIndicators(
@SuppressWarnings("rawtypes")
public static InferredBasicValueResolution fromEnum(
EnumJavaTypeDescriptor enumJavaDescriptor,
BasicJavaDescriptor explicitJavaType,
BasicJavaTypeDescriptor explicitJavaType,
JdbcTypeDescriptor explicitJdbcType,
JdbcTypeDescriptorIndicators stdIndicators,
TypeConfiguration typeConfiguration) {
@ -344,7 +343,7 @@ public static InferredBasicValueResolution fromEnum(
relationalJtd = typeConfiguration.getJavaTypeDescriptorRegistry().getDescriptor( Integer.class );
}
final JdbcTypeDescriptor jdbcTypeDescriptor = explicitJdbcType != null ? explicitJdbcType : TinyIntTypeDescriptor.INSTANCE;
final JdbcTypeDescriptor jdbcTypeDescriptor = explicitJdbcType != null ? explicitJdbcType : TinyIntJdbcTypeDescriptor.INSTANCE;
//noinspection unchecked
final OrdinalEnumValueConverter valueConverter = new OrdinalEnumValueConverter(
@ -384,7 +383,7 @@ public static InferredBasicValueResolution fromEnum(
@SuppressWarnings({"rawtypes", "unchecked"})
public static InferredBasicValueResolution fromTemporal(
TemporalJavaTypeDescriptor reflectedJtd,
BasicJavaDescriptor explicitJavaType,
BasicJavaTypeDescriptor explicitJavaType,
JdbcTypeDescriptor explicitJdbcType,
Type resolvedJavaType,
JdbcTypeDescriptorIndicators stdIndicators,
@ -464,27 +463,17 @@ public static InferredBasicValueResolution fromTemporal(
//
// - for the moment continue to use the legacy resolution to registered
// BasicType
final Type javaType;
if ( resolvedJavaType == null ) {
javaType = reflectedJtd.getJavaType();
}
else {
javaType = resolvedJavaType;
}
final BasicType registeredType = typeConfiguration.getBasicTypeRegistry().getRegisteredType( javaType );
final AllowableTemporalParameterType legacyTemporalType = (AllowableTemporalParameterType) registeredType;
final BasicType basicType;
if ( requestedTemporalPrecision != null ) {
basicType = (BasicType) legacyTemporalType.resolveTemporalPrecision(
requestedTemporalPrecision,
typeConfiguration
if ( requestedTemporalPrecision != null && requestedTemporalPrecision != reflectedJtd.getPrecision() ) {
basicType = typeConfiguration.getBasicTypeRegistry().resolve(
reflectedJtd.resolveTypeForPrecision( requestedTemporalPrecision, typeConfiguration ),
TemporalJavaTypeDescriptor.resolveJdbcTypeCode( requestedTemporalPrecision )
);
}
else {
basicType = (BasicType) legacyTemporalType.resolveTemporalPrecision(
reflectedJtd.getPrecision(),
typeConfiguration
basicType = typeConfiguration.getBasicTypeRegistry().resolve(
reflectedJtd,
reflectedJtd.getRecommendedJdbcType( stdIndicators )
);
}

8
hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/NamedConverterResolution.java
View File

@ -21,7 +21,7 @@
import org.hibernate.type.BasicType;
import org.hibernate.type.descriptor.converter.AttributeConverterMutabilityPlanImpl;
import org.hibernate.type.descriptor.converter.AttributeConverterTypeAdapter;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.MutabilityPlan;
@ -37,7 +37,7 @@ public class NamedConverterResolution<J> implements BasicValue.Resolution<J> {
public static NamedConverterResolution from(
ConverterDescriptor converterDescriptor,
Function<TypeConfiguration, BasicJavaDescriptor> explicitJtdAccess,
Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJtdAccess,
Function<TypeConfiguration, JdbcTypeDescriptor> explicitStdAccess,
Function<TypeConfiguration, MutabilityPlan> explicitMutabilityPlanAccess,
JdbcTypeDescriptorIndicators sqlTypeIndicators,
@ -55,7 +55,7 @@ public static NamedConverterResolution from(
public static NamedConverterResolution from(
String name,
Function<TypeConfiguration, BasicJavaDescriptor> explicitJtdAccess,
Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJtdAccess,
Function<TypeConfiguration, JdbcTypeDescriptor> explicitStdAccess,
Function<TypeConfiguration, MutabilityPlan> explicitMutabilityPlanAccess,
JdbcTypeDescriptorIndicators sqlTypeIndicators,
@ -84,7 +84,7 @@ public static NamedConverterResolution from(
}
private static NamedConverterResolution fromInternal(
Function<TypeConfiguration, BasicJavaDescriptor> explicitJtdAccess,
Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJtdAccess,
Function<TypeConfiguration, JdbcTypeDescriptor> explicitStdAccess,
Function<TypeConfiguration, MutabilityPlan> explicitMutabilityPlanAccess,
JpaAttributeConverter converter, JdbcTypeDescriptorIndicators sqlTypeIndicators,

10
hibernate-core/src/main/java/org/hibernate/boot/model/process/internal/VersionResolution.java
View File

@ -15,11 +15,11 @@
import org.hibernate.metamodel.model.convert.spi.BasicValueConverter;
import org.hibernate.type.BasicType;
import org.hibernate.type.RowVersionType;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.MutabilityPlan;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptorIndicators;
import org.hibernate.type.spi.TypeConfiguration;
@ -36,7 +36,7 @@ public class VersionResolution<E> implements BasicValue.Resolution<E> {
@SuppressWarnings({"rawtypes", "unchecked"})
public static <E> VersionResolution<E> from(
Function<TypeConfiguration, java.lang.reflect.Type> implicitJavaTypeAccess,
Function<TypeConfiguration, BasicJavaDescriptor> explicitJtdAccess,
Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJtdAccess,
Function<TypeConfiguration, JdbcTypeDescriptor> explicitStdAccess,
TypeConfiguration typeConfiguration,
@SuppressWarnings("unused") MetadataBuildingContext context) {
@ -46,7 +46,7 @@ public static <E> VersionResolution<E> from(
final java.lang.reflect.Type implicitJavaType = implicitJavaTypeAccess.apply( typeConfiguration );
final JavaTypeDescriptor registered = typeConfiguration.getJavaTypeDescriptorRegistry().resolveDescriptor( implicitJavaType );
if ( registered instanceof PrimitiveByteArrayTypeDescriptor ) {
if ( registered instanceof PrimitiveByteArrayJavaTypeDescriptor ) {
return new VersionResolution<>(
RowVersionType.INSTANCE.getJavaTypeDescriptor(),
RowVersionType.INSTANCE.getJdbcTypeDescriptor(),
@ -55,7 +55,7 @@ public static <E> VersionResolution<E> from(
);
}
final BasicJavaDescriptor jtd = (BasicJavaDescriptor) registered;
final BasicJavaTypeDescriptor jtd = (BasicJavaTypeDescriptor) registered;
final JdbcTypeDescriptor recommendedJdbcType = jtd.getRecommendedJdbcType(
new JdbcTypeDescriptorIndicators() {

13
hibernate-core/src/main/java/org/hibernate/boot/model/source/internal/hbm/ModelBinder.java
View File

@ -155,7 +155,6 @@
import org.hibernate.type.ClobType;
import org.hibernate.type.ComponentType;
import org.hibernate.type.CustomType;
import org.hibernate.type.DiscriminatorType;
import org.hibernate.type.ForeignKeyDirection;
import org.hibernate.type.NClobType;
import org.hibernate.type.StandardBasicTypes;
@ -2396,7 +2395,7 @@ private void bindAny(
);
final String discriminatorTypeName;
final DiscriminatorType<?> discriminatorType;
final BasicType<?> discriminatorType;
if ( discriminatorTypeResolution != null && discriminatorTypeResolution.typeName != null ) {
discriminatorTypeName = discriminatorTypeResolution.typeName;
discriminatorType = resolveExplicitlyNamedAnyDiscriminatorType(
@ -2417,7 +2416,7 @@ private void bindAny(
anyMapping.getDiscriminatorSource().getValueMappings().forEach(
(discriminatorValueString, entityName) -> {
try {
final Object discriminatorValue = discriminatorType.stringToObject( discriminatorValueString );
final Object discriminatorValue = discriminatorType.getJavaTypeDescriptor().fromString( discriminatorValueString );
discriminatorValueToEntityNameMap.put( discriminatorValue, entityName );
}
catch (Exception e) {
@ -2458,7 +2457,7 @@ private void bindAny(
);
}
private DiscriminatorType<?> resolveExplicitlyNamedAnyDiscriminatorType(
private BasicType<?> resolveExplicitlyNamedAnyDiscriminatorType(
String typeName,
Properties parameters,
Any.MetaValue discriminatorMapping) {
@ -2471,7 +2470,7 @@ private DiscriminatorType<?> resolveExplicitlyNamedAnyDiscriminatorType(
.getBasicTypeRegistry()
.getRegisteredType( typeName );
if ( basicTypeByName != null ) {
return (DiscriminatorType<?>) basicTypeByName;
return basicTypeByName;
}
}
@ -2489,7 +2488,7 @@ private DiscriminatorType<?> resolveExplicitlyNamedAnyDiscriminatorType(
discriminatorMapping.setTypeParameters( resolution.getCombinedTypeParameters() );
}
return (DiscriminatorType<?>) resolution.getLegacyResolvedBasicType();
return resolution.getLegacyResolvedBasicType();
}
final ClassLoaderService classLoaderService = bootstrapContext
@ -2520,7 +2519,7 @@ private DiscriminatorType<?> resolveExplicitlyNamedAnyDiscriminatorType(
}
assert typeInstance instanceof BasicType;
return (DiscriminatorType<?>) typeInstance;
return (BasicType<?>) typeInstance;
}
catch (ClassLoadingException e) {
log.debugf( "Unable to load explicit any-discriminator type name as Java Class - %s", typeName );

7
hibernate-core/src/main/java/org/hibernate/cfg/AnnotationBinder.java
View File

@ -73,7 +73,6 @@
import org.hibernate.AnnotationException;
import org.hibernate.AssertionFailure;
import org.hibernate.EntityMode;
import org.hibernate.FetchMode;
import org.hibernate.MappingException;
import org.hibernate.annotations.BatchSize;
@ -171,7 +170,7 @@
import org.hibernate.mapping.ToOne;
import org.hibernate.mapping.UnionSubclass;
import org.hibernate.resource.beans.spi.ManagedBeanRegistry;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import static org.hibernate.internal.CoreLogging.messageLogger;
@ -372,8 +371,8 @@ private static void handleJavaTypeDescriptorRegistration(
MetadataBuildingContext context,
ManagedBeanRegistry managedBeanRegistry,
JavaTypeRegistration annotation) {
final Class<? extends BasicJavaDescriptor<?>> jtdClass = annotation.descriptorClass();
final BasicJavaDescriptor<?> jtd = managedBeanRegistry.getBean( jtdClass ).getBeanInstance();
final Class<? extends BasicJavaTypeDescriptor<?>> jtdClass = annotation.descriptorClass();
final BasicJavaTypeDescriptor<?> jtd = managedBeanRegistry.getBean( jtdClass ).getBeanInstance();
context.getMetadataCollector().addJavaTypeRegistration( annotation.javaType(), jtd );
}

6
hibernate-core/src/main/java/org/hibernate/cfg/BinderHelper.java
View File

@ -60,7 +60,7 @@
import org.hibernate.mapping.Table;
import org.hibernate.mapping.ToOne;
import org.hibernate.mapping.Value;
import org.hibernate.type.DiscriminatorType;
import org.hibernate.type.BasicType;
import org.jboss.logging.Logger;
@ -981,7 +981,7 @@ public static Any buildAnyValue(
value.setMetaType( metaDefToUse.metaType() );
final HashMap<Object,String> values = new HashMap<>();
final DiscriminatorType<?> metaType = (DiscriminatorType<?>) context.getMetadataCollector()
final BasicType<?> metaType = context.getMetadataCollector()
.getTypeConfiguration()
.getBasicTypeRegistry()
.getRegisteredType( value.getMetaType() );
@ -989,7 +989,7 @@ public static Any buildAnyValue(
for (int i = 0; i < metaDefToUse.metaValues().length; i++) {
final MetaValue metaValue = metaDefToUse.metaValues()[ i ];
try {
final Object discriminator = metaType.stringToObject( metaValue.value() );
final Object discriminator = metaType.getJavaTypeDescriptor().fromString( metaValue.value() );
final String entityName = metaValue.targetEntity().getName();
values.put( discriminator, entityName );
}

8
hibernate-core/src/main/java/org/hibernate/cfg/annotations/BasicValueBinder.java
View File

@ -60,7 +60,7 @@
import org.hibernate.mapping.Table;
import org.hibernate.type.BasicType;
import org.hibernate.type.SerializableToBlobType;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.ImmutableMutabilityPlan;
import org.hibernate.type.descriptor.java.MutabilityPlan;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
@ -105,7 +105,7 @@ public enum Kind {
private Map explicitLocalTypeParams;
private Function<TypeConfiguration, JdbcTypeDescriptor> explicitSqlTypeAccess;
private Function<TypeConfiguration, BasicJavaDescriptor> explicitJtdAccess;
private Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJtdAccess;
private Function<TypeConfiguration, MutabilityPlan> explicitMutabilityAccess;
private Function<TypeConfiguration, java.lang.reflect.Type> implicitJavaTypeAccess;
@ -545,7 +545,7 @@ private void mapKeySupplementalDetails(XProperty attributeXProperty) {
}
final JavaType jtdAnn = mapKeyJtdAnn.value();
final Class<? extends BasicJavaDescriptor<?>> jtdJavaType = jtdAnn.value();
final Class<? extends BasicJavaTypeDescriptor<?>> jtdJavaType = jtdAnn.value();
try {
return jtdJavaType.newInstance();
}
@ -583,7 +583,7 @@ private void normalSupplementalDetails(
explicitJtdAccess = typeConfiguration -> {
final JavaType explicitJtdAnn = attributeXProperty.getAnnotation( JavaType.class );
if ( explicitJtdAnn != null ) {
final Class<? extends BasicJavaDescriptor<?>> jtdImplJavaType = explicitJtdAnn.value();
final Class<? extends BasicJavaTypeDescriptor<?>> jtdImplJavaType = explicitJtdAnn.value();
try {
return jtdImplJavaType.newInstance();

55
hibernate-core/src/main/java/org/hibernate/dialect/AbstractHANADialect.java
View File

@ -57,6 +57,7 @@
import org.hibernate.type.descriptor.ValueExtractor;
import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.descriptor.java.DataHelper;
import org.hibernate.type.descriptor.java.DoubleJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.*;
import org.hibernate.type.internal.StandardBasicTypeImpl;
@ -387,7 +388,7 @@ protected X doExtract(CallableStatement statement, String name, WrapperOptions o
// using non-contextual lob creation and HANA then closes our StringReader.
// see test case LobLocatorTest
private static class HANAClobTypeDescriptor extends ClobTypeDescriptor {
private static class HANAClobJdbcTypeDescriptor extends ClobJdbcTypeDescriptor {
@Override
public String toString() {
return "HANAClobTypeDescriptor";
@ -399,7 +400,7 @@ public String toString() {
final int maxLobPrefetchSize;
final boolean useUnicodeStringTypes;
public HANAClobTypeDescriptor(int maxLobPrefetchSize, boolean useUnicodeStringTypes) {
public HANAClobJdbcTypeDescriptor(int maxLobPrefetchSize, boolean useUnicodeStringTypes) {
this.maxLobPrefetchSize = maxLobPrefetchSize;
this.useUnicodeStringTypes = useUnicodeStringTypes;
}
@ -452,14 +453,14 @@ public <X> ValueExtractor<X> getExtractor(JavaTypeDescriptor<X> javaTypeDescript
@Override
protected X doExtract(ResultSet rs, int paramIndex, WrapperOptions options) throws SQLException {
Clob rsClob;
if ( HANAClobTypeDescriptor.this.useUnicodeStringTypes ) {
if ( HANAClobJdbcTypeDescriptor.this.useUnicodeStringTypes ) {
rsClob = rs.getNClob( paramIndex );
}
else {
rsClob = rs.getClob( paramIndex );
}
if ( rsClob == null || rsClob.length() < HANAClobTypeDescriptor.this.maxLobPrefetchSize ) {
if ( rsClob == null || rsClob.length() < HANAClobJdbcTypeDescriptor.this.maxLobPrefetchSize ) {
return javaTypeDescriptor.wrap( rsClob, options );
}
Clob clob = new MaterializedNClob( DataHelper.extractString( rsClob ) );
@ -487,14 +488,14 @@ public boolean isUseUnicodeStringTypes() {
}
}
private static class HANANClobTypeDescriptor extends NClobTypeDescriptor {
private static class HANANClobJdbcTypeDescriptor extends NClobJdbcTypeDescriptor {
/** serial version uid. */
private static final long serialVersionUID = 5651116091681647859L;
final int maxLobPrefetchSize;
public HANANClobTypeDescriptor(int maxLobPrefetchSize) {
public HANANClobJdbcTypeDescriptor(int maxLobPrefetchSize) {
this.maxLobPrefetchSize = maxLobPrefetchSize;
}
@ -551,7 +552,7 @@ public <X> ValueExtractor<X> getExtractor(JavaTypeDescriptor<X> javaTypeDescript
@Override
protected X doExtract(ResultSet rs, int paramIndex, WrapperOptions options) throws SQLException {
NClob rsNClob = rs.getNClob( paramIndex );
if ( rsNClob == null || rsNClob.length() < HANANClobTypeDescriptor.this.maxLobPrefetchSize ) {
if ( rsNClob == null || rsNClob.length() < HANANClobJdbcTypeDescriptor.this.maxLobPrefetchSize ) {
return javaTypeDescriptor.wrap( rsNClob, options );
}
NClob nClob = new MaterializedNClob( DataHelper.extractString( rsNClob ) );
@ -640,10 +641,10 @@ public <X> BasicBinder<X> getBinder(final JavaTypeDescriptor<X> javaTypeDescript
@Override
protected void doBind(PreparedStatement st, X value, int index, WrapperOptions options) throws SQLException {
JdbcTypeDescriptor descriptor = BlobTypeDescriptor.BLOB_BINDING;
JdbcTypeDescriptor descriptor = BlobJdbcTypeDescriptor.BLOB_BINDING;
if ( byte[].class.isInstance( value ) ) {
// performance shortcut for binding BLOB data in byte[] format
descriptor = BlobTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
descriptor = BlobJdbcTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
}
else if ( options.useStreamForLobBinding() ) {
descriptor = HANABlobTypeDescriptor.this.hanaStreamBlobTypeDescriptor;
@ -653,10 +654,10 @@ else if ( options.useStreamForLobBinding() ) {
@Override
protected void doBind(CallableStatement st, X value, String name, WrapperOptions options) throws SQLException {
JdbcTypeDescriptor descriptor = BlobTypeDescriptor.BLOB_BINDING;
JdbcTypeDescriptor descriptor = BlobJdbcTypeDescriptor.BLOB_BINDING;
if ( byte[].class.isInstance( value ) ) {
// performance shortcut for binding BLOB data in byte[] format
descriptor = BlobTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
descriptor = BlobJdbcTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
}
else if ( options.useStreamForLobBinding() ) {
descriptor = HANABlobTypeDescriptor.this.hanaStreamBlobTypeDescriptor;
@ -686,11 +687,11 @@ public int getMaxLobPrefetchSize() {
private static final Boolean USE_LEGACY_BOOLEAN_TYPE_DEFAULT_VALUE = Boolean.FALSE;
private static final Boolean TREAT_DOUBLE_TYPED_FIELDS_AS_DECIMAL_DEFAULT_VALUE = Boolean.FALSE;
private HANANClobTypeDescriptor nClobTypeDescriptor = new HANANClobTypeDescriptor( MAX_LOB_PREFETCH_SIZE_DEFAULT_VALUE );
private HANANClobJdbcTypeDescriptor nClobTypeDescriptor = new HANANClobJdbcTypeDescriptor( MAX_LOB_PREFETCH_SIZE_DEFAULT_VALUE );
private HANABlobTypeDescriptor blobTypeDescriptor = new HANABlobTypeDescriptor( MAX_LOB_PREFETCH_SIZE_DEFAULT_VALUE );
private HANAClobTypeDescriptor clobTypeDescriptor;
private HANAClobJdbcTypeDescriptor clobTypeDescriptor;
private boolean useLegacyBooleanType = USE_LEGACY_BOOLEAN_TYPE_DEFAULT_VALUE.booleanValue();
private boolean useUnicodeStringTypes;
@ -741,8 +742,10 @@ public AbstractHANADialect() {
super();
this.useUnicodeStringTypes = useUnicodeStringTypesDefault().booleanValue();
this.clobTypeDescriptor = new HANAClobTypeDescriptor( MAX_LOB_PREFETCH_SIZE_DEFAULT_VALUE,
useUnicodeStringTypesDefault().booleanValue() );
this.clobTypeDescriptor = new HANAClobJdbcTypeDescriptor(
MAX_LOB_PREFETCH_SIZE_DEFAULT_VALUE,
useUnicodeStringTypesDefault().booleanValue()
);
// Note that 38 is the maximum precision HANA supports
registerColumnType( Types.DECIMAL, "decimal($p, $s)" );
@ -1035,13 +1038,13 @@ protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(final int sqlCode) {
return this.blobTypeDescriptor;
case Types.TINYINT:
// tinyint is unsigned on HANA
return SmallIntTypeDescriptor.INSTANCE;
return SmallIntJdbcTypeDescriptor.INSTANCE;
case Types.VARCHAR:
return this.isUseUnicodeStringTypes() ? NVarcharTypeDescriptor.INSTANCE : VarcharTypeDescriptor.INSTANCE;
return this.isUseUnicodeStringTypes() ? NVarcharJdbcTypeDescriptor.INSTANCE : VarcharJdbcTypeDescriptor.INSTANCE;
case Types.CHAR:
return this.isUseUnicodeStringTypes() ? NCharTypeDescriptor.INSTANCE : CharTypeDescriptor.INSTANCE;
return this.isUseUnicodeStringTypes() ? NCharJdbcTypeDescriptor.INSTANCE : CharJdbcTypeDescriptor.INSTANCE;
case Types.DOUBLE:
return this.treatDoubleTypedFieldsAsDecimal ? DecimalTypeDescriptor.INSTANCE : DoubleTypeDescriptor.INSTANCE;
return this.treatDoubleTypedFieldsAsDecimal ? DecimalJdbcTypeDescriptor.INSTANCE : DoubleJdbcTypeDescriptor.INSTANCE;
default:
return super.getSqlTypeDescriptorOverride( sqlCode );
}
@ -1429,7 +1432,7 @@ public Integer convert(Object value) {
Integer.valueOf( maxLobPrefetchSizeDefault ) ).intValue();
if ( this.nClobTypeDescriptor.getMaxLobPrefetchSize() != maxLobPrefetchSize ) {
this.nClobTypeDescriptor = new HANANClobTypeDescriptor( maxLobPrefetchSize );
this.nClobTypeDescriptor = new HANANClobJdbcTypeDescriptor( maxLobPrefetchSize );
}
if ( this.blobTypeDescriptor.getMaxLobPrefetchSize() != maxLobPrefetchSize ) {
@ -1454,7 +1457,7 @@ public Integer convert(Object value) {
if ( this.clobTypeDescriptor.getMaxLobPrefetchSize() != maxLobPrefetchSize
|| this.clobTypeDescriptor.isUseUnicodeStringTypes() != this.useUnicodeStringTypes ) {
this.clobTypeDescriptor = new HANAClobTypeDescriptor( maxLobPrefetchSize, this.useUnicodeStringTypes );
this.clobTypeDescriptor = new HANAClobJdbcTypeDescriptor( maxLobPrefetchSize, this.useUnicodeStringTypes );
}
}
@ -1475,8 +1478,8 @@ public Integer convert(Object value) {
typeContributions.getTypeConfiguration().getBasicTypeRegistry()
.register(
new StandardBasicTypeImpl<>(
org.hibernate.type.descriptor.java.DoubleTypeDescriptor.INSTANCE,
NumericTypeDescriptor.INSTANCE
DoubleJavaTypeDescriptor.INSTANCE,
NumericJdbcTypeDescriptor.INSTANCE
),
Double.class.getName()
);
@ -1500,15 +1503,15 @@ public Integer convert(Object value) {
.add( StandardBasicTypes.BIG_DECIMAL.getName() );
typeContributions.getTypeConfiguration().getJdbcTypeDescriptorRegistry().addDescriptor(
Types.FLOAT,
NumericTypeDescriptor.INSTANCE
NumericJdbcTypeDescriptor.INSTANCE
);
typeContributions.getTypeConfiguration().getJdbcTypeDescriptorRegistry().addDescriptor(
Types.REAL,
NumericTypeDescriptor.INSTANCE
NumericJdbcTypeDescriptor.INSTANCE
);
typeContributions.getTypeConfiguration().getJdbcTypeDescriptorRegistry().addDescriptor(
Types.DOUBLE,
NumericTypeDescriptor.INSTANCE
NumericJdbcTypeDescriptor.INSTANCE
);
}
}

4
hibernate-core/src/main/java/org/hibernate/dialect/AbstractTransactSQLDialect.java
View File

@ -26,7 +26,7 @@
import org.hibernate.query.sqm.mutation.internal.idtable.TempIdTableExporter;
import org.hibernate.query.sqm.mutation.spi.SqmMultiTableMutationStrategy;
import org.hibernate.sql.ast.spi.SqlAppender;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeDescriptorRegistry;
@ -314,6 +314,6 @@ public boolean supportsPartitionBy() {
@Override
public void appendBinaryLiteral(SqlAppender appender, byte[] bytes) {
appender.appendSql( "0x" );
PrimitiveByteArrayTypeDescriptor.INSTANCE.appendString( appender, bytes );
PrimitiveByteArrayJavaTypeDescriptor.INSTANCE.appendString( appender, bytes );
}
}

20
hibernate-core/src/main/java/org/hibernate/dialect/DB2Dialect.java
View File

@ -44,7 +44,7 @@
import org.hibernate.tool.schema.extract.spi.SequenceInformationExtractor;
import org.hibernate.type.JavaObjectType;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.*;
import java.sql.CallableStatement;
@ -502,15 +502,15 @@ protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
final int version = getVersion();
if ( version < 1100 && sqlCode == Types.BOOLEAN ) {
return SmallIntTypeDescriptor.INSTANCE;
return SmallIntJdbcTypeDescriptor.INSTANCE;
}
else if ( version < 1100 && sqlCode == Types.VARBINARY ) {
// Binary literals were only added in 11. See https://www.ibm.com/support/knowledgecenter/SSEPGG_11.1.0/com.ibm.db2.luw.sql.ref.doc/doc/r0000731.html#d79816e393
return VarbinaryTypeDescriptor.INSTANCE_WITHOUT_LITERALS;
return VarbinaryJdbcTypeDescriptor.INSTANCE_WITHOUT_LITERALS;
}
else if ( version < 970 ) {
return sqlCode == Types.NUMERIC
? DecimalTypeDescriptor.INSTANCE
? DecimalJdbcTypeDescriptor.INSTANCE
: super.getSqlTypeDescriptorOverride(sqlCode);
}
else {
@ -521,15 +521,15 @@ else if ( version < 970 ) {
// use the non-N variants which are supported.
switch ( sqlCode ) {
case Types.NCHAR:
return CharTypeDescriptor.INSTANCE;
return CharJdbcTypeDescriptor.INSTANCE;
case Types.NCLOB:
return useInputStreamToInsertBlob()
? ClobTypeDescriptor.STREAM_BINDING
: ClobTypeDescriptor.CLOB_BINDING;
? ClobJdbcTypeDescriptor.STREAM_BINDING
: ClobJdbcTypeDescriptor.CLOB_BINDING;
case Types.NVARCHAR:
return VarcharTypeDescriptor.INSTANCE;
return VarcharJdbcTypeDescriptor.INSTANCE;
case Types.NUMERIC:
return DecimalTypeDescriptor.INSTANCE;
return DecimalJdbcTypeDescriptor.INSTANCE;
default:
return super.getSqlTypeDescriptorOverride(sqlCode);
}
@ -557,7 +557,7 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry
@Override
public void appendBinaryLiteral(SqlAppender appender, byte[] bytes) {
appender.appendSql( "BX'" );
PrimitiveByteArrayTypeDescriptor.INSTANCE.appendString( appender, bytes );
PrimitiveByteArrayJavaTypeDescriptor.INSTANCE.appendString( appender, bytes );
appender.appendSql( '\'' );
}

12
hibernate-core/src/main/java/org/hibernate/dialect/DerbyDialect.java
View File

@ -55,11 +55,11 @@
import org.hibernate.tool.schema.extract.spi.SequenceInformationExtractor;
import org.hibernate.type.JavaObjectType;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.jdbc.DecimalTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.DecimalJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ObjectNullResolvingJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.SmallIntTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.SmallIntJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampJdbcTypeDescriptor;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
@ -494,13 +494,13 @@ public boolean supportsOrderByInSubquery() {
protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
if ( getVersion() < 1070 && sqlCode == Types.BOOLEAN) {
return SmallIntTypeDescriptor.INSTANCE;
return SmallIntJdbcTypeDescriptor.INSTANCE;
}
switch ( sqlCode ) {
case Types.NUMERIC:
return DecimalTypeDescriptor.INSTANCE;
return DecimalJdbcTypeDescriptor.INSTANCE;
case Types.TIMESTAMP_WITH_TIMEZONE:
return TimestampTypeDescriptor.INSTANCE;
return TimestampJdbcTypeDescriptor.INSTANCE;
default:
return super.getSqlTypeDescriptorOverride(sqlCode);
}

25
hibernate-core/src/main/java/org/hibernate/dialect/Dialect.java
View File

@ -9,7 +9,6 @@
import org.hibernate.HibernateException;
import org.hibernate.LockMode;
import org.hibernate.LockOptions;
import org.hibernate.MappingException;
import org.hibernate.NotYetImplementedFor6Exception;
import org.hibernate.dialect.sequence.NoSequenceSupport;
import org.hibernate.query.FetchClauseType;
@ -77,13 +76,13 @@
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.LongNVarcharTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NCharTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NVarcharTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.LongNVarcharJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NCharJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NVarcharJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeDescriptorRegistry;
import jakarta.persistence.TemporalType;
@ -984,10 +983,10 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry
final NationalizationSupport nationalizationSupport = getNationalizationSupport();
if ( nationalizationSupport == NationalizationSupport.EXPLICIT ) {
typeContributions.contributeJdbcTypeDescriptor( NCharTypeDescriptor.INSTANCE );
typeContributions.contributeJdbcTypeDescriptor( NVarcharTypeDescriptor.INSTANCE );
typeContributions.contributeJdbcTypeDescriptor( LongNVarcharTypeDescriptor.INSTANCE );
typeContributions.contributeJdbcTypeDescriptor( NClobTypeDescriptor.DEFAULT );
typeContributions.contributeJdbcTypeDescriptor( NCharJdbcTypeDescriptor.INSTANCE );
typeContributions.contributeJdbcTypeDescriptor( NVarcharJdbcTypeDescriptor.INSTANCE );
typeContributions.contributeJdbcTypeDescriptor( LongNVarcharJdbcTypeDescriptor.INSTANCE );
typeContributions.contributeJdbcTypeDescriptor( NClobJdbcTypeDescriptor.DEFAULT );
}
}
@ -1182,7 +1181,7 @@ protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
JdbcTypeDescriptor descriptor;
switch ( sqlCode ) {
case Types.CLOB: {
descriptor = useInputStreamToInsertBlob() ? ClobTypeDescriptor.STREAM_BINDING : null;
descriptor = useInputStreamToInsertBlob() ? ClobJdbcTypeDescriptor.STREAM_BINDING : null;
break;
}
default: {
@ -3418,7 +3417,7 @@ public boolean supportsBitType() {
public void appendBinaryLiteral(SqlAppender appender, byte[] bytes) {
appender.appendSql( "X'" );
PrimitiveByteArrayTypeDescriptor.INSTANCE.appendString( appender, bytes );
PrimitiveByteArrayJavaTypeDescriptor.INSTANCE.appendString( appender, bytes );
appender.appendSql( '\'' );
}

12
hibernate-core/src/main/java/org/hibernate/dialect/OracleDialect.java
View File

@ -59,8 +59,8 @@
import org.hibernate.type.JavaObjectType;
import org.hibernate.type.NullType;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NullJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ObjectNullAsNullTypeJdbcTypeDescriptor;
@ -665,9 +665,9 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry
false
);
BlobTypeDescriptor descriptor = preferLong ?
BlobTypeDescriptor.PRIMITIVE_ARRAY_BINDING :
BlobTypeDescriptor.DEFAULT;
BlobJdbcTypeDescriptor descriptor = preferLong ?
BlobJdbcTypeDescriptor.PRIMITIVE_ARRAY_BINDING :
BlobJdbcTypeDescriptor.DEFAULT;
typeContributions.contributeJdbcTypeDescriptor( descriptor );
}
@ -1189,7 +1189,7 @@ public static Replacer datetimeFormat(String format, boolean useFm, boolean rese
@Override
public void appendBinaryLiteral(SqlAppender appender, byte[] bytes) {
appender.appendSql( "hextoraw('" );
PrimitiveByteArrayTypeDescriptor.INSTANCE.appendString( appender, bytes );
PrimitiveByteArrayJavaTypeDescriptor.INSTANCE.appendString( appender, bytes );
appender.appendSql( "')" );
}

12
hibernate-core/src/main/java/org/hibernate/dialect/PostgreSQLDialect.java
View File

@ -66,9 +66,9 @@
import org.hibernate.type.JavaObjectType;
import org.hibernate.type.PostgresUUIDType;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ObjectNullAsBinaryTypeJdbcTypeDescriptor;
@ -356,9 +356,9 @@ public JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
// with @Lob will attempt to use
// BlobTypeDescriptor.PRIMITIVE_ARRAY_BINDING. Since the
// dialect uses oid for Blobs, byte arrays cannot be used.
return BlobTypeDescriptor.BLOB_BINDING;
return BlobJdbcTypeDescriptor.BLOB_BINDING;
case Types.CLOB:
return ClobTypeDescriptor.CLOB_BINDING;
return ClobJdbcTypeDescriptor.CLOB_BINDING;
default:
return super.getSqlTypeDescriptorOverride( sqlCode );
}
@ -740,7 +740,7 @@ public String translateExtractField(TemporalUnit unit) {
@Override
public void appendBinaryLiteral(SqlAppender appender, byte[] bytes) {
appender.appendSql( "bytea '\\x" );
PrimitiveByteArrayTypeDescriptor.INSTANCE.appendString( appender, bytes );
PrimitiveByteArrayJavaTypeDescriptor.INSTANCE.appendString( appender, bytes );
appender.appendSql( '\'' );
}

8
hibernate-core/src/main/java/org/hibernate/dialect/SQLServerDialect.java
View File

@ -45,9 +45,9 @@
import org.hibernate.tool.schema.internal.StandardSequenceExporter;
import org.hibernate.tool.schema.spi.Exporter;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.SmallIntTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.SmallIntJdbcTypeDescriptor;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
@ -159,7 +159,7 @@ public long getDefaultLobLength() {
@Override
protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
return sqlCode == Types.TINYINT
? SmallIntTypeDescriptor.INSTANCE
? SmallIntJdbcTypeDescriptor.INSTANCE
: super.getSqlTypeDescriptorOverride( sqlCode );
}
@ -697,7 +697,7 @@ public static Replacer datetimeFormat(String format) {
@Override
public void appendBinaryLiteral(SqlAppender appender, byte[] bytes) {
appender.appendSql( "0x" );
PrimitiveByteArrayTypeDescriptor.INSTANCE.appendString( appender, bytes );
PrimitiveByteArrayJavaTypeDescriptor.INSTANCE.appendString( appender, bytes );
}
@Override

8
hibernate-core/src/main/java/org/hibernate/dialect/SybaseASEDialect.java
View File

@ -35,8 +35,8 @@
import org.hibernate.sql.exec.spi.JdbcOperation;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntJdbcTypeDescriptor;
import static org.hibernate.exception.spi.TemplatedViolatedConstraintNameExtractor.extractUsingTemplate;
@ -185,11 +185,11 @@ public boolean supportsBitType() {
protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
switch ( sqlCode ) {
case Types.BOOLEAN:
return TinyIntTypeDescriptor.INSTANCE;
return TinyIntJdbcTypeDescriptor.INSTANCE;
case Types.TIMESTAMP_WITH_TIMEZONE:
// At least the jTDS driver does not support this type code
if ( jtdsDriver ) {
return TimestampTypeDescriptor.INSTANCE;
return TimestampJdbcTypeDescriptor.INSTANCE;
}
default:
return super.getSqlTypeDescriptorOverride( sqlCode );

28
hibernate-core/src/main/java/org/hibernate/dialect/SybaseDialect.java
View File

@ -39,13 +39,13 @@
import org.hibernate.sql.ast.tree.select.SelectStatement;
import org.hibernate.sql.exec.spi.JdbcOperation;
import org.hibernate.type.JavaObjectType;
import org.hibernate.type.descriptor.jdbc.BlobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ObjectNullAsNullTypeJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.SmallIntTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.SmallIntJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeDescriptorRegistry;
import java.sql.DatabaseMetaData;
@ -115,8 +115,8 @@ public JdbcTypeDescriptor resolveSqlTypeDescriptor(
@Override
public JdbcTypeDescriptor remapSqlTypeDescriptor(JdbcTypeDescriptor jdbcTypeDescriptor) {
if ( jtdsDriver && TinyIntTypeDescriptor.INSTANCE == jdbcTypeDescriptor ) {
return SmallIntTypeDescriptor.INSTANCE;
if ( jtdsDriver && TinyIntJdbcTypeDescriptor.INSTANCE == jdbcTypeDescriptor ) {
return SmallIntJdbcTypeDescriptor.INSTANCE;
}
return super.remapSqlTypeDescriptor( jdbcTypeDescriptor );
}
@ -177,13 +177,13 @@ public void contributeTypes(TypeContributions typeContributions, ServiceRegistry
if ( jtdsDriver ) {
typeContributions.getTypeConfiguration().getJdbcTypeDescriptorRegistry().addDescriptor(
Types.NCLOB,
ClobTypeDescriptor.CLOB_BINDING
ClobJdbcTypeDescriptor.CLOB_BINDING
);
typeContributions.getTypeConfiguration().getJdbcTypeDescriptorRegistry().addDescriptor(
Types.NVARCHAR,
ClobTypeDescriptor.CLOB_BINDING
ClobJdbcTypeDescriptor.CLOB_BINDING
);
typeContributions.contributeJdbcTypeDescriptor( ClobTypeDescriptor.CLOB_BINDING );
typeContributions.contributeJdbcTypeDescriptor( ClobJdbcTypeDescriptor.CLOB_BINDING );
}
// Sybase requires a custom binder for binding untyped nulls with the NULL type
@ -210,20 +210,20 @@ public NationalizationSupport getNationalizationSupport() {
protected JdbcTypeDescriptor getSqlTypeDescriptorOverride(int sqlCode) {
switch (sqlCode) {
case Types.BLOB:
return BlobTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
return BlobJdbcTypeDescriptor.PRIMITIVE_ARRAY_BINDING;
case Types.CLOB:
// Some Sybase drivers cannot support getClob. See HHH-7889
// The jTDS driver doesn't support the JDBC4 signatures using 'long length' for stream bindings
return jtdsDriver ? ClobTypeDescriptor.CLOB_BINDING : ClobTypeDescriptor.STREAM_BINDING_EXTRACTING;
return jtdsDriver ? ClobJdbcTypeDescriptor.CLOB_BINDING : ClobJdbcTypeDescriptor.STREAM_BINDING_EXTRACTING;
case Types.NCLOB:
// The jTDS driver doesn't support the JDBC4 signatures using 'long length' for stream bindings
if ( jtdsDriver ) {
return NClobTypeDescriptor.NCLOB_BINDING;
return NClobJdbcTypeDescriptor.NCLOB_BINDING;
}
case Types.NVARCHAR:
// The jTDS driver doesn't support the JDBC4 setNString method
if ( jtdsDriver ) {
return NClobTypeDescriptor.NCLOB_BINDING;
return NClobJdbcTypeDescriptor.NCLOB_BINDING;
}
default:
return super.getSqlTypeDescriptorOverride( sqlCode );

13
hibernate-core/src/main/java/org/hibernate/engine/internal/UnsavedValueFactory.java
View File

@ -6,7 +6,6 @@
*/
package org.hibernate.engine.internal;
import java.io.Serializable;
import java.lang.reflect.Constructor;
import org.hibernate.InstantiationException;
@ -14,10 +13,11 @@
import org.hibernate.engine.spi.IdentifierValue;
import org.hibernate.engine.spi.VersionValue;
import org.hibernate.property.access.spi.Getter;
import org.hibernate.type.IdentifierType;
import org.hibernate.type.PrimitiveType;
import org.hibernate.type.BasicType;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.VersionJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.spi.PrimitiveJavaTypeDescriptor;
/**
* Helper for dealing with unsaved value handling
@ -68,8 +68,9 @@ public static IdentifierValue getUnsavedIdentifierValue(
final Object defaultValue = identifierGetter.get( instantiate( constructor ) );
return new IdentifierValue( defaultValue );
}
else if ( identifierGetter != null && (identifierType instanceof PrimitiveType) ) {
final Object defaultValue = ( (PrimitiveType) identifierType ).getDefaultValue();
final JavaTypeDescriptor<?> jtd;
if ( identifierGetter != null && ( identifierType instanceof BasicType<?> ) && ( jtd = ( (BasicType<?>) identifierType ).getJavaTypeDescriptor() ) instanceof PrimitiveJavaTypeDescriptor ) {
final Object defaultValue = ( (PrimitiveJavaTypeDescriptor<?>) jtd ).getDefaultValue();
return new IdentifierValue( defaultValue );
}
else {
@ -90,7 +91,7 @@ else if ( "any".equals( unsavedValue ) ) {
}
else {
try {
return new IdentifierValue( ( (IdentifierType) identifierType ).stringToObject( unsavedValue ) );
return new IdentifierValue( ( (BasicType<?>) identifierType ).getJavaTypeDescriptor().fromString( unsavedValue ) );
}
catch ( ClassCastException cce ) {
throw new MappingException( "Bad identifier type: " + identifierType.getName() );

12
hibernate-core/src/main/java/org/hibernate/id/UUIDGenerator.java
View File

@ -19,7 +19,7 @@
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.UUIDTypeDescriptor;
import org.hibernate.type.descriptor.java.UUIDJavaTypeDescriptor;
/**
* An {@link IdentifierGenerator} which generates {@link UUID} values using a pluggable
@ -45,12 +45,12 @@ public class UUIDGenerator implements IdentifierGenerator, Configurable {
private static final CoreMessageLogger LOG = CoreLogging.messageLogger( UUIDGenerator.class );
private UUIDGenerationStrategy strategy;
private UUIDTypeDescriptor.ValueTransformer valueTransformer;
private UUIDJavaTypeDescriptor.ValueTransformer valueTransformer;
public static UUIDGenerator buildSessionFactoryUniqueIdentifierGenerator() {
final UUIDGenerator generator = new UUIDGenerator();
generator.strategy = StandardRandomStrategy.INSTANCE;
generator.valueTransformer = UUIDTypeDescriptor.ToStringTransformer.INSTANCE;
generator.valueTransformer = UUIDJavaTypeDescriptor.ToStringTransformer.INSTANCE;
return generator;
}
@ -83,13 +83,13 @@ public void configure(Type type, Properties params, ServiceRegistry serviceRegis
}
if ( UUID.class.isAssignableFrom( type.getReturnedClass() ) ) {
valueTransformer = UUIDTypeDescriptor.PassThroughTransformer.INSTANCE;
valueTransformer = UUIDJavaTypeDescriptor.PassThroughTransformer.INSTANCE;
}
else if ( String.class.isAssignableFrom( type.getReturnedClass() ) ) {
valueTransformer = UUIDTypeDescriptor.ToStringTransformer.INSTANCE;
valueTransformer = UUIDJavaTypeDescriptor.ToStringTransformer.INSTANCE;
}
else if ( byte[].class.isAssignableFrom( type.getReturnedClass() ) ) {
valueTransformer = UUIDTypeDescriptor.ToBytesTransformer.INSTANCE;
valueTransformer = UUIDJavaTypeDescriptor.ToBytesTransformer.INSTANCE;
}
else {
throw new HibernateException( "Unanticipated return type [" + type.getReturnedClass().getName() + "] for UUID conversion" );

7
hibernate-core/src/main/java/org/hibernate/internal/util/ReflectHelper.java
View File

@ -27,8 +27,9 @@
import org.hibernate.internal.util.collections.ArrayHelper;
import org.hibernate.property.access.internal.PropertyAccessStrategyMixedImpl;
import org.hibernate.property.access.spi.Getter;
import org.hibernate.type.PrimitiveType;
import org.hibernate.type.BasicType;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.spi.PrimitiveJavaTypeDescriptor;
/**
* Utility class for various reflection operations.
@ -339,8 +340,8 @@ public static Constructor getConstructor(Class clazz, Type[] types) throws Prope
boolean found = true;
for ( int j = 0; j < params.length; j++ ) {
final boolean ok = types[j] == null || params[j].isAssignableFrom( types[j].getReturnedClass() ) || (
types[j] instanceof PrimitiveType &&
params[j] == ( (PrimitiveType) types[j] ).getPrimitiveClass()
types[j] instanceof BasicType<?> && ( (BasicType<?>) types[j] ).getJavaTypeDescriptor() instanceof PrimitiveJavaTypeDescriptor
&& params[j] == ( (PrimitiveJavaTypeDescriptor<?>) ( ( (BasicType<?>) types[j] ).getJavaTypeDescriptor() ) ).getPrimitiveClass()
);
if ( !ok ) {
found = false;

13
hibernate-core/src/main/java/org/hibernate/mapping/Array.java
View File

@ -13,8 +13,10 @@
import org.hibernate.collection.internal.StandardArraySemantics;
import org.hibernate.collection.spi.CollectionSemantics;
import org.hibernate.type.ArrayType;
import org.hibernate.type.BasicType;
import org.hibernate.type.CollectionType;
import org.hibernate.type.PrimitiveType;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.spi.PrimitiveJavaTypeDescriptor;
/**
* An array mapping has a primary key consisting of the key columns + index column.
@ -30,10 +32,11 @@ public Array(MetadataBuildingContext buildingContext, PersistentClass owner) {
public Class getElementClass() throws MappingException {
if ( elementClassName == null ) {
org.hibernate.type.Type elementType = getElement().getType();
return isPrimitiveArray()
? ( (PrimitiveType) elementType ).getPrimitiveClass()
: elementType.getReturnedClass();
final org.hibernate.type.Type elementType = getElement().getType();
if ( isPrimitiveArray() ) {
return ( (PrimitiveJavaTypeDescriptor<?>) ( (BasicType<?>) elementType ).getJavaTypeDescriptor() ).getPrimitiveClass();
}
return elementType.getReturnedClass();
}
else {
try {

12
hibernate-core/src/main/java/org/hibernate/mapping/BasicValue.java
View File

@ -39,7 +39,7 @@
import org.hibernate.type.BasicType;
import org.hibernate.type.ConvertedBasicType;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.MutabilityPlan;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
@ -67,7 +67,7 @@ public class BasicValue extends SimpleValue implements JdbcTypeDescriptorIndicat
private String explicitTypeName;
private Map explicitLocalTypeParams;
private Function<TypeConfiguration, BasicJavaDescriptor> explicitJavaTypeAccess;
private Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJavaTypeAccess;
private Function<TypeConfiguration, JdbcTypeDescriptor> explicitSqlTypeAccess;
private Function<TypeConfiguration, MutabilityPlan> explicitMutabilityPlanAccess;
private Function<TypeConfiguration, java.lang.reflect.Type> implicitJavaTypeAccess;
@ -131,7 +131,7 @@ public void setJpaAttributeConverterDescriptor(ConverterDescriptor descriptor) {
}
@SuppressWarnings({"rawtypes"})
public void setExplicitJavaTypeAccess(Function<TypeConfiguration, BasicJavaDescriptor> explicitJavaTypeAccess) {
public void setExplicitJavaTypeAccess(Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJavaTypeAccess) {
this.explicitJavaTypeAccess = explicitJavaTypeAccess;
}
@ -348,7 +348,7 @@ public TypeConfiguration getTypeConfiguration() {
// determine JTD if we can
if ( explicitJavaTypeAccess != null ) {
final BasicJavaDescriptor explicitJtd = explicitJavaTypeAccess.apply( typeConfiguration );
final BasicJavaTypeDescriptor explicitJtd = explicitJavaTypeAccess.apply( typeConfiguration );
if ( explicitJtd != null ) {
jtd = explicitJtd;
}
@ -371,7 +371,7 @@ public TypeConfiguration getTypeConfiguration() {
}
final TypeDefinitionRegistry typeDefinitionRegistry = getBuildingContext().getTypeDefinitionRegistry();
final TypeDefinition autoAppliedTypeDef = typeDefinitionRegistry.resolveAutoApplied( (BasicJavaDescriptor<?>) jtd );
final TypeDefinition autoAppliedTypeDef = typeDefinitionRegistry.resolveAutoApplied( (BasicJavaTypeDescriptor<?>) jtd );
if ( autoAppliedTypeDef != null && ( !jtd.getJavaTypeClass().isEnum() || enumerationStyle == null ) ) {
log.debug( "BasicValue resolution matched auto-applied type-definition" );
return autoAppliedTypeDef.resolve(
@ -430,7 +430,7 @@ private static Resolution interpretExplicitlyNamedType(
String name,
EnumType enumerationStyle,
Function<TypeConfiguration, java.lang.reflect.Type> implicitJavaTypeAccess,
Function<TypeConfiguration, BasicJavaDescriptor> explicitJtdAccess,
Function<TypeConfiguration, BasicJavaTypeDescriptor> explicitJtdAccess,
Function<TypeConfiguration, JdbcTypeDescriptor> explicitStdAccess,
Function<TypeConfiguration, MutabilityPlan> explicitMutabilityPlanAccess,
ConverterDescriptor converterDescriptor,

4
hibernate-core/src/main/java/org/hibernate/mapping/SimpleValue.java
View File

@ -51,7 +51,7 @@
import org.hibernate.type.descriptor.JdbcTypeNameMapper;
import org.hibernate.type.descriptor.converter.AttributeConverterJdbcTypeDescriptorAdapter;
import org.hibernate.type.descriptor.converter.AttributeConverterTypeAdapter;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.LobTypeMappings;
import org.hibernate.type.descriptor.jdbc.NationalizedTypeMappings;
@ -657,7 +657,7 @@ public TypeConfiguration getTypeConfiguration() {
}
);
final BasicJavaDescriptor<?> domainJtd = (BasicJavaDescriptor<?>) jpaAttributeConverter.getDomainJavaTypeDescriptor();
final BasicJavaTypeDescriptor<?> domainJtd = (BasicJavaTypeDescriptor<?>) jpaAttributeConverter.getDomainJavaTypeDescriptor();
// build the SqlTypeDescriptor adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

24
hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/AllowableTemporalParameterType.java
View File

@ -1,24 +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.metamodel.model.domain;
import jakarta.persistence.TemporalType;
import org.hibernate.type.spi.TypeConfiguration;
/**
* Specialization of DomainType for types that can be used as temporal bind values
* for a query parameter
*
* @author Steve Ebersole
*/
public interface AllowableTemporalParameterType<T> extends AllowableParameterType<T> {
/**
* Convert the value and/or type to the specified temporal precision
*/
AllowableTemporalParameterType resolveTemporalPrecision(TemporalType temporalPrecision, TypeConfiguration typeConfiguration);
}

6
hibernate-core/src/main/java/org/hibernate/metamodel/model/domain/internal/ArrayTupleType.java
View File

@ -15,7 +15,7 @@
import org.hibernate.metamodel.model.domain.TupleType;
import org.hibernate.query.sqm.SqmExpressable;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.ObjectArrayTypeDescriptor;
import org.hibernate.type.descriptor.java.ObjectArrayJavaTypeDescriptor;
/**
* @author Christian Beikov
@ -23,12 +23,12 @@
public class ArrayTupleType implements TupleType<Object[]>, AllowableParameterType<Object[]>, AllowableFunctionReturnType<Object[]>,
MappingModelExpressable {
private final ObjectArrayTypeDescriptor javaTypeDescriptor;
private final ObjectArrayJavaTypeDescriptor javaTypeDescriptor;
private final SqmExpressable<?>[] components;
public ArrayTupleType(SqmExpressable<?>[] components) {
this.components = components;
this.javaTypeDescriptor = new ObjectArrayTypeDescriptor( getTypeDescriptors( components ) );
this.javaTypeDescriptor = new ObjectArrayJavaTypeDescriptor( getTypeDescriptors( components ) );
}
private static JavaTypeDescriptor<?>[] getTypeDescriptors(SqmExpressable<?>[] components) {

15
hibernate-core/src/main/java/org/hibernate/persister/entity/DiscriminatorType.java
View File

@ -27,9 +27,9 @@
import org.hibernate.type.descriptor.ValueBinder;
import org.hibernate.type.descriptor.ValueExtractor;
import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.descriptor.java.ClassTypeDescriptor;
import org.hibernate.type.descriptor.java.ClassJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.StringTypeDescriptor;
import org.hibernate.type.descriptor.java.StringJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
/**
@ -37,7 +37,7 @@
*
* @author Steve Ebersole
*/
public class DiscriminatorType<T> extends AbstractType implements org.hibernate.type.DiscriminatorType<T>, BasicType<T>, ValueExtractor<T>, ValueBinder<T> {
public class DiscriminatorType<T> extends AbstractType implements BasicType<T>, ValueExtractor<T>, ValueBinder<T> {
private final BasicType<Object> underlyingType;
private final Loadable persister;
@ -225,11 +225,6 @@ public int getColumnSpan(Mapping mapping) throws MappingException {
return underlyingType.getColumnSpan( mapping );
}
@Override
public T stringToObject(CharSequence sequence) throws Exception {
return ( (org.hibernate.type.DiscriminatorType<T>) underlyingType ).stringToObject( sequence );
}
@Override
public boolean canDoExtraction() {
return underlyingType.canDoExtraction();
@ -238,8 +233,8 @@ public boolean canDoExtraction() {
@Override
public JavaTypeDescriptor<T> getExpressableJavaTypeDescriptor() {
return (JavaTypeDescriptor<T>) ( EntityMode.POJO == persister.getEntityMode() ?
ClassTypeDescriptor.INSTANCE :
StringTypeDescriptor.INSTANCE );
ClassJavaTypeDescriptor.INSTANCE :
StringJavaTypeDescriptor.INSTANCE );
}
@Override

11
hibernate-core/src/main/java/org/hibernate/persister/entity/JoinedSubclassEntityPersister.java
View File

@ -66,7 +66,6 @@
import org.hibernate.sql.results.graph.entity.internal.EntityResultJoinedSubclassImpl;
import org.hibernate.type.BasicType;
import org.hibernate.type.CompositeType;
import org.hibernate.type.DiscriminatorType;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
@ -139,7 +138,7 @@ public class JoinedSubclassEntityPersister extends AbstractEntityPersister {
private final Object discriminatorValue;
private final String discriminatorSQLString;
private final DiscriminatorType<?> discriminatorType;
private final BasicType<?> discriminatorType;
private final String explicitDiscriminatorColumnName;
private final String discriminatorAlias;
@ -183,7 +182,7 @@ public JoinedSubclassEntityPersister(
explicitDiscriminatorColumnName = column.getQuotedName( factory.getDialect() );
discriminatorAlias = column.getAlias( factory.getDialect(), persistentClass.getRootTable() );
}
discriminatorType = (DiscriminatorType<?>) persistentClass.getDiscriminator().getType();
discriminatorType = (BasicType<?>) persistentClass.getDiscriminator().getType();
if ( persistentClass.isDiscriminatorValueNull() ) {
discriminatorValue = NULL_DISCRIMINATOR;
discriminatorSQLString = InFragment.NULL;
@ -194,7 +193,7 @@ else if ( persistentClass.isDiscriminatorValueNotNull() ) {
}
else {
try {
discriminatorValue = discriminatorType.stringToObject( persistentClass.getDiscriminatorValue() );
discriminatorValue = discriminatorType.getJavaTypeDescriptor().fromString( persistentClass.getDiscriminatorValue() );
discriminatorSQLString = discriminatorType.getJdbcTypeDescriptor().getJdbcLiteralFormatter( (JavaTypeDescriptor) discriminatorType.getJavaTypeDescriptor() )
.toJdbcLiteral(
discriminatorValue,
@ -535,7 +534,7 @@ else if ( persistentClass.isDiscriminatorValueNotNull() ) {
// the type indicated by `#discriminatorType` (String -> Integer, e.g.).
try {
Table table = persistentClass.getTable();
final Object convertedDiscriminatorValue = discriminatorType.stringToObject( discriminatorSQLString );
final Object convertedDiscriminatorValue = discriminatorType.getJavaTypeDescriptor().fromString( discriminatorSQLString );
discriminatorValues = new String[subclassSpan];
initDiscriminatorProperties( factory, jdbcEnvironment, subclassSpanMinusOne, table, convertedDiscriminatorValue
);
@ -592,7 +591,7 @@ else if ( sc.isDiscriminatorValueNotNull() ) {
}
else {
try {
discriminatorValue = discriminatorType.stringToObject( sc.getDiscriminatorValue() );
discriminatorValue = discriminatorType.getJavaTypeDescriptor().fromString( sc.getDiscriminatorValue() );
}
catch (ClassCastException cce) {
throw new MappingException( "Illegal discriminator type: " + discriminatorType.getName() );

9
hibernate-core/src/main/java/org/hibernate/persister/entity/SingleTableEntityPersister.java
View File

@ -61,7 +61,6 @@
import org.hibernate.sql.ast.tree.predicate.Predicate;
import org.hibernate.type.AssociationType;
import org.hibernate.type.BasicType;
import org.hibernate.type.DiscriminatorType;
import org.hibernate.type.Type;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
@ -116,7 +115,7 @@ public class SingleTableEntityPersister extends AbstractEntityPersister {
private final String discriminatorFormula;
private final String discriminatorFormulaTemplate;
private final String discriminatorAlias;
private final DiscriminatorType<?> discriminatorType;
private final BasicType<?> discriminatorType;
private final Object discriminatorValue;
private final String discriminatorSQLValue;
private final boolean discriminatorInsertable;
@ -326,7 +325,7 @@ public SingleTableEntityPersister(
discriminatorFormula = null;
discriminatorFormulaTemplate = null;
}
discriminatorType = (DiscriminatorType<?>) persistentClass.getDiscriminator().getType();
discriminatorType = (BasicType<?>) persistentClass.getDiscriminator().getType();
if ( persistentClass.isDiscriminatorValueNull() ) {
discriminatorValue = NULL_DISCRIMINATOR;
discriminatorSQLValue = InFragment.NULL;
@ -340,7 +339,7 @@ else if ( persistentClass.isDiscriminatorValueNotNull() ) {
else {
discriminatorInsertable = persistentClass.isDiscriminatorInsertable() && !discrimValue.hasFormula();
try {
discriminatorValue = discriminatorType.stringToObject( persistentClass.getDiscriminatorValue() );
discriminatorValue = discriminatorType.getJavaTypeDescriptor().fromString( persistentClass.getDiscriminatorValue() );
discriminatorSQLValue = discriminatorType.getJdbcTypeDescriptor().getJdbcLiteralFormatter( (JavaTypeDescriptor) discriminatorType.getJavaTypeDescriptor() )
.toJdbcLiteral(
discriminatorValue,
@ -444,7 +443,7 @@ else if ( sc.isDiscriminatorValueNotNull() ) {
try {
addSubclassByDiscriminatorValue(
subclassesByDiscriminatorValueLocal,
discriminatorType.stringToObject( sc.getDiscriminatorValue() ),
discriminatorType.getJavaTypeDescriptor().fromString( sc.getDiscriminatorValue() ),
sc.getEntityName()
);
}

4
hibernate-core/src/main/java/org/hibernate/procedure/internal/FunctionReturnImpl.java
View File

@ -21,7 +21,7 @@
import org.hibernate.sql.exec.internal.JdbcCallParameterExtractorImpl;
import org.hibernate.sql.exec.internal.JdbcCallRefCursorExtractorImpl;
import org.hibernate.sql.exec.spi.JdbcCallFunctionReturn;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
@ -62,7 +62,7 @@ public JdbcCallFunctionReturn toJdbcFunctionReturn(SharedSessionContractImplemen
final TypeConfiguration typeConfiguration = persistenceContext.getFactory().getMetamodel().getTypeConfiguration();
final JdbcTypeDescriptor sqlTypeDescriptor = typeConfiguration.getJdbcTypeDescriptorRegistry()
.getDescriptor( getJdbcTypeCode() );
final BasicJavaDescriptor javaTypeMapping = sqlTypeDescriptor
final BasicJavaTypeDescriptor javaTypeMapping = sqlTypeDescriptor
.getJdbcRecommendedJavaTypeMapping( null, null, typeConfiguration );
ormType = typeConfiguration.standardBasicTypeForJavaType( javaTypeMapping.getJavaType().getClass() );
parameterExtractor = new JdbcCallParameterExtractorImpl( procedureCall.getProcedureName(), null, 0, ormType );

22
hibernate-core/src/main/java/org/hibernate/procedure/internal/ProcedureParameterImpl.java
View File

@ -15,12 +15,12 @@
import org.hibernate.engine.jdbc.env.spi.ExtractedDatabaseMetaData;
import org.hibernate.engine.jdbc.env.spi.JdbcEnvironment;
import org.hibernate.metamodel.model.domain.AllowableParameterType;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.procedure.spi.NamedCallableQueryMemento;
import org.hibernate.procedure.spi.ParameterStrategy;
import org.hibernate.procedure.spi.ProcedureCallImplementor;
import org.hibernate.procedure.spi.ProcedureParameterImplementor;
import org.hibernate.query.AbstractQueryParameter;
import org.hibernate.query.internal.BindingTypeHelper;
import org.hibernate.query.spi.QueryParameterBinding;
import org.hibernate.type.BasicType;
import org.hibernate.type.ProcedureParameterNamedBinder;
@ -136,20 +136,14 @@ public void prepare(
int startIndex,
ProcedureCallImplementor<?> procedureCall) throws SQLException {
final QueryParameterBinding<?> binding = procedureCall.getParameterBindings().getBinding( this );
final AllowableParameterType typeToUse;
// for Calendar binding with an explicit TemporalType we may need to adjust this...
final TypeConfiguration typeConfiguration = procedureCall.getSession().getFactory().getTypeConfiguration();
if ( binding != null && binding.getExplicitTemporalPrecision() != null ) {
typeToUse = ( (AllowableTemporalParameterType) getHibernateType() ).resolveTemporalPrecision(
binding.getExplicitTemporalPrecision(),
typeConfiguration
);
}
else {
//set up the Type we will use for binding as the explicit type.
typeToUse = getHibernateType();
}
final AllowableParameterType<T> typeToUse = BindingTypeHelper.INSTANCE.resolveTemporalPrecision(
binding == null || binding.getExplicitTemporalPrecision() == null
? null
: binding.getExplicitTemporalPrecision(),
getHibernateType(),
typeConfiguration
);
if ( mode == ParameterMode.INOUT || mode == ParameterMode.OUT ) {

22
hibernate-core/src/main/java/org/hibernate/query/internal/BindingTypeHelper.java
View File

@ -15,7 +15,6 @@
import org.hibernate.metamodel.mapping.JdbcMapping;
import org.hibernate.metamodel.model.domain.AllowableParameterType;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.CalendarDateType;
import org.hibernate.type.CalendarTimeType;
import org.hibernate.type.CalendarType;
@ -39,16 +38,25 @@ public class BindingTypeHelper {
private BindingTypeHelper() {
}
@SuppressWarnings("unchecked")
public <T> AllowableParameterType<T> resolveTemporalPrecision(
TemporalType precision,
AllowableParameterType baseType,
AllowableParameterType<T> declaredParameterType,
TypeConfiguration typeConfiguration) {
if ( ! ( baseType instanceof AllowableTemporalParameterType ) ) {
throw new UnsupportedOperationException( "Cannot treat non-temporal parameter type with temporal precision" );
if ( precision != null ) {
if ( !( declaredParameterType.getExpressableJavaTypeDescriptor() instanceof TemporalJavaTypeDescriptor ) ) {
throw new UnsupportedOperationException(
"Cannot treat non-temporal parameter type with temporal precision"
);
}
final TemporalJavaTypeDescriptor<T> temporalJtd = (TemporalJavaTypeDescriptor<T>) declaredParameterType.getExpressableJavaTypeDescriptor();
if ( temporalJtd.getPrecision() != precision ) {
return typeConfiguration.getBasicTypeRegistry().resolve(
temporalJtd.resolveTypeForPrecision( precision, typeConfiguration ),
TemporalJavaTypeDescriptor.resolveJdbcTypeCode( precision )
);
}
}
return ( (AllowableTemporalParameterType) baseType ).resolveTemporalPrecision( precision, typeConfiguration );
return declaredParameterType;
}
public AllowableParameterType determineTypeForTemporalType(TemporalType temporalType, AllowableParameterType baseType, Object bindValue) {

6
hibernate-core/src/main/java/org/hibernate/query/sqm/tree/domain/SqmBasicValuedSimplePath.java
View File

@ -16,7 +16,7 @@
import org.hibernate.query.sqm.NodeBuilder;
import org.hibernate.query.sqm.SemanticQueryWalker;
import org.hibernate.query.sqm.SqmPathSource;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
/**
@ -68,8 +68,8 @@ public SqmPathSource<T> getNodeType() {
}
@Override
public BasicJavaDescriptor<T> getJavaTypeDescriptor() {
return (BasicJavaDescriptor<T>) super.getJavaTypeDescriptor();
public BasicJavaTypeDescriptor<T> getJavaTypeDescriptor() {
return (BasicJavaTypeDescriptor<T>) super.getJavaTypeDescriptor();
}
@Override

12
hibernate-core/src/main/java/org/hibernate/query/sqm/tree/expression/LiteralHelper.java
View File

@ -16,9 +16,9 @@
import org.hibernate.query.spi.QueryEngine;
import org.hibernate.query.hql.spi.SqmCreationState;
import org.hibernate.type.StandardBasicTypes;
import org.hibernate.type.descriptor.java.JdbcDateTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcTimeTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcTimestampTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcDateJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcTimeJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcTimestampJavaTypeDescriptor;
/**
* @author Steve Ebersole
@ -26,7 +26,7 @@
public class LiteralHelper {
public static SqmLiteral<Timestamp> timestampLiteralFrom(String literalText, SqmCreationState creationState) {
final Timestamp literal = Timestamp.valueOf(
LocalDateTime.from( JdbcTimestampTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) )
LocalDateTime.from( JdbcTimestampJavaTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) )
);
return new SqmLiteral<>(
@ -53,7 +53,7 @@ public static SqmLiteral<Integer> integerLiteral(int value, QueryEngine queryEng
}
public static SqmLiteral<Date> dateLiteralFrom(String literalText, SqmCreationState creationState) {
final LocalDate localDate = LocalDate.from( JdbcDateTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) );
final LocalDate localDate = LocalDate.from( JdbcDateJavaTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) );
final Date literal = new Date( localDate.toEpochDay() );
return new SqmLiteral<>(
@ -64,7 +64,7 @@ public static SqmLiteral<Date> dateLiteralFrom(String literalText, SqmCreationSt
}
public static SqmLiteral<Time> timeLiteralFrom(String literalText, SqmCreationState creationState) {
final LocalTime localTime = LocalTime.from( JdbcTimeTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) );
final LocalTime localTime = LocalTime.from( JdbcTimeJavaTypeDescriptor.LITERAL_FORMATTER.parse( literalText ) );
final Time literal = Time.valueOf( localTime );
return new SqmLiteral<>(

5
hibernate-core/src/main/java/org/hibernate/query/sqm/tree/predicate/SqmPredicate.java
View File

@ -9,8 +9,7 @@
import org.hibernate.query.criteria.JpaPredicate;
import org.hibernate.query.sqm.tree.SqmVisitableNode;
import org.hibernate.query.sqm.tree.expression.SqmExpression;
import org.hibernate.query.sqm.sql.internal.DomainResultProducer;
import org.hibernate.type.descriptor.java.BooleanTypeDescriptor;
import org.hibernate.type.descriptor.java.BooleanJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
/**
@ -20,7 +19,7 @@ public interface SqmPredicate
extends SqmVisitableNode, JpaPredicate, SqmExpression<Boolean> {
@Override
default JavaTypeDescriptor<Boolean> getJavaTypeDescriptor(){
return BooleanTypeDescriptor.INSTANCE;
return BooleanJavaTypeDescriptor.INSTANCE;
}
@Override

4
hibernate-core/src/main/java/org/hibernate/type/AbstractStandardBasicType.java
View File

@ -95,8 +95,8 @@ public String toString(T value) {
}
@Override
public T fromStringValue(CharSequence xml) throws HibernateException {
return fromString( xml );
public T fromStringValue(CharSequence charSequence) throws HibernateException {
return javaTypeDescriptor.fromString( charSequence );
}
protected MutabilityPlan<T> getMutabilityPlan() {

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

@ -63,6 +63,21 @@ public <J> BasicType<J> getRegisteredType(Class<J> javaType) {
return getRegisteredType( javaType.getName() );
}
public <J> BasicType<J> resolve(Class<J> javaType, int sqlTypeCode) {
return resolve( (java.lang.reflect.Type) javaType, sqlTypeCode );
}
public <J> BasicType<J> resolve(java.lang.reflect.Type javaType, int sqlTypeCode) {
return resolve( typeConfiguration.getJavaTypeDescriptorRegistry().getDescriptor( javaType ), sqlTypeCode );
}
public <J> BasicType<J> resolve(JavaTypeDescriptor<J> jtdToUse, int sqlTypeCode) {
return resolve(
jtdToUse,
typeConfiguration.getJdbcTypeDescriptorRegistry().getDescriptor( sqlTypeCode )
);
}
/**
* Find an existing BasicType registration for the given JavaTypeDescriptor and
* SqlTypeDescriptor combo or create (and register) one.

6
hibernate-core/src/main/java/org/hibernate/type/BigDecimalType.java
View File

@ -8,8 +8,8 @@
import java.math.BigDecimal;
import org.hibernate.type.descriptor.java.BigDecimalTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NumericTypeDescriptor;
import org.hibernate.type.descriptor.java.BigDecimalJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NumericJdbcTypeDescriptor;
/**
* A type that maps between a {@link java.sql.Types#NUMERIC NUMERIC} and {@link BigDecimal}.
@ -21,7 +21,7 @@ public class BigDecimalType extends AbstractSingleColumnStandardBasicType<BigDec
public static final BigDecimalType INSTANCE = new BigDecimalType();
public BigDecimalType() {
super( NumericTypeDescriptor.INSTANCE, BigDecimalTypeDescriptor.INSTANCE );
super( NumericJdbcTypeDescriptor.INSTANCE, BigDecimalJavaTypeDescriptor.INSTANCE );
}
@Override

13
hibernate-core/src/main/java/org/hibernate/type/BigIntegerType.java
View File

@ -8,8 +8,8 @@
import java.math.BigInteger;
import org.hibernate.type.descriptor.java.BigIntegerTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NumericTypeDescriptor;
import org.hibernate.type.descriptor.java.BigIntegerJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NumericJdbcTypeDescriptor;
/**
* A type that maps between a {@link java.sql.Types#NUMERIC NUMERIC} and {@link BigInteger}.
@ -18,13 +18,12 @@
* @author Steve Ebersole
*/
public class BigIntegerType
extends AbstractSingleColumnStandardBasicType<BigInteger>
implements DiscriminatorType<BigInteger> {
extends AbstractSingleColumnStandardBasicType<BigInteger> {
public static final BigIntegerType INSTANCE = new BigIntegerType();
public BigIntegerType() {
super( NumericTypeDescriptor.INSTANCE, BigIntegerTypeDescriptor.INSTANCE );
super( NumericJdbcTypeDescriptor.INSTANCE, BigIntegerJavaTypeDescriptor.INSTANCE );
}
@Override
@ -37,8 +36,4 @@ protected boolean registerUnderJavaType() {
return true;
}
@Override
public BigInteger stringToObject(CharSequence string) {
return BigIntegerTypeDescriptor.INSTANCE.fromString( string );
}
}

6
hibernate-core/src/main/java/org/hibernate/type/BinaryType.java
View File

@ -8,8 +8,8 @@
import java.sql.Types;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarbinaryTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarbinaryJdbcTypeDescriptor;
/**
* A type that maps between a {@link Types#VARBINARY VARBINARY} and {@code byte[]}
@ -28,7 +28,7 @@ public String getName() {
}
public BinaryType() {
super( VarbinaryTypeDescriptor.INSTANCE, PrimitiveByteArrayTypeDescriptor.INSTANCE );
super( VarbinaryJdbcTypeDescriptor.INSTANCE, PrimitiveByteArrayJavaTypeDescriptor.INSTANCE );
}
@Override

5
hibernate-core/src/main/java/org/hibernate/type/BlobType.java
View File

@ -9,7 +9,8 @@
import java.sql.Blob;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.type.descriptor.java.BlobTypeDescriptor;
import org.hibernate.type.descriptor.java.BlobJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#BLOB BLOB} and {@link Blob}
@ -21,7 +22,7 @@ public class BlobType extends AbstractSingleColumnStandardBasicType<Blob> {
public static final BlobType INSTANCE = new BlobType();
public BlobType() {
super( org.hibernate.type.descriptor.jdbc.BlobTypeDescriptor.DEFAULT, BlobTypeDescriptor.INSTANCE );
super( BlobJdbcTypeDescriptor.DEFAULT, BlobJavaTypeDescriptor.INSTANCE );
}
@Override

22
hibernate-core/src/main/java/org/hibernate/type/BooleanType.java
View File

@ -6,12 +6,12 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import java.sql.Types;
import org.hibernate.Incubating;
import org.hibernate.type.descriptor.java.BooleanTypeDescriptor;
import org.hibernate.type.descriptor.java.BooleanJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BooleanJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
/**
@ -22,14 +22,14 @@
*/
public class BooleanType
extends AbstractSingleColumnStandardBasicType<Boolean>
implements PrimitiveType<Boolean>, DiscriminatorType<Boolean>, AdjustableBasicType<Boolean> {
implements AdjustableBasicType<Boolean> {
public static final BooleanType INSTANCE = new BooleanType();
public BooleanType() {
this( org.hibernate.type.descriptor.jdbc.BooleanTypeDescriptor.INSTANCE, BooleanTypeDescriptor.INSTANCE );
this( BooleanJdbcTypeDescriptor.INSTANCE, BooleanJavaTypeDescriptor.INSTANCE );
}
protected BooleanType(JdbcTypeDescriptor jdbcTypeDescriptor, BooleanTypeDescriptor javaTypeDescriptor) {
protected BooleanType(JdbcTypeDescriptor jdbcTypeDescriptor, BooleanJavaTypeDescriptor javaTypeDescriptor) {
super( jdbcTypeDescriptor, javaTypeDescriptor );
}
@ -47,17 +47,5 @@ public String getName() {
public String[] getRegistrationKeys() {
return new String[] { getName(), boolean.class.getName(), Boolean.class.getName() };
}
@Override
public Class getPrimitiveClass() {
return boolean.class;
}
@Override
public Serializable getDefaultValue() {
return Boolean.FALSE;
}
@Override
public Boolean stringToObject(CharSequence string) {
return fromString( string );
}
}

33
hibernate-core/src/main/java/org/hibernate/type/ByteType.java
View File

@ -6,10 +6,8 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import org.hibernate.type.descriptor.java.ByteTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntTypeDescriptor;
import org.hibernate.type.descriptor.java.ByteJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TinyIntJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#TINYINT TINYINT} and {@link Byte}
@ -18,15 +16,12 @@
* @author Steve Ebersole
*/
public class ByteType
extends AbstractSingleColumnStandardBasicType<Byte>
implements PrimitiveType<Byte>, DiscriminatorType<Byte> {
extends AbstractSingleColumnStandardBasicType<Byte> {
public static final ByteType INSTANCE = new ByteType();
private static final Byte ZERO = (byte) 0;
public ByteType() {
super( TinyIntTypeDescriptor.INSTANCE, ByteTypeDescriptor.INSTANCE );
super( TinyIntJdbcTypeDescriptor.INSTANCE, ByteJavaTypeDescriptor.INSTANCE );
}
@Override
@ -38,24 +33,4 @@ public String getName() {
public String[] getRegistrationKeys() {
return new String[] {getName(), byte.class.getName(), Byte.class.getName()};
}
@Override
public Serializable getDefaultValue() {
return ZERO;
}
@Override
public Class getPrimitiveClass() {
return byte.class;
}
@Override
public Byte stringToObject(CharSequence sequence) {
return fromString( sequence );
}
@Override
public Byte fromStringValue(CharSequence xml) {
return fromString( xml );
}
}

32
hibernate-core/src/main/java/org/hibernate/type/CalendarDateType.java
View File

@ -8,13 +8,8 @@
import java.util.Calendar;
import jakarta.persistence.TemporalType;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.CalendarDateTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.DateTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import org.hibernate.type.descriptor.java.CalendarDateJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.DateJdbcTypeDescriptor;
/**
* A type mapping {@link java.sql.Types#DATE DATE} and {@link Calendar}
@ -23,12 +18,11 @@
* @author Steve Ebersole
*/
public class CalendarDateType
extends AbstractSingleColumnStandardBasicType<Calendar>
implements AllowableTemporalParameterType<Calendar> {
extends AbstractSingleColumnStandardBasicType<Calendar> {
public static final CalendarDateType INSTANCE = new CalendarDateType();
public CalendarDateType() {
super( DateTypeDescriptor.INSTANCE, CalendarDateTypeDescriptor.INSTANCE );
super( DateJdbcTypeDescriptor.INSTANCE, CalendarDateJavaTypeDescriptor.INSTANCE );
}
public String getName() {
@ -36,22 +30,4 @@ public String getName() {
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case DATE: {
return this;
}
case TIME: {
return CalendarTimeType.INSTANCE;
}
case TIMESTAMP: {
return CalendarType.INSTANCE;
}
}
throw new QueryException( "Calendar-date type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}

32
hibernate-core/src/main/java/org/hibernate/type/CalendarTimeType.java
View File

@ -8,13 +8,8 @@
import java.util.Calendar;
import jakarta.persistence.TemporalType;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.CalendarTimeTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimeTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import org.hibernate.type.descriptor.java.CalendarTimeJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimeJdbcTypeDescriptor;
/**
* A type mapping {@link java.sql.Types#TIME TIME} and {@link Calendar}.
@ -25,34 +20,15 @@
* @author Steve Ebersole
*/
public class CalendarTimeType
extends AbstractSingleColumnStandardBasicType<Calendar>
implements AllowableTemporalParameterType<Calendar> {
extends AbstractSingleColumnStandardBasicType<Calendar> {
public static final CalendarTimeType INSTANCE = new CalendarTimeType();
public CalendarTimeType() {
super( TimeTypeDescriptor.INSTANCE, CalendarTimeTypeDescriptor.INSTANCE );
super( TimeJdbcTypeDescriptor.INSTANCE, CalendarTimeJavaTypeDescriptor.INSTANCE );
}
public String getName() {
return "calendar_time";
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case TIME: {
return this;
}
case DATE: {
return CalendarDateType.INSTANCE;
}
case TIMESTAMP: {
return CalendarType.INSTANCE;
}
}
throw new QueryException( "Calendar-time type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}

31
hibernate-core/src/main/java/org/hibernate/type/CalendarType.java
View File

@ -9,13 +9,8 @@
import java.util.Calendar;
import java.util.GregorianCalendar;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.CalendarTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import jakarta.persistence.TemporalType;
import org.hibernate.type.descriptor.java.CalendarJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#TIMESTAMP TIMESTAMP} and {@link Calendar}
@ -24,13 +19,12 @@
* @author Steve Ebersole
*/
public class CalendarType
extends AbstractSingleColumnStandardBasicType<Calendar>
implements AllowableTemporalParameterType<Calendar> {
extends AbstractSingleColumnStandardBasicType<Calendar> {
public static final CalendarType INSTANCE = new CalendarType();
public CalendarType() {
super( TimestampTypeDescriptor.INSTANCE, CalendarTypeDescriptor.INSTANCE );
super( TimestampJdbcTypeDescriptor.INSTANCE, CalendarJavaTypeDescriptor.INSTANCE );
}
@Override
@ -43,21 +37,4 @@ public String[] getRegistrationKeys() {
return new String[] { getName(), Calendar.class.getName(), GregorianCalendar.class.getName() };
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case TIMESTAMP: {
return this;
}
case DATE: {
return CalendarDateType.INSTANCE;
}
case TIME: {
return CalendarTimeType.INSTANCE;
}
}
throw new QueryException( "Calendar type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}

6
hibernate-core/src/main/java/org/hibernate/type/CharArrayType.java
View File

@ -8,8 +8,8 @@
import java.sql.Types;
import org.hibernate.type.descriptor.java.PrimitiveCharacterArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveCharacterArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharJdbcTypeDescriptor;
/**
* A type that maps between {@link Types#VARCHAR VARCHAR} and {@code char[]}
@ -23,7 +23,7 @@ public class CharArrayType
public static final CharArrayType INSTANCE = new CharArrayType();
public CharArrayType() {
super( VarcharTypeDescriptor.INSTANCE, PrimitiveCharacterArrayTypeDescriptor.INSTANCE );
super( VarcharJdbcTypeDescriptor.INSTANCE, PrimitiveCharacterArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

11
hibernate-core/src/main/java/org/hibernate/type/CharacterArrayClobType.java
View File

@ -8,13 +8,8 @@
import java.sql.Types;
import org.hibernate.type.descriptor.java.CharacterArrayTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptorIndicators;
import org.hibernate.type.descriptor.jdbc.spi.JdbcTypeDescriptorRegistry;
import org.hibernate.type.spi.TypeConfiguration;
import org.hibernate.type.descriptor.java.CharacterArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
/**
* A type that maps between {@link Types#CLOB CLOB} and {@link Character Character[]}
@ -30,7 +25,7 @@ public class CharacterArrayClobType
public static final CharacterArrayClobType INSTANCE = new CharacterArrayClobType();
public CharacterArrayClobType() {
super( ClobTypeDescriptor.DEFAULT, CharacterArrayTypeDescriptor.INSTANCE );
super( ClobJdbcTypeDescriptor.DEFAULT, CharacterArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

6
hibernate-core/src/main/java/org/hibernate/type/CharacterArrayNClobType.java
View File

@ -8,8 +8,8 @@
import java.sql.Types;
import org.hibernate.type.descriptor.java.CharacterArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobTypeDescriptor;
import org.hibernate.type.descriptor.java.CharacterArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobJdbcTypeDescriptor;
/**
* A type that maps between {@link Types#NCLOB NCLOB} and {@link Character Character[]}
@ -25,7 +25,7 @@ public class CharacterArrayNClobType
public static final CharacterArrayNClobType INSTANCE = new CharacterArrayNClobType();
public CharacterArrayNClobType() {
super( NClobTypeDescriptor.DEFAULT, CharacterArrayTypeDescriptor.INSTANCE );
super( NClobJdbcTypeDescriptor.DEFAULT, CharacterArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

6
hibernate-core/src/main/java/org/hibernate/type/CharacterArrayType.java
View File

@ -8,8 +8,8 @@
import java.sql.Types;
import org.hibernate.type.descriptor.java.CharacterArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.java.CharacterArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharJdbcTypeDescriptor;
/**
* A type that maps between {@link Types#VARCHAR VARCHAR} and {@link Character Character[]}
@ -23,7 +23,7 @@ public class CharacterArrayType
public static final CharacterArrayType INSTANCE = new CharacterArrayType();
public CharacterArrayType() {
super( VarcharTypeDescriptor.INSTANCE, CharacterArrayTypeDescriptor.INSTANCE );
super( VarcharJdbcTypeDescriptor.INSTANCE, CharacterArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

23
hibernate-core/src/main/java/org/hibernate/type/CharacterNCharType.java
View File

@ -6,10 +6,8 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import org.hibernate.type.descriptor.java.CharacterTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NCharTypeDescriptor;
import org.hibernate.type.descriptor.java.CharacterJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NCharJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#NCHAR NCHAR(1)} and {@link Character}
@ -18,29 +16,16 @@
* @author Steve Ebersole
*/
public class CharacterNCharType
extends AbstractSingleColumnStandardBasicType<Character>
implements PrimitiveType<Character>, DiscriminatorType<Character> {
extends AbstractSingleColumnStandardBasicType<Character> {
public static final CharacterNCharType INSTANCE = new CharacterNCharType();
public CharacterNCharType() {
super( NCharTypeDescriptor.INSTANCE, CharacterTypeDescriptor.INSTANCE );
super( NCharJdbcTypeDescriptor.INSTANCE, CharacterJavaTypeDescriptor.INSTANCE );
}
public String getName() {
return "ncharacter";
}
public Serializable getDefaultValue() {
throw new UnsupportedOperationException( "not a valid id type" );
}
public Class getPrimitiveClass() {
return char.class;
}
public Character stringToObject(CharSequence sequence) {
return fromString( sequence );
}
}

21
hibernate-core/src/main/java/org/hibernate/type/CharacterType.java
View File

@ -6,11 +6,10 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import java.sql.Types;
import org.hibernate.type.descriptor.java.CharacterTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.CharTypeDescriptor;
import org.hibernate.type.descriptor.java.CharacterJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.CharJdbcTypeDescriptor;
/**
* A type that maps between {@link Types#CHAR CHAR(1)} and {@link Character}
@ -20,12 +19,12 @@
*/
public class CharacterType
extends AbstractSingleColumnStandardBasicType<Character>
implements PrimitiveType<Character>, DiscriminatorType<Character>, AdjustableBasicType<Character> {
implements AdjustableBasicType<Character> {
public static final CharacterType INSTANCE = new CharacterType();
public CharacterType() {
super( CharTypeDescriptor.INSTANCE, CharacterTypeDescriptor.INSTANCE );
super( CharJdbcTypeDescriptor.INSTANCE, CharacterJavaTypeDescriptor.INSTANCE );
}
public String getName() {
@ -37,16 +36,4 @@ public String[] getRegistrationKeys() {
return new String[] { getName(), char.class.getName(), Character.class.getName() };
}
public Serializable getDefaultValue() {
throw new UnsupportedOperationException( "not a valid id type" );
}
public Class getPrimitiveClass() {
return char.class;
}
public Character stringToObject(CharSequence sequence) {
return fromString( sequence );
}
}

6
hibernate-core/src/main/java/org/hibernate/type/ClassType.java
View File

@ -5,8 +5,8 @@
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.ClassTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.java.ClassJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#VARCHAR VARCHAR} and {@link Class}
@ -18,7 +18,7 @@ public class ClassType extends AbstractSingleColumnStandardBasicType<Class> {
public static final ClassType INSTANCE = new ClassType();
public ClassType() {
super( VarcharTypeDescriptor.INSTANCE, ClassTypeDescriptor.INSTANCE );
super( VarcharJdbcTypeDescriptor.INSTANCE, ClassJavaTypeDescriptor.INSTANCE );
}
public String getName() {

5
hibernate-core/src/main/java/org/hibernate/type/ClobType.java
View File

@ -10,7 +10,8 @@
import java.sql.Types;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.type.descriptor.java.ClobTypeDescriptor;
import org.hibernate.type.descriptor.java.ClobJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
/**
* A type that maps between {@link Types#CLOB CLOB} and {@link Clob}
@ -22,7 +23,7 @@ public class ClobType extends AbstractSingleColumnStandardBasicType<Clob> implem
public static final ClobType INSTANCE = new ClobType();
public ClobType() {
super( org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor.DEFAULT, ClobTypeDescriptor.INSTANCE );
super( ClobJdbcTypeDescriptor.DEFAULT, ClobJavaTypeDescriptor.INSTANCE );
}
@Override

6
hibernate-core/src/main/java/org/hibernate/type/CurrencyType.java
View File

@ -8,8 +8,8 @@
import java.util.Currency;
import org.hibernate.type.descriptor.java.CurrencyTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.java.CurrencyJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#VARCHAR VARCHAR} and {@link Currency}
@ -23,7 +23,7 @@ public class CurrencyType
public static final CurrencyType INSTANCE = new CurrencyType();
public CurrencyType() {
super( VarcharTypeDescriptor.INSTANCE, CurrencyTypeDescriptor.INSTANCE );
super( VarcharJdbcTypeDescriptor.INSTANCE, CurrencyJavaTypeDescriptor.INSTANCE );
}
public String getName() {

17
hibernate-core/src/main/java/org/hibernate/type/CustomType.java
View File

@ -23,7 +23,7 @@
import org.hibernate.internal.util.collections.ArrayHelper;
import org.hibernate.type.descriptor.ValueBinder;
import org.hibernate.type.descriptor.ValueExtractor;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypedExpressable;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
@ -52,14 +52,14 @@
*/
public class CustomType
extends AbstractType
implements BasicType, IdentifierType, DiscriminatorType, StringRepresentableType, ProcedureParameterNamedBinder, ProcedureParameterExtractionAware {
implements BasicType, StringRepresentableType, ProcedureParameterNamedBinder, ProcedureParameterExtractionAware {
private final UserType<Object> userType;
private final String[] registrationKeys;
private final String name;
private final BasicJavaDescriptor<Object> mappedJavaTypeDescriptor;
private final BasicJavaTypeDescriptor<Object> mappedJavaTypeDescriptor;
private final JdbcTypeDescriptor jdbcTypeDescriptor;
private final ValueExtractor<Object> valueExtractor;
@ -76,13 +76,13 @@ public CustomType(UserType userType, String[] registrationKeys, TypeConfiguratio
this.userType = userType;
this.name = userType.getClass().getName();
if ( userType instanceof BasicJavaDescriptor ) {
if ( userType instanceof BasicJavaTypeDescriptor ) {
//noinspection rawtypes
this.mappedJavaTypeDescriptor = ( (BasicJavaDescriptor) userType );
this.mappedJavaTypeDescriptor = ( (BasicJavaTypeDescriptor) userType );
}
else if ( userType instanceof JavaTypedExpressable ) {
//noinspection rawtypes
this.mappedJavaTypeDescriptor = (BasicJavaDescriptor) ( (JavaTypedExpressable) userType ).getExpressableJavaTypeDescriptor();
this.mappedJavaTypeDescriptor = (BasicJavaTypeDescriptor) ( (JavaTypedExpressable) userType ).getExpressableJavaTypeDescriptor();
}
else if ( userType instanceof UserVersionType ) {
this.mappedJavaTypeDescriptor = new UserTypeVersionJavaTypeWrapper<>( (UserVersionType) userType );
@ -253,11 +253,6 @@ public boolean isMutable() {
return getUserType().isMutable();
}
@Override
public Object stringToObject(CharSequence sequence) {
return fromStringValue( sequence );
}
@Override
public String toLoggableString(Object value, SessionFactoryImplementor factory) {
if ( value == null ) {

39
hibernate-core/src/main/java/org/hibernate/type/DateType.java
View File

@ -8,12 +8,8 @@
import java.util.Date;
import jakarta.persistence.TemporalType;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.JdbcDateTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import org.hibernate.type.descriptor.java.JdbcDateJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.DateJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#DATE DATE} and {@link java.sql.Date}
@ -22,13 +18,12 @@
* @author Steve Ebersole
*/
public class DateType
extends AbstractSingleColumnStandardBasicType<Date>
implements IdentifierType<Date>, AllowableTemporalParameterType<Date> {
extends AbstractSingleColumnStandardBasicType<Date> {
public static final DateType INSTANCE = new DateType();
public DateType() {
super( org.hibernate.type.descriptor.jdbc.DateTypeDescriptor.INSTANCE, JdbcDateTypeDescriptor.INSTANCE );
super( DateJdbcTypeDescriptor.INSTANCE, JdbcDateJavaTypeDescriptor.INSTANCE );
}
public String getName() {
@ -43,30 +38,4 @@ public String[] getRegistrationKeys() {
};
}
// @Override
// protected boolean registerUnderJavaType() {
// return true;
// }
public Date stringToObject(CharSequence sequence) {
return fromString( sequence );
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case DATE: {
return this;
}
case TIME: {
return TimeType.INSTANCE;
}
case TIMESTAMP: {
return TimestampType.INSTANCE;
}
}
throw new QueryException( "Date type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}

6
hibernate-core/src/main/java/org/hibernate/type/DbTimestampType.java
View File

@ -11,10 +11,10 @@
import org.hibernate.internal.CoreMessageLogger;
import org.hibernate.type.descriptor.java.DbTimestampJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcTimestampTypeDescriptor;
import org.hibernate.type.descriptor.java.JdbcTimestampJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.TemporalJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampJdbcTypeDescriptor;
import org.jboss.logging.Logger;
@ -38,7 +38,7 @@ public class DbTimestampType extends TimestampType {
);
public DbTimestampType() {
this( TimestampTypeDescriptor.INSTANCE, JdbcTimestampTypeDescriptor.INSTANCE );
this( TimestampJdbcTypeDescriptor.INSTANCE, JdbcTimestampJavaTypeDescriptor.INSTANCE );
}
public DbTimestampType(JdbcTypeDescriptor jdbcTypeDescriptor, JavaTypeDescriptor<Date> javaTypeDescriptor) {

32
hibernate-core/src/main/java/org/hibernate/type/DiscriminatorType.java
View File

@ -1,32 +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;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
/**
* Additional contract for a {@link Type} may be used for a discriminator.
*
* @author Gavin King
* @author Steve Ebersole
*/
public interface DiscriminatorType<T> extends IdentifierType<T> {
/**
* The descriptor for the Java type represented by this
* expressable type
*/
JavaTypeDescriptor<T> getJavaTypeDescriptor();
/**
* The descriptor for the SQL type represented by this
* expressable type
*/
JdbcTypeDescriptor getJdbcTypeDescriptor();
}

20
hibernate-core/src/main/java/org/hibernate/type/DoubleType.java
View File

@ -6,9 +6,8 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import org.hibernate.type.descriptor.java.DoubleTypeDescriptor;
import org.hibernate.type.descriptor.java.DoubleJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.DoubleJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#DOUBLE DOUBLE} and {@link Double}
@ -17,14 +16,11 @@
* @author Steve Ebersole
*/
public class DoubleType
extends AbstractSingleColumnStandardBasicType<Double>
implements PrimitiveType<Double> {
extends AbstractSingleColumnStandardBasicType<Double> {
public static final DoubleType INSTANCE = new DoubleType();
public static final Double ZERO = 0.0;
public DoubleType() {
super( org.hibernate.type.descriptor.jdbc.DoubleTypeDescriptor.INSTANCE, DoubleTypeDescriptor.INSTANCE );
super( DoubleJdbcTypeDescriptor.INSTANCE, DoubleJavaTypeDescriptor.INSTANCE );
}
@Override
public String getName() {
@ -35,12 +31,4 @@ public String getName() {
public String[] getRegistrationKeys() {
return new String[] { getName(), double.class.getName(), Double.class.getName() };
}
@Override
public Serializable getDefaultValue() {
return ZERO;
}
@Override
public Class getPrimitiveClass() {
return double.class;
}
}

6
hibernate-core/src/main/java/org/hibernate/type/DurationType.java
View File

@ -8,8 +8,8 @@
import java.time.Duration;
import org.hibernate.type.descriptor.java.DurationJavaDescriptor;
import org.hibernate.type.descriptor.jdbc.NumericTypeDescriptor;
import org.hibernate.type.descriptor.java.DurationJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NumericJdbcTypeDescriptor;
/**
* @author Steve Ebersole
@ -22,7 +22,7 @@ public class DurationType
public static final DurationType INSTANCE = new DurationType();
public DurationType() {
super( NumericTypeDescriptor.INSTANCE, DurationJavaDescriptor.INSTANCE );
super( NumericJdbcTypeDescriptor.INSTANCE, DurationJavaTypeDescriptor.INSTANCE );
}
@Override

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

@ -30,7 +30,7 @@
import org.hibernate.metamodel.model.convert.spi.EnumValueConverter;
import org.hibernate.type.descriptor.ValueBinder;
import org.hibernate.type.descriptor.ValueExtractor;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.EnumJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptorIndicators;
@ -147,7 +147,7 @@ else if ( jakarta.persistence.EnumType.STRING.equals( enumType ) ) {
reader
);
final BasicJavaDescriptor<?> relationalJtd = resolveRelationalJavaTypeDescriptor(
final BasicJavaTypeDescriptor<?> relationalJtd = resolveRelationalJavaTypeDescriptor(
indicators,
enumJavaDescriptor
);
@ -194,7 +194,7 @@ else if ( jakarta.persistence.EnumType.STRING.equals( enumType ) ) {
}
}
private BasicJavaDescriptor<?> resolveRelationalJavaTypeDescriptor(
private BasicJavaTypeDescriptor<?> resolveRelationalJavaTypeDescriptor(
LocalJdbcTypeDescriptorIndicators indicators,
EnumJavaTypeDescriptor<?> enumJavaDescriptor) {
return enumJavaDescriptor.getRecommendedJdbcType( indicators ).getJdbcRecommendedJavaTypeMapping(
@ -253,8 +253,8 @@ private EnumValueConverter<T,Object> interpretParameters(Properties parameters)
-1L,
null
);
final BasicJavaDescriptor<?> stringJavaDescriptor = (BasicJavaDescriptor<?>) typeConfiguration.getJavaTypeDescriptorRegistry().getDescriptor( String.class );
final BasicJavaDescriptor<?> integerJavaDescriptor = (BasicJavaDescriptor<?>) typeConfiguration.getJavaTypeDescriptorRegistry().getDescriptor( Integer.class );
final BasicJavaTypeDescriptor<?> stringJavaDescriptor = (BasicJavaTypeDescriptor<?>) typeConfiguration.getJavaTypeDescriptorRegistry().getDescriptor( String.class );
final BasicJavaTypeDescriptor<?> integerJavaDescriptor = (BasicJavaTypeDescriptor<?>) typeConfiguration.getJavaTypeDescriptorRegistry().getDescriptor( Integer.class );
if ( parameters.containsKey( NAMED ) ) {
final boolean useNamed = ConfigurationHelper.getBoolean( NAMED, parameters );

16
hibernate-core/src/main/java/org/hibernate/type/FloatType.java
View File

@ -6,9 +6,8 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import org.hibernate.type.descriptor.java.FloatTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.FloatJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#FLOAT FLOAT} and {@link Float}
@ -16,13 +15,12 @@
* @author Gavin King
* @author Steve Ebersole
*/
public class FloatType extends AbstractSingleColumnStandardBasicType<Float> implements PrimitiveType<Float> {
public class FloatType extends AbstractSingleColumnStandardBasicType<Float> {
public static final FloatType INSTANCE = new FloatType();
public static final Float ZERO = 0.0f;
public FloatType() {
super( org.hibernate.type.descriptor.jdbc.FloatTypeDescriptor.INSTANCE, FloatTypeDescriptor.INSTANCE );
super( FloatJdbcTypeDescriptor.INSTANCE, FloatTypeDescriptor.INSTANCE );
}
@Override
public String getName() {
@ -33,12 +31,4 @@ public String getName() {
public String[] getRegistrationKeys() {
return new String[] { getName(), float.class.getName(), Float.class.getName() };
}
@Override
public Serializable getDefaultValue() {
return ZERO;
}
@Override
public Class getPrimitiveClass() {
return float.class;
}
}

28
hibernate-core/src/main/java/org/hibernate/type/IdentifierType.java
View File

@ -1,28 +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;
/**
* Additional contract for a {@link Type} may be used for a discriminator. THis contract is used to process
* the string representation as presented in metadata, especially in <tt>XML</tt> files.
*
* @author Gavin King
*/
public interface IdentifierType<T> extends Type {
/**
* Convert the value from the mapping file to a Java object.
*
* @param sequence the value of <tt>discriminator-value</tt> or <tt>unsaved-value</tt> attribute
* @return The converted value of the string representation.
*
* @throws Exception Indicates a problem converting from the string
*/
public T stringToObject(CharSequence sequence) throws Exception;
}

6
hibernate-core/src/main/java/org/hibernate/type/ImageType.java
View File

@ -5,8 +5,8 @@
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.LongVarbinaryTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.LongVarbinaryJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#LONGVARBINARY LONGVARBINARY} and {@code byte[]}
@ -20,7 +20,7 @@ public class ImageType extends AbstractSingleColumnStandardBasicType<byte[]> {
public static final ImageType INSTANCE = new ImageType();
public ImageType() {
super( LongVarbinaryTypeDescriptor.INSTANCE, PrimitiveByteArrayTypeDescriptor.INSTANCE );
super( LongVarbinaryJdbcTypeDescriptor.INSTANCE, PrimitiveByteArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

31
hibernate-core/src/main/java/org/hibernate/type/InstantType.java
View File

@ -10,13 +10,8 @@
import java.time.format.DateTimeFormatter;
import java.util.Locale;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.InstantJavaDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import jakarta.persistence.TemporalType;
import org.hibernate.type.descriptor.java.InstantJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#TIMESTAMP TIMESTAMP} and {@link java.time.LocalDateTime}.
@ -24,8 +19,7 @@
* @author Steve Ebersole
*/
public class InstantType
extends AbstractSingleColumnStandardBasicType<Instant>
implements AllowableTemporalParameterType<Instant> {
extends AbstractSingleColumnStandardBasicType<Instant> {
/**
* Singleton access
*/
@ -34,7 +28,7 @@ public class InstantType
public static final DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm:ss.S 'Z'", Locale.ENGLISH );
public InstantType() {
super( TimestampTypeDescriptor.INSTANCE, InstantJavaDescriptor.INSTANCE );
super( TimestampJdbcTypeDescriptor.INSTANCE, InstantJavaTypeDescriptor.INSTANCE );
}
@Override
@ -47,21 +41,4 @@ protected boolean registerUnderJavaType() {
return true;
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case TIMESTAMP: {
return this;
}
case TIME: {
return TimeType.INSTANCE;
}
case DATE: {
return DateType.INSTANCE;
}
}
throw new QueryException( "Instant type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}

26
hibernate-core/src/main/java/org/hibernate/type/IntegerType.java
View File

@ -6,9 +6,8 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import org.hibernate.type.descriptor.java.IntegerTypeDescriptor;
import org.hibernate.type.descriptor.java.IntegerJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.IntegerJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#INTEGER INTEGER} and @link Integer}
@ -16,15 +15,12 @@
* @author Gavin King
* @author Steve Ebersole
*/
public class IntegerType extends AbstractSingleColumnStandardBasicType<Integer>
implements PrimitiveType<Integer>, DiscriminatorType<Integer> {
public class IntegerType extends AbstractSingleColumnStandardBasicType<Integer> {
public static final IntegerType INSTANCE = new IntegerType();
public static final Integer ZERO = 0;
public IntegerType() {
super( org.hibernate.type.descriptor.jdbc.IntegerTypeDescriptor.INSTANCE, IntegerTypeDescriptor.INSTANCE );
super( IntegerJdbcTypeDescriptor.INSTANCE, IntegerJavaTypeDescriptor.INSTANCE );
}
@Override
@ -37,18 +33,4 @@ public String[] getRegistrationKeys() {
return new String[] {getName(), int.class.getName(), Integer.class.getName()};
}
@Override
public Serializable getDefaultValue() {
return ZERO;
}
@Override
public Class getPrimitiveClass() {
return int.class;
}
@Override
public Integer stringToObject(CharSequence sequence) {
return fromString( sequence );
}
}

4
hibernate-core/src/main/java/org/hibernate/type/JavaObjectType.java
View File

@ -6,7 +6,7 @@
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.JavaObjectTypeDescriptor;
import org.hibernate.type.descriptor.java.ObjectJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ObjectJdbcTypeDescriptor;
@ -21,7 +21,7 @@ public class JavaObjectType extends AbstractSingleColumnStandardBasicType<Object
public static final JavaObjectType INSTANCE = new JavaObjectType();
public JavaObjectType() {
super( ObjectJdbcTypeDescriptor.INSTANCE, JavaObjectTypeDescriptor.INSTANCE );
super( ObjectJdbcTypeDescriptor.INSTANCE, ObjectJavaTypeDescriptor.INSTANCE );
}
public JavaObjectType(JdbcTypeDescriptor jdbcTypeDescriptor, JavaTypeDescriptor<Object> javaTypeDescriptor) {

30
hibernate-core/src/main/java/org/hibernate/type/LocalDateTimeType.java
View File

@ -8,13 +8,8 @@
import java.time.LocalDateTime;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.LocalDateTimeJavaDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import jakarta.persistence.TemporalType;
import org.hibernate.type.descriptor.java.LocalDateTimeJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#TIMESTAMP TIMESTAMP} and {@link LocalDateTime}.
@ -22,15 +17,14 @@
* @author Steve Ebersole
*/
public class LocalDateTimeType
extends AbstractSingleColumnStandardBasicType<LocalDateTime>
implements AllowableTemporalParameterType<LocalDateTime> {
extends AbstractSingleColumnStandardBasicType<LocalDateTime> {
/**
* Singleton access
*/
public static final LocalDateTimeType INSTANCE = new LocalDateTimeType();
public LocalDateTimeType() {
super( TimestampTypeDescriptor.INSTANCE, LocalDateTimeJavaDescriptor.INSTANCE );
super( TimestampJdbcTypeDescriptor.INSTANCE, LocalDateTimeJavaTypeDescriptor.INSTANCE );
}
@Override
@ -43,20 +37,4 @@ protected boolean registerUnderJavaType() {
return true;
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case TIMESTAMP: {
return this;
}
case DATE: {
return LocalDateType.INSTANCE;
}
default: {
throw new QueryException( "LocalDateTime type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}
}
}

29
hibernate-core/src/main/java/org/hibernate/type/LocalDateType.java
View File

@ -7,20 +7,15 @@
package org.hibernate.type;
import java.time.LocalDate;
import jakarta.persistence.TemporalType;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.LocalDateJavaDescriptor;
import org.hibernate.type.descriptor.jdbc.DateTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import org.hibernate.type.descriptor.java.LocalDateJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.DateJdbcTypeDescriptor;
/**
* @author Steve Ebersole
*/
public class LocalDateType
extends AbstractSingleColumnStandardBasicType<LocalDate>
implements AllowableTemporalParameterType<LocalDate> {
extends AbstractSingleColumnStandardBasicType<LocalDate> {
/**
* Singleton access
@ -28,7 +23,7 @@ public class LocalDateType
public static final LocalDateType INSTANCE = new LocalDateType();
public LocalDateType() {
super( DateTypeDescriptor.INSTANCE, LocalDateJavaDescriptor.INSTANCE );
super( DateJdbcTypeDescriptor.INSTANCE, LocalDateJavaTypeDescriptor.INSTANCE );
}
@Override
@ -41,20 +36,4 @@ protected boolean registerUnderJavaType() {
return true;
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case DATE: {
return this;
}
case TIMESTAMP: {
return LocalDateTimeType.INSTANCE;
}
default: {
throw new QueryException( "LocalDate type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}
}
}

30
hibernate-core/src/main/java/org/hibernate/type/LocalTimeType.java
View File

@ -7,12 +7,9 @@
package org.hibernate.type;
import java.time.LocalTime;
import jakarta.persistence.TemporalType;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.LocalTimeJavaDescriptor;
import org.hibernate.type.descriptor.jdbc.TimeTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import org.hibernate.type.descriptor.java.LocalTimeJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimeJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#TIMESTAMP TIMESTAMP} and {@link java.time.LocalDateTime}.
@ -20,15 +17,14 @@
* @author Steve Ebersole
*/
public class LocalTimeType
extends AbstractSingleColumnStandardBasicType<LocalTime>
implements AllowableTemporalParameterType<LocalTime> {
extends AbstractSingleColumnStandardBasicType<LocalTime> {
/**
* Singleton access
*/
public static final LocalTimeType INSTANCE = new LocalTimeType();
public LocalTimeType() {
super( TimeTypeDescriptor.INSTANCE, LocalTimeJavaDescriptor.INSTANCE );
super( TimeJdbcTypeDescriptor.INSTANCE, LocalTimeJavaTypeDescriptor.INSTANCE );
}
@Override
@ -41,22 +37,4 @@ protected boolean registerUnderJavaType() {
return true;
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case TIME: {
return this;
}
case TIMESTAMP: {
return LocalDateTimeType.INSTANCE;
}
case DATE: {
return LocalDateType.INSTANCE;
}
}
// Why Java? Why?
return null;
}
}

6
hibernate-core/src/main/java/org/hibernate/type/LocaleType.java
View File

@ -8,8 +8,8 @@
import java.util.Locale;
import org.hibernate.type.descriptor.java.LocaleTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharTypeDescriptor;
import org.hibernate.type.descriptor.java.LocaleJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarcharJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#VARCHAR VARCHAR} and @link Locale}
@ -22,7 +22,7 @@ public class LocaleType extends AbstractSingleColumnStandardBasicType<Locale> {
public static final LocaleType INSTANCE = new LocaleType();
public LocaleType() {
super( VarcharTypeDescriptor.INSTANCE, LocaleTypeDescriptor.INSTANCE );
super( VarcharJdbcTypeDescriptor.INSTANCE, LocaleJavaTypeDescriptor.INSTANCE );
}
public String getName() {

28
hibernate-core/src/main/java/org/hibernate/type/LongType.java
View File

@ -6,10 +6,8 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import org.hibernate.type.descriptor.java.LongTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BigIntTypeDescriptor;
import org.hibernate.type.descriptor.java.LongJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BigIntJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#BIGINT BIGINT} and {@link Long}
@ -18,15 +16,12 @@
* @author Steve Ebersole
*/
public class LongType
extends AbstractSingleColumnStandardBasicType<Long>
implements PrimitiveType<Long>, DiscriminatorType<Long> {
extends AbstractSingleColumnStandardBasicType<Long> {
public static final LongType INSTANCE = new LongType();
private static final Long ZERO = (long) 0;
public LongType() {
super( BigIntTypeDescriptor.INSTANCE, LongTypeDescriptor.INSTANCE );
super( BigIntJdbcTypeDescriptor.INSTANCE, LongJavaTypeDescriptor.INSTANCE );
}
@Override
@ -39,19 +34,4 @@ public String[] getRegistrationKeys() {
return new String[] { getName(), long.class.getName(), Long.class.getName() };
}
@Override
public Serializable getDefaultValue() {
return ZERO;
}
@Override
public Class getPrimitiveClass() {
return long.class;
}
@Override
public Long stringToObject(CharSequence sequence) throws Exception {
return Long.valueOf( sequence.toString() );
}
}

6
hibernate-core/src/main/java/org/hibernate/type/MaterializedBlobType.java
View File

@ -5,8 +5,8 @@
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveByteArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#BLOB BLOB} and {@code byte[]}
@ -20,7 +20,7 @@ public class MaterializedBlobType extends AbstractSingleColumnStandardBasicType<
public static final MaterializedBlobType INSTANCE = new MaterializedBlobType();
public MaterializedBlobType() {
super( BlobTypeDescriptor.DEFAULT, PrimitiveByteArrayTypeDescriptor.INSTANCE );
super( BlobJdbcTypeDescriptor.DEFAULT, PrimitiveByteArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

6
hibernate-core/src/main/java/org/hibernate/type/MaterializedClobType.java
View File

@ -8,8 +8,8 @@
import java.sql.Types;
import org.hibernate.type.descriptor.java.StringTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor;
import org.hibernate.type.descriptor.java.StringJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
/**
* A type that maps between {@link Types#CLOB CLOB} and {@link String}
@ -24,7 +24,7 @@ public class MaterializedClobType
public static final MaterializedClobType INSTANCE = new MaterializedClobType();
public MaterializedClobType() {
super( ClobTypeDescriptor.DEFAULT, StringTypeDescriptor.INSTANCE );
super( ClobJdbcTypeDescriptor.DEFAULT, StringJavaTypeDescriptor.INSTANCE );
}
public String getName() {

6
hibernate-core/src/main/java/org/hibernate/type/MaterializedNClobType.java
View File

@ -6,8 +6,8 @@
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.StringTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobTypeDescriptor;
import org.hibernate.type.descriptor.java.StringJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#CLOB CLOB} and {@link String}
@ -20,7 +20,7 @@ public class MaterializedNClobType extends AbstractSingleColumnStandardBasicType
public static final MaterializedNClobType INSTANCE = new MaterializedNClobType();
public MaterializedNClobType() {
super( NClobTypeDescriptor.DEFAULT, StringTypeDescriptor.INSTANCE );
super( NClobJdbcTypeDescriptor.DEFAULT, StringJavaTypeDescriptor.INSTANCE );
}
public String getName() {

5
hibernate-core/src/main/java/org/hibernate/type/NClobType.java
View File

@ -9,7 +9,8 @@
import java.sql.NClob;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.type.descriptor.java.NClobTypeDescriptor;
import org.hibernate.type.descriptor.java.NClobJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#NCLOB NCLOB} and {@link NClob}
@ -21,7 +22,7 @@ public class NClobType extends AbstractSingleColumnStandardBasicType<NClob> {
public static final NClobType INSTANCE = new NClobType();
public NClobType() {
super( org.hibernate.type.descriptor.jdbc.NClobTypeDescriptor.DEFAULT, NClobTypeDescriptor.INSTANCE );
super( NClobJdbcTypeDescriptor.DEFAULT, NClobJavaTypeDescriptor.INSTANCE );
}
@Override

6
hibernate-core/src/main/java/org/hibernate/type/NTextType.java
View File

@ -6,8 +6,8 @@
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.StringTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.LongNVarcharTypeDescriptor;
import org.hibernate.type.descriptor.java.StringJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.LongNVarcharJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#LONGNVARCHAR LONGNVARCHAR} and {@link String}
@ -20,7 +20,7 @@ public class NTextType extends AbstractSingleColumnStandardBasicType<String> {
public static final NTextType INSTANCE = new NTextType();
public NTextType() {
super( LongNVarcharTypeDescriptor.INSTANCE, StringTypeDescriptor.INSTANCE );
super( LongNVarcharJdbcTypeDescriptor.INSTANCE, StringJavaTypeDescriptor.INSTANCE );
}
public String getName() {

5
hibernate-core/src/main/java/org/hibernate/type/NullType.java
View File

@ -6,10 +6,9 @@
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.JavaObjectTypeDescriptor;
import org.hibernate.type.descriptor.java.ObjectJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.JdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ObjectJdbcTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ObjectNullResolvingJdbcTypeDescriptor;
/**
@ -22,7 +21,7 @@ public class NullType extends JavaObjectType {
public static final NullType INSTANCE = new NullType();
public NullType() {
super( ObjectNullResolvingJdbcTypeDescriptor.INSTANCE, JavaObjectTypeDescriptor.INSTANCE );
super( ObjectNullResolvingJdbcTypeDescriptor.INSTANCE, ObjectJavaTypeDescriptor.INSTANCE );
}
public NullType(JdbcTypeDescriptor jdbcTypeDescriptor, JavaTypeDescriptor<Object> javaTypeDescriptor) {

28
hibernate-core/src/main/java/org/hibernate/type/NumericBooleanType.java
View File

@ -6,13 +6,12 @@
*/
package org.hibernate.type;
import java.io.Serializable;
import org.hibernate.metamodel.model.convert.spi.BasicValueConverter;
import org.hibernate.query.CastType;
import org.hibernate.type.descriptor.java.BooleanTypeDescriptor;
import org.hibernate.type.descriptor.java.BooleanJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.IntegerJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.IntegerTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.IntegerJdbcTypeDescriptor;
/**
* A type that maps between {@link java.sql.Types#INTEGER INTEGER} and {@link Boolean} (using 1 and 0)
@ -21,30 +20,19 @@
*/
public class NumericBooleanType
extends AbstractSingleColumnStandardBasicType<Boolean>
implements PrimitiveType<Boolean>, DiscriminatorType<Boolean>, ConvertedBasicType<Boolean> {
implements ConvertedBasicType<Boolean> {
public static final NumericBooleanType INSTANCE = new NumericBooleanType();
public static final NumericConverter CONVERTER = new NumericConverter();
public NumericBooleanType() {
super( IntegerTypeDescriptor.INSTANCE, BooleanTypeDescriptor.INSTANCE );
super( IntegerJdbcTypeDescriptor.INSTANCE, BooleanJavaTypeDescriptor.INSTANCE );
}
@Override
public String getName() {
return "numeric_boolean";
}
@Override
public Class getPrimitiveClass() {
return boolean.class;
}
@Override
public Serializable getDefaultValue() {
return Boolean.FALSE;
}
@Override
public Boolean stringToObject(CharSequence string) {
return fromString( string );
}
@Override
public CastType getCastType() {
@ -98,12 +86,12 @@ public static Integer toRelational(Boolean domainForm) {
@Override
public JavaTypeDescriptor<Boolean> getDomainJavaDescriptor() {
return BooleanTypeDescriptor.INSTANCE;
return BooleanJavaTypeDescriptor.INSTANCE;
}
@Override
public JavaTypeDescriptor<Integer> getRelationalJavaDescriptor() {
return org.hibernate.type.descriptor.java.IntegerTypeDescriptor.INSTANCE;
return IntegerJavaTypeDescriptor.INSTANCE;
}
}
}

35
hibernate-core/src/main/java/org/hibernate/type/OffsetDateTimeType.java
View File

@ -8,21 +8,15 @@
import java.time.OffsetDateTime;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.query.CastType;
import org.hibernate.type.descriptor.java.OffsetDateTimeJavaDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampWithTimeZoneDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import jakarta.persistence.TemporalType;
import org.hibernate.type.descriptor.java.OffsetDateTimeJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimestampWithTimeZoneJdbcTypeDescriptor;
/**
* @author Steve Ebersole
*/
public class OffsetDateTimeType
extends AbstractSingleColumnStandardBasicType<OffsetDateTime>
implements AllowableTemporalParameterType<OffsetDateTime> {
extends AbstractSingleColumnStandardBasicType<OffsetDateTime> {
/**
* Singleton access
@ -30,7 +24,7 @@ public class OffsetDateTimeType
public static final OffsetDateTimeType INSTANCE = new OffsetDateTimeType();
public OffsetDateTimeType() {
super( TimestampWithTimeZoneDescriptor.INSTANCE, OffsetDateTimeJavaDescriptor.INSTANCE );
super( TimestampWithTimeZoneJdbcTypeDescriptor.INSTANCE, OffsetDateTimeJavaTypeDescriptor.INSTANCE );
}
@Override
@ -43,27 +37,6 @@ protected boolean registerUnderJavaType() {
return true;
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case TIMESTAMP: {
return this;
}
case TIME: {
return OffsetTimeType.INSTANCE;
}
case DATE: {
return DateType.INSTANCE;
}
default: {
// should never happen, but switch requires this branch so...
throw new QueryException( "OffsetDateTime type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}
}
@Override
public CastType getCastType() {
return CastType.OFFSET_TIMESTAMP;

29
hibernate-core/src/main/java/org/hibernate/type/OffsetTimeType.java
View File

@ -7,20 +7,15 @@
package org.hibernate.type;
import java.time.OffsetTime;
import jakarta.persistence.TemporalType;
import org.hibernate.QueryException;
import org.hibernate.metamodel.model.domain.AllowableTemporalParameterType;
import org.hibernate.type.descriptor.java.OffsetTimeJavaDescriptor;
import org.hibernate.type.descriptor.jdbc.TimeTypeDescriptor;
import org.hibernate.type.spi.TypeConfiguration;
import org.hibernate.type.descriptor.java.OffsetTimeJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.TimeJdbcTypeDescriptor;
/**
* @author Steve Ebersole
*/
public class OffsetTimeType
extends AbstractSingleColumnStandardBasicType<OffsetTime>
implements AllowableTemporalParameterType<OffsetTime> {
extends AbstractSingleColumnStandardBasicType<OffsetTime> {
/**
* Singleton access
@ -28,7 +23,7 @@ public class OffsetTimeType
public static final OffsetTimeType INSTANCE = new OffsetTimeType();
public OffsetTimeType() {
super( TimeTypeDescriptor.INSTANCE, OffsetTimeJavaDescriptor.INSTANCE );
super( TimeJdbcTypeDescriptor.INSTANCE, OffsetTimeJavaTypeDescriptor.INSTANCE );
}
@Override
@ -41,20 +36,4 @@ protected boolean registerUnderJavaType() {
return true;
}
@Override
public AllowableTemporalParameterType resolveTemporalPrecision(
TemporalType temporalPrecision,
TypeConfiguration typeConfiguration) {
switch ( temporalPrecision ) {
case TIME: {
return this;
}
case TIMESTAMP: {
return OffsetDateTimeType.INSTANCE;
}
default: {
throw new QueryException( "OffsetTime type cannot be treated using `" + temporalPrecision.name() + "` precision" );
}
}
}
}

10
hibernate-core/src/main/java/org/hibernate/type/PostgresUUIDType.java
View File

@ -16,9 +16,9 @@
import org.hibernate.type.descriptor.ValueBinder;
import org.hibernate.type.descriptor.ValueExtractor;
import org.hibernate.type.descriptor.WrapperOptions;
import org.hibernate.type.descriptor.java.BasicJavaDescriptor;
import org.hibernate.type.descriptor.java.BasicJavaTypeDescriptor;
import org.hibernate.type.descriptor.java.JavaTypeDescriptor;
import org.hibernate.type.descriptor.java.UUIDTypeDescriptor;
import org.hibernate.type.descriptor.java.UUIDJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BasicBinder;
import org.hibernate.type.descriptor.jdbc.BasicExtractor;
import org.hibernate.type.descriptor.jdbc.JdbcLiteralFormatter;
@ -37,7 +37,7 @@ public class PostgresUUIDType extends AbstractSingleColumnStandardBasicType<UUID
public static final PostgresUUIDType INSTANCE = new PostgresUUIDType();
public PostgresUUIDType() {
super( PostgresUUIDJdbcTypeDescriptor.INSTANCE, UUIDTypeDescriptor.INSTANCE );
super( PostgresUUIDJdbcTypeDescriptor.INSTANCE, UUIDJavaTypeDescriptor.INSTANCE );
}
public String getName() {
@ -76,11 +76,11 @@ public boolean canBeRemapped() {
}
@Override
public <J> BasicJavaDescriptor<J> getJdbcRecommendedJavaTypeMapping(
public <J> BasicJavaTypeDescriptor<J> getJdbcRecommendedJavaTypeMapping(
Integer length,
Integer scale,
TypeConfiguration typeConfiguration) {
return (BasicJavaDescriptor<J>) typeConfiguration.getJavaTypeDescriptorRegistry().resolveDescriptor( UUID.class );
return (BasicJavaTypeDescriptor<J>) typeConfiguration.getJavaTypeDescriptorRegistry().resolveDescriptor( UUID.class );
}
@Override

6
hibernate-core/src/main/java/org/hibernate/type/PrimitiveCharacterArrayClobType.java
View File

@ -6,8 +6,8 @@
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.PrimitiveCharacterArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveCharacterArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.ClobJdbcTypeDescriptor;
/**
* Map a char[] to a Clob
@ -20,7 +20,7 @@ public class PrimitiveCharacterArrayClobType
public static final CharacterArrayClobType INSTANCE = new CharacterArrayClobType();
public PrimitiveCharacterArrayClobType() {
super( ClobTypeDescriptor.DEFAULT, PrimitiveCharacterArrayTypeDescriptor.INSTANCE );
super( ClobJdbcTypeDescriptor.DEFAULT, PrimitiveCharacterArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

6
hibernate-core/src/main/java/org/hibernate/type/PrimitiveCharacterArrayNClobType.java
View File

@ -6,8 +6,8 @@
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.PrimitiveCharacterArrayTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobTypeDescriptor;
import org.hibernate.type.descriptor.java.PrimitiveCharacterArrayJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.NClobJdbcTypeDescriptor;
/**
* Map a char[] to a NClob
@ -18,7 +18,7 @@ public class PrimitiveCharacterArrayNClobType extends AbstractSingleColumnStanda
public static final CharacterArrayNClobType INSTANCE = new CharacterArrayNClobType();
public PrimitiveCharacterArrayNClobType() {
super( NClobTypeDescriptor.DEFAULT, PrimitiveCharacterArrayTypeDescriptor.INSTANCE );
super( NClobJdbcTypeDescriptor.DEFAULT, PrimitiveCharacterArrayJavaTypeDescriptor.INSTANCE );
}
public String getName() {

40
hibernate-core/src/main/java/org/hibernate/type/PrimitiveType.java
View File

@ -1,40 +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;
/**
* Additional contract for primitive / primitive wrapper types.
*
* @author Gavin King
* @author Steve Ebersole
*/
public interface PrimitiveType<T> extends AdjustableBasicType<T> {
/**
* Retrieve the primitive counterpart to the wrapper type identified by
* {@link Type#getReturnedClass()}.
*
* @return The primitive Java type.
*/
Class<?> getPrimitiveClass();
/**
* Retrieve the string representation of the given value.
*
* @param value The value to be stringified.
*
* @return The string representation
*/
String toString(T value);
/**
* Get this type's default value.
*
* @return The default value.
*/
Object getDefaultValue();
}

6
hibernate-core/src/main/java/org/hibernate/type/RowVersionType.java
View File

@ -6,8 +6,8 @@
*/
package org.hibernate.type;
import org.hibernate.type.descriptor.java.RowVersionTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarbinaryTypeDescriptor;
import org.hibernate.type.descriptor.java.RowVersionJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.VarbinaryJdbcTypeDescriptor;
/**
* A type that maps between a {@link java.sql.Types#VARBINARY VARBINARY} and {@code byte[]}
@ -27,7 +27,7 @@ public String getName() {
}
public RowVersionType() {
super( VarbinaryTypeDescriptor.INSTANCE, RowVersionTypeDescriptor.INSTANCE );
super( VarbinaryJdbcTypeDescriptor.INSTANCE, RowVersionJavaTypeDescriptor.INSTANCE );
}
@Override

10
hibernate-core/src/main/java/org/hibernate/type/SerializableToBlobType.java
View File

@ -11,8 +11,8 @@
import org.hibernate.MappingException;
import org.hibernate.internal.util.ReflectHelper;
import org.hibernate.type.descriptor.java.SerializableTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobTypeDescriptor;
import org.hibernate.type.descriptor.java.SerializableJavaTypeDescriptor;
import org.hibernate.type.descriptor.jdbc.BlobJdbcTypeDescriptor;
import org.hibernate.usertype.DynamicParameterizedType;
/**
@ -25,7 +25,7 @@ public class SerializableToBlobType<T extends Serializable> extends AbstractSing
private static final long serialVersionUID = 1L;
public SerializableToBlobType() {
super( BlobTypeDescriptor.DEFAULT, new SerializableTypeDescriptor( Serializable.class ) );
super( BlobJdbcTypeDescriptor.DEFAULT, new SerializableJavaTypeDescriptor( Serializable.class ) );
}
@Override
@ -38,7 +38,7 @@ public String getName() {
public void setParameterValues(Properties parameters) {
ParameterType reader = (ParameterType) parameters.get( PARAMETER_TYPE );
if ( reader != null ) {
setJavaTypeDescriptor( new SerializableTypeDescriptor<>( reader.getReturnedClass() ) );
setJavaTypeDescriptor( new SerializableJavaTypeDescriptor<>( reader.getReturnedClass() ) );
}
else {
String className = parameters.getProperty( CLASS_NAME );
@ -46,7 +46,7 @@ public void setParameterValues(Properties parameters) {
throw new MappingException( "No class name defined for type: " + SerializableToBlobType.class.getName() );
}
try {
setJavaTypeDescriptor( new SerializableTypeDescriptor<>( ReflectHelper.classForName( className ) ) );
setJavaTypeDescriptor( new SerializableJavaTypeDescriptor<>( ReflectHelper.classForName( className ) ) );
}
catch ( ClassNotFoundException e ) {
throw new MappingException( "Unable to load class from " + CLASS_NAME + " parameter", e );

Some files were not shown because too many files have changed in this diff Show More