Wraps exceptions that occur during ADO.NET calls.

Indicates failure of an assertion: a possible bug in NHibernate

Transforms Criteria queries

Indicates that an expected getter or setter method could not be found on a class

Any exception that occurs in the O-R persistence layer.

Thrown if Hibernate can't instantiate an entity or component class at runtime.

Thrown when an invalid type is specified as a proxy for a class. The exception is also thrown when a class is specified as lazy, but cannot be used as a proxy for itself.

A problem occurred trying to lazily initialize a collection or proxy (for example the session was closed) or iterate query results.

Instances represent a lock mode for a row of a relational database table.

An exception that usually occurs at configuration time, rather than runtime, as a result of something screwy in the O-R mappings

Provides access to the full range of NHibernate built-in types. IType instances may be used to bind values to query parameters. Also a factory for new Blobs and Clobs.

This exception is thrown when an operation would break session-scoped identity. This occurs if the user tries to associate two different instances of the same class with a particular identifier, in the scope of a single ISession.

Thrown when the application calls IQuery.UniqueResult() and the query returned more than one result. Unlike all other NHibernate exceptions, this one is recoverable!

Thrown when the user tries to pass a deleted object to the ISession.

Thrown when ISession.Load() fails to select a row with the given primary key (identifier value). This exception might not be thrown when Load() is called, even if there was no row on the database, because Load() returns a proxy if possible. Applications should use ISession.Get() to test if a row exists in the database.

Thrown when the user passes a persistent instance to a ISession method that expects a transient instance

A problem occurred accessing a property of an instance of a persistent class by reflection

Indicates that an expected getter or setter method could not be found on a class

A problem occurred translating a Hibernate query to SQL due to invalid query syntax, etc.

Represents a replication strategy.

Thrown when a version number check failed, indicating that the ISession contained stale data (when using long transactions with versioning).

Indicated that a transaction could not be begun, committed, or rolled back

Throw when the user passes a transient instance to a ISession method that expects a persistent instance

Used when a user provided type does not match the expected one

Thrown when Hibernate could not resolve an object by id, especially when loading an association.

Thrown when ISession.Load() selects a row with the given primary key (identifier value) but the row's discriminator value specifies a different subclass from the one requested

Criteria is a simplified API for retrieving entities by composing Expression objects.

Provides XML marshalling for classes registered with a SessionFactory

Interface to create queries in "detached mode" where the NHibernate session is not available. All methods have the same semantics as the corresponding methods of the IQuery interface.

Type definition of Filter. Filter defines the user's view into enabled dynamic filters, allowing them to set filter parameter values.

Allows user code to inspect and/or change property values before they are written and after they are read from the database

Combines several queries into a single DB call

Combines sevaral queries into a single database call

An object-oriented representation of a NHibernate query.

QueryOver<TRoot> is an API for retrieving entities by composing Expression objects expressed using Lambda expression syntax.

QueryOver<TRoot,TSubType> is an API for retrieving entities by composing Expression objects expressed using Lambda expression syntax.

The main runtime interface between a .NET application and NHibernate. This is the central API class abstracting the notion of a persistence service.

Creates ISessions.

A command-oriented API for performing bulk operations against a database.

Allows the application to define units of work, while maintaining abstraction from the underlying transaction implementation

Controls how the session interacts with the second-level cache and query cache.

Defines the representation modes available for entities.

Represents a fetching strategy.

Represents a flushing strategy.