org.hibernate.type
Class OneToOneType

java.lang.Object
  extended by org.hibernate.type.AbstractType
      extended by org.hibernate.type.EntityType
          extended by 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