## 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(TypeFactory.TypeScope scope, 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 value?
`boolean` `isDirty(Object old, Object current, SessionImplementor session)` Should the parent be considered dirty, given both the old and current value?
`boolean` `isModified(Object old, Object current, boolean[] checkable, SessionImplementor 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.SessionImplementor)` methods is that here we need to account for "partially" built values.
`boolean` `isNull(Object owner, SessionImplementor session)`
`protected boolean` `isNullable()`
`boolean` `isOneToOne()` Is the association modeled here defined as a 1-1 in the database (physical model)?
`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 JDBC types codes (per `Types`) 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, isLogicalOneToOne, isMutable, isNotEmbedded, isReferenceToPrimaryKey, isSame, isXMLElement, loadByUniqueKey, nullSafeGet, nullSafeGet, replace, resolve, resolveIdentifier, scope, 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(TypeFactory.TypeScope scope,
                        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. Always the same as `sqlTypes(mapping).length`

  Parameters:
    `session` - The mapping object :/
  Returns:
    The number of columns
  Throws:
    `MappingException` - Generally indicates an issue accessing the passed mapping object.

### sqlTypes

    public int[] sqlTypes(Mapping session)
                   throws MappingException

  Description copied from interface: `Type`
  Return the JDBC types codes (per `Types`) for the columns mapped by this type.

  Parameters:
    `session` - The mapping object :/
  Returns:
    The JDBC type codes.
  Throws:
    `MappingException` - Generally indicates an issue accessing the passed mapping object.

### 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()

  Description copied from class: `EntityType`
  Is the association modeled here defined as a 1-1 in the database (physical model)?

  Specified by:
    `isOneToOne` in class `EntityType`
  Returns:
    True if a 1-1 in the database; false otherwise.

### 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 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

### 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 value?

  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

### isModified

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

  Description copied from interface: `Type`
  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.SessionImplementor)` 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 to `Type.isDirty(java.lang.Object, java.lang.Object, org.hibernate.engine.SessionImplementor)` here/

  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
    `session` - The session from which the request originated.
  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

Copyright © 2001-2010 Red Hat, Inc. All Rights Reserved.