Package org.hibernate.type

Class CustomType<J>

java.lang.Object

org.hibernate.type.AbstractType

org.hibernate.type.CustomType<J>

All Implemented Interfaces:

BasicType<J>, Type<J>, Serializable, BasicValuedMapping, Bindable, JdbcMapping, JdbcMappingContainer, MappingModelExpressible, MappingType, SqlExpressible, ValueMapping, BasicDomainType<J>, DomainType<J>, SimpleDomainType<J>, BindableType<J>, OutputableType<J>, ReturnableType<J>, SqmExpressible<J>, BasicType<J>, ConvertedBasicType<J>, JavaTypedExpressible, ProcedureParameterExtractionAware<J>, ProcedureParameterNamedBinder<J>, Type

public class CustomType<J>
extends AbstractType
implements ConvertedBasicType<J>, ProcedureParameterNamedBinder<J>, ProcedureParameterExtractionAware<J>

Adapts UserType to the generic Type interface, in order to isolate user code from changes in the internal Type contracts.

See Also:

• Serialized Form

API Note:

Many of the interfaces implemented here are implemented just to handle the case of the wrapped type implementing them so we can pass them along.

Nested Class Summary

Nested classes/interfaces inherited from interface org.hibernate.metamodel.mapping.Bindable

Bindable.JdbcValuesBiConsumer<X,Y>, Bindable.JdbcValuesConsumer

Nested classes/interfaces inherited from interface jakarta.persistence.metamodel.Type

Type.PersistenceType

Constructor Summary

Constructors

Constructor	Description
CustomType(UserType<J> userType, String[] registrationKeys, TypeConfiguration typeConfiguration)
CustomType(UserType<J> userType, TypeConfiguration typeConfiguration)

Method Summary

Modifier and Type	Method	Description
void	addToCacheKey(MutableCacheKeyBuilder cacheKey, Object value, SharedSessionContractImplementor session)	Add to the MutableCacheKey the values obtained disassembling the value and the hasCode generated from the disassembled value.
Object	assemble(Serializable cached, SharedSessionContractImplementor session, Object owner)	Reconstruct the object from its disassembled state.
boolean	canDoExtraction()	Can the given instance of this type actually perform the parameter value extractions?
boolean	canDoSetting()	Can the given instance of this type actually set the parameter value by name
Object	deepCopy(Object value, SessionFactoryImplementor factory)	Return a deep copy of the persistent state, stopping at entities and at collections.
Serializable	disassemble(Object value, SessionFactoryImplementor sessionFactory)	Return a disassembled representation of the object.
Object	disassemble(Object value, SharedSessionContractImplementor session)	Breaks down a value of J into its simple pieces.
Serializable	disassemble(Object value, SharedSessionContractImplementor session, Object owner)	Return a disassembled representation of the object.
boolean	equals(Object obj)
J	extract(CallableStatement statement, int startIndex, SharedSessionContractImplementor session)	Perform the extraction
J	extract(CallableStatement statement, String paramName, SharedSessionContractImplementor session)	Perform the extraction
int	getColumnSpan(MappingContext session)	How many columns are used to persist this type?
JavaType<J>	getExpressibleJavaType()	The Java type descriptor for this expressible
int	getHashCode(Object x)	Get a hash code, consistent with persistence "equality".
Class<J>	getJavaType()
JavaType<J>	getJavaTypeDescriptor()	The descriptor for the Java type represented by this expressible type
JavaType<?>	getJdbcJavaType()
JdbcLiteralFormatter<J>	getJdbcLiteralFormatter()	The strategy for formatting values of this expressible type to a SQL literal.
JdbcType	getJdbcType()	Descriptor for the SQL type mapped by this type.
ValueBinder<J>	getJdbcValueBinder()	The strategy for binding values of this expressible type to JDBC PreparedStatements and CallableStatements.
ValueExtractor<J>	getJdbcValueExtractor()	The strategy for extracting values of this expressible type from JDBC ResultSets, CallableStatements, etc
JavaType<J>	getMappedJavaType()	The descriptor descriptor for the mapped Java type
String	getName()	Returns the abbreviated name of the type.
String[]	getRegistrationKeys()	Get the names under which this type should be registered in the type registry.
Class<J>	getReturnedClass()	The class handled by this type.
int[]	getSqlTypeCodes(MappingContext mappingContext)	Return the JDBC types codes as defined by Types or SqlTypes for the columns mapped by this type.
UserType<J>	getUserType()
BasicValueConverter<J,Object>	getValueConverter()	Returns the converter that this basic type uses for transforming from the domain type, to the relational type, or null if there is no conversion.
int	hashCode()
boolean	isDirty(Object old, Object current, boolean[] checkable, SharedSessionContractImplementor session)	Should the parent be considered dirty, given both the old and current value?
boolean	isEqual(Object x, Object y)	Compare two instances of the class mapped by this type for persistence "equality", that is, equality of persistent state.
boolean	isMutable()	Are objects of this type mutable with respect to the referencing object? Entities and collections are considered immutable because they manage their own internal state.
void	nullSafeSet(CallableStatement statement, J value, String name, SharedSessionContractImplementor session)	Bind a value to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter.
void	nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SharedSessionContractImplementor session)	Bind a value represented by an instance of the mapped class to the given JDBC PreparedStatement, ignoring some columns as dictated by the settable parameter.
void	nullSafeSet(PreparedStatement st, Object value, int index, SharedSessionContractImplementor session)	Bind a value represented by an instance of the mapped class to the given JDBC PreparedStatement, ignoring some columns as dictated by the settable parameter.
Object	replace(Object original, Object target, SharedSessionContractImplementor session, Object owner, Map<Object,Object> copyCache)	During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging.
boolean[]	toColumnNullness(Object value, MappingContext mapping)	Given an instance of the type, return an array of boolean values indicating which mapped columns would be null.
String	toLoggableString(Object value, SessionFactoryImplementor factory)	Generate a representation of the given value for logging purposes.

