Movatterモバイル変換

Class SerializableToBlobType<T extendsSerializable>

java.lang.Object
- org.hibernate.type.SerializableToBlobType<T>

All Implemented Interfaces:
BasicType<T>,Type<T>,Serializable,BasicValuedMapping,Bindable,JdbcMapping,JdbcMappingContainer,MappingModelExpressible,MappingType,SqlExpressible,ValueMapping,BasicDomainType<T>,DomainType<T>,SimpleDomainType<T>,BindableType<T>,OutputableType<T>,ReturnableType<T>,SqmExpressible<T>,BasicType<T>,JavaTypedExpressible,ProcedureParameterExtractionAware<T>,ProcedureParameterNamedBinder<T>,Type,DynamicParameterizedType,ParameterizedType
```
public classSerializableToBlobType<T extendsSerializable>extendsObjectimplementsBasicType<T>,ProcedureParameterExtractionAware<T>,ProcedureParameterNamedBinder<T>,DynamicParameterizedType
```
See Also:
Serialized Form

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 org.hibernate.usertype.DynamicParameterizedType
  DynamicParameterizedType.ParameterType
- Nested classes/interfaces inherited from interface jakarta.persistence.metamodel.Type
  Type.PersistenceType

Field Summary
Fields
Modifier and Type Field Description
staticString CLASS_NAME
- Fields inherited from interface org.hibernate.usertype.DynamicParameterizedType
  ACCESS_TYPE,ENTITY,IS_DYNAMIC,IS_PRIMARY_KEY,PARAMETER_TYPE,PROPERTY,RETURNED_CLASS,XPROPERTY

Fields
Modifier and Type	Field	Description
`staticString`	`CLASS_NAME`

Constructor Summary
Constructors
Constructor Description
SerializableToBlobType()

