Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.hibernate.type
Class OneToOneType

    java.lang.Object
      org.hibernate.type.AbstractType
          org.hibernate.type.EntityType
              org.hibernate.type.OneToOneType

All Implemented Interfaces:
  Serializable, AssociationType, Type

Direct Known Subclasses:
  SpecialOneToOneType

    public class OneToOneType

extends EntityType

A one-to-one association to an entity

Author:
  Gavin King
See Also:
  Serialized Form

Field Summary

Fields inherited from class org.hibernate.type.EntityType
`isEmbeddedInXML, uniqueKeyPropertyName`

Constructor Summary
`OneToOneType(String referencedEntityName, ForeignKeyDirection foreignKeyType, String uniqueKeyPropertyName, boolean lazy, boolean unwrapProxy, boolean isEmbeddedInXML, String entityName, String propertyName)`

Method Summary
`Object` | `assemble(Serializable oid, SessionImplementor session, Object owner)` Reconstruct the object from its cached "disassembled" state.
`Serializable` | `disassemble(Object value, SessionImplementor session, Object owner)` Return a cacheable "disassembled" representation of the object.
`int` | `getColumnSpan(Mapping session)` How many columns are used to persist this type.
`ForeignKeyDirection` | `getForeignKeyDirection()` Get the foreign key directionality of this association
`String` | `getPropertyName()`
`Object` | `hydrate(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class, or the identifier of an entity or collection, from a JDBC resultset.
`boolean` | `isAlwaysDirtyChecked()` We don't need to dirty check one-to-one because of how assemble/disassemble is implemented and because a one-to-one association is never dirty
`boolean` | `isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)` Should the parent be considered dirty, given both the old and current field or element value?
`boolean` | `isDirty(Object old, Object current, SessionImplementor session)` Should the parent be considered dirty, given both the old and current field or element value?
`boolean` | `isModified(Object old, Object current, boolean[] checkable, SessionImplementor session)` Has the parent object been modified, compared to the current database state?
`boolean` | `isNull(Object owner, SessionImplementor session)`
`protected boolean` | `isNullable()`
`boolean` | `isOneToOne()`
`void` | `nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Write an instance of the mapped class to a prepared statement, ignoring some columns.
`void` | `nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Write an instance of the mapped class to a prepared statement.
`int[]` | `sqlTypes(Mapping session)` Return the SQL type codes for the columns mapped by this type.
`boolean[]` | `toColumnNullness(Object value, Mapping mapping)` Given an instance of the type, return an array of boolean, indicating which mapped columns would be null.
`boolean` | `useLHSPrimaryKey()` Is the primary key of the owning entity table to be used in the join?

Methods inherited from class org.hibernate.type.EntityType
`compare, deepCopy, fromXMLNode, getAssociatedEntityName, getAssociatedEntityName, getAssociatedJoinable, getHashCode, getIdentifier, getIdentifierOrUniqueKeyPropertyName, getIdentifierOrUniqueKeyType, getLHSPropertyName, getName, getOnCondition, getReturnedClass, getRHSUniqueKeyPropertyName, getSemiResolvedType, isAssociationType, isEmbeddedInXML, isEntityType, isEqual, isMutable, isNotEmbedded, isReferenceToPrimaryKey, isSame, isXMLElement, loadByUniqueKey, nullSafeGet, nullSafeGet, replace, resolve, resolveIdentifier, setToXMLNode, toLoggableString, toString`

Methods inherited from class org.hibernate.type.AbstractType
`beforeAssemble, getHashCode, isAnyType, isCollectionType, isComponentType, isEqual, replace, replaceNode, semiResolve`

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, isAnyType, isCollectionType, isComponentType, isEqual, replace, semiResolve`

Constructor Detail

### OneToOneType

    public OneToOneType(String referencedEntityName,
                        ForeignKeyDirection foreignKeyType,
                        String uniqueKeyPropertyName,
                        boolean lazy,
                        boolean unwrapProxy,
                        boolean isEmbeddedInXML,
                        String entityName,
                        String propertyName)

Method Detail

### getPropertyName

    public String getPropertyName()

  Overrides:
    `getPropertyName` in class `EntityType`

### isNull

    public boolean isNull(Object owner,
                          SessionImplementor session)

  Overrides:
    `isNull` in class `EntityType`

### getColumnSpan

    public int getColumnSpan(Mapping session)
                      throws MappingException

  Description copied from interface: `Type`
  How many columns are used to persist this type.

  Throws:
    `MappingException`

### sqlTypes

    public int[] sqlTypes(Mapping session)
                   throws MappingException

  Description copied from interface: `Type`
  Return the SQL type codes for the columns mapped by this type. The codes are defined on `java.sql.Types`.

  Returns:
    the typecodes
  Throws:
    `MappingException`
  See Also:
    `Types`

