Movatterモバイル変換

Class CollectionType

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

All Implemented Interfaces:
Serializable,AssociationType,Type
Direct Known Subclasses:
ArrayType,BagType,CustomCollectionType,IdentifierBagType,ListType,MapType,SetType
```
public abstract classCollectionTypeextendsAbstractTypeimplementsAssociationType
```
A type that handles HibernatePersistentCollections (including arrays).
See Also:
Serialized Form

Field Summary
Fields
Modifier and Type Field Description
staticObject UNFETCHED_COLLECTION
- Fields inherited from class org.hibernate.type.AbstractType
  LEGACY_DEFAULT_SIZE,LEGACY_DICTATED_SIZE

Fields
Modifier and Type	Field	Description
`staticObject`	`UNFETCHED_COLLECTION`

Constructor Summary
Constructors
Constructor Description
CollectionType(String role,String foreignKeyPropertyName)

Constructors
Constructor	Description
`CollectionType(String role,String foreignKeyPropertyName)`

Method Summary

All Methods Instance Methods Abstract 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.
`int`	`compare(Object x,Object y)`	Perform a`Comparator`-style comparison of the given values.
`int`	`compare(Object x,Object y,SessionFactoryImplementor sessionFactory)`
`boolean`	`contains(Object collection,Object childObject,SharedSessionContractImplementor session)`
`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.
`Serializable`	`disassemble(Object value,SharedSessionContractImplementor session,Object owner)`	Return a disassembled representation of the object.
`String`	`getAssociatedEntityName(SessionFactoryImplementor factory)`	Get the entity name of the associated entity
`Joinable`	`getAssociatedJoinable(SessionFactoryImplementor factory)`	Get the "persister" for this association - a class or collection persister
`Object`	`getCollection(Object key,SharedSessionContractImplementor session,Object owner,Boolean overridingEager)`	instantiate a collection wrapper (called when loading an object)
`abstractCollectionClassification`	`getCollectionClassification()`
`int`	`getColumnSpan(Mapping session)`	How many columns are used to persist this type?
`Iterator<?>`	`getElementsIterator(Object collection)`	Get an iterator over the element set of the collection, which may not yet be wrapped
`Iterator<?>`	`getElementsIterator(Object collection,SharedSessionContractImplementor session)`	Deprecated. use`getElementsIterator(Object)`
`Type`	`getElementType(SessionFactoryImplementor factory)`	Get the Hibernate type of the collection elements
`ForeignKeyDirection`	`getForeignKeyDirection()`	Get the foreign key directionality of this association
`int`	`getHashCode(Object x)`	Get a hash code, consistent with persistence "equality".
`Object`	`getIdOfOwnerOrNull(Object key,SharedSessionContractImplementor session)`	Get the id value from the owning entity key, usually the same as the key, but might be some other property, in the case of property-ref
`@NullableObject`	`getKeyOfOwner(Object owner,SharedSessionContractImplementor session)`	Get the key value from the owning entity instance, usually the identifier, but might be some other unique key, in the case of property-ref
`String`	`getLHSPropertyName()`	Get the name of a property in the owning entity that provides the join key (null if the identifier)
`String`	`getName()`	Returns the abbreviated name of the type.
`String`	`getRHSUniqueKeyPropertyName()`	The name of a unique property of the associated entity that provides the join key (null if the identifier of an entity, or key of a collection)
`String`	`getRole()`
`int[]`	`getSqlTypeCodes(Mapping session)`	Return the JDBC types codes as defined by`Types` or`SqlTypes` for the columns mapped by this type.
`boolean`	`hasHolder()`
`Object`	`indexOf(Object collection,Object element)`
`protected boolean`	`initializeImmediately()`
`abstractObject`	`instantiate(int anticipatedSize)`	Instantiate an empty instance of the "underlying" collection (not a wrapper), but with the given anticipated size (i.e.
`abstractPersistentCollection<?>`	`instantiate(SharedSessionContractImplementor session,CollectionPersister persister,Object key)`	Instantiate an uninitialized collection wrapper or holder.
`protectedObject`	`instantiateResult(Object original)`	Instantiate a new "underlying" collection exhibiting the same capacity characteristics and the passed "original".
`boolean`	`isAlwaysDirtyChecked()`	We always need to dirty check the collection because we sometimes need to increment version number of owner and also because of how assemble/disassemble is implemented for uks
`boolean`	`isArrayType()`
`boolean`	`isAssociationType()`	Note: return true because this type is castable to`AssociationType`.
`boolean`	`isCollectionType()`	Return true if the implementation is castable to`CollectionType`.
`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`	`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`	`isInverse(SessionFactoryImplementor factory)`
`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`	`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(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.
`protectedString`	`renderLoggableString(Object value,SessionFactoryImplementor factory)`
`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`	`replaceElements(Object original,Object target,Object owner,Map<Object,Object> copyCache,SharedSessionContractImplementor session)`	Replace the elements of a collection with the elements of another collection.
`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.
`String`	`toString()`
`boolean`	`useLHSPrimaryKey()`	Is the primary key of the owning entity table to be used in the join?
`abstractPersistentCollection<?>`	`wrap(SharedSessionContractImplementor session,Object collection)`	Wrap the naked collection instance in a wrapper, or instantiate a holder.

Methods inherited from class org.hibernate.type.AbstractType
beforeAssemble,getHashCode,isAnyType,isComponentType,isEntityType,isEqual,isSame,replace

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

Methods inherited from interface org.hibernate.type.Type
beforeAssemble,getHashCode,getReturnedClass,getReturnedClassName,getTypeForEqualsHashCode,isAnyType,isComponentType,isEntityType,isEqual,isSame,replace

- Field Detail
  - UNFETCHED_COLLECTION
```
@Internalpublic static final Object UNFETCHED_COLLECTION
```
- Constructor Detail
  - CollectionType
```
public CollectionType(String role,String foreignKeyPropertyName)
```
- Method Detail
  - getCollectionClassification
```
public abstract CollectionClassification getCollectionClassification()
```
  - getRole
```
public String getRole()
```
  - indexOf
```
public Object indexOf(Object collection,Object element)
```
  - contains
```
public boolean contains(Object collection,Object childObject,SharedSessionContractImplementor session)
```
  - 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
    Overrides:
    isCollectionType in class AbstractType
    Returns:
    True if this type is also aCollectionType implementor; false otherwise.
  - isEqual
```
public final 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
    Overrides:
    isEqual in class AbstractType
    Parameters:
    x - The first value
    y - The second value
    Returns:
    True if there are considered equal (see discussion above).
  - 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
    Overrides:
    compare in class AbstractType
    Parameters:
    x - The first value
    y - The second value
    Returns:
    The comparison result.
    See Also:
    Comparator.compare(Object, Object)
  - compare
```
public int compare(Object x,Object y,SessionFactoryImplementor sessionFactory)
```
    Specified by:
    compare in interface Type
  - 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
  - instantiate
```
public abstract PersistentCollection<?> instantiate(SharedSessionContractImplementor session,CollectionPersister persister,Object key)
```
    Instantiate an uninitialized collection wrapper or holder. Callers MUST add the holder to the persistence context!
    Parameters:
    session - The session from which the request is originating.
    persister - The underlying collection persister (metadata)
    key - The owner key.
    Returns:
    The instantiated collection.
  - 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(PreparedStatement st,Object value,                        int index,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
    session - The originating session
    Throws:
    HibernateException - An error from Hibernate
    SQLException - An error from the JDBC driver
  - getSqlTypeCodes
```
public int[] getSqlTypeCodes(Mapping session)                      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:
    session - The mapping object :/
    Returns:
    The JDBC type codes.
    Throws:
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - getColumnSpan
```
public int getColumnSpan(Mapping session)                  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:
    session - The mapping object :/
    Returns:
    The number of columns
    Throws:
    MappingException - Generally indicates an issue accessing the passed mapping object.
  - 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
  - renderLoggableString
```
protected String renderLoggableString(Object value,SessionFactoryImplementor factory)
```
  - deepCopy
```
public 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
  - 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
  - getElementsIterator
```
@Deprecatedpublic Iterator<?> getElementsIterator(Object collection,SharedSessionContractImplementor session)
```
    Deprecated.
    usegetElementsIterator(Object)
    Get an iterator over the element set of the collection, which may not yet be wrapped
    Parameters:
    collection - The collection to be iterated
    session - The session from which the request is originating.
    Returns:
    The iterator.
  - getElementsIterator
```
public Iterator<?> getElementsIterator(Object collection)
```
    Get an iterator over the element set of the collection, which may not yet be wrapped
    Parameters:
    collection - The collection to be iterated
    Returns:
    The element iterator
  - 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
  - isInverse
```
@Internal@Incubatingpublic boolean isInverse(SessionFactoryImplementor factory)
```
  - 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
    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
    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
    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
  - 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
    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
    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
    Overrides:
    isDirty in class AbstractType
    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
  - 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
  - wrap
```
public abstract PersistentCollection<?> wrap(SharedSessionContractImplementor session,Object collection)
```
    Wrap the naked collection instance in a wrapper, or instantiate a holder. CallersMUST add the holder to the persistence context!
    Parameters:
    session - The session from which the request is originating.
    collection - The bare collection to be wrapped.
    Returns:
    The wrapped collection.
  - isAssociationType
```
public boolean isAssociationType()
```
    Note: return true because this type is castable toAssociationType. Not because all collections are associations.
    Specified by:
    isAssociationType in interface Type
    Overrides:
    isAssociationType in class AbstractType
    Returns:
    True if this type is also anAssociationType implementor; false otherwise.
  - getForeignKeyDirection
```
public ForeignKeyDirection getForeignKeyDirection()
```
    Description copied from interface: AssociationType
    Get the foreign key directionality of this association
    Specified by:
    getForeignKeyDirection in interface AssociationType
  - getKeyOfOwner
```
public @NullableObject getKeyOfOwner(Object owner,SharedSessionContractImplementor session)
```
    Get the key value from the owning entity instance, usually the identifier, but might be some other unique key, in the case of property-ref
    Parameters:
    owner - The collection owner
    session - The session from which the request is originating.
    Returns:
    The collection owner's key
  - getIdOfOwnerOrNull
```
public Object getIdOfOwnerOrNull(Object key,SharedSessionContractImplementor session)
```
    Get the id value from the owning entity key, usually the same as the key, but might be some other property, in the case of property-ref
    Parameters:
    key - The collection owner key
    session - The session from which the request is originating.
    Returns:
    The collection owner's id, if it can be obtained from the key; otherwise, null is returned
  - isArrayType
```
public boolean isArrayType()
```
  - useLHSPrimaryKey
```
public boolean useLHSPrimaryKey()
```
    Description copied from interface: AssociationType
    Is the primary key of the owning entity table to be used in the join?
    Specified by:
    useLHSPrimaryKey in interface AssociationType
  - getRHSUniqueKeyPropertyName
```
public String getRHSUniqueKeyPropertyName()
```
    Description copied from interface: AssociationType
    The name of a unique property of the associated entity that provides the join key (null if the identifier of an entity, or key of a collection)
    Specified by:
    getRHSUniqueKeyPropertyName in interface AssociationType
  - getAssociatedJoinable
```
public Joinable getAssociatedJoinable(SessionFactoryImplementor factory)                               throwsMappingException
```
    Description copied from interface: AssociationType
    Get the "persister" for this association - a class or collection persister
    Specified by:
    getAssociatedJoinable in interface AssociationType
    Throws:
    MappingException
  - isModified
```
public boolean isModified(Object old,Object current,                          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
    Overrides:
    isModified in class AbstractType
    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
  - getAssociatedEntityName
```
public String getAssociatedEntityName(SessionFactoryImplementor factory)                               throwsMappingException
```
    Description copied from interface: AssociationType
    Get the entity name of the associated entity
    Specified by:
    getAssociatedEntityName in interface AssociationType
    Throws:
    MappingException
  - replaceElements
```
public Object replaceElements(Object original,Object target,Object owner,Map<Object,Object> copyCache,SharedSessionContractImplementor session)
```
    Replace the elements of a collection with the elements of another collection.
    Parameters:
    original - The 'source' of the replacement elements (where we copy from)
    target - The target of the replacement elements (where we copy to)
    owner - The owner of the collection being merged
    copyCache - The map of elements already replaced.
    session - The session from which the merge event originated.
    Returns:
    The merged collection.
  - instantiateResult
```
protected Object instantiateResult(Object original)
```
    Instantiate a new "underlying" collection exhibiting the same capacity characteristics and the passed "original".
    Parameters:
    original - The original collection.
    Returns:
    The newly instantiated collection.
  - instantiate
```
public abstract Object instantiate(int anticipatedSize)
```
    Instantiate an empty instance of the "underlying" collection (not a wrapper), but with the given anticipated size (i.e. accounting for initial capacity and perhaps load factor).
    Parameters:
    anticipatedSize - The anticipated size of the instantiated collection after we are done populating it.
    Returns:
    A newly instantiated collection to be wrapped.
  - 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
  - getElementType
```
public final Type getElementType(SessionFactoryImplementor factory)                          throwsMappingException
```
    Get the Hibernate type of the collection elements
    Parameters:
    factory - The session factory.
    Returns:
    The type of the collection elements
    Throws:
    MappingException - Indicates the underlying persister could not be located.
  - toString
```
public String toString()
```
    Overrides:
    toString in class Object
  - getCollection
```
public Object getCollection(Object key,SharedSessionContractImplementor session,Object owner,Boolean overridingEager)
```
    instantiate a collection wrapper (called when loading an object)
    Parameters:
    key - The collection owner key
    session - The session from which the request is originating.
    owner - The collection owner
    Returns:
    The collection
  - hasHolder
```
public boolean hasHolder()
```
  - initializeImmediately
```
protected boolean initializeImmediately()
```
  - getLHSPropertyName
```
public String getLHSPropertyName()
```
    Description copied from interface: AssociationType
    Get the name of a property in the owning entity that provides the join key (null if the identifier)
    Specified by:
    getLHSPropertyName in interface AssociationType
  - isAlwaysDirtyChecked
```
public boolean isAlwaysDirtyChecked()
```
    We always need to dirty check the collection because we sometimes need to increment version number of owner and also because of how assemble/disassemble is implemented for uks
    Specified by:
    isAlwaysDirtyChecked in interface AssociationType
  - 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

Movatterモバイル変換

Class CollectionType

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.type.Type

Field Detail

UNFETCHED_COLLECTION

Constructor Detail

CollectionType

Method Detail

getCollectionClassification

getRole

indexOf

contains

isCollectionType

isEqual

compare

compare

getHashCode

instantiate

nullSafeSet

nullSafeSet

getSqlTypeCodes

getColumnSpan

toLoggableString

renderLoggableString

deepCopy

getName

getElementsIterator

getElementsIterator

isMutable

isInverse

disassemble

disassemble

assemble

isDirty

isDirty

wrap

isAssociationType

getForeignKeyDirection

getKeyOfOwner

getIdOfOwnerOrNull

isArrayType

useLHSPrimaryKey

getRHSUniqueKeyPropertyName

getAssociatedJoinable

isModified

getAssociatedEntityName

replaceElements

instantiateResult

instantiate

replace

getElementType

toString

getCollection

hasHolder

initializeImmediately

getLHSPropertyName

isAlwaysDirtyChecked

toColumnNullness