Methods inherited from class org.hibernate.type.AbstractType

beforeAssemble, compare, getHashCode, isAnyType, isAssociationType, isCollectionType, isComponentType, isDirty, isEntityType, isEqual, isModified, isSame, replace

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.hibernate.metamodel.model.domain.BasicDomainType

areEqual, getPersistenceType

Methods inherited from interface org.hibernate.type.BasicType

compare, forEachDisassembledJdbcValue, forEachJdbcType, forEachJdbcType, getCheckCondition, getJdbcMapping, getJdbcMapping, getJdbcTypeCount, getMappedType, getSingleJdbcMapping

Methods inherited from interface org.hibernate.metamodel.mapping.Bindable

forEachDisassembledJdbcValue, forEachDisassembledJdbcValue, forEachDisassembledJdbcValue, forEachJdbcValue, forEachJdbcValue, forEachJdbcValue, forEachJdbcValue

Methods inherited from interface org.hibernate.metamodel.model.domain.DomainType

getSqmType, getTupleLength

Methods inherited from interface org.hibernate.metamodel.mapping.JdbcMapping

convertToDomainValue, convertToRelationalValue, getCastType

Methods inherited from interface org.hibernate.metamodel.model.domain.SimpleDomainType

getBindableJavaType

Methods inherited from interface org.hibernate.query.sqm.SqmExpressible

getRelationalJavaType, getTypeName, isInstance, resolveExpressible

Methods inherited from interface org.hibernate.type.Type

beforeAssemble, compare, getColumnSpan, getHashCode, getReturnedClassName, getSqlTypeCodes, getTypeForEqualsHashCode, isAnyType, isAssociationType, isCollectionType, isComponentType, isDirty, isEntityType, isEqual, isModified, isSame, replace, toColumnNullness

Methods inherited from interface org.hibernate.metamodel.mapping.ValueMapping

treatAs

Constructor Details

CustomType

public CustomType(UserType<J> userType,
 TypeConfiguration typeConfiguration)
           throws MappingException

Throws:

MappingException

CustomType

public CustomType(UserType<J> userType,
 String[] registrationKeys,
 TypeConfiguration typeConfiguration)
           throws MappingException

Throws:

MappingException

Method Details

getUserType

public UserType<J> getUserType()

getJdbcValueExtractor

public ValueExtractor<J> getJdbcValueExtractor()

Description copied from interface: JdbcMapping

The strategy for extracting values of this expressible type from JDBC ResultSets, CallableStatements, etc

Specified by:

getJdbcValueExtractor in interface BasicType<J>

Specified by:

getJdbcValueExtractor in interface JdbcMapping

getJdbcValueBinder

public ValueBinder<J> getJdbcValueBinder()

Description copied from interface: JdbcMapping

The strategy for binding values of this expressible type to JDBC PreparedStatements and CallableStatements.

Specified by:

getJdbcValueBinder in interface BasicType<J>

Specified by:

getJdbcValueBinder in interface JdbcMapping

getJdbcLiteralFormatter

public JdbcLiteralFormatter<J> getJdbcLiteralFormatter()

Description copied from interface: JdbcMapping

The strategy for formatting values of this expressible type to a SQL literal.

Specified by:

getJdbcLiteralFormatter in interface BasicType<J>

Specified by:

getJdbcLiteralFormatter in interface JdbcMapping

getJdbcType

public JdbcType getJdbcType()

Description copied from interface: OutputableType

Descriptor for the SQL type mapped by this type.

Specified by:

getJdbcType in interface JdbcMapping

Specified by:

getJdbcType in interface OutputableType<J>

getSqlTypeCodes

public int[] getSqlTypeCodes(MappingContext mappingContext)

Description copied from interface: Type

Return the JDBC types codes as defined by Types or SqlTypes for the columns mapped by this type.

The number of elements in this array must match the return from Type.getColumnSpan(org.hibernate.engine.spi.Mapping).

Specified by:

getSqlTypeCodes in interface Type

Parameters:

mappingContext - The mapping context MappingContext :/

Returns:

The JDBC type codes.

getRegistrationKeys

public String[] getRegistrationKeys()

Description copied from interface: BasicType

Get the names under which this type should be registered in the type registry.

Specified by:

getRegistrationKeys in interface BasicType<J>

Returns:

The keys under which to register this type.

getColumnSpan

public int getColumnSpan(MappingContext session)

Description copied from interface: Type

How many columns are used to persist this type?

Always the same as getSqlTypCodes(mappingContext).length.

Specified by:

getColumnSpan in interface Type

Parameters:

session - The mapping Context object MappingContext

Returns:

The number of columns

getReturnedClass

public Class<J> getReturnedClass()

Description copied from interface: Type

The class handled by this type.

Specified by:

getReturnedClass in interface Type

Returns:

The Java class handled by this type.

isEqual

public boolean isEqual(Object x,
 Object y)
                throws HibernateException

Description copied from interface: Type

Compare two instances of the class mapped by this type for persistence "equality", that is, equality of persistent state. For most types this could simply delegate to equals().

This should always equate to some form of comparison of the value's internal state. As an example, for Java's Date class, the comparison should be of its internal state, but based only on the specific part which is persistent (the timestamp, date, or time).

Specified by:

isEqual in interface Type

Overrides:

isEqual in class AbstractType

Parameters:

x - The first value

y - The second value

Returns:

True if there are considered equal (see discussion above).

Throws:

HibernateException - A problem occurred performing the comparison

getHashCode

public int getHashCode(Object x)

Description copied from interface: Type

Get a hash code, consistent with persistence "equality". For most types this could simply delegate to the given value's hashCode.

Specified by:

getHashCode in interface Type

Overrides:

