Uses of Interface

Packages that use Nestable
org.hibernate This package defines the central Hibernate APIs. 
org.hibernate.cache This package defines APIs and implementations for the second-level cache and query cache. 
org.hibernate.classic This package implements backward-compatibility with Hibernate 2.1 APIs now deprecated in Hibernate3. 
org.hibernate.exception This package is a fork of Apache commons-lang nestable exceptions. 
org.hibernate.hql This package defines the interface between Hibernate and the HQL query parser implementation (to allow switching between the 2.x and 3.0 HQL parsers). 
org.hibernate.hql.ast An ANTLR-based parser for Hibernate Query Language. This package contains internal implementation classes for the main API interfaces. 
org.hibernate.jdbc This package abstracts the mechanism for dispatching SQL statements to the database, and implements interaction with JDBC. 
org.hibernate.type A Hibernate Type is a strategy for mapping a Java property type to a JDBC type or types. 

Uses of Nestable in org.hibernate

Classes in org.hibernate that implement Nestable
 class AssertionFailure
          Indicates failure of an assertion: a possible bug in Hibernate.
 class CallbackException
          Should be thrown by persistent objects from Lifecycle or Interceptor callbacks.
 class DuplicateMappingException
          Raised whenever a duplicate for a certain type occurs.
 class HibernateException
          Any exception that occurs inside the persistence layer or JDBC driver.
 class InstantiationException
          Thrown if Hibernate can't instantiate an entity or component class at runtime.
 class InvalidMappingException
          Thrown when a mapping is found to be invalid.
 class JDBCException
          Wraps an SQLException.
 class LazyInitializationException
          Indicates access to unfetched data outside of a session context.
 class MappingException
          An exception that usually occurs at configuration time, rather than runtime, as a result of something screwy in the O-R mappings.
 class MappingNotFoundException
          Thrown when a resource for a mapping could not be found.
 class NonUniqueObjectException
          This exception is thrown when an operation would break session-scoped identity.
 class NonUniqueResultException
          Thrown when the application calls Query.uniqueResult() and the query returned more than one result.
 class ObjectDeletedException
          Thrown when the user tries to do something illegal with a deleted object.
 class ObjectNotFoundException
          Thrown when Session.load() fails to select a row with the given primary key (identifier value).
 class PersistentObjectException
          Thrown when the user passes a persistent instance to a Session method that expects a transient instance.
 class PropertyAccessException
          A problem occurred accessing a property of an instance of a persistent class by reflection, or via CGLIB.
 class PropertyNotFoundException
          Indicates that an expected getter or setter method could not be found on a class.
 class PropertyValueException
          Thrown when the (illegal) value of a property can not be persisted.
 class QueryException
          A problem occurred translating a Hibernate query to SQL due to invalid query syntax, etc.
 class QueryParameterException
          Parameter invalid or not found in the query
 class SessionException
          Thrown when the user calls a method of a Session that is in an inappropropriate state for the given call (for example, the the session is closed or disconnected).
 class StaleObjectStateException
          A StaleStateException that carries information about a particular entity instance that was the source of the failure.
 class StaleStateException
          Thrown when a version number or timestamp check failed, indicating that the Session contained stale data (when using long transactions with versioning).
 class TransactionException
          Indicates that a transaction could not be begun, committed or rolled back.
 class TransientObjectException
          Thrown when the user passes a transient instance to a Session method that expects a persistent instance.
 class TypeMismatchException
          Used when a user provided type does not match the expected one
 class UnresolvableObjectException
          Thrown when Hibernate could not resolve an object by id, especially when loading an association.
 class WrongClassException
          Thrown when Session.load() selects a row with the given primary key (identifier value) but the row's discriminator value specifies a subclass that is not assignable to the class requested by the user.

Uses of Nestable in org.hibernate.cache

Classes in org.hibernate.cache that implement Nestable
 class CacheException
          Something went wrong in the cache
 class NoCachingEnabledException
          Implementation of NoCachingEnabledException.

Uses of Nestable in org.hibernate.classic

Classes in org.hibernate.classic that implement Nestable
 class ValidationFailure
          Thrown from Validatable.validate() when an invariant was violated.

Uses of Nestable in org.hibernate.exception

Classes in org.hibernate.exception that implement Nestable
 class ConstraintViolationException
          Implementation of JDBCException indicating that the requested DML operation resulted in a violation of a defined integrity constraint.
 class DataException
          Implementation of JDBCException indicating that evaluation of the valid SQL statement against the given data resulted in some illegal operation, mismatched types or incorrect cardinality.
 class GenericJDBCException
          Generic, non-specific JDBCException.
 class JDBCConnectionException
          Implementation of JDBCException indicating problems with communicating with the database (can also include incorrect JDBC setup).
 class LockAcquisitionException
          Implementation of JDBCException indicating a problem acquiring lock on the database.
 class NestableException
          The base class of all exceptions which can contain other exceptions.
 class NestableRuntimeException
          The base class of all runtime exceptions which can contain other exceptions.
 class SQLGrammarException
          Implementation of JDBCException indicating that the SQL sent to the database server was invalid (syntax error, invalid object references, etc).

Constructors in org.hibernate.exception with parameters of type Nestable
NestableDelegate(Nestable nestable)
          Constructs a new NestableDelegate instance to manage the specified Nestable.

Uses of Nestable in org.hibernate.hql

Classes in org.hibernate.hql that implement Nestable
 class QueryExecutionRequestException
          Expecting to execute an illegal operation regarding the query type

Uses of Nestable in org.hibernate.hql.ast

Classes in org.hibernate.hql.ast that implement Nestable
 class InvalidWithClauseException
 class QuerySyntaxException
          Exception thrown when there is a syntax error in the HQL.

Uses of Nestable in

Classes in that implement Nestable
 class IdentifierGenerationException
          Thrown by IdentifierGenerator implementation class when ID generation fails.

Uses of Nestable in org.hibernate.jdbc

Classes in org.hibernate.jdbc that implement Nestable
 class BatchedTooManyRowsAffectedException
          Much like TooManyRowsAffectedException, indicates that more rows than what we were expcecting were affected.
 class BatchFailedException
          Indicates a failed batch entry (-3 return).
 class TooManyRowsAffectedException
          Indicates that more rows were affected then we were expecting to be.

Uses of Nestable in org.hibernate.type

Classes in org.hibernate.type that implement Nestable
 class SerializationException
          Thrown when a property cannot be serializaed/deserialized