## org.hibernate.type
Class NullableType

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

All Implemented Interfaces:
  Serializable, StringRepresentableType, Type, XmlRepresentableType

Direct Known Subclasses:
  ImmutableType, MutableType

Deprecated. Use the `AbstractStandardBasicType` approach instead

    @Deprecated
    public abstract class NullableType

extends AbstractType
implements StringRepresentableType, XmlRepresentableType

Superclass of single-column nullable types.

See Also:
  Serialized Form

Field Summary

Fields inherited from class org.hibernate.type.AbstractType
`LEGACY_DEFAULT_SIZE, LEGACY_DICTATED_SIZE`

Constructor Summary
`NullableType()` Deprecated.

Method Summary
`Size` `defaultSize()` Deprecated. A convenience form of `defaultSizes(org.hibernate.engine.spi.Mapping)`, returning just a single size since we are explicitly dealing with single column mappings here.
`Size[]` `defaultSizes(Mapping mapping)` Deprecated. Defines the column sizes to use according to this type if the user did not explicitly say (and if no `Type.dictatedSizes(org.hibernate.engine.spi.Mapping)` were given).
`Size` `dictatedSize()` Deprecated. A convenience form of `dictatedSizes(org.hibernate.engine.spi.Mapping)`, returning just a single size since we are explicitly dealing with single column mappings here.
`Size[]` `dictatedSizes(Mapping mapping)` Deprecated. Return the column sizes dictated by this type.
`abstract Object` `fromStringValue(String xml)` Deprecated. Consume the given string representation back into this types java form.
`Object` `fromXMLNode(org.dom4j.Node xml, Mapping factory)` Deprecated. Parse the XML representation of an instance.
`Object` `fromXMLString(String xml, Mapping factory)` Deprecated.
`abstract Object` `get(ResultSet rs, String name)` Deprecated. Get a column value from a result set, without worrying about the possibility of null values.
`int` `getColumnSpan(Mapping session)` Deprecated. How many columns are used to persist this type.
`boolean` `isDirty(Object old, Object current, boolean[] checkable, SessionImplementor session)` Deprecated. Should the parent be considered dirty, given both the old and current value?
`boolean` `isEqual(Object x, Object y)` Deprecated. Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`Object` `nullSafeGet(ResultSet rs, String name)` Deprecated.
`Object` `nullSafeGet(ResultSet rs, String[] names)` Deprecated.
`Object` `nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Deprecated. Extract a value of the `mapped class` from the JDBC result set.
`Object` `nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Deprecated. Extract a value of the `mapped class` from the JDBC result set.
`void` `nullSafeSet(PreparedStatement st, Object value, int index)` Deprecated.
`void` `nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Deprecated. Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter.
`void` `nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated. Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement.
`String` `nullSafeToString(Object value)` Deprecated. A null-safe version of `toString(Object)`.
`abstract void` `set(PreparedStatement st, Object value, int index)` Deprecated. Set a parameter value without worrying about the possibility of null values.
`void` `setToXMLNode(org.dom4j.Node xml, Object value, SessionFactoryImplementor factory)` Deprecated. A representation of the value to be embedded in an XML element.
`abstract int` `sqlType()` Deprecated. A convenience form of `sqlTypes(org.hibernate.engine.spi.Mapping)`, returning just a single type value since these are explicitly dealing with single column mappings.
`int[]` `sqlTypes(Mapping session)` Deprecated. Return the JDBC types codes (per `Types`) for the columns mapped by this type.
`boolean[]` `toColumnNullness(Object value, Mapping mapping)` Deprecated. Given an instance of the type, return an array of boolean, indicating which mapped columns would be null.
`String` `toLoggableString(Object value, SessionFactoryImplementor factory)` Deprecated. Generate a representation of the value for logging purposes.
`abstract String` `toString(Object value)` Deprecated. Render the value to the string representation.
`String` `toXMLString(Object value, SessionFactoryImplementor pc)` Deprecated.

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

  Deprecated.

Method Detail

### sqlType

    public abstract int sqlType()

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

  Returns:
    The `Types` mapping value.

### dictatedSize

    public Size dictatedSize()

  Deprecated.
  A convenience form of `dictatedSizes(org.hibernate.engine.spi.Mapping)`, returning just a single size since we are explicitly dealing with single column mappings here.

  Returns:
    The `Types` mapping value.

### defaultSize

    public Size defaultSize()

  Deprecated.
  A convenience form of `defaultSizes(org.hibernate.engine.spi.Mapping)`, returning just a single size since we are explicitly dealing with single column mappings here.

  Returns:
    The `Types` mapping value.

### get

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

  Deprecated.
  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.spi.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

  Deprecated.
  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.spi.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).

### nullSafeToString

    public String nullSafeToString(Object value)
                            throws HibernateException

  Deprecated.
  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

  Deprecated.
  Description copied from interface: `StringRepresentableType`
  Render the value to the string representation.

  Specified by:
    `toString` in interface `StringRepresentableType`
  Parameters:
    `value` - The value to render to string.
  Returns:
    The string representation
  Throws:
    `HibernateException` - Problem rendering

### fromStringValue

    public abstract Object fromStringValue(String xml)
                                    throws HibernateException

  Deprecated.
  Description copied from interface: `StringRepresentableType`
  Consume the given string representation back into this types java form.

  Specified by:
    `fromStringValue` in interface `StringRepresentableType`
  Parameters:
    `xml` - The string representation to be consumed.
  Returns:
    The java type representation
  Throws:
    `HibernateException` - Problem consuming

