Uses of Package
org.hibernate

Packages that use org.hibernate
Package
Description
This package defines the central Hibernate APIs, beginning with SessionFactory, which represents an instance of Hibernate at runtime and is the source of new instances of Session and StatelessSession, the most important APIs exposing persistence-related operations for entities.
The various concrete action implementations.
This SPI package defines an abstraction over the notion of an "action" which is scheduled for asynchronous execution by the event listeners.
Implementation of ConnectionProvider using Agroal.
A set of mapping annotations which extend the O/R mapping annotations defined by JPA.
Annotations used to drive annotation processors: @Find is used to generate finder methods using the Metamodel Generator, @HQL and @SQL are used to generate query methods using the Metamodel Generator, and CheckHQL instructs the Query Validator to check all HQL queries in the annotated package or type.
This package defines an easy way to extend Hibernate with user-defined annotations that define customized O/R mappings of annotated entities and annotated entity attributes.
This package contains the interfaces that make up the bootstrap API for Hibernate.
Defines a model for archives which may be scanned to discover managed classes and named resources.
Support for integrating Jakarta Bean Validation.
 
JAXB details.
 
 
Contains basic support for Java XML Processing (JAXP) via Streaming API for XML (StAX)
 
 
This package defines the boot-time metamodel, which is an interpretation of the domain model (entity classes, embeddable classes, and attributes) and the mapping of these "domain model parts" to the database.
Defines the SPI of a registry of JPA AttributeConverters.
 
This API allows intervention by generic code in the process of determining the names of database objects (tables, columns, and constraints).
 
Some SPIs related to DDL generation and schema management.
 
Support for handling named queries during the bootstrap process.
Defines service registry contracts a program may use for configuring Hibernate.
The class loading service internals.
The class loading service SPI.
Defines actual contract used for strategy selection.
A range of SPIs allowing integration with—and customization of—the process of building metadata.
Support for XSD handling.
 
Package defining bytecode code enhancement (instrumentation) support.
Support for bytecode interceptor implementations.
 
Byte Buddy support internals
Package defining bytecode code enhancement (instrumentation) support.
This package defines the API of the second-level cache service.
Internal implementations and support for second-level caching.
Defines the integration aspect of Hibernate's second-level caching, allowing a "caching backend" to be plugged in as a cache provider.
Defines contracts for transactional and concurrent access to cached entity and collection data.
This package defines formats for disassembled state kept in the second level cache.
This package defines APIs for configuring Hibernate.
This package historically provided backward-compatibility with Hibernate 2.1 APIs which were deprecated in Hibernate 3.
This package defines the SPI of a framework for lazy-initializing and state-tracking collection wrappers.
Contains SPIs which define: the notion of a context-bound or "current" session, and the notion of a "current" tenant id.
Internal implementations and support around "current session" handling.
SPI-level contracts around "current session" and "current tenant" support.
This package abstracts over the multifarious dialects of SQL understood by the databases supported by Hibernate.
Support for Dialect-specific aggregate column types, including user-defined composite types, and JSON or XML types.
Support for Dialect-specific identity column handling.
Support for Dialect-specific locking strategies.
Support for Dialect-specific pagination strategies.
Support for Dialect-specific sequence handling.
Support for many of the internal workings of Hibernate.
Internals for JDBC batching support.
Defines contracts for JDBC batching support.
Various implementations of the SPI contracts for obtaining JDBC Connections.
Internal support for Dialect resolution (from JDBC metadata) and Dialect building.
Contracts supporting Dialect resolution (from JDBC metadata) and Dialect building.
Package defining support for executing mutation SQL statements produced by an entity persister or collection persister.
 
 
SPI contracts supporting various aspects of JDBC interaction.
Support for JNDI within Hibernate
Models the fetch profiles defined by the application.
Support for dealing with parameters of native queries.
An SPI for dealing with parameters of native queries.
This package defines some central internal SPI abstractions used throughout the implementation of Hibernate.
 
An SPI for integrating with container-provided implementations of JTA.
An SPI abstracting the object which implements Transaction.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
This package defines a default set of event listeners that implement the default behaviors of Hibernate session operations.
An SPI for the event listener registration service.
Defines the event types and event listener interfaces for events produced by the stateful Session.
Defines certain very important flavors of JDBCException, along with an SPI for interpreting product-specific SQLExceptions arising from a JDBC driver into something more uniform and meaningful.
 
An SPI for Dialect-specific exception interpretation and conversion.
This package defines an abstraction over all kinds of automatic value generation, including id generation and version number generation.
 
 
Implements and extends the JPA-defined entity graph API.
Implementation of ConnectionProvider using HikariCP.
This package and its subpackages, especially org.hibernate.id.enhanced, contain the built-in id generators, all of which implement either IdentifierGenerator or PostInsertIdentifierGenerator.
Enhanced/improved versions of table and sequence based identifier generators targeting portability and unified configuration.
Defines a service for creating id generators.
Contains an SPI for id generator factories.
Contains the UuidGenerator.
An SPI for extensions which integrate with Hibernate via the Java ServiceLoader facility.
An internal package containing implementations of central Hibernate APIs, mostly defined in org.hibernate.
Internal utility classes
 
 
 
 
A small API allowing the client of a Hibernate session to interact directly with JDBC, using the same connection and transaction obtained by the session.
 
An SPI used to initiate and control the JPA bootstrap process, along with SPI interfaces allowing certain sorts of extensions to be contributed during the bootstrap process.
 
