Class BaseUserTypeSupport<T>

    • Constructor Detail

      • BaseUserTypeSupport

        public BaseUserTypeSupport()
    • Method Detail

      • jdbcType

        protected JdbcType jdbcType()
      • sqlTypes

        public int[] sqlTypes()
        Description copied from interface: UserType
        Return the SQL type codes for the columns mapped by this type. The codes are defined on java.sql.Types.
        Specified by:
        sqlTypes in interface UserType<T>
        Returns:
        int[] the typecodes
        See Also:
        Types
      • returnedClass

        public Class<T> returnedClass()
        Description copied from interface: UserType
        The class returned by nullSafeGet().
        Specified by:
        returnedClass in interface UserType<T>
        Returns:
        Class
      • deepCopy

        public Object deepCopy​(Object value)
                        throws HibernateException
        Description copied from interface: UserType
        Return a deep copy of the persistent state, stopping at entities and at collections. It is not necessary to copy immutable objects, or null values, in which case it is safe to simply return the argument.
        Specified by:
        deepCopy in interface UserType<T>
        Parameters:
        value - the object to be cloned, which may be null
        Returns:
        Object a copy
        Throws:
        HibernateException
      • isMutable

        public boolean isMutable()
        Description copied from interface: UserType
        Are objects of this type mutable?
        Specified by:
        isMutable in interface UserType<T>
        Returns:
        boolean
      • disassemble

        public Serializable disassemble​(Object value)
                                 throws HibernateException
        Description copied from interface: UserType
        Transform the object into its cacheable representation. At the very least this method should perform a deep copy if the type is mutable. That may not be enough for some implementations, however; for example, associations must be cached as identifier values. (optional operation)
        Specified by:
        disassemble in interface UserType<T>
        Parameters:
        value - the object to be cached
        Returns:
        a cacheable representation of the object
        Throws:
        HibernateException
      • assemble

        public Object assemble​(Serializable cached,
                               Object owner)
                        throws HibernateException
        Description copied from interface: UserType
        Reconstruct an object from the cacheable representation. At the very least this method should perform a deep copy if the type is mutable. (optional operation)
        Specified by:
        assemble in interface UserType<T>
        Parameters:
        cached - the object to be cached
        owner - the owner of the cached object
        Returns:
        a reconstructed object from the cacheable representation
        Throws:
        HibernateException
      • replace

        public Object replace​(Object original,
                              Object target,
                              Object owner)
                       throws HibernateException
        Description copied from interface: UserType
        During merge, replace the existing (target) value in the entity we are merging to with a new (original) value from the detached entity we are merging. For immutable objects, or null values, it is safe to simply return the first parameter. For mutable objects, it is safe to return a copy of the first parameter. For objects with component values, it might make sense to recursively replace component values.
        Specified by:
        replace in interface UserType<T>
        Parameters:
        original - the value from the detached entity being merged
        target - the value in the managed entity
        Returns:
        the value to be merged
        Throws:
        HibernateException