Movatterモバイル変換

Class AbstractType

java.lang.Object
- org.hibernate.type.AbstractType

All Implemented Interfaces:
Serializable,Type
Direct Known Subclasses:
AnyType,CollectionType,ComponentType,CustomType,DiscriminatorType,EntityType,MetaType
```
public abstract classAbstractTypeextendsObjectimplementsType
```
Abstract superclass of the built-inType hierarchy.
See Also:
Serialized Form

Field Summary

Fields
Modifier and Type	Field	Description
`protected staticSize`	`LEGACY_DEFAULT_SIZE`	Deprecated, for removal: This API element is subject to removal in a future version.
`protected staticSize`	`LEGACY_DICTATED_SIZE`	Deprecated, for removal: This API element is subject to removal in a future version.

Constructor Summary
Constructors
Constructor Description
AbstractType()

Constructors
Constructor	Description
`AbstractType()`

Method Summary

All Methods Instance Methods Concrete 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.
`int`	`compare(Object x,Object y)`	Perform a`Comparator`-style comparison of the given values.
`Serializable`	`disassemble(Object value,SessionFactoryImplementor sessionFactory)`	Return a disassembled representation of the object.
`Serializable`	`disassemble(Object value,SharedSessionContractImplementor session,Object owner)`	Return a disassembled representation of the object.
`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".
`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`.
`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 x,Object y)`	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 old,Object current, 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`	`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.
`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.

Methods inherited from class java.lang.Object
clone,equals,finalize,getClass,hashCode,notify,notifyAll,toString,wait,wait,wait

Methods inherited from interface org.hibernate.type.Type
compare,deepCopy,getColumnSpan,getName,getReturnedClass,getReturnedClassName,getSqlTypeCodes,getTypeForEqualsHashCode,isDirty,isMutable,nullSafeSet,nullSafeSet,replace,toColumnNullness,toLoggableString

- Field Detail
  - LEGACY_DICTATED_SIZE
```
@Deprecated(forRemoval=true)protected static final Size LEGACY_DICTATED_SIZE
```
    Deprecated, for removal: This API element is subject to removal in a future version.
  - LEGACY_DEFAULT_SIZE
```
@Deprecated(forRemoval=true)protected static final Size LEGACY_DEFAULT_SIZE
```
    Deprecated, for removal: This API element is subject to removal in a future version.
- Constructor Detail
  - AbstractType
```
public AbstractType()
```
- Method Detail
  - isAssociationType
```
public 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 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 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 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.
  - compare
```
public 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)
  - disassemble
```
public 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
  - 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
    Parameters:
    value - the value to cache
    sessionFactory - the session factory
    Returns:
    the disassembled, deep cloned state
    Throws:
    HibernateException - An error from Hibernate
  - assemble
```
public 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
  - isDirty
```
public boolean isDirty(Object old,Object current,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
    session - The session from which the request originated.
    Returns:
    true if the field is dirty
    Throws:
    HibernateException - A problem occurred performing the checking
  - isAnyType
```
public 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.
  - isModified
```
public boolean isModified(Object old,Object current,                          boolean[] checkable,SharedSessionContractImplementor session)                   throwsHibernateException
```
    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:
    old - the database state, in a "hydrated" form, with identifiers unresolved
    current - 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
    Throws:
    HibernateException - A problem occurred performing the checking
  - isSame
```
public boolean isSame(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, 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).
    Throws:
    HibernateException - A problem occurred performing the comparison
  - isEqual
```
public boolean isEqual(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. 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:
    x - The first value
    y - The second value
    Returns:
    True if there are considered equal (see discussion above).
  - 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
    Parameters:
    x - The value for which to retrieve a hash code
    Returns:
    The hash code
  - isEqual
```
public 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).
  - getHashCode
```
public 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
  - replace
```
public Object replace(Object original,Object target,SharedSessionContractImplementor session,Object owner,Map<Object,Object> copyCache,ForeignKeyDirection foreignKeyDirection)               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
    foreignKeyDirection - For associations, which direction does the foreign key point?
    Returns:
    the value to be merged
    Throws:
    HibernateException - An error from Hibernate
  - beforeAssemble
```
public 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

Movatterモバイル変換

Class AbstractType

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.hibernate.type.Type

Field Detail

LEGACY_DICTATED_SIZE

LEGACY_DEFAULT_SIZE

Constructor Detail

AbstractType

Method Detail

isAssociationType

isCollectionType

isComponentType

isEntityType

compare

disassemble

disassemble

assemble

isDirty

isAnyType

isModified

isSame

isEqual

getHashCode

isEqual

getHashCode

replace

beforeAssemble