Constructors
Constructor	Description
`SerializableToBlobType()`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`Object`	`assemble(Serializable cached,SharedSessionContractImplementor session,Object owner)`	Reconstruct the object from its disassembled state.
`void`	`beforeAssemble(Serializable cached,SharedSessionContractImplementor session)`	Called before assembling a query result set from the query cache, to allow batch fetching of entities missing from the second-level cache.
`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
`int`	`compare(Object x,Object y)`	Perform a`Comparator`-style comparison of the given values.
`Object`	`deepCopy(Object value,SessionFactoryImplementor factory)`	Return a deep copy of the persistent state, stopping at entities and at collections.
`protectedT`	`deepCopy(T value)`
`Serializable`	`disassemble(Object value,SharedSessionContractImplementor session,Object owner)`	Return a disassembled representation of the object.
`T`	`extract(CallableStatement statement, int startIndex,SharedSessionContractImplementor session)`	Perform the extraction
`T`	`extract(CallableStatement statement,String paramName,SharedSessionContractImplementor session)`	Perform the extraction
`T`	`fromString(CharSequence string)`
`int`	`getColumnSpan(Mapping mapping)`	How many columns are used to persist this type?
`protectedSize`	`getDictatedSize()`
`int`	`getHashCode(Object x)`	Get a hash code, consistent with persistence "equality".
`int`	`getHashCode(Object x,SessionFactoryImplementor factory)`	Get a hash code, consistent with persistence "equality".
`Class<T>`	`getJavaType()`
`JavaType<T>`	`getJavaTypeDescriptor()`	The descriptor for the Java type represented by this expressible type
`JdbcLiteralFormatter<T>`	`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<T>`	`getJdbcValueBinder()`	The strategy for binding values of this expressible type to JDBC`PreparedStatement`s and`CallableStatement`s.
`ValueExtractor<T>`	`getJdbcValueExtractor()`	The strategy for extracting values of this expressible type from JDBC ResultSets, CallableStatements, etc
`protectedMutabilityPlan<T>`	`getMutabilityPlan()`
`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<?>`	`getReturnedClass()`	The class handled by this type.
`int[]`	`getSqlTypeCodes(Mapping mapping)`	Return the JDBC types codes as defined by`Types` or`SqlTypes` for the columns mapped by this type.
`boolean`	`isAnyType()`	Return true if the implementation is castable to`AnyType`.
`boolean`	`isAssociationType()`	Return true if the implementation is castable to`AssociationType`.
`boolean`	`isCollectionType()`	Return true if the implementation is castable to`CollectionType`.
`boolean`	`isComponentType()`	Return true if the implementation is castable to`CompositeType`.
`protected boolean`	`isDirty(Object old,Object current)`
`boolean`	`isDirty(Object old,Object current, boolean[] checkable,SharedSessionContractImplementor session)`	Should the parent be considered dirty, given both the old and current value?
`boolean`	`isDirty(Object old,Object current,SharedSessionContractImplementor session)`	Should the parent be considered dirty, given both the old and current value?
`boolean`	`isEntityType()`	Return true if the implementation is castable to`EntityType`.
`boolean`	`isEqual(Object one,Object another)`	Compare two instances of the class mapped by this type for persistence "equality", that is, equality of persistent state.
`boolean`	`isEqual(Object x,Object y,SessionFactoryImplementor factory)`	Compare two instances of the class mapped by this type for persistence "equality", that is, equality of persistent state.
`boolean`	`isModified(Object oldHydratedState,Object currentState, boolean[] checkable,SharedSessionContractImplementor session)`	Has the value been modified compared to the current database state? The difference between this and the`Type.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor)` methods is that here we need to account for "partially" built values.
`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.
`boolean`	`isSame(Object x,Object y)`	Compare two instances of the class mapped by this type for persistence "equality", that is, equality of persistent state, taking a shortcut for entity references.
`protected void`	`nullSafeSet(CallableStatement st,Object value,String name,WrapperOptions options)`
`void`	`nullSafeSet(CallableStatement st,T 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.
`protected void`	`nullSafeSet(PreparedStatement st,T value, int index,WrapperOptions options)`
`protected boolean`	`registerUnderJavaType()`
`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.
`Object`	`replace(Object original,Object target,SharedSessionContractImplementor session,Object owner,Map<Object,Object> copyCache,ForeignKeyDirection foreignKeyDirection)`	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.
`void`	`setJavaTypeDescriptor(JavaType<T> javaType)`	Deprecated.
`void`	`setParameterValues(Properties parameters)`	Gets called by Hibernate to pass the configured type parameters to the implementation.
`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 java.lang.Object
clone,equals,finalize,getClass,hashCode,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,disassemble,forEachDisassembledJdbcValue,forEachJdbcType,forEachJdbcType,getCheckCondition,getExpressibleJavaType,getJdbcMapping,getJdbcMapping,getJdbcTypeCount,getMappedJavaType,getMappedType,getSingleJdbcMapping,getValueConverter

Methods inherited from interface org.hibernate.metamodel.mapping.BasicValuedMapping
addToCacheKey

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,getJdbcJavaType

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
disassemble,getReturnedClassName,getTypeForEqualsHashCode

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

- Field Detail
  - CLASS_NAME
```
public static final String CLASS_NAME
```
    See Also:
    Constant Field Values
- Constructor Detail
  - SerializableToBlobType
```
public SerializableToBlobType()
```
- Method Detail
  - setParameterValues
```
public void setParameterValues(Properties parameters)
```
    Description copied from interface: ParameterizedType
    Gets called by Hibernate to pass the configured type parameters to the implementation.
    Specified by:
    setParameterValues in interface ParameterizedType
  - 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
  - getJdbcValueExtractor
```
public ValueExtractor<T> 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<T extendsSerializable>
    Specified by:
    getJdbcValueExtractor in interface JdbcMapping
  - getJdbcValueBinder
