Movatterモバイル変換

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 classCustomType<J>extendsAbstractTypeimplementsConvertedBasicType<J>,ProcedureParameterNamedBinder<J>,ProcedureParameterExtractionAware<J>
```
AdaptsUserType to the genericType 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

Field Summary
- Fields inherited from class org.hibernate.type.AbstractType
  LEGACY_DEFAULT_SIZE,LEGACY_DICTATED_SIZE

Constructor Summary

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

Method Summary

All Methods Instance Methods Concrete Methods
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(Mapping 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`PreparedStatement`s and`CallableStatement`s.
`ValueExtractor<J>`	`getJdbcValueExtractor()`	The strategy for extracting values of this expressible type from JDBC ResultSets, CallableStatements, etc
`JavaType<J>`	`getMappedJavaType()`	Thedescriptor 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(Mapping pi)`	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,Mapping 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,getHashCode,getReturnedClassName,getTypeForEqualsHashCode,isAnyType,isAssociationType,isCollectionType,isComponentType,isDirty,isEntityType,isEqual,isModified,isSame,replace

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

- Constructor Detail
  - CustomType
```
public CustomType(UserType<J> userType,TypeConfiguration typeConfiguration)           throwsMappingException
```
    Throws:
    MappingException
  - CustomType
```
public CustomType(UserType<J> userType,String[] registrationKeys,TypeConfiguration typeConfiguration)           throwsMappingException
```
    Throws:
    MappingException
- Method Detail
  - 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 JDBCPreparedStatements andCallableStatements.
    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(Mapping pi)
```
    Description copied from interface: Type
    Return the JDBC types codes as defined byTypes orSqlTypes for the columns mapped by this type.
    The number of elements in this array must match the return fromType.getColumnSpan(org.hibernate.engine.spi.Mapping).
    Specified by:
    getSqlTypeCodes in interface Type
    Parameters:
    pi - The mapping object :/
    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(Mapping session)
```
    Description copied from interface: Type
    How many columns are used to persist this type?
    Always the same asgetSqlTypCodes(mapping).length.
    Specified by:
    getColumnSpan in interface Type
    Parameters:
    session - The mapping object :/
    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)                throwsHibernateException
```
    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 toequals().
    This should always equate to some form of comparison of the value's internal state. As an example, for Java'sDate 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'shashCode.
    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 ofType.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)                         throwsHibernateException
```
    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 withType.isEqual(Object, Object, SessionFactoryImplementor) and withType.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 ofJ 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 viaEntityEntry.
    @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 aPerson value, so we'd ask theBindable for thePerson entity to disassemble. Given aPerson 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:
    EntityEntry
  - 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)               throwsHibernateException
```
    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)                 throwsSQLException
```
    Description copied from interface: Type
    Bind a value represented by an instance of themapped class to the given JDBCPreparedStatement, ignoring some columns as dictated by thesettable parameter. Implementors should handle the possibility of null values. A multi-column type should bind parameters starting fromindex.
    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)                 throwsSQLException
```
    Description copied from interface: Type
    Bind a value represented by an instance of themapped class to the given JDBCPreparedStatement, ignoring some columns as dictated by thesettable parameter. Implementors should handle the possibility of null values. A multi-column type should bind parameters starting fromindex.
    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)                throwsHibernateException
```
    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,Mapping mapping)
```
    Description copied from interface: Type
    Given an instance of the type, return an array ofboolean values indicating which mapped columns would be null.
    Specified by:
    toColumnNullness in interface Type
    Parameters:
    value - an instance of the type
    mapping - The mapping abstraction
    Returns:
    array indicating column nullness for a value instance
  - isDirty
```
public boolean isDirty(Object old,Object current,                       boolean[] checkable,SharedSessionContractImplementor session)                throwsHibernateException
```
    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)                 throwsSQLException
```
    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 thatOutputableType.extract(java.sql.CallableStatement, int, org.hibernate.engine.spi.SharedSessionContractImplementor) calls will not fail due toIllegalStateException.
  - extract
```
public J extract(CallableStatement statement,                 int startIndex,SharedSessionContractImplementor session)          throwsSQLException
```
    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)          throwsSQLException
```
    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
    Thedescriptor 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, ornull 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

Movatterモバイル変換

Class CustomType<J>

Nested Class Summary

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

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

Field Summary

Fields inherited from class org.hibernate.type.AbstractType

Constructor Summary

Method Summary

Methods inherited from class org.hibernate.type.AbstractType

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.hibernate.type.BasicType

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

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

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

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

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

Methods inherited from interface org.hibernate.type.Type

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

Constructor Detail

CustomType

CustomType

Method Detail

getUserType

getJdbcValueExtractor

getJdbcValueBinder

getJdbcLiteralFormatter

getJdbcType

getSqlTypeCodes

getRegistrationKeys

getColumnSpan

getReturnedClass

isEqual

getHashCode

assemble

disassemble

disassemble

disassemble

addToCacheKey

replace

nullSafeSet

nullSafeSet

getName

deepCopy

isMutable

toLoggableString

toColumnNullness

isDirty

canDoSetting

nullSafeSet

canDoExtraction

extract

extract

hashCode

equals

getJavaType

getMappedJavaType

getExpressibleJavaType

getJavaTypeDescriptor

getJdbcJavaType

getValueConverter