Uses of Package
org.hibernate.engine.spi

Packages that use org.hibernate.engine.spi
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.
This package contains the interfaces that make up the bootstrap API for Hibernate.
Support for integrating Jakarta Bean Validation.
 
JAXB details.
 
 
 
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.
 
Support for handling named queries during the bootstrap process.
A range of SPIs allowing integration with—and customization of—the process of building metadata.
package containing bytecode enhancement code (internals)
specialized classes to keep track of changes
Package defining bytecode code enhancement (instrumentation) support.
Support for bytecode interceptor implementations.
 
Byte Buddy support internals
Package defining bytecode code enhancement (instrumentation) support.
An SPI modelling various aspects of the second-level cache configuration.
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 provides a framework intended to reduce the work needed to implement a caching provider.
Internal implementations and support for persistent collections.
This package defines the SPI of a framework for lazy-initializing and state-tracking collection wrappers.
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.
Contains implementations of SqmFunctionDescriptor describing a range of relatively-sophisticated SQL functions available in various dialects.
 
Support for Dialect-specific identity column handling.
Support for temporary tables.
Support for many of the internal workings of Hibernate.
Internals for JDBC batching support.
Package defining support for executing mutation SQL statements produced by an entity persister or collection persister.
 
 
 
An SPI for dealing with parameters of native queries.
This package defines some central internal SPI abstractions used throughout the implementation of Hibernate.
 
 
 
 
 
 
 
 
 
 
 
 
This package defines a default set of event listeners that implement the default behaviors of Hibernate session operations.
Defines the event types and event listener interfaces for events produced by the stateful Session.
This package defines an abstraction over all kinds of automatic value generation, including id generation and version number generation.
 
Contains a framework of strategies for efficient retrieval of database-generated values.
 
Implements and extends the JPA-defined entity graph API.
 
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.
Contains a framework of strategies for retrieving database-generated ids.
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
Defines Hibernate implementation of Java Persistence specification.
 
 
 
This package defines the Hibernate configuration-time mapping model.
 
Defines the runtime mapping metamodel, which describes the mapping of the application's domain model parts (entities, attributes) to relational database objects (tables, columns).
 
Support for set and map ordering
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.
Defines support for performing mutation operations against collections.
This package abstracts persistence mechanisms for entities.
Defines support for performing mutation operations originating from persistence-context events.
Contains some functions for pretty-printing things for exception and log messages.
Defines the internal implementation of the stored procedure SPI.
Defines an SPI for calling stored procedures and functions.
Validation for HQL queries.
Contains various implementations of PropertyAccessStrategy.
An SPI abstracting how persistent attributes of an entity or embeddable type are accessed by Hibernate.
This package defines a framework for lazy-initializing entity proxies.
Proxies for entity objects represented as Java maps.
Proxies for plain Java objects.
 
Everything related to HQL/JPQL, native SQL, and criteria queries.
 
 
Implementation of the SPIs for HQL support.
 
Support for named queries
 
Support for mutable result/fetch builder graphs nodes built dynamically.
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.
An SPI for defining, registering, and rendering functions in HQL.
Package for the SQM-backed Query implementation details
 
 
Support for multi-table SQM mutation (insert, update, delete) operations using a table to temporarily hold the matching ids.
SPI for handling SQM UPDATE and DELETE queries
SPI-level SQM contracts
Package for the translation of SQM into SQL AST
 
 
An SPI for managing JDBC connections and other heavyweight resources, based around the idea of a "JDBC session".
Internal implementation details for reacting to JTA transaction completion via Synchronization callbacks
 
 
Implementation of the SPI for integrating pluggable services.
Defines an SPI for integrating pluggable services.
 
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.
Support for common table expressions (CTE) in a SQL tree.
AST nodes representing expressions in a SQL tree.
AST nodes representing root tables and joins in a SQL tree.
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.
Support for building TableMutation references for persisting entity mutation events
Concrete implementations of MutationGroup, MutationOperation, and TableMutation.
Extensions to JdbcOperation for model mutations.
Support for caching of query results.
 
 
 
 
 
 
 
 
 
The built-in implementation of the statistics collection service.
An SPI allowing customized statistics collection.
 
 
 
 
 
 
 
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.
Contracts for reading and writing values to and from JDBC.
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.
 
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.