This package defines functionality for processing JDBC result sets and returning complex graphs of persistent objects.
 
 
 
This package defines the Hibernate configuration-time mapping model.
This package defines an API for accessing details about model mapping.
This package defines an API for accessing the runtime metamodel describing persistent entities in Java and their mappings to the relational database schema.
 
Defines the runtime mapping metamodel, which describes the mapping of the application's domain model parts (entities, attributes) to relational database objects (tables, columns).
 
 
Defines the runtime domain metamodel, which describes the Java aspect of the application's domain model parts (entities, attributes).
Implementation of the SPI for the runtime domain metamodel.
An SPI supporting custom instantiation of entity instances and embeddable objects.
This package abstracts persistence mechanisms for collections.
This package abstracts persistence mechanisms for entities.
Defines support for performing mutation operations originating from persistence-context events.
Built-in implementation of the SPI for integrating entity and collection persisters.
An SPI for integrating custom entity and collection persisters.
Contains some functions for pretty-printing things for exception and log messages.
Defines support for executing database stored procedures and functions and accessing their outputs.
Defines the internal implementation of the stored procedure SPI.
Defines an SPI for calling stored procedures and functions.
Validation for HQL queries.
An SPI abstracting how persistent attributes of an entity or embeddable type are accessed by Hibernate.
Implementation of ConnectionProvider using the proxool Connection pool.
This package defines a framework for lazy-initializing entity proxies.
 
Everything related to HQL/JPQL, native SQL, and criteria queries.
The JPA-standard criteria query API defines all the operations needed express any query written in standard JPQL.
 
SPI for extending HibernateCriteriaBuilder with additional functionality by registering a Service.
 
Package defining support for HQL, including JPQL as a subset of HQL.
Implementation of the SPIs for HQL support.
SPIs for HQL support.
 
Support for named queries
Support SQL functions in the SQM model.
Support for defining result set mappings used in NativeQuery, ProcedureCall, and StoredProcedureQuery.
Support for immutable result/fetch builder graph nodes built from static sources such as SqlResultSetMapping or the hbm.xml mapping element <resultset/>.
Support for mutable result/fetch builder graphs nodes built dynamically via Hibernate's NativeQuery APIs
Contains a range of internal abstractions for dealing with query execution, query plans, query options, and query parameters.
Implementation of the SPIs for native SQL query support.
SPIs for native SQL query support.
This package defines a semantic model of HQL queries.
Package for the SQM-backed Query implementation details
 
Package defining support for SqmFunctionDescriptor handling.
SPI-level SQM contracts
Package for the translation of SQM into SQL AST
 
This package contains the classes that make up the SQM tree nodes.
Nodes representing path expressions in the SQM tree.
Nodes representing expressions in the SQM tree.
Nodes representing root entities and joins in the SQM tree.
Nodes representing insert statements in the SQM tree.
Nodes representing select statements in the SQM tree.
Programmatic access to the schema management tool.
An implementation of the bean container SPI based on CDI.
An SPI for managing JDBC connections and other heavyweight resources, based around the idea of a "JDBC session".
Defines the resource-level transaction capabilities of Hibernate, centered around the TransactionCoordinator contract.
An implementation of TransactionCoordinator based on JdbcResourceTransaction.
Implementations of TransactionCoordinator based on JTA.
Extended SPI contracts for the resource-level transaction capabilities of Hibernate.
Defines support for dealing with results returned from database via JDBC.
 
Defines a framework for pluggable services, allowing for customization of key components of Hibernate, and abstraction of these components as SPI interfaces.
Implementation of the SPI for integrating pluggable services.
Defines an SPI for integrating pluggable services.
A tiny SPI for dealing with compound names and navigable paths.
This package contains helper classes for rendering SQL fragments and SQL statements.
Package defining a SQL AST for use in generation of SQL.
Package defining support for creating and consuming a SQL AST.
AST nodes representing expressions in a SQL tree.
AST nodes representing root tables and joins in a SQL tree.
Support for execution of SQL statements via JDBC.
Implementation of the SPI for execution of SQL statements via JDBC.
SPI for execution of SQL statements via JDBC.
Package contains specialized SQL AST nodes and builders for table mutations of model parts originating from normal persistence-context events.
SQL AST extensions for model mutations.
Package for processing JDBC ResultSets into hydrated domain model graphs based on a "load plan" defined by a "domain result graph", that is, one or more DomainResult nodes with zero or more Fetch nodes.
Defines domain result graphs.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Implementation of the SPI for schema information extraction from the database via JDBC.
Defines an SPI for schema information extraction from the database via JDBC.
An implementation of the SPI for the tooling related to DDL generation, export, migration, and validation.
An SPI for tooling related to DDL generation, export, migration, and validation.
Most contracts here have been replaced by the new runtime mapping model.
 
A Hibernate Type is a strategy for mapping a Java property type to a JDBC type or types.
Implements the SPI for basic-typed value conversions.
An SPI for basic-typed value conversions, including support for handling JPA AttributeConverter instances as part of the Hibernate Type system.
Integrates a range of types defined by the JDK with the type system of Hibernate.
 
Defines handling of almost the full range of standard JDBC-defined SQL data types.
An API for working with abstract families of DDL types parameterized by varying length, precision, and scale.
Support for type mappings which format composite values to a structured text format (JSON or XML) for storage in a database-specific column type supporting that structured format.
 
Defines a registry for Hibernate Types.
An API for user-defined custom types which extend the set of built-in types defined in org.hibernate.type.