```
public ValueBinder<T> getJdbcValueBinder()
```
    Description copied from interface: JdbcMapping
    The strategy for binding values of this expressible type to JDBCPreparedStatements andCallableStatements.
    Specified by:
    getJdbcValueBinder in interface BasicType<T extendsSerializable>
    Specified by:
    getJdbcValueBinder in interface JdbcMapping
  - getJdbcLiteralFormatter
```
public JdbcLiteralFormatter<T> 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<T extendsSerializable>
    Specified by:
    getJdbcLiteralFormatter in interface JdbcMapping
  - getJavaType
```
public Class<T> getJavaType()
```
    Specified by:
    getJavaType in interface Type<T extendsSerializable>
  - fromString
```
public T fromString(CharSequence string)
```
  - getMutabilityPlan
```
protected MutabilityPlan<T> getMutabilityPlan()
```
  - 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
  - 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<T extendsSerializable>
    Returns:
    The keys under which to register this type.
  - registerUnderJavaType
```
protected boolean registerUnderJavaType()
```
  - getDictatedSize
```
protected Size getDictatedSize()
```
  - getJavaTypeDescriptor
```
public final JavaType<T> getJavaTypeDescriptor()
```
    Description copied from interface: JdbcMapping
    The descriptor for the Java type represented by this expressible type
    Specified by:
    getJavaTypeDescriptor in interface BasicType<T extendsSerializable>
    Specified by:
    getJavaTypeDescriptor in interface JdbcMapping
  - setJavaTypeDescriptor
```
@Deprecatedpublic final void setJavaTypeDescriptor(JavaType<T> javaType)
```
    Deprecated.
  - getJdbcType
```
public final 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<T extendsSerializable>
  - getReturnedClass
```
public final Class<?> 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.
  - getColumnSpan
```
public final int getColumnSpan(Mapping mapping)                        throwsMappingException
```
    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:
    mapping - The mapping object :/
    Returns:
    The number of columns
    Throws:
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - getSqlTypeCodes
```
public final int[] getSqlTypeCodes(Mapping mapping)                            throwsMappingException
```
    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:
    mapping - The mapping object :/
    Returns:
    The JDBC type codes.
    Throws:
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - isAssociationType
```
public final boolean isAssociationType()
```
    Description copied from interface: Type
    Return true if the implementation is castable toAssociationType. This does not necessarily imply that the type actually represents an association. Shortcut fortype instanceof AssociationType.
    Specified by:
    isAssociationType in interface Type
    Returns:
    True if this type is also anAssociationType implementor; false otherwise.
  - isCollectionType
```
public final boolean isCollectionType()
```
    Description copied from interface: Type
    Return true if the implementation is castable toCollectionType. Shortcut fortype instanceof CollectionType
    ACollectionType is additionally anAssociationType; so if this method returns true,Type.isAssociationType() should also return true.
    Specified by:
    isCollectionType in interface Type
    Returns:
    True if this type is also aCollectionType implementor; false otherwise.
  - isComponentType
```
public final boolean isComponentType()
```
    Description copied from interface: Type
    Return true if the implementation is castable toCompositeType. Shortcut fortype instanceof CompositeType.
    A component type may own collections or associations and hence must provide certain extra functionality.
    Specified by:
    isComponentType in interface Type
    Returns:
    True if this type is also aCompositeType implementor; false otherwise.
  - isEntityType
```
public final boolean isEntityType()
```
    Description copied from interface: Type
    Return true if the implementation is castable toEntityType. Shortcut fortype instanceof EntityType.
    AnEntityType is additionally anAssociationType; so if this method returns true,Type.isAssociationType() should also return true.
    Specified by:
    isEntityType in interface Type
    Returns:
    True if this type is also anEntityType implementor; false otherwise.
  - isAnyType
```
public final boolean isAnyType()
```
    Description copied from interface: Type
    Return true if the implementation is castable toAnyType. Shortcut fortype instanceof AnyType.
    AnAnyType is additionally anAssociationType; so if this method returns true, thenType.isAssociationType() should also return true.
    Specified by:
    isAnyType in interface Type
    Returns:
    True if this type is also anAnyType implementor; false otherwise.
  - isSame
```
public final boolean isSame(Object x,Object y)
```
    Description copied from interface: Type
    Compare two instances of the class mapped by this type for persistence "equality", that is, equality of persistent state, taking a shortcut for entity references.
    For most types this should boil down to anequality comparison of the given values, and it's reasonable to simply delegate toType.isEqual(Object, Object). But for associations the semantics are a bit different.
    Specified by:
    isSame in interface Type
    Parameters:
    x - The first value
    y - The second value
    Returns:
    True if there are considered the same (see discussion above).
  - isEqual
```
public final boolean isEqual(Object x,Object y,SessionFactoryImplementor factory)
```
    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 toType.isEqual(Object, Object).
    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
    Parameters:
    x - The first value
    y - The second value
    factory - The session factory
    Returns:
    True if there are considered equal (see discussion above).
  - isEqual
```
public boolean isEqual(Object one,Object another)
```
    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
    Parameters:
    one - The first value
    another - The second value
    Returns:
    True if there are considered equal (see discussion above).
  - getHashCode
```
public final 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
    Parameters:
    x - The value for which to retrieve a hash code
    Returns:
    The hash code
  - getHashCode