getHashCode in class AbstractType

Parameters:

x - The value for which to retrieve a hash code

Returns:

The hash code

assemble

public Object assemble(Serializable cached,
 SharedSessionContractImplementor session,
 Object owner)

Description copied from interface: Type

Reconstruct the object from its disassembled state. This function is the inverse of Type.disassemble(Object, SharedSessionContractImplementor, Object).

Specified by:

assemble in interface Type

Overrides:

assemble in class AbstractType

Parameters:

cached - the disassembled state from the cache

session - the originating session

owner - the parent entity object

Returns:

the (re)assembled object

disassemble

public Serializable disassemble(Object value,
 SharedSessionContractImplementor session,
 Object owner)

Description copied from interface: Type

Return a disassembled representation of the object. This is the representation that is stored in the second-level cache.

A reference to an associated entity should be disassembled to its primary key value.

Specified by:

disassemble in interface Type

Overrides:

disassemble in class AbstractType

Parameters:

value - the value to cache

session - the originating session

owner - optional parent entity object (needed for collections)

Returns:

the disassembled, deep cloned state

disassemble

public Serializable disassemble(Object value,
 SessionFactoryImplementor sessionFactory)
                         throws HibernateException

Description copied from interface: Type

Return a disassembled representation of the object. This is the representation that is stored in the second-level cache.

A reference to an associated entity should be disassembled to its primary key value.

A high-quality implementation of this method should ensure that:

 Objects.equals(disassemble(x,s), disassemble(y,s)) == isEqual(x,y,sf)
 

and that:

 Objects.equals(x, assemble(disassemble(x,s),s,o))
 

That is, the implementation must be consistent with Type.isEqual(Object, Object, SessionFactoryImplementor) and with Type.assemble(Serializable, SharedSessionContractImplementor, Object).

Specified by:

disassemble in interface Type

Overrides:

disassemble in class AbstractType

Parameters:

value - the value to cache

sessionFactory - the session factory

Returns:

the disassembled, deep cloned state

Throws:

HibernateException - An error from Hibernate

disassemble

public Object disassemble(Object value,
 SharedSessionContractImplementor session)

Description copied from interface: Bindable

Breaks down a value of J into its simple pieces. E.g., an embedded value gets broken down into an array of its attribute state; a basic value converts to itself; etc.

Generally speaking, this is the form in which entity state is kept relative to a Session via EntityEntry.

 @Entity class Person {
     @Id Integer id;
     @Embedded Name name;
     int age;
 }

 @Embeddable class Name {
     String familiarName;
     String familyName;
 }
 

At the top level, we would want to disassemble a Person value, so we'd ask the Bindable for the Person entity to disassemble. Given a Person value:

 Person( id=1, name=Name( 'Steve', 'Ebersole' ), 28 )
 

this disassemble would result in a multidimensional array:

 [ ["Steve", "Ebersole"], 28 ]
 

Note that the identifier is not part of this disassembled state. Note also how the embedded value results in a sub-array.

Specified by:

disassemble in interface BasicType<J>

Specified by:

disassemble in interface BasicValuedMapping

Specified by:

disassemble in interface Bindable

See Also:

addToCacheKey

public void addToCacheKey(MutableCacheKeyBuilder cacheKey,
 Object value,
 SharedSessionContractImplementor session)

Description copied from interface: Bindable

Add to the MutableCacheKey the values obtained disassembling the value and the hasCode generated from the disassembled value.

Specified by:

addToCacheKey in interface BasicValuedMapping

Specified by:

addToCacheKey in interface Bindable

Specified by:

addToCacheKey in interface JavaTypedExpressible<J>

Parameters:

cacheKey - the MutableCacheKey used to add the disassembled value and the hashCode

value - the value to disassemble

session - the SharedSessionContractImplementor

replace

public Object replace(Object original,
 Object target,
 SharedSessionContractImplementor session,
 Object owner,
 Map<Object,Object> copyCache)
               throws HibernateException

