All Classes

Class	Description
AbstractReactiveFlushingEventListener	Collects commons methods needed during the management of flush events.
AbstractReactiveInformationSchemaBasedExtractorImpl	An implementation of InformationExtractor that obtains metadata information from a database's information_schema.
AffectedEntities	A description of the entities and tables affected by a native query.
AsyncCloseable	Copy of com.ibm.asyncutil.util.AsyncClosable in com.ibm.async:asyncutil:0.1.0 with minor changes to the java doc.
AsyncIterator<T>	Copy of com.ibm.asyncutil.iteration.AsyncIterator from com.ibm.async:asyncutil:0.1.0 without all the methods and imports we don't need for Hibernate Reactive.
AsyncIterator.End	A marker enum that indicates there are no elements left in the iterator.
AsyncTrampoline	Copy of com.ibm.asyncutil.iteration.AyncTrampoline from com.ibm.async:asyncutil:0.1.0 without all the methods and imports we don't need for Hibernate Reactive.
BaseKey<T>	Implementation of Context.Key suitable for storing instances of Session or StatelessSession, or really anything at all, in the Vert.x context.
BatchingConnection	A ReactiveConnection that automatically performs batching of insert, update, and delete statements, relieving the client persister code of the responsibility to manage batching.
BlockingIdentifierGenerator	A ReactiveIdentifierGenerator which uses the database to allocate blocks of ids.
CachingReactiveLoader<T>	Defines common reactive operations inherited by query loaders, in particular, interaction with the cache.
Cascade<C>	Delegate responsible for, in conjunction with the various actions, implementing cascade processing.
CascadingAction<C>	A reactive session operation that may be cascaded from a parent entity to its children.
CascadingActions	The possible cascading actions for a reactive session.
CascadingActions.BaseCascadingAction<C>
ClassFormatter	Used with JBoss Logging's FormatWith to display Class names in log messages.
CompletionStages
ConstraintViolationException	the requested DML operation resulted in a violation of a defined integrity constraint.
Context	Abstracts away from the Vert.x Context object, enabling alternative strategies for associating state with the current reactive stream.
Context.Key<T>	An object that identifies something we store in the Vert.x local context, usually a Session or StatelessSession, but in principle anything at all.
Criteria<R>	Abstracts over criteria queries, updates, and deletes.
CriteriaQueryOptions
CriteriaQueryRenderingContext	A RenderingContext used when compiling criteria queries for reactive execution.
DefaultReactiveAutoFlushEventListener
DefaultReactiveDeleteEventListener	A reactific DefaultDeleteEventListener.
DefaultReactiveFlushEntityEventListener	A reactific DefaultFlushEntityEventListener.
DefaultReactiveFlushEventListener	A reactific DefaultFlushEventListener.
DefaultReactiveInitializeCollectionEventListener
DefaultReactiveLoadEventListener	A reactive DefaultLoadEventListener.
DefaultReactiveLockEventListener
DefaultReactiveMergeEventListener	A reactific DefaultMergeEventListener.
DefaultReactivePersistEventListener	A reactific DefaultPersistEventListener.
DefaultReactivePersistOnFlushEventListener	A reactific DefaultPersistOnFlushEventListener.
DefaultReactivePostLoadEventListener	We do 2 things here: Call Lifecycle interface if necessary Perform needed EntityEntry.getLockMode() related processing
DefaultReactiveRefreshEventListener	A reactific DefaultRefreshEventListener.
DefaultReactiveResolveNaturalIdEventListener	A reactific DefaultResolveNaturalIdEventListener.
DefaultSqlClientPool	A pool of reactive connections backed by a Vert.x Pool.
DefaultSqlClientPoolConfiguration	The default SqlClientPoolConfiguration which configures the Pool using the Hibernate ORM configuration properties defined in Settings.
DefaultVertxInstance	A singleton instance of Vertx that is created on demand and destroyed automatically along with the Hibernate session factory.
Either<L,R>	Copy of com.ibm.asyncutil.util.Either from com.ibm.async:asyncutil:0.1.0 without all the methods and imports we don't need for Hibernate Reactive.
EmulatedSequenceReactiveIdentifierGenerator	Support for JPA's SequenceGenerator for databases which do not support sequences.
EntityTypes	Reactive operations that really belong to EntityType
ExternalSqlClientPool	A pool of reactive connections backed by a Vert.x Pool.
ForeignKeys	Algorithms related to foreign key constraint transparency
ForeignKeys.Nullifier	Delegate for handling nullifying ("null"ing-out) non-cascaded associations
Identifier<T>	Represents a value of an attribute that forms part of the natural key of an entity.
Identifier.Composite<T>
Identifier.Id<T>
IdentifierGeneration
Implementor	Allows access to object that can be useful for integrators
IntBiFunction<T,R>	Similar to a BiFunction but one of the arguments is a primitive integer.
IntBiPredicate<T>	Similar to a BiPredicate but one of the arguments is a primitive integer.
InternalStateAssertions	Commonly used assertions to verify that the operations are running on the expected events and threads.
JdbcNull
Log
LogCategory	Log category to be used with LoggerFactory.make(Class, LogCategory).
LoggerFactory
MultitenantKey<T>	Implementation of Context.Key suitable for use with multi-tenancy.
Mutiny	An API for Hibernate Reactive where non-blocking operations are represented by a Mutiny Uni.
Mutiny.Closeable	An object whose Mutiny.Closeable.close() method returns a Uni.
Mutiny.Query<R>	A non-blocking counterpart to the Hibernate Query interface, allowing reactive execution of HQL and JPQL queries.
Mutiny.Session	A non-blocking counterpart to the Hibernate Session interface, allowing a reactive style of interaction with the database.
Mutiny.SessionFactory	Factory for reactive sessions.
Mutiny.StatelessSession	A non-blocking counterpart to the Hibernate StatelessSession interface, which provides a command-oriented API for performing bulk operations against a database.
Mutiny.Transaction	Allows code within Mutiny.Session.withTransaction(Function) to mark a transaction for rollback.
MutinyImplementor	Deprecated. It will be removed
MutinyQueryImpl<R>	Implementation of Mutiny.Query.
MutinySessionFactoryImpl	Implementation of Mutiny.SessionFactory.
MutinySessionImpl	Implements the Mutiny.Session API.
MutinyStatelessSessionImpl	Implements the Mutiny.StatelessSession API.
MutinyValueGenerator<T>	A reactive ValueGenerator that gives access to a Mutiny.Session.
MySqlReactiveInformationExtractorImpl	An implementation of AbstractReactiveInformationSchemaBasedExtractorImpl specifically for MySQL that obtains metadata from MySQL's non-standard information_schema tables.
NoJdbcConnectionProvider	A dummy Hibernate ConnectionProvider throws an exception if a JDBC connection is requested.
NoJdbcConnectionProviderInitiator	A Hibernate service initiator that wraps the Hibernate ConnectionProvider in an instance of NoJdbcConnectionProvider.
NoJdbcEnvironmentInitiator	A Hibernate service initiator that provides an implementation of JdbcEnvironment that infers the Hibernate Dialect from the JDBC URL.
NoJdbcMultiTenantConnectionProvider	A dummy Hibernate MultiTenantConnectionProvider which throws an exception if a JDBC connection is requested.
NoJdbcMultiTenantConnectionProviderInitiator	A Hibernate service initiator for NoJdbcMultiTenantConnectionProvider.
NoJtaPlatformInitiator	A Hibernate service initiator for the non-configured form of JTA platform.
OracleParameters
OracleSqlReactiveInformationExtractorImpl
Parameters	Some databases have a different parameter syntax, which the Vert.x SqlClient does not abstract.
PostgresParameters
PostgreSqlReactiveInformationExtractorImpl	An implementation of AbstractReactiveInformationSchemaBasedExtractorImpl specifically for PostgreSQL that obtains metadata from PostgreSQL's system tables, when it is not available from PosgreSQL's information_schema.
PreparedStatementAdaptor	Collects parameter bindings from Hibernate core code that expects a JDBC PreparedStatement.
PreparedStatementAdaptor.Binder
ProvidedVertxInstance	An implementation of VertxInstance which allows the client to provide an instance of Vertx whose lifecycle is managed externally to Hibernate Reactive.
QueryParametersAdaptor
QueryType
QueuedOperationCollectionAction	Copy of QueuedOperationCollectionAction, that adapts to ReactiveExecutable
ReactiveAbstractCollectionPersister	Reactive version of AbstractCollectionPersister
ReactiveAbstractCollectionPersister.ExpectationAdaptor
ReactiveAbstractEntityLoader	A reactific AbstractEntityLoader.
ReactiveAbstractEntityPersister	An abstract implementation of ReactiveEntityPersister whose concrete implementations each extend a concrete subclass of AbstractEntityPersister.
ReactiveAbstractEntityPersister.DeleteExpectation
ReactiveAbstractEntityPersister.InsertExpectation
ReactiveAbstractEntityPersister.UpdateExpectation
ReactiveActionQueue	A reactive counterpart to ActionQueue, where DML operations are queued before execution during a flush.
ReactiveAfterTransactionCompletionProcess	Contract representing some process that needs to occur during after transaction completion.
ReactiveAutoFlushEventListener
ReactiveBasicCollectionLoader	A reactive BasicCollectionLoader
ReactiveBasicCollectionPersister	A reactive BasicCollectionPersister
ReactiveBatchingCollectionInitializerBuilder	Superclass of builders for batching collection initializers.
ReactiveBatchingEntityLoader	The base contract for loaders capable of performing batch-fetch loading of entities using multiple primary key values in the SQL WHERE clause.
ReactiveBatchingEntityLoaderBuilder	Superclass of builders for batching entity loaders.
ReactiveBeforeTransactionCompletionProcess	Contract representing some process that needs to occur during before transaction completion.
ReactiveBulkIdStrategy	A reactive version of AbstractMultiTableBulkIdStrategyImpl used for handling HQL update and delete queries that affect multiple tables.
ReactiveCacheEntityLoaderHelper
ReactiveCascadeEntityLoader	A reactive EntityLoader that is used for initializing unfetched associations during the cascade process.
ReactiveCollectionInitializer	A reactific CollectionInitializer, the contract implemented by all reactive collection loaders, including batch loaders.
ReactiveCollectionLoader	A reactific CollectionLoader.
ReactiveCollectionPersister	A reactive CollectionPersister
ReactiveCollectionRecreateAction
ReactiveCollectionRemoveAction
ReactiveCollectionUpdateAction	Like CollectionUpdateAction but reactive
ReactiveConnection	Abstracts over reactive database connections, defining operations that allow queries to be executed asynchronously via CompletionStage.
ReactiveConnection.Expectation
ReactiveConnection.Result
ReactiveConnectionPool	A Hibernate Service that provides access to pooled reactive connections.
ReactiveConnectionPoolInitiator	A Hibernate service initiator that integrates our ReactiveConnectionPool.
ReactiveConnectionSupplier	A source of ReactiveConnections.
ReactiveCriteriaBuilderImpl	A JPA CriteriaBuilder for that acts as a factory for ReactiveCriteriaQueryImpl.
ReactiveCriteriaDeleteImpl<T>	A reactific CriteriaDeleteImpl, providing the implementation of CriteriaDelete.
ReactiveCriteriaQueryImpl<T>	A reactific CriteriaQueryImpl, providing the implementation of CriteriaQuery.
ReactiveCriteriaUpdateImpl<T>	A reactific CriteriaUpdateImpl, providing the implementation of CriteriaUpdate.
ReactiveCustomLoader<T>	A reactive Loader for native SQL queries.
ReactiveDeleteEventListener	Defines the contract for handling of deletion events generated from a session.
ReactiveDynamicBatchingCollectionDelegator	A batching entity loader for BatchFetchStyle.DYNAMIC which selects between a single-key ReactiveCollectionInitializer and a batching ReactiveDynamicBatchingCollectionInitializer depending upon how many keys it's given.
ReactiveDynamicBatchingCollectionInitializerBuilder	A ReactiveBatchingCollectionInitializerBuilder that is enabled when BatchFetchStyle.DYNAMIC is selected.
ReactiveDynamicBatchingEntityDelegator	A batching entity loader for BatchFetchStyle.DYNAMIC which selects between a single-key ReactiveEntityLoader and a batching ReactiveDynamicBatchingEntityLoader depending upon how many keys it's given.
ReactiveDynamicBatchingEntityLoaderBuilder	A ReactiveBatchingEntityLoaderBuilder that is enabled when BatchFetchStyle.DYNAMIC is selected.
ReactiveEntityDeleteAction	A reactific EntityDeleteAction.
ReactiveEntityIdentityInsertAction	A reactific EntityIdentityInsertAction (used when inserting into tables with autoincrement columns).
ReactiveEntityIncrementVersionProcess	A BeforeTransactionCompletionProcess impl to verify and increment an entity version as party of before-transaction-completion processing
ReactiveEntityInsertAction	Abstracts over ReactiveEntityRegularInsertAction and ReactiveEntityIdentityInsertAction.
ReactiveEntityLoader	A reactific EntityLoader.
ReactiveEntityManagerFactoryBuilder	Heavily inspired by EntityManagerFactoryBuilderImpl.
ReactiveEntityPersister	A reactive EntityPersister.
ReactiveEntityRegularInsertAction	A reactific EntityInsertAction.
ReactiveEntityUpdateAction	A reactific EntityUpdateAction.
ReactiveEntityVerifyVersionProcess	A BeforeTransactionCompletionProcess impl to verify an entity version as part of before-transaction-completion processing
ReactiveExceptionConverter	Handle exceptions and convert them following the logic used in Hibernate ORM.
ReactiveExecutable	An operation that is scheduled for later non-blocking execution in an ReactiveActionQueue.
ReactiveFlushEventListener	Defines the contract for handling of reactive session flush events.
ReactiveGenerationTarget	Adaptor that redirects DDL generated by the schema export tool to the reactive connection.
ReactiveGeneratorWrapper<T>
ReactiveIdentifierGenerator<Id>	A replacement for IdentifierGenerator, which supports a non-blocking method for obtaining the generated identifier.
ReactiveIdentifierGeneratorFactory
ReactiveIdentifierGeneratorFactoryInitiator
ReactiveIdentityGenerator	Fix the insert and select id queries generated by Hibernate ORM
ReactiveIdentityGenerator.Db2IdentifierGeneratingInsert
ReactiveIdentityGenerator.PostgresIdentifierGeneratingInsert
ReactiveIdentityGenerator.ReactiveInsertAndSelectDelegate
ReactiveIdentityGenerator.SqlServerIdentifierGeneratingInsert
ReactiveImprovedExtractionContextImpl
ReactiveIntegrator	Integrates Hibernate Reactive with Hibernate ORM by replacing the built-in event listeners with reactive listeners.
ReactiveJoinedSubclassEntityPersister	An ReactiveEntityPersister backed by JoinedSubclassEntityPersister and ReactiveAbstractEntityPersister.
ReactiveLoader	Defines common reactive operations inherited by all kinds of loaders.
ReactiveLoaderBasedLoader	An interface intended for ReactiveLoader implementations that also extend a Loader implementation.
ReactiveLoaderBasedResultSetProcessor	A ReactiveResultSetProcessor intended to be used by ReactiveLoaderBasedLoader implementations.
ReactiveLoadEventListener	Defines the contract for handling of load events generated from a session.
ReactiveLockEventListener	Defines the contract for handling of lock events generated from a session.
ReactiveMarkerService	This service is only used to "mark" the registry as being intended for use by an instance of Hibernate Reactive.
ReactiveMarkerServiceInitiator	A Hibernate service initiator for ReactiveMarkerService.
ReactiveMarkerServiceSingleton	A singleton ReactiveMarkerService that marks the registry as running in "Reactive mode" allowing the registration of reactive components.
ReactiveMergeEventListener	Defines the contract for handling of merge events generated from a session.
ReactiveModeCheck	General utilities to check if certain Hibernate ORM components belong to an ORM instance which is running in "Reactive mode".
ReactiveNativeQuery<R>	An internal contract between the reactive session implementation and the Stage.Query and Mutiny.Query APIs.
ReactiveNativeQueryImpl<R>	Implementation of ReactiveNativeQuery by extension of NativeQueryImpl.
ReactiveNativeSQLQueryPlan
ReactiveOneToManyLoader	A reactive OneToManyLoader
ReactiveOneToManyPersister	A reactive OneToManyPersister
ReactiveOrphanRemovalAction
ReactivePaddedBatchingCollectionInitializerBuilder	A ReactiveBatchingCollectionInitializerBuilder that is enabled when BatchFetchStyle.PADDED is selected.
ReactivePaddedBatchingEntityLoader	A batching entity loader for BatchFetchStyle.PADDED.
ReactivePaddedBatchingEntityLoaderBuilder	A ReactiveBatchingEntityLoaderBuilder that is enabled when BatchFetchStyle.PADDED is selected.
ReactivePersistenceContextAdapter	Add reactive methods to a PersistenceContext.
ReactivePersistenceProvider	JPA PersistenceProvider for Hibernate Reactive.
ReactivePersisterClassResolver	Define the persisters required by Hibernate Reactive, usually a reactive version of the ones in Hibernate ORM.
ReactivePersisterClassResolverInitiator	A Hibernate service initiator that creates a ReactivePersisterClassResolver to register the persisters Hibernate Reactive needs.
ReactivePersistEventListener	Defines the contract for handling of create events generated from a session.
ReactivePlanEntityLoader	An entity loader that respects the JPA EntityGraph in effect.
ReactivePlanEntityLoader.Builder
ReactiveProviderChecker	Helper for handling checks to see whether ReactivePersistenceProvider is the requested PersistenceProvider.
ReactiveQuery<R>	An internal contract between the reactive session implementation and the Stage.Query and Mutiny.Query APIs.
ReactiveQueryExecutor	Executes queries in a non-blocking fashion.
ReactiveQueryImpl<R>	Implementation of ReactiveQuery by extension of QueryImpl.
ReactiveQueryLoader<T>	A reactive QueryLoader for HQL queries.
ReactiveQueryTranslatorFactory	Facade for the generation of reactive QueryTranslator and FilterTranslator instances.
ReactiveQueryTranslatorFactoryInitiator	A Hibernate service initiator that creates ReactiveQueryTranslatorFactory instances.
ReactiveQueryTranslatorImpl<T>	A FilterTranslator that adds reactive versions of the existing methods in the interface and throw an exception if the non-reactive variant is invoked.
ReactiveRefreshEventListener	Defines the contract for handling of refresh events generated from a session.
ReactiveResolveNaturalIdEventListener	Defines the contract for handling of resolve natural id events generated from a session.
ReactiveResultSetProcessor	An interface intended to unify how a ResultSet is processed by by ReactiveLoader implementations..
ReactiveSchemaManagementTool
ReactiveSchemaManagementToolInitiator
ReactiveServiceInitiators	Provides the list of service initiators that Hibernate Reactive needs to integrate with Hibernate ORM.
ReactiveServiceRegistryBuilder	Adaptation of StandardServiceRegistryBuilder; the main difference is the use of a different initial set of services and the fact this will not attempt to load service contributors and other Integrators.
ReactiveSession	A contract with the Hibernate session backing the user-visible reactive session.
ReactiveSessionFactoryBuilder	A SessionFactoryBuilder for SessionFactory instances that can be unwrapped to produce a Stage.SessionFactory or Mutiny.SessionFactory.
ReactiveSessionFactoryBuilderInitiator	A Hibernate service initiator that wraps the Hibernate ConnectionProvider in an instance of NoJdbcConnectionProvider.
ReactiveSessionFactoryImpl	A Hibernate SessionFactory that can be unwrapped to produce a Stage.SessionFactory or a Mutiny.SessionFactory.
ReactiveSessionImpl	An ReactiveSession implemented by extension of the SessionImpl in Hibernate core.
ReactiveSingleTableEntityPersister	An ReactiveEntityPersister backed by SingleTableEntityPersister and ReactiveAbstractEntityPersister.
ReactiveStatelessSession	Mutiny A contract with the Hibernate stateless session backing the user-visible reactive session.
ReactiveStatelessSessionImpl	An ReactiveStatelessSession implemented by extension of the StatelessSessionImpl in Hibernate core.
ReactiveSubselectCollectionLoader
ReactiveSubselectOneToManyLoader	Implements subselect fetching for a one to many association
ReactiveTypeContributor	Overrides Hibernate's built-in `materialized_blob` and `materialized_clob` type mappings and replaces them with the same handling as regular byte arrays and strings, since the SqlClient doesn't support any special handling for LOBs.
ReactiveUnionSubclassEntityPersister	An ReactiveEntityPersister backed by UnionSubclassEntityPersister and ReactiveAbstractEntityPersister.
ReactiveUniqueEntityLoader	A reactific UniqueEntityLoader, the contract implemented by all reactive entity loaders, including batch loaders.
ResultSetAdaptor	An adaptor that allows Hibenate core code which expects a JDBC ResultSet to read values from Vert.x's RowSet.
ResultSetMapping<T>	Represents the shape of a native SQL query result set, as specified by an instance of the annotation SqlResultSetMapping.
SequenceReactiveIdentifierGenerator	Support for JPA's SequenceGenerator.
SessionUtil
Settings	Configuration properties for the Hibernate Reactive persistence provider, for use with ReactiveServiceRegistryBuilder.
SqlClientConnection	A reactive connection based on Vert.x's SqlConnection.
SqlClientPool	A pool of reactive connections backed by a supplier of Vert.x Pool instances.
SqlClientPoolConfiguration	A strategy for configuring the Vert.x Pool used by DefaultSqlClientPool.
SqlClientPoolConfigurationInitiator	A Hibernate service initiator that allows the user to define their own SqlClientPoolConfiguration strategy.
SQLServerParameters
SqlServerReactiveInformationExtractorImpl	An implementation of AbstractReactiveInformationSchemaBasedExtractorImpl specifically for SQL Server that obtains metadata from SQL Server's system tables, when it is not available from SQL Server's information_schema.
Stage	An API for Hibernate Reactive where non-blocking operations are represented by a Java CompletionStage.
Stage.Closeable	An object whose Stage.Closeable.close() method returns a CompletionStage.
Stage.Query<R>	A non-blocking counterpart to the Hibernate Query interface, allowing reactive execution of HQL and JPQL queries.
Stage.Session	A non-blocking counterpart to the Hibernate Session interface, allowing a reactive style of interaction with the database.
Stage.SessionFactory	Factory for reactive sessions.
Stage.StatelessSession	A non-blocking counterpart to the Hibernate StatelessSession interface, which provides a command-oriented API for performing bulk operations against a database.
Stage.Transaction	Allows code within Stage.Session.withTransaction(Function) to mark a transaction for rollback.
StageQueryImpl<R>	Implementation of Stage.Query.
StageSessionFactoryImpl	Implementation of Stage.SessionFactory.
StageSessionImpl	Implements the Stage.Session API.
StageStatelessSessionImpl	Implements the Stage.StatelessSession API.
StageValueGenerator<T>	A reactive ValueGenerator that gives access to a Stage.Session.
StatementsWithParameters	A list of SQL statements to be executed as a single logical unit.
TableReactiveIdentifierGenerator	Support for JPA's TableGenerator.
UnexpectedAccessToTheDatabase	For situation where we don't excpect to access the database,
VertxContext	An adaptor for the Vert.x Context.
VertxContextInitiator
VertxInstance	Used by DefaultSqlClientPool and VertxContext to obtain an instance of Vertx.
VertxInstanceInitiator	Factory for the default implementation of VertxInstance.
VertxSqlClientException	Wraps a SQLException.