```
public final int getHashCode(Object x,SessionFactoryImplementor factory)
```
    Description copied from interface: Type
    Get a hash code, consistent with persistence "equality". For most types this could simply delegate toType.getHashCode(Object).
    Specified by:
    getHashCode in interface Type
    Parameters:
    x - The value for which to retrieve a hash code
    factory - The session factory
    Returns:
    The hash code
  - compare
```
public final int compare(Object x,Object y)
```
    Description copied from interface: Type
    Perform aComparator-style comparison of the given values.
    Specified by:
    compare in interface Type
    Parameters:
    x - The first value
    y - The second value
    Returns:
    The comparison result.
    See Also:
    Comparator.compare(Object, Object)
  - isDirty
```
public final boolean isDirty(Object old,Object current,SharedSessionContractImplementor session)
```
    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
    session - The session from which the request originated.
    Returns:
    true if the field is dirty
  - isDirty
```
public final boolean isDirty(Object old,Object current,                             boolean[] checkable,SharedSessionContractImplementor session)
```
    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
  - isDirty
```
protected final boolean isDirty(Object old,Object current)
```
  - isModified
```
public final boolean isModified(Object oldHydratedState,Object currentState,                                boolean[] checkable,SharedSessionContractImplementor session)
```
    Description copied from interface: Type
    Has the value been modified compared to the current database state? The difference between this and theType.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor) methods is that here we need to account for "partially" built values. This is really only an issue with association types. For most type implementations it is enough to simply delegate toType.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.spi.SharedSessionContractImplementor).
    Specified by:
    isModified in interface Type
    Parameters:
    oldHydratedState - the database state, in a "hydrated" form, with identifiers unresolved
    currentState - the current state of the object
    checkable - which columns are actually checkable
    session - The session from which the request originated.
    Returns:
    true if the field has been modified
  - nullSafeSet
```
public final 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
  - nullSafeSet
```
protected void nullSafeSet(PreparedStatement st,T value,                           int index,WrapperOptions options)                    throwsSQLException
```
    Throws:
    SQLException
  - toLoggableString
```
public final 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
  - isMutable
```
public final 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
  - deepCopy
```
public final Object deepCopy(Object value,SessionFactoryImplementor factory)
```
    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
  - deepCopy
```
protected final T deepCopy(T value)
```
  - disassemble
```
public final Serializable disassemble(Object value,SharedSessionContractImplementor session,Object owner)                               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.
    Specified by:
    disassemble in interface Type
    Parameters:
    value - the value to cache
    session - the originating session
    owner - optional parent entity object (needed for collections)
    Returns:
    the disassembled, deep cloned state
    Throws:
    HibernateException - An error from Hibernate
  - assemble