Description copied from interface: Type

During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. For immutable objects, or null values, it is safe to simply return the first parameter. For mutable objects, it is safe to return a copy of the first parameter. For objects with component values, it might make sense to recursively replace component values.

Specified by:

replace in interface Type

Parameters:

original - the value from the detached entity being merged

target - the value in the managed entity

session - The originating session

owner - The owner of the value

copyCache - The cache of already copied/replaced values

Returns:

the value to be merged

Throws:

HibernateException - An error from Hibernate

nullSafeSet

public void nullSafeSet(PreparedStatement st,
 Object value,
 int index,
 boolean[] settable,
 SharedSessionContractImplementor session)
                 throws SQLException

Description copied from interface: Type

Bind a value represented by an instance of the mapped class to the given JDBC PreparedStatement, ignoring some columns as dictated by the settable parameter. Implementors should handle the possibility of null values. A multi-column type should bind parameters starting from index.

Specified by:

nullSafeSet in interface Type

Parameters:

st - The JDBC prepared statement to which to bind

value - the object to write

index - starting parameter bind index

settable - an array indicating which columns to bind/ignore

session - The originating session

Throws:

SQLException - An error from the JDBC driver

nullSafeSet

public void nullSafeSet(PreparedStatement st,
 Object value,
 int index,
 SharedSessionContractImplementor session)
                 throws SQLException

Description copied from interface: Type

Bind a value represented by an instance of the mapped class to the given JDBC PreparedStatement, ignoring some columns as dictated by the settable parameter. Implementors should handle the possibility of null values. A multi-column type should bind parameters starting from index.

Specified by:

nullSafeSet in interface Type

Parameters:

st - The JDBC prepared statement to which to bind

value - the object to write

index - starting parameter bind index

session - The originating session

Throws:

SQLException - An error from the JDBC driver

getName

public String getName()

Description copied from interface: Type

Returns the abbreviated name of the type.

Specified by:

getName in interface Type

Returns:

the Hibernate type name

deepCopy

public Object deepCopy(Object value,
 SessionFactoryImplementor factory)
                throws HibernateException

Description copied from interface: Type

Return a deep copy of the persistent state, stopping at entities and at collections.

Specified by:

deepCopy in interface Type

Parameters:

value - The value to be copied

factory - The session factory

Returns:

The deep copy

Throws:

HibernateException - An error from Hibernate

isMutable

public boolean isMutable()

Description copied from interface: Type

Are objects of this type mutable with respect to the referencing object? Entities and collections are considered immutable because they manage their own internal state.

Specified by:

isMutable in interface Type

Returns:

boolean

toLoggableString

public String toLoggableString(Object value,
 SessionFactoryImplementor factory)

Description copied from interface: Type

Generate a representation of the given value for logging purposes.

Specified by:

toLoggableString in interface Type

Parameters:

value - The value to be logged

factory - The session factory

Returns:

The loggable representation

toColumnNullness

public boolean[] toColumnNullness(Object value,
 MappingContext mapping)

Description copied from interface: Type

Given an instance of the type, return an array of boolean values indicating which mapped columns would be null.

Specified by:

toColumnNullness in interface Type

Parameters:

value - an instance of the type

mapping - The mapping context MappingContext

Returns:

array indicating column nullness for a value instance

isDirty

public boolean isDirty(Object old,
 Object current,
 boolean[] checkable,
 SharedSessionContractImplementor session)
                throws HibernateException

Description copied from interface: Type

Should the parent be considered dirty, given both the old and current value?

Specified by:

isDirty in interface Type

Parameters:

old - the old value

current - the current value

checkable - An array of booleans indicating which columns making up the value are actually checkable

session - The session from which the request originated.

Returns:

true if the field is dirty

Throws:

HibernateException - A problem occurred performing the checking

canDoSetting

public boolean canDoSetting()

Description copied from interface: ProcedureParameterNamedBinder

