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 NullableType

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

All Implemented Interfaces:
  Serializable, Type

Direct Known Subclasses:
  ImmutableType, MutableType

    public abstract class NullableType

extends AbstractType

Superclass of single-column nullable types.

Author:
  Gavin King
See Also:
  Serialized Form

Constructor Summary
`NullableType()`

Method Summary
`abstract Object` | `fromStringValue(String xml)`
`Object` | `fromXMLNode(org.dom4j.Node xml, Mapping factory)` Parse the XML representation of an instance.
`Object` | `fromXMLString(String xml, Mapping factory)`
`abstract Object` | `get(ResultSet rs, String name)` Get a column value from a result set, without worrying about the possibility of null values.
`int` | `getColumnSpan(Mapping session)` How many columns are used to persist this type.
`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` | `isEqual(Object x, Object y)`
`boolean` | `isEqual(Object x, Object y, EntityMode entityMode)` Compare two instances of the class mapped by this type for persistence "equality" - equality of persistent state.
`Object` | `nullSafeGet(ResultSet rs, String name)`
`Object` | `nullSafeGet(ResultSet rs, String[] names)`
`Object` | `nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`Object` | `nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Retrieve an instance of the mapped class from a JDBC resultset.
`void` | `nullSafeSet(PreparedStatement st, Object value, int index)`
`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.
`String` | `nullSafeToString(Object value)` A null-safe version of `toString(Object)`.
`abstract void` | `set(PreparedStatement st, Object value, int index)` Set a parameter value without worrying about the possibility of null values.
`void` | `setToXMLNode(org.dom4j.Node xml, Object value, SessionFactoryImplementor factory)` A representation of the value to be embedded in an XML element.
`abstract int` | `sqlType()` A convenience form of `sqlTypes(org.hibernate.engine.Mapping)`, returning just a single type value since these are explicitly dealing with single column mappings.
`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.
`String` | `toLoggableString(Object value, SessionFactoryImplementor factory)` A representation of the value to be embedded in a log file.
`abstract String` | `toString(Object value)`
`String` | `toXMLString(Object value, SessionFactoryImplementor pc)`

Methods inherited from class org.hibernate.type.AbstractType
`assemble, beforeAssemble, compare, disassemble, getHashCode, getHashCode, getSemiResolvedType, hydrate, isAnyType, isAssociationType, isCollectionType, isComponentType, isDirty, isEntityType, isEqual, isModified, isSame, isXMLElement, replace, replaceNode, resolve, semiResolve`

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
`deepCopy, getName, getReturnedClass, isMutable, replace`

Constructor Detail

### NullableType

    public NullableType()

Method Detail

### get

    public abstract Object get(ResultSet rs,
                               String name)
                        throws HibernateException,
                               SQLException

  Get a column value from a result set, without worrying about the possibility of null values. Called from `nullSafeGet(java.sql.ResultSet, java.lang.String[], org.hibernate.engine.SessionImplementor, java.lang.Object)` after nullness checks have been performed.

  Parameters:
    `rs` - The result set from which to extract the value.
    `name` - The name of the value to extract.
  Returns:
    The extracted value.
  Throws:
    `HibernateException` - Generally some form of mismatch error.
    `SQLException` - Indicates problem making the JDBC call(s).

### set

    public abstract void set(PreparedStatement st,
                             Object value,
                             int index)
                      throws HibernateException,
                             SQLException

  Set a parameter value without worrying about the possibility of null values. Called from `nullSafeSet(java.sql.PreparedStatement, java.lang.Object, int, boolean[], org.hibernate.engine.SessionImplementor)` after nullness checks have been performed.

  Parameters:
    `st` - The statement into which to bind the parameter value.
    `value` - The parameter value to bind.
    `index` - The position or index at which to bind the param value.
  Throws:
    `HibernateException` - Generally some form of mismatch error.
    `SQLException` - Indicates problem making the JDBC call(s).

### sqlType

    public abstract int sqlType()

  A convenience form of `sqlTypes(org.hibernate.engine.Mapping)`, returning just a single type value since these are explicitly dealing with single column mappings.

  Returns:
    The `Types` mapping value.

