## org.hibernate.type
Class AbstractLobType

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

All Implemented Interfaces:
  Serializable, Type

Direct Known Subclasses:
  ByteArrayBlobType, SerializableToBlobType

Deprecated.

    @Deprecated
    public abstract class AbstractLobType

extends AbstractType
implements Serializable

Author:
  Emmanuel Bernard
See Also:
  Serialized Form

Constructor Summary
`AbstractLobType()` Deprecated.

Method Summary
`protected abstract Object` `get(ResultSet rs, String name)` Deprecated.
`int` `getColumnSpan(Mapping mapping)` Deprecated. How many columns are used to persist this type.
`int` `getHashCode(Object x, EntityMode entityMode)` Deprecated. Get a hash code, consistent with persistence "equality".
`String` `getName()` Deprecated. Returns the abbreviated name of the 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, EntityMode entityMode)` Deprecated. Compare two instances of the class mapped by this type for persistence "equality" (equality of persistent state).
`Object` `nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)` Deprecated. Retrieve an instance of the mapped class from a JDBC resultset.
`Object` `nullSafeGet(ResultSet rs, String name, SessionImplementor session, Object owner)` Deprecated. Retrieve an instance of the mapped class from a JDBC resultset.
`void` `nullSafeSet(PreparedStatement st, Object value, int index, boolean[] settable, SessionImplementor session)` Deprecated. Write an instance of the mapped class to a prepared statement, ignoring some columns.
`void` `nullSafeSet(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated. Write an instance of the mapped class to a prepared statement.
`protected abstract void` `set(PreparedStatement st, Object value, int index, SessionImplementor session)` Deprecated.

Methods inherited from class org.hibernate.type.AbstractType
`assemble, beforeAssemble, compare, disassemble, 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, fromXMLNode, getReturnedClass, isMutable, replace, setToXMLNode, sqlTypes, toColumnNullness, toLoggableString`

Constructor Detail

### AbstractLobType

    public AbstractLobType()

  Deprecated.

Method Detail

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

### isEqual

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

  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
    `entityMode` - The entity mode of the values.
  Returns:
    True if there are considered equal (see discussion above).

### getHashCode

    public int getHashCode(Object x,
                           EntityMode entityMode)

  Deprecated.
  Description copied from interface: `Type`
  Get a hash code, consistent with persistence "equality". Again for most types the normal usage is to delegate to the value's `#hashCode`.

  Specified by:
    `getHashCode` in interface `Type`
  Overrides:
    `getHashCode` in class `AbstractType`
  Parameters:
    `x` - The value for which to retrieve a hash code
    `entityMode` - The entity mode of the value.
  Returns:
    The hash code

### getName

    public String getName()

  Deprecated.
  Description copied from interface: `Type`
  Returns the abbreviated name of the type.

  Specified by:
    `getName` in interface `Type`
  Returns:
    String the Hibernate type name

### getColumnSpan

    public int getColumnSpan(Mapping mapping)
                      throws MappingException

  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:
    `mapping` - The mapping object :/
  Returns:
    The number of columns
  Throws:
    `MappingException` - Generally indicates an issue accessing the passed mapping object.

### get

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

  Deprecated.
  Throws:
    `SQLException`

### nullSafeGet

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

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

  Specified by:
    `nullSafeGet` in interface `Type`
    `names` - the column names
    `owner` - the parent entity
  Returns:
    Object
  Throws:
    `HibernateException`
    `SQLException`
  See Also:
    `alternative, 2-phase property initialization`

### nullSafeGet

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

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

  Specified by:
    `nullSafeGet` in interface `Type`
    `name` - the column name
    `owner` - the parent entity
  Returns:
    Object
  Throws:
    `HibernateException`
    `SQLException`

### nullSafeSet

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

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

  Specified by:
    `nullSafeSet` in interface `Type`
    `value` - the object to write
    `index` - statement parameter index
    `settable` - an array indicating which columns to ignore
  Throws:
    `HibernateException`
    `SQLException`

### set

    protected abstract void set(PreparedStatement st,
                                Object value,
                                int index,
                                SessionImplementor session)
                         throws SQLException

  Deprecated.
  Throws:
    `SQLException`

### nullSafeSet

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

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

  Specified by:
    `nullSafeSet` in interface `Type`
    `value` - the object to write
    `index` - statement parameter index
  Throws:
    `HibernateException`
    `SQLException`

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