Can the given instance of this type actually set the parameter value by name

Specified by:

canDoSetting in interface ProcedureParameterNamedBinder<J>

Returns:

true indicates that @{link #nullSafeSet} calls will not fail

nullSafeSet

public void nullSafeSet(CallableStatement statement,
 J value,
 String name,
 SharedSessionContractImplementor session)
                 throws SQLException

Description copied from interface: ProcedureParameterNamedBinder

Bind a value to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter. Implementors should handle the possibility of null values. Does not support multi-column type

Specified by:

nullSafeSet in interface ProcedureParameterNamedBinder<J>

Parameters:

statement - The CallableStatement to which to bind

value - the object to write

name - parameter bind name

session - The originating session

Throws:

SQLException - An error from the JDBC driver

canDoExtraction

public boolean canDoExtraction()

Description copied from interface: OutputableType

Can the given instance of this type actually perform the parameter value extractions?

Specified by:

canDoExtraction in interface OutputableType<J>

Returns:

true indicates that OutputableType.extract(java.sql.CallableStatement, int, org.hibernate.engine.spi.SharedSessionContractImplementor) calls will not fail due to IllegalStateException.

extract

public J extract(CallableStatement statement,
 int startIndex,
 SharedSessionContractImplementor session)
          throws SQLException

Description copied from interface: OutputableType

Perform the extraction

Specified by:

extract in interface OutputableType<J>

Parameters:

statement - The CallableStatement from which to extract the parameter value(s).

startIndex - The parameter index from which to extract

session - The originating session

Returns:

The extracted value.

Throws:

SQLException - Indicates an issue calling into the CallableStatement

extract

public J extract(CallableStatement statement,
 String paramName,
 SharedSessionContractImplementor session)
          throws SQLException

Description copied from interface: OutputableType

Perform the extraction

Specified by:

extract in interface OutputableType<J>

Parameters:

statement - The CallableStatement from which to extract the parameter value(s).

paramName - The parameter names.

session - The originating session

Returns:

The extracted value.

Throws:

SQLException - Indicates an issue calling into the CallableStatement

hashCode

public int hashCode()

Overrides:

hashCode in class Object

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

getJavaType

public Class<J> getJavaType()

Specified by:

getJavaType in interface Type<J>

getMappedJavaType

public JavaType<J> getMappedJavaType()

Description copied from interface: MappingType

The descriptor descriptor for the mapped Java type

Specified by:

getMappedJavaType in interface BasicType<J>

Specified by:

getMappedJavaType in interface JdbcMapping

Specified by:

getMappedJavaType in interface MappingType

getExpressibleJavaType

public JavaType<J> getExpressibleJavaType()

Description copied from interface: SqmExpressible

The Java type descriptor for this expressible

Specified by:

getExpressibleJavaType in interface BasicType<J>

Specified by:

getExpressibleJavaType in interface JavaTypedExpressible<J>

Specified by:

getExpressibleJavaType in interface SqmExpressible<J>

Specified by:

getExpressibleJavaType in interface ValueMapping

getJavaTypeDescriptor

public JavaType<J> getJavaTypeDescriptor()

Description copied from interface: JdbcMapping

The descriptor for the Java type represented by this expressible type

Specified by:

getJavaTypeDescriptor in interface BasicType<J>

Specified by:

getJavaTypeDescriptor in interface JdbcMapping

getJdbcJavaType

public JavaType<?> getJdbcJavaType()

Specified by:

getJdbcJavaType in interface JdbcMapping

getValueConverter

public BasicValueConverter<J,Object> getValueConverter()

Description copied from interface: JdbcMapping

Returns the converter that this basic type uses for transforming from the domain type, to the relational type, or null if there is no conversion.

Specified by:

getValueConverter in interface BasicType<J>

Specified by:

getValueConverter in interface ConvertedBasicType<J>

Specified by:

getValueConverter in interface JdbcMapping