```
public final Object assemble(Serializable cached,SharedSessionContractImplementor session,Object owner)                      throwsHibernateException
```
    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
    Parameters:
    cached - the disassembled state from the cache
    session - the originating session
    owner - the parent entity object
    Returns:
    the (re)assembled object
    Throws:
    HibernateException - An error from Hibernate
  - beforeAssemble
```
public final void beforeAssemble(Serializable cached,SharedSessionContractImplementor session)
```
    Description copied from interface: Type
    Called before assembling a query result set from the query cache, to allow batch fetching of entities missing from the second-level cache.
    Specified by:
    beforeAssemble in interface Type
    Parameters:
    cached - The key
    session - The originating session
  - replace
```
public final Object replace(Object original,Object target,SharedSessionContractImplementor session,Object owner,Map<Object,Object> copyCache)
```
    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
  - replace
```
public Object replace(Object original,Object target,SharedSessionContractImplementor session,Object owner,Map<Object,Object> copyCache,ForeignKeyDirection foreignKeyDirection)
```
    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
    foreignKeyDirection - For associations, which direction does the foreign key point?
    Returns:
    the value to be merged
  - 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<T extendsSerializable>
    Returns:
    true indicates thatOutputableType.extract(java.sql.CallableStatement, int, org.hibernate.engine.spi.SharedSessionContractImplementor) calls will not fail due toIllegalStateException.
  - extract
```
public T extract(CallableStatement statement,                 int startIndex,SharedSessionContractImplementor session)          throwsSQLException
```
    Description copied from interface: OutputableType
    Perform the extraction
    Specified by:
    extract in interface OutputableType<T extendsSerializable>
    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 T extract(CallableStatement statement,String paramName,SharedSessionContractImplementor session)          throwsSQLException
```
    Description copied from interface: OutputableType
    Perform the extraction
    Specified by:
    extract in interface OutputableType<T extendsSerializable>
    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
  - nullSafeSet
```
public final void nullSafeSet(PreparedStatement st,Object value,                              int index,                              boolean[] settable,SharedSessionContractImplementor session)                       throwsHibernateException,SQLException
```
    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:
    HibernateException - An error from Hibernate
    SQLException - An error from the JDBC driver
  - nullSafeSet
```
public void nullSafeSet(CallableStatement st,T 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<T extendsSerializable>
    Parameters:
    st - 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
  - nullSafeSet
```
protected final void nullSafeSet(CallableStatement st,Object value,String name,WrapperOptions options)                          throwsSQLException
```
    Throws:
    SQLException
  - 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<T extendsSerializable>
    Returns:
    true indicates that @{link #nullSafeSet} calls will not fail

Movatterモバイル変換

Class SerializableToBlobType<T extendsSerializable>

Nested Class Summary

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

Nested classes/interfaces inherited from interface org.hibernate.usertype.DynamicParameterizedType

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

Field Summary

Fields inherited from interface org.hibernate.usertype.DynamicParameterizedType

Constructor Summary

Method Summary

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.BasicValuedMapping

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

Field Detail

CLASS_NAME

Constructor Detail

SerializableToBlobType

Method Detail

setParameterValues

getName

getJdbcValueExtractor

getJdbcValueBinder

getJdbcLiteralFormatter

getJavaType

fromString

getMutabilityPlan

toColumnNullness

getRegistrationKeys

registerUnderJavaType

getDictatedSize

getJavaTypeDescriptor

setJavaTypeDescriptor

getJdbcType

getReturnedClass

getColumnSpan

getSqlTypeCodes

isAssociationType

isCollectionType

isComponentType

isEntityType

isAnyType

isSame

isEqual

isEqual

getHashCode

getHashCode

compare

isDirty

isDirty

isDirty

isModified

nullSafeSet

nullSafeSet

toLoggableString

isMutable

deepCopy

deepCopy

disassemble

assemble

beforeAssemble

replace

replace

canDoExtraction

extract

extract

nullSafeSet

nullSafeSet

nullSafeSet

canDoSetting