### nullSafeSet

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

  Deprecated.
  Description copied from interface: `Type`
  Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement, ignoring some columns as dictated by the 'settable' parameter. Implementors should handle the possibility of null values. A multi-column type should bind parameters starting from `index`.

  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 final void nullSafeSet(PreparedStatement st,
                                  Object value,
                                  int index,
                                  SessionImplementor session)
                           throws HibernateException,
                                  SQLException

  Deprecated.
  Description copied from interface: `Type`
  Bind a value represented by an instance of the `mapped class` to the JDBC prepared statement. Implementors should handle possibility of null values. A multi-column type should bind parameters starting from `index`.

  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

### nullSafeSet

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

  Deprecated.
  Throws:
    `HibernateException`
    `SQLException`

### nullSafeGet

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

  Deprecated.
  Description copied from interface: `Type`
  Extract a value of the `mapped class` from the JDBC result set. Implementors should handle possibility of null values.

  Specified by:
    `nullSafeGet` in interface `Type`
  Parameters:
    `rs` - The result set from which to extract value.
    `names` - the column names making up this type value (use to read from result set)
    `session` - The originating session
    `owner` - the parent entity
  Returns:
    The extracted value
  Throws:
    `HibernateException` - An error from Hibernate
    `SQLException` - An error from the JDBC driver
  See Also:
    `alternative, 2-phase property initialization`

### nullSafeGet

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

  Deprecated.
  Throws:
    `HibernateException`
    `SQLException`

### nullSafeGet

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

  Deprecated.
  Throws:
    `HibernateException`
    `SQLException`

### nullSafeGet

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

  Deprecated.
  Description copied from interface: `Type`
  Extract a value of the `mapped class` from the JDBC result set. Implementors should handle possibility of null values. This form might be called if the type is known to be a single-column type.

  Specified by:
    `nullSafeGet` in interface `Type`
  Parameters:
    `rs` - The result set from which to extract value.
    `name` - the column name making up this type value (use to read from result set)
    `session` - The originating session
    `owner` - the parent entity
  Returns:
    The extracted value
  Throws:
    `HibernateException` - An error from Hibernate
    `SQLException` - An error from the JDBC driver

### toXMLString

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

  Deprecated.
  Specified by:
    `toXMLString` in interface `XmlRepresentableType`
  Throws:
    `HibernateException`

### fromXMLString

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

  Deprecated.
  Specified by:
    `fromXMLString` in interface `XmlRepresentableType`
  Throws:
    `HibernateException`

### getColumnSpan

    public final int getColumnSpan(Mapping session)

  Deprecated.
  Description copied from interface: `Type`
  How many columns are used to persist this type. Always the same as `sqlTypes(mapping).length`

  Specified by:
    `getColumnSpan` in interface `Type`
  Parameters:
    `session` - The mapping object :/
  Returns:
    The number of columns

### sqlTypes

    public final int[] sqlTypes(Mapping session)

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

  NOTE: The number of elements in this array matches the return from `Type.getColumnSpan(org.hibernate.engine.spi.Mapping)`.

  Specified by:
    `sqlTypes` in interface `Type`
  Parameters:
    `session` - The mapping object :/
  Returns:
    The JDBC type codes.

### dictatedSizes

    public Size[] dictatedSizes(Mapping mapping)
                         throws MappingException

  Deprecated.
  Description copied from interface: `Type`
  Return the column sizes dictated by this type. For example, the mapping for a `char`/`Character` would have a dictated length limit of 1; for a string-based `UUID` would have a size limit of 36; etc.

  NOTE: The number of elements in this array matches the return from `Type.getColumnSpan(org.hibernate.engine.spi.Mapping)`.

  Specified by:
    `dictatedSizes` in interface `Type`
  Parameters:
    `mapping` - The mapping object :/
  Returns:
    The dictated sizes.
  Throws:
    `MappingException` - Generally indicates an issue accessing the passed mapping object.

### defaultSizes

    public Size[] defaultSizes(Mapping mapping)
                        throws MappingException

  Deprecated.
  Description copied from interface: `Type`
  Defines the column sizes to use according to this type if the user did not explicitly say (and if no `Type.dictatedSizes(org.hibernate.engine.spi.Mapping)` were given).

  NOTE: The number of elements in this array matches the return from `Type.getColumnSpan(org.hibernate.engine.spi.Mapping)`.

  Specified by:
    `defaultSizes` in interface `Type`
  Parameters:
    `mapping` - The mapping object :/
  Returns:
    The default sizes.
  Throws:
    `MappingException` - Generally indicates an issue accessing the passed mapping object.

### isEqual

    public boolean isEqual(Object x,
                           Object y)

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

  This should always equate to some form of comparison of the value's internal state. As an example, for something like a date the comparison should be based on its internal "time" state based on the specific portion it is meant to represent (timestamp, date, 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).

### toLoggableString

    public String toLoggableString(Object value,
                                   SessionFactoryImplementor factory)

  Deprecated.
  Description copied from interface: `Type`
  Generate a representation of the 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

### fromXMLNode

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

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

  Specified by:
    `fromXMLNode` in interface `Type`
  Parameters:
    `xml` - The XML node from which to read the value
    `factory` - The session factory
  Returns:
    an instance of the `mapped class`
  Throws:
    `HibernateException` - An error from Hibernate

### setToXMLNode

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

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

  Specified by:
    `setToXMLNode` in interface `Type`
  Parameters:
    `xml` - The XML node to which to write the value
    `value` - The value to write
    `factory` - The session factory
  Throws:
    `HibernateException` - An error from Hibernate

### toColumnNullness

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

  Deprecated.
  Description copied from interface: `Type`
  Given an instance of the type, return an array of boolean, 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

### isDirty

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

  Deprecated.
  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

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