Package org.hibernate.type

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

Related Packages

Package	Description
org.hibernate	This package defines the central Hibernate APIs, beginning with SessionFactory, which represents an instance of Hibernate at runtime and is the source of new instances of Session and StatelessSession, the most important APIs exposing persistence-related operations for entities.
org.hibernate.type.descriptor	Contracts for reading and writing values to and from JDBC.
org.hibernate.type.format	Support for type mappings which format composite values to a structured text format (JSON or XML) for storage in a database-specific column type supporting that structured format.
org.hibernate.type.internal
org.hibernate.type.spi	Defines a registry for Hibernate Types.

Class	Description
AbstractSingleColumnStandardBasicType<T>	TODO : javadoc
AbstractStandardBasicType<T>	Convenience base class for BasicType implementations.
AbstractType	Abstract superclass of the built-in Type hierarchy.
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.
AnyType	Handles "any" mappings
AnyType.ObjectTypeCacheEntry	Used to externalize discrimination per a given identifier.
ArrayType	A type for persistent arrays.
AssociationType	A type that represents some kind of association between entities.
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>
BasicPluralType<C,E>	A basic plural type.
BasicType<T>	Marker interface for basic types.
BasicTypeReference<T>	A basic type reference.
BasicTypeRegistry	A registry of BasicType instances
BindableType<J>	Represents a type of argument which can be bound to a positional or named query parameter.
BindingContext	A context within which a BindableType can be resolved to an instance of SqmExpressible.
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.
CompositeType	Represents a composite type, a type which itself has typed attributes.
ConvertedBasicArrayType<T,S,E>	Given a BasicValueConverter for an array type,
ConvertedBasicCollectionType<C extends Collection<E>,E>	A converted basic array type.
ConvertedBasicType<J>	Extension for implementations of BasicType which have an implied conversion.
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.
ForeignKeyDirection	Represents directionality of the foreign key constraint
IdentifierBagType
JavaObjectType
ListType
ManyToOneType	A many-to-one association to an entity.
MappingContext	Declares operations used by implementors of Type that are common to the fully-"compiled" runtime mapping metadata held by a SessionFactory and the incomplete metamodel which exists during the metadata building process.
MapType
MetaType
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.
OutputableType<J>	Specialization of DomainType for types that can be used as a parameter output for a ProcedureCall.
ProcedureParameterExtractionAware<T>	Optional Type contract for implementations that are aware of how to extract values from stored procedure OUT/INOUT parameters.
ProcedureParameterNamedBinder<J>	Optional Type contract for implementations enabled to set store procedure OUT/INOUT parameters values by name.
QueryParameterJavaObjectType
SerializableType<T extends Serializable>	A type that maps between a VARBINARY and Serializable classes.
SerializationException	Thrown when a property cannot be serialized/deserialized
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 instances of BasicTypeReference.
StandardBasicTypeTemplate<J>	A BasicType adapter targeting partial portability to 6.0's type system changes.
StandardBooleanConverter<R>	Marker for Hibernate defined converters of Boolean-typed domain values
StandardConverter<O,R>	Marker for Hibernate supplied converter classes.
TimeZoneStorageStrategy	Enumerates the possible storage strategies for offset or zoned datetimes.
TrueFalseConverter	Handles conversion to/from Boolean as 'T' or 'F'
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.
TypeHelper	Certain operations for working with arrays of property values.
UserComponentType<T>	Handles CompositeUserTypes.
WrapperArrayHandling	Possible options for how to handle Byte[] and Character[] basic mappings encountered in the application domain model.
YesNoConverter	Handles conversion to/from Boolean as 'Y' or 'N'