### toColumnNullness

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

  Description copied from interface: `Type`
  Given an instance of the type, return an array of boolean, indicating which mapped columns would be null.

  Parameters:
    `value` - an instance of the type

### nullSafeSet

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

  Description copied from interface: `Type`
  Write an instance of the mapped class to a prepared statement, ignoring some columns. Implementors should handle possibility of null values. A multi-column type should be written to parameters starting from `index`.

    `value` - the object to write
    `index` - statement parameter index
    `settable` - an array indicating which columns to ignore

### nullSafeSet

    public void nullSafeSet(PreparedStatement st,
                            Object value,
                            int index,
                            SessionImplementor session)

  Description copied from interface: `Type`
  Write an instance of the mapped class to a prepared statement. Implementors should handle possibility of null values. A multi-column type should be written to parameters starting from `index`.

    `value` - the object to write
    `index` - statement parameter index

### isOneToOne

    public boolean isOneToOne()

  Specified by:
    `isOneToOne` in class `EntityType`

### isDirty

    public boolean isDirty(Object old,
                           Object current,
                           SessionImplementor session)

  Description copied from interface: `Type`
  Should the parent be considered dirty, given both the old and current field or element value?

  Specified by:
    `isDirty` in interface `Type`
  Overrides:
    `isDirty` in class `AbstractType`
  Parameters:
    `old` - the old value
    `current` - the current value
  Returns:
    true if the field is dirty

### isDirty

    public boolean isDirty(Object old,
                           Object current,
                           boolean[] checkable,
                           SessionImplementor session)

  Description copied from interface: `Type`
  Should the parent be considered dirty, given both the old and current field or element value?

  Parameters:
    `old` - the old value
    `current` - the current value
    `checkable` - which columns are actually updatable
  Returns:
    true if the field is dirty

### isModified

    public boolean isModified(Object old,
                              Object current,
                              boolean[] checkable,
                              SessionImplementor session)

  Description copied from interface: `Type`
  Has the parent object been modified, compared to the current database state?

  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 updatable
  Returns:
    true if the field has been modified

### getForeignKeyDirection

    public ForeignKeyDirection getForeignKeyDirection()

  Description copied from interface: `AssociationType`
  Get the foreign key directionality of this association

### hydrate

    public Object hydrate(ResultSet rs,
                          String[] names,
                          SessionImplementor session,
                          Object owner)
                   throws HibernateException,
                          SQLException

  Description copied from interface: `Type`
  Retrieve an instance of the mapped class, or the identifier of an entity or collection, from a JDBC resultset. This is useful for 2-phase property initialization - the second phase is a call to `resolveIdentifier()`.

  Specified by:
    `hydrate` in interface `Type`
  Overrides:
    `hydrate` in class `AbstractType`
    `names` - the column names
    `session` - the session
    `owner` - the parent entity
  Returns:
    Object an identifier or actual value
  Throws:
    `HibernateException`
    `SQLException`
  See Also:
    `Type.resolve(Object, SessionImplementor, Object)`

### isNullable

    protected boolean isNullable()

  Specified by:
    `isNullable` in class `EntityType`

### useLHSPrimaryKey

    public boolean useLHSPrimaryKey()

  Description copied from interface: `AssociationType`
  Is the primary key of the owning entity table to be used in the join?

### disassemble

    public Serializable disassemble(Object value,
                                    SessionImplementor session,
                                    Object owner)
                             throws HibernateException

  Description copied from interface: `Type`
  Return a cacheable "disassembled" representation of the object.

  Specified by:
    `disassemble` in interface `Type`
  Overrides:
    `disassemble` in class `AbstractType`
  Parameters:
    `value` - the value to cache
    `session` - the session
    `owner` - optional parent entity object (needed for collections)
  Returns:
    the disassembled, deep cloned state
  Throws:
    `HibernateException`

### assemble

    public Object assemble(Serializable oid,
                           SessionImplementor session,
                           Object owner)
                    throws HibernateException

  Description copied from interface: `Type`
  Reconstruct the object from its cached "disassembled" state.

  Specified by:
    `assemble` in interface `Type`
  Overrides:
    `assemble` in class `AbstractType`
  Parameters:
    `oid` - the disassembled state from the cache
    `session` - the session
    `owner` - the parent entity object
  Returns:
    the the object
  Throws:
    `HibernateException`

### isAlwaysDirtyChecked

    public boolean isAlwaysDirtyChecked()

  We don't need to dirty check one-to-one because of how assemble/disassemble is implemented and because a one-to-one association is never dirty

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD