Package org.hibernate.type

A Hibernate Type is a strategy for mapping a Java property type to a JDBC type or types. Every persistent attribute of an entity or embeddable object has a Type, even attributes which represent associations or hold references to embedded objects.

On the other hand, in modern Hibernate, Type itself is of receding importance to application developers, though it remains a very important internal abstraction.

Basic types

For basic types, we prefer to model the type mapping in terms the combination of:

• a JavaType, with
• a JdbcType, and,
• possibly, a converter, though this is not usually needed.

A JdbcType is able to read and write a single Java type to one, or sometimes several, JDBC types.

A JavaType is able to determine if an attribute of a given Java type is dirty, and then convert it to one of several other equivalent Java representations at the request of its partner JdbcType.

For example, if an entity attribute of Java type BigInteger is mapped to the JDBC type Types.VARCHAR, the VarcharJdbcType will ask its BigIntegerJavaType to convert instances of BigInteger to and from String when writing to and reading from JDBC statements and result sets.

An important point is that the set of available JavaTypes and of available JdbcTypes is not fixed—a TypeConfiguration is customizable during the bootstrap process.

This approach provides quite some flexibility in allowing a given Java type to map to a range of JDBC types. However, when the built-in conversions don't handle a particular mapping, a converter may assist in the conversion process. For example, a JPA AttributeConverter might be provided.

A JavaType comes with a built-in MutabilityPlan, but this may be overridden when types are composed.

See org.hibernate.annotations for information on how to influence basic type mappings using annotations.

Custom types

The package org.hibernate.usertype provides a way for application developers to define new types without being exposed to the full complexity of the Type framework defined in this package.

• A UserType may be used to define single-column type mappings, and thus competes with the "compositional" approach to basic type mappings described above.
• On the other hand, a CompositeUserType defines a way to handle multi-column type mappings, and is a much more flexible form of Embeddable object mapping.

Built-in converters for boolean mappings

In older versions of Hibernate there were dedicated Types mapping Java boolean to char(1) or integer database columns. These have now been replaced by the converters:

• TrueFalseConverter, which encodes a boolean value as 'T' or 'F',
• YesNoConverter, which encodes a boolean value as 'Y' or 'N', and
• NumericBooleanConverter, which encodes a boolean value as 1 or 0.

These converters may be applied, as usual, using the JPA-defined Converter annotation.

See Also:

Type, SqlTypes

Interface Summary

Interface	Description
AdjustableBasicType<J>	Extension contract for BasicType implementations which understand how to adjust themselves relative to where/how they're used by, for example, accounting for LOB, nationalized, primitive/wrapper, etc.
AssociationType	A type that represents some kind of association between entities.
BasicPluralType<C,E>	A basic plural type.
BasicType<T>	Marker interface for basic types.
CompositeType	Represents a composite type, a type which itself has typed attributes.
ConvertedBasicType<J>	Extension for implementations of BasicType which have an implied conversion.
ProcedureParameterExtractionAware<T>	Optional Type contract for implementations that are aware of how to extract values from store procedure OUT/INOUT parameters.
ProcedureParameterNamedBinder<J>	Optional Type contract for implementations enabled to set store procedure OUT/INOUT parameters values by name.
StandardBooleanConverter<R>	Marker for Hibernate defined converters of Boolean-typed domain values
StandardConverter<O,R>	Marker for Hibernate supplied converter classes.
Type	Defines a mapping between a Java type and one or more JDBC types, as well as describing the in-memory semantics of the given Java type, including: how to compare values and check for "dirtiness", how to clone values, and how to assemble/disassemble values for storage in the second-level cache.

Class Summary

Class	Description
AbstractSingleColumnStandardBasicType<T>	TODO : javadoc
AbstractStandardBasicType<T>	Convenience base class for BasicType implementations.
AbstractType	Abstract superclass of the built-in Type hierarchy.
AnyType	Handles "any" mappings
AnyType.ObjectTypeCacheEntry	Used to externalize discrimination per a given identifier.
ArrayType	A type for persistent arrays.
BagType
BasicArrayType<T,E>	A type that maps between ARRAY and T[]
BasicCollectionType<C extends Collection<E>,E>	A type that maps between ARRAY and Collection<T>
BasicTypeReference<T>	A basic type reference.
BasicTypeRegistry	A registry of BasicType instances
BottomType	A type that is assignable to every non-primitive type, that is, the type of null.
CharBooleanConverter	Abstract supertype of converters which map Boolean to Character.
CollectionType	A type that handles Hibernate PersistentCollections (including arrays).
ComponentType	Handles embedded mappings.
ConvertedBasicArrayType<T,S,E>	Given a BasicValueConverter for an array type,
ConvertedBasicCollectionType<C extends Collection<E>,E>	A converted basic array type.
CustomCollectionType	A custom type for mapping user-written classes that implement PersistentCollection
CustomType<J>	Adapts UserType to the generic Type interface, in order to isolate user code from changes in the internal Type contracts.
EmbeddedComponentType
EntityType	Base for types which map associations to persistent entities.
EnumType<T extends Enum<T>>	Deprecated, for removal: This API element is subject to removal in a future version. Use the built-in support for enums
IdentifierBagType
JavaObjectType
ListType
ManyToOneType	A many-to-one association to an entity.
MapType
MetaType	Deprecated, for removal: This API element is subject to removal in a future version. The functionality of MetaType, DiscriminatorType and DiscriminatorMetadata have been consolidated into EntityDiscriminatorMapping and DiscriminatorConverter
NullType
NumericBooleanConverter	Handles conversion to/from Boolean as 0 (false) or 1 (true)
OneToOneType	A one-to-one association to an entity
OrderedMapType	A specialization of the map type, with (resultset-based) ordering.
OrderedSetType	A specialization of the set type, with (resultset-based) ordering.
QueryParameterJavaObjectType
SerializableToBlobType<T extends Serializable>
SerializableType<T extends Serializable>	A type that maps between a VARBINARY and Serializable classes.
SetType
SortedMapType
SortedSetType
SpecialOneToOneType	A one-to-one association that maps to specific formula(s) instead of the primary key column of the owning entity.
SqlTypes	Defines a list of constant type codes used to identify generic SQL types.
StandardBasicTypes	References to common BasicTypeReference instances
StandardBasicTypeTemplate<J>	A BasicType adapter targeting partial portability to 6.0's type system changes.
TrueFalseConverter	Handles conversion to/from Boolean as 'T' or 'F'
TypeHelper	Certain operations for working with arrays of property values.
UserComponentType<T>	Handles CompositeUserTypes.
YesNoConverter	Handles conversion to/from Boolean as 'Y' or 'N'

Enum Summary

Enum	Description
ForeignKeyDirection	Represents directionality of the foreign key constraint
WrapperArrayHandling	Possible options for how to handle Byte[] and Character[] basic mappings encountered in the application domain model.

Exception Summary

Exception	Description
SerializationException	Thrown when a property cannot be serialized/deserialized