### nullSafeToString

    public String nullSafeToString(Object value)
                            throws HibernateException

  A null-safe version of `toString(Object)`. Specifically we are worried about null safeness in regards to the incoming value parameter, not the return.

  Parameters:
    `value` - The value to convert to a string representation; may be null.
  Returns:
    The string representation; may be null.
  Throws:
    `HibernateException` - Thrown by `toString(Object)`, which this calls.

### toString

    public abstract String toString(Object value)
                             throws HibernateException

  Throws:
    `HibernateException`

### fromStringValue

    public abstract Object fromStringValue(String xml)
                                    throws HibernateException

  Throws:
    `HibernateException`

### nullSafeSet

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

  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
  Throws:
    `HibernateException`
    `SQLException`

### nullSafeSet

    public final void nullSafeSet(PreparedStatement st,
                                  Object value,
                                  int index,
                                  SessionImplementor session)
                           throws HibernateException,
                                  SQLException

  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
  Throws:
    `HibernateException`
    `SQLException`

### nullSafeSet

    public final void nullSafeSet(PreparedStatement st,
                                  Object value,
                                  int index)
                           throws HibernateException,
                                  SQLException

  Throws:
    `HibernateException`
    `SQLException`

### nullSafeGet

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

  Description copied from interface: `Type`
  Retrieve an instance of the mapped class from a JDBC resultset. Implementors should handle possibility of null values.

    `names` - the column names
    `owner` - the parent entity
  Returns:
    Object
  Throws:
    `HibernateException`
    `SQLException`
  See Also:
    `alternative, 2-phase property initialization`

### nullSafeGet

    public final Object nullSafeGet(ResultSet rs,
                                    String[] names)
                             throws HibernateException,
                                    SQLException

  Throws:
    `HibernateException`
    `SQLException`

### nullSafeGet

    public final Object nullSafeGet(ResultSet rs,
                                    String name)
                             throws HibernateException,
                                    SQLException

  Throws:
    `HibernateException`
    `SQLException`

### nullSafeGet

    public final Object nullSafeGet(ResultSet rs,
                                    String name,
                                    SessionImplementor session,
                                    Object owner)
                             throws HibernateException,
                                    SQLException

  Description copied from interface: `Type`
  Retrieve an instance of the mapped class from a JDBC resultset. Implementations should handle possibility of null values. This method might be called if the type is known to be a single-column type.

    `name` - the column name
    `owner` - the parent entity
  Returns:
    Object
  Throws:
    `HibernateException`
    `SQLException`

### toXMLString

    public final String toXMLString(Object value,
                                    SessionFactoryImplementor pc)
                             throws HibernateException

  Throws:
    `HibernateException`

### fromXMLString

    public final Object fromXMLString(String xml,
                                      Mapping factory)
                               throws HibernateException

  Throws:
    `HibernateException`

### getColumnSpan

    public final int getColumnSpan(Mapping session)

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

### sqlTypes

    public final int[] sqlTypes(Mapping session)

  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
  See Also:
    `Types`

### isEqual

    public final boolean isEqual(Object x,
                                 Object y,
                                 EntityMode entityMode)

  Description copied from interface: `Type`
  Compare two instances of the class mapped by this type for persistence "equality" - equality of persistent state.

  Specified by:
    `isEqual` in interface `Type`
  Overrides:
    `isEqual` in class `AbstractType`
  Returns:
    boolean

### isEqual

    public boolean isEqual(Object x,
                           Object y)

### toLoggableString

    public String toLoggableString(Object value,
                                   SessionFactoryImplementor factory)

  Description copied from interface: `Type`
  A representation of the value to be embedded in a log file.

  Returns:
    String

### fromXMLNode

    public Object fromXMLNode(org.dom4j.Node xml,
                              Mapping factory)
                       throws HibernateException

  Description copied from interface: `Type`
  Parse the XML representation of an instance.

  Returns:
    an instance of the type
  Throws:
    `HibernateException`

### setToXMLNode

    public void setToXMLNode(org.dom4j.Node xml,
                             Object value,
                             SessionFactoryImplementor factory)
                      throws HibernateException

  Description copied from interface: `Type`
  A representation of the value to be embedded in an XML element.

  Throws:
    `HibernateException`

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

### isDirty

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

  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
  Throws:
    `HibernateException`

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