All Classes and Interfaces
Class
Description
Collects commons methods needed during the management of flush events.
An implementation of
InformationExtractor that obtains metadata
information from a database's information_schema.A description of the entities and tables affected by a native query.
Copy of com.ibm.asyncutil.util.AsyncClosable in com.ibm.async:asyncutil:0.1.0
with minor changes to the java doc.
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.
A marker enum that indicates there are no elements left in the iterator.
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.
Implementation of
Context.Key suitable for storing
instances of Session or StatelessSession,
or really anything at all, in the Vert.x context.A
ReactiveConnection that automatically performs batching
of insert, update, and delete statements, relieving the client
persister code of the responsibility to manage batching.A
ReactiveIdentifierGenerator which uses the database to allocate
blocks of ids.Delegate responsible for, in conjunction with the various
actions, implementing cascade processing.A
reactive session operation that may
be cascaded from a parent entity to its children.The possible
cascading actions for
a reactive session.Used with JBoss Logging's
FormatWith to display Class names in log
messages.Reactive operations that really belong to
CollectionTypeMakes the code simpler when dealing with ORM visitor pattern.
Standard Hibernate implementation of SelectQueryPlan for SQM-backed
Query implementations, which means
HQL/JPQL or CriteriaQueryAbstracts away from the Vert.x
Context
object, enabling alternative strategies for associating state
with the current reactive stream.An object that identifies something we store in the Vert.x
local context, usually a
Session or
StatelessSession, but in principle anything at all.A reactive
DefaultDeleteEventListener.A reactific
DefaultFlushEntityEventListener.A reactific
DefaultFlushEventListener.A reactive
DefaultLoadEventListener.A reactific
DefaultMergeEventListener.A reactific
DefaultPersistEventListener.A reactific
DefaultPersistOnFlushEventListener.We do two things here:
Perform needed
EntityEntry.getLockMode() related processing
A reactific
DefaultRefreshEventListener.A pool of reactive connections backed by a Vert.x
Pool.The default
SqlClientPoolConfiguration which configures the
Pool using the Hibernate ORM configuration
properties defined in Settings.A singleton instance of
Vertx that is created on
demand and destroyed automatically along with the Hibernate
session factory.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.
Support for JPA's
SequenceGenerator
for databases which do not support sequences.Reactive operations that really belong to
EntityTypeA pool of reactive connections backed by a Vert.x
Pool.Algorithms related to foreign key constraint transparency
Delegate for handling nullifying ("null"ing-out) non-cascaded associations
Represents a value of an attribute that forms part of the
natural key of an entity.
Allows access to object that can be useful for integrators
Similar to a
BiFunction
but one of the arguments is a primitive integer.Similar to a
BiPredicate
but one of the arguments is a primitive integer.Commonly used assertions to verify that the operations
are running on the expected events and threads.
Log category to be used with
LoggerFactory.make(Class, LogCategory).Implementation of
Context.Key suitable for use with
multi-tenancy.An API for Hibernate Reactive where non-blocking operations are
represented by a Mutiny
Uni.A non-blocking counterpart to the Hibernate
Query interface, allowing reactive
execution of HQL and JPQL queries.An object whose
Mutiny.Closeable.close() method returns a Uni.Operations common to objects which act as factories for instances of
Mutiny.Query.A non-blocking counterpart to the Hibernate
Session
interface, allowing a reactive style of interaction with the database.Factory for
reactive sessions.A non-blocking counterpart to the Hibernate
StatelessSession interface, which provides a
command-oriented API for performing bulk operations against a database.Allows code within
Mutiny.Session.withTransaction(Function) to mark a
transaction for rollback.Wraps a MutinySessionDelegator.delegate() session.
Implementation of
Mutiny.SessionFactory.Implements the
Mutiny.Session API.Wraps a MutinyStatelessSessionDelegator.delegate() stateless session.
Implements the
Mutiny.StatelessSession API.An implementation of
AbstractReactiveInformationSchemaBasedExtractorImpl
specifically for MySQL that obtains metadata from MySQL's non-standard
information_schema tables.Replaces the JdbcParameterRendererInitiator so to not require
users to set AvailableSettings.DIALECT_NATIVE_PARAM_MARKERS : this
gets enforces as the Vert.x SQL clients require it.
A dummy Hibernate
ConnectionProvider throws an
exception if a JDBC connection is requested.A Hibernate service initiator
that wraps the Hibernate
ConnectionProvider in an instance of
NoJdbcConnectionProvider.A Hibernate service initiator
that provides an implementation of
JdbcEnvironment that infers
the Hibernate Dialect from the JDBC URL.A dummy Hibernate
MultiTenantConnectionProvider
which throws an exception if a JDBC connection is requested.A Hibernate service initiator
for
NoJdbcMultiTenantConnectionProvider.A Hibernate service initiator
for the non-configured form of JTA platform.
Some databases have a different parameter syntax, which
the Vert.x
SqlClient does not abstract.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.Collects parameter bindings from Hibernate core code
that expects a JDBC
PreparedStatement.An implementation of
VertxInstance which allows the client
to provide an instance of Vertx whose lifecycle is managed
externally to Hibernate Reactive.Copy of
QueuedOperationCollectionAction, that adapts to ReactiveExecutableReactive version of
AbstractCollectionPersisterWith this interface we can have multiple delete coordinators that extend
AbstractDeleteCoordinator.An abstract implementation of
ReactiveEntityPersister whose
concrete implementations each extend a concrete subclass of
AbstractEntityPersister.Emulate
AbstractSelectionQuery.A reactive counterpart to
ActionQueue, where DML
operations are queued before execution during a flush.Reactive version of
AfterLoadActionContract representing some process that needs to occur during after transaction completion.
Connection has a method Connection.createArrayOf(String, Object[]), but we don't have
it in Vert.x SQL Client.Factory for
ReactiveArrayJdbcType.A reactive
BasicCollectionPersisterInitiator for
ReactiveStandardBatchLoaderFactoryContract representing some process that needs to occur during before transaction completion.
Reactive equivalent of
CallbackImplReactiveCollectionDomainResult.ReactiveCollectionInitializerAdapter<T extends org.hibernate.sql.results.graph.InitializerData>
A reactive
CollectionPersisterLike
CollectionUpdateAction but reactiveAbstracts over reactive database connections, defining
operations that allow queries to be executed asynchronously
via
CompletionStage.A Hibernate
Service that provides access to pooled
reactive connections.A Hibernate service initiator that
integrates our
ReactiveConnectionPool.A source of
ReactiveConnections.Defines the contract for handling of deletion events generated from a session.
A reactive
EntityDeleteAction.A reactific
EntityIdentityInsertAction (used when
inserting into tables with autoincrement columns).A BeforeTransactionCompletionProcess impl to verify and increment an entity version as party
of before-transaction-completion processing
Abstracts over
ReactiveEntityRegularInsertAction and ReactiveEntityIdentityInsertAction.Heavily inspired by
EntityManagerFactoryBuilderImpl.A reactive
EntityPersister.A reactive
EntityInsertAction.ReactiveEntitySelectFetchInitializer<Data extends org.hibernate.sql.results.graph.entity.internal.EntitySelectFetchInitializer.EntitySelectFetchInitializerData>
A reactific
EntityUpdateAction.A BeforeTransactionCompletionProcess impl to verify an entity version as part of
before-transaction-completion processing
Handle exceptions and convert them following the logic used in Hibernate ORM.
An operation that is scheduled for later non-blocking
execution in an
ReactiveActionQueue.Defines the contract for handling of reactive session flush events.
Adaptor that redirects DDL generated by the schema export
tool to the reactive connection.
A replacement for
IdentifierGenerator,
which supports a non-blocking method for obtaining the generated
identifier.Fix the insert and select id queries generated by Hibernate ORM
ReactiveInitializer<Data extends org.hibernate.sql.results.graph.InitializerData>
InsertRowsCoordinatorNoOpIntegrates Hibernate Reactive with Hibernate ORM by
replacing the built-in
event
listeners with reactive listeners.An
ReactiveEntityPersister backed by JoinedSubclassEntityPersister
and ReactiveAbstractEntityPersister.Map a JSON column as
JsonObjectWays this consumer can handle in-memory row de-duplication
Defines the contract for handling of load events generated from a session.
Defines the contract for handling of lock events generated from a session.
This service is only used to "mark" the registry as being
intended for use by an instance of Hibernate Reactive.
A Hibernate service initiator for
ReactiveMarkerService.A singleton
ReactiveMarkerService that marks the registry as running in "Reactive mode" allowing
the registration of reactive components.Defines the contract for handling of merge events generated from a session.
General utilities to check if certain Hibernate ORM components belong
to an ORM instance which is running in "Reactive mode".
The common natural id loader implementation for
ReactiveSimpleNaturalIdLoader and ReactiveCompoundNaturalIdLoader.A reactive
NonSelectQueryPlanA reactive
OneToManyPersisterAdd reactive methods to a
PersistenceContext.A JPA
PersistenceProvider for Hibernate Reactive.Define the persisters required by Hibernate Reactive, usually a reactive version of the ones
in Hibernate ORM.
A Hibernate service initiator
that creates a
ReactivePersisterClassResolver to register the
persisters needed by Hibernate Reactive.Defines the contract for handling of create events generated from a session.
Helper for handling checks to see whether ReactivePersistenceProvider is the requested
PersistenceProvider.This is a dirty trick to mitigate the performance impact of JDK-8180450;
hopefully temporary but we have no indication about a possible fix at
the moment.
Executes queries in a non-blocking fashion.
A reactive
QuerySqmImplDefines the contract for handling of refresh events generated from a session.
The reactive version of
RestrictedDeleteExecutionDelegateScoped to a single operation, so that we can keep
instance scoped state.
Support for JPA's
SequenceGenerator.Provides the list of service initiators that Hibernate Reactive needs to integrate with Hibernate ORM.
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.A contract with the Hibernate session backing the user-visible
reactive session.A Hibernate service initiator that wraps
the Hibernate
ConnectionProvider
in an instance of NoJdbcConnectionProvider.A Hibernate
SessionFactory that can be
unwrapped to produce a Stage.SessionFactory or a
Mutiny.SessionFactory.An
ReactiveSession implemented by extension of
the SessionImpl in Hibernate core.A reactive load plan for loading an array of state by a single restrictive part.
Reactive version of
SingleIdEntityLoader.Implementation of SingleIdEntityLoader for cases where the application has
provided the select load query
Standard implementation of
ReactiveSingleIdEntityLoader.Reactive loader subtype for loading an entity by a single unique-key value.
Custom variations for SqmMultiTableMutationStrategyProvider
An internal contract between the reactive session implementation
and the
Stage.Query and
Mutiny.Query APIs.A reactive
SqmSelectionQueryImplMutiny
A contract with the Hibernate stateless session backing the user-visible
reactive session.An
ReactiveStatelessSession implemented by extension of
the StatelessSessionImpl in Hibernate core.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.An
ReactiveEntityPersister backed by UnionSubclassEntityPersister
and ReactiveAbstractEntityPersister.A reactive
UpdateCoordinator that allows the creation of a ReactiveScopedUpdateCoordinator scoped
to a single update operation.Reactive version of
UpdateCoordinatorStandard, but it cannot be shared between multiple update operations.An adaptor that allows Hibernate core code which expects a JDBC
ResultSet to read values from Vert.x's RowSet.Represents the shape of a native SQL query result
set, as specified by an instance of the annotation
SqlResultSetMapping.Configuration properties for the Hibernate Reactive persistence provider,
for use with
ReactiveServiceRegistryBuilder.A reactive connection based on Vert.x's
SqlConnection.A pool of reactive connections backed by a supplier of
Vert.x
Pool instances.A strategy for configuring the Vert.x
Pool
used by DefaultSqlClientPool.A Hibernate service initiator that
allows the user to define their own
SqlClientPoolConfiguration
strategy.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.An API for Hibernate Reactive where non-blocking operations are
represented by a Java
CompletionStage.A non-blocking counterpart to the Hibernate
Query interface, allowing reactive
execution of HQL and JPQL queries.An object whose
Stage.Closeable.close() method returns a CompletionStage.Operations common to objects which act as factories for instances of
Stage.Query.A non-blocking counterpart to the Hibernate
Session
interface, allowing a reactive style of interaction with the database.Factory for
reactive sessions.A non-blocking counterpart to the Hibernate
StatelessSession interface, which provides a
command-oriented API for performing bulk operations against a database.Allows code within
Stage.Session.withTransaction(Function) to mark a
transaction for rollback.Implementation of
Stage.SessionFactory.Implements the
Stage.Session API.Implements the
Stage.StatelessSession API.see
CachedJdbcValuesMetadataSupport for JPA's
TableGenerator.For situation where we don't excpect to access the database,
Information about the version of Hibernate Reactive.
An adaptor for the Vert.x
Context.Factory for the default implementation of
VertxInstance.