Uses of Annotation Interface
org.hibernate.Incubating

Packages that use Incubating

Package	Description
org.hibernate	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.
org.hibernate.action.queue.spi	Service and decomposition contracts for Hibernate action queue implementations.
org.hibernate.action.queue.spi.bind
org.hibernate.action.queue.spi.decompose
org.hibernate.action.queue.spi.decompose.collection
org.hibernate.action.queue.spi.decompose.entity
org.hibernate.action.queue.spi.meta
org.hibernate.action.queue.spi.plan
org.hibernate.annotations	A set of mapping annotations which extend the O/R mapping annotations defined by JPA.
org.hibernate.annotations.processing	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.
org.hibernate.binder	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.
org.hibernate.boot	This package contains the interfaces that make up the bootstrap API for Hibernate.
org.hibernate.boot.model	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.
org.hibernate.boot.model.convert.spi	Defines the SPI of a registry of JPA AttributeConverters.
org.hibernate.boot.model.naming	This API allows intervention by generic code in the process of determining the names of database objects (tables, columns, and constraints).
org.hibernate.boot.model.relational	Some SPIs related to DDL generation and schema management.
org.hibernate.boot.spi	A range of SPIs allowing integration with—and customization of—the process of building metadata.
org.hibernate.bytecode.enhance.spi	Package defining bytecode code enhancement (instrumentation) support.
org.hibernate.bytecode.enhance.spi.interceptor	Support for bytecode interceptor implementations.
org.hibernate.callback.spi
org.hibernate.cfg	This package defines APIs for configuring Hibernate.
org.hibernate.collection.spi	This package defines the SPI of a framework for lazy-initializing and state-tracking collection wrappers.
org.hibernate.context.spi	SPI-level contracts around "current session" and "current tenant" support.
org.hibernate.dialect	Defines the root contracts and built-in implementations for SQL dialects.
org.hibernate.dialect.literal.spi	Supported Dialect contracts for rendering SQL literals.
org.hibernate.dialect.lob.spi
org.hibernate.dialect.lock.spi	Incubating Dialect contracts for describing database locking capabilities, selecting locking strategies, and rendering locking SQL.
org.hibernate.dialect.schema.spi
org.hibernate.dialect.sql.ast.spi	Dialect contracts for selecting SQL AST translators and expressing database-specific SQL AST rendering behavior.
org.hibernate.dialect.testing	Provider-facing entry points and immutable results for the Hibernate ORM Dialect contract test kit.
org.hibernate.dialect.testing.spi	Contracts implemented or consumed by external Dialect providers when using the Hibernate ORM Dialect contract test kit.
org.hibernate.dialect.type.spi
org.hibernate.engine.creation	Support for the creation of stateful and stateless sessions.
org.hibernate.engine.extension.spi	This package contains an SPI for Session extensions.
org.hibernate.engine.jdbc.batch.spi	Defines contracts for JDBC batching support.
org.hibernate.engine.jdbc.connections.spi	Defines SPI contracts for obtaining JDBC Connections from a provider implemented as a service.
org.hibernate.engine.jdbc.mutation	Package defining support for executing mutation SQL statements produced by an entity persister or collection persister.
org.hibernate.engine.jdbc.mutation.group
org.hibernate.engine.jdbc.spi	SPI contracts supporting various aspects of JDBC interaction.
org.hibernate.engine.query.spi	An SPI for dealing with parameters of native queries.
org.hibernate.engine.spi	This package defines some central internal SPI abstractions used throughout the implementation of Hibernate.
org.hibernate.envers	Hibernate's entity version (audit/history) support.
org.hibernate.envers.boot.spi
org.hibernate.envers.query
org.hibernate.envers.strategy.spi
org.hibernate.event.monitor.spi	An SPI for services which collect, report, or monitor diagnostic events.
org.hibernate.event.service.spi	An SPI for the event listener registration service.
org.hibernate.event.spi	Defines the event types and event listener interfaces for events produced by the stateful Session.
org.hibernate.exception	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.
org.hibernate.generator	This package defines an abstraction over all kinds of automatic value generation, including id generation and version number generation.
org.hibernate.graph	Implements and extends the JPA-defined entity graph API.
org.hibernate.graph.spi	This package defines an internal SPI abstracting over implementations of the APIs defined in org.hibernate.graph.
org.hibernate.id.enhanced	Enhanced/improved versions of table and sequence based identifier generators targeting portability and unified configuration.
org.hibernate.integrator.spi	An SPI for extensions which integrate with Hibernate via the Java ServiceLoader facility.
org.hibernate.jpa	The packages in this namespace are responsible for implementing certain requirements of the JPA specification, especially things which are only needed when Hibernate is acting as a JPA persistence provider.
org.hibernate.mapping	This package defines the Hibernate configuration-time mapping model.
org.hibernate.metamodel	This package defines an API for accessing the runtime metamodel describing persistent entities in Java and their mappings to the relational database schema.
org.hibernate.metamodel.mapping	Defines the runtime mapping metamodel describing how domain-model parts map to relational database objects.
org.hibernate.metamodel.model.domain	Defines the runtime domain metamodel, which describes the Java aspect of the application's domain model parts (entities, attributes).
org.hibernate.metamodel.spi	An SPI supporting custom instantiation of entity instances and embeddable objects.
org.hibernate.persister.collection	This package abstracts persistence mechanisms for collections.
org.hibernate.persister.entity	This package abstracts persistence mechanisms for entities.
org.hibernate.persister.entity.mutation	Defines support for performing mutation operations originating from persistence-context events.
org.hibernate.persister.state.spi	Extension point for customized state management, enabling functionality such as soft delete, temporal data, and audit logging.
org.hibernate.procedure	Defines support for executing database stored procedures and functions and accessing their outputs.
org.hibernate.procedure.spi	Defines an SPI for calling stored procedures and functions.
org.hibernate.property.access.spi	An SPI abstracting how persistent attributes of an entity or embeddable type are accessed by Hibernate.
org.hibernate.query	Everything related to HQL/JPQL, native SQL, and criteria queries.
org.hibernate.query.assignment	Support for assignment with MutationSpecification.
org.hibernate.query.criteria	The JPA-standard criteria query API defines all the operations needed express any query written in standard JPQL.
org.hibernate.query.criteria.spi	SPI for extending HibernateCriteriaBuilder with additional functionality by registering a Service.
org.hibernate.query.hql.spi	SPIs for HQL support.
org.hibernate.query.named.spi
org.hibernate.query.range	The Range framework.
org.hibernate.query.restriction	The Restriction framework.
org.hibernate.query.results.spi
org.hibernate.query.specification	Support for SelectionSpecification and MutationSpecification which is similar in concept to criteria queries, but focused on ease-of-use and less verbosity.
org.hibernate.query.spi	Contains a range of internal abstractions for dealing with query execution, query plans, query options, and query parameters.
org.hibernate.query.sql.spi	SPIs for native SQL query support.
org.hibernate.query.sqm.function	An SPI for defining, registering, and rendering functions in HQL.
org.hibernate.query.sqm.produce.function	Package defining support for SqmFunctionDescriptor handling.
org.hibernate.query.sqm.spi	SPI-level SQM contracts
org.hibernate.query.sqm.tree.spi	This package contains the classes that make up the SQM tree nodes.
org.hibernate.query.sqm.tree.spi.domain	Nodes representing path expressions in the SQM tree.
org.hibernate.query.sqm.tree.spi.expression	Nodes representing expressions in the SQM tree.
org.hibernate.query.sqm.tree.spi.from	Nodes representing root entities and joins in the SQM tree.
org.hibernate.query.sqm.tree.spi.insert	Nodes representing insert statements in the SQM tree.
org.hibernate.relational	Programmatic access to the schema management tool.
org.hibernate.resource.beans.spi	Defines contracts for accessing managed beans, choosing a caching policy, and supplying fallback instances independently of a particular bean container.
org.hibernate.resource.jdbc.spi	An SPI for managing JDBC connections and other heavyweight resources, based around the idea of a "JDBC session".
org.hibernate.settings
org.hibernate.spi	A tiny SPI for dealing with compound names and navigable paths.
org.hibernate.sql.ast.spi.model.builder	Supported construction contracts and reusable implementations for mapping-model mutations.
org.hibernate.sql.ast.spi.query	Package defining the SQL AST.
org.hibernate.sql.ast.spi.query.expression	AST nodes representing expressions in a SQL tree.
org.hibernate.sql.ast.spi.translation	Contracts for translating a SQL AST to executable SQL.
org.hibernate.sql.exec.spi	SPI for execution of SQL statements via JDBC.
org.hibernate.sql.model	Package contains specialized SQL AST nodes and builders for table mutations of model parts originating from normal persistence-context events.
org.hibernate.sql.results.graph	Defines the provider-facing graph used to turn JDBC rows into domain results.
org.hibernate.sql.results.graph.embeddable	Embeddable-valued result graph contracts.
org.hibernate.sql.results.jdbc.spi
org.hibernate.sql.results.spi
org.hibernate.sql.spi.mutation	Logical post-translation mutation contracts used for batching and execution.
org.hibernate.temporal	Support for working with temporal or audited data.
org.hibernate.temporal.spi	SPI for integrating with a source of changeset identifiers for use with temporal or audited data.
org.hibernate.tool.schema	Contains tooling related to DDL generation, export, migration, and validation.
org.hibernate.tool.schema.extract.spi	Defines an SPI for schema information extraction from the database via JDBC.
org.hibernate.tool.schema.spi	An SPI for tooling related to DDL generation, export, migration, and validation.
org.hibernate.type	A Hibernate Type is a strategy for mapping a Java property type to a JDBC type or types.
org.hibernate.type.descriptor.converter.spi	An SPI for basic-typed value conversions, including support for handling JPA AttributeConverter instances as part of the Hibernate Type system.
org.hibernate.type.descriptor.java	Integrates a range of types defined by the JDK with the type system of Hibernate.
org.hibernate.type.descriptor.java.spi	SPIs related to JavaType.
org.hibernate.type.descriptor.jdbc	Defines handling of almost the full range of standard JDBC-defined SQL data types.
org.hibernate.type.descriptor.jdbc.spi	SPIs related to JdbcType.
org.hibernate.type.descriptor.sql	An API for working with abstract families of DDL types parameterized by varying length, precision, and scale.
org.hibernate.type.format	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.
org.hibernate.type.spi	Defines a registry for Hibernate Types.
org.hibernate.usertype	An API for user-defined custom types which extend the set of built-in types defined in org.hibernate.type.

Packages with annotations of type Incubating

Package	Description
org.hibernate.query.assignment	Support for assignment with MutationSpecification.
org.hibernate.audit	API for querying the history of audited entities.
org.hibernate.sql.ast.spi.model.builder	Supported construction contracts and reusable implementations for mapping-model mutations.
org.hibernate.query.common	Common APIs used internally, in the SQL tree, in the dialects, and in the criteria query API.
org.hibernate.query.criteria	The JPA-standard criteria query API defines all the operations needed express any query written in standard JPQL.
org.hibernate.metamodel.model.domain	Defines the runtime domain metamodel, which describes the Java aspect of the application's domain model parts (entities, attributes).
org.hibernate.sql.exec	Support for execution of SQL statements via JDBC.
org.hibernate.type.format	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.
org.hibernate.query.sqm.produce.function	Package defining support for SqmFunctionDescriptor handling.
org.hibernate.graph	Implements and extends the JPA-defined entity graph API.
org.hibernate.sql.results.graph	Defines the provider-facing graph used to turn JDBC rows into domain results.
org.hibernate.sql.spi.mutation.jdbc	Extensions to JdbcOperation for model mutations.
org.hibernate.dialect.lock	Shared locking vocabulary for Dialect.
org.hibernate.metamodel.mapping	Defines the runtime mapping metamodel describing how domain-model parts map to relational database objects.
org.hibernate.metamodel	This package defines an API for accessing the runtime metamodel describing persistent entities in Java and their mappings to the relational database schema.
org.hibernate.sql.ast.spi.model	SQL AST and builders used with flushed-based mutations (persist, merge, etc.).
org.hibernate.sql.model	Package contains specialized SQL AST nodes and builders for table mutations of model parts originating from normal persistence-context events.
org.hibernate.boot.models	Overall, this module is responsible for taking managed-resources and building the hibernate-models model (ClassDetails, etc.) to ultimately be bound into Hibernate's boot-time model.
org.hibernate.engine.jdbc.mutation	Package defining support for executing mutation SQL statements produced by an entity persister or collection persister.
org.hibernate.persister.collection.mutation	Defines support for performing mutation operations against collections.
org.hibernate.persister.entity.mutation	Defines support for performing mutation operations originating from persistence-context events.
org.hibernate.sql.spi.mutation	Logical post-translation mutation contracts used for batching and execution.
org.hibernate.annotations.processing	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.
org.hibernate.query.range	The Range framework.
org.hibernate.query.restriction	The Restriction framework.
org.hibernate.sql.ast.spi.result	Incubating contracts for producing domain results from a SQL AST.
org.hibernate.action.queue.spi	Service and decomposition contracts for Hibernate action queue implementations.
org.hibernate.dialect.aggregate.spi	Supported aggregate-column mapping, rendering, DDL, and capability contracts supplied by a Dialect.
org.hibernate.dialect.lock.spi	Incubating Dialect contracts for describing database locking capabilities, selecting locking strategies, and rendering locking SQL.
org.hibernate.dialect.rowsecurity.spi	Supported row-level-security strategies, rendering requests, and declarative schema DDL supplied by a Dialect.
org.hibernate.dialect.temporal.spi	Supported temporal-table capabilities, requests, and declarative DDL results supplied by a Dialect.
org.hibernate.engine.extension.spi	This package contains an SPI for Session extensions.
org.hibernate.graph.spi	This package defines an internal SPI abstracting over implementations of the APIs defined in org.hibernate.graph.
org.hibernate.metamodel.spi	An SPI supporting custom instantiation of entity instances and embeddable objects.
org.hibernate.query.criteria.spi	SPI for extending HibernateCriteriaBuilder with additional functionality by registering a Service.
org.hibernate.query.sqm.tuple.spi	Support for tuples in SQM.
org.hibernate.sql.spi	Incubating contracts for rendering SQL and describing its parameters and comments.
org.hibernate.type.descriptor.converter.spi	An SPI for basic-typed value conversions, including support for handling JPA AttributeConverter instances as part of the Hibernate Type system.
org.hibernate.query.sqm	This package defines a semantic model of HQL queries.
org.hibernate.generator.values	Strategies for efficient retrieval of database-generated values.

Uses of Incubating in org.hibernate

Classes in org.hibernate with annotations of type Incubating

Modifier and Type	Class	Description
class	DetachedObjectException	Thrown if a detached instance of an entity class is passed to a Session method that expects a managed instance.
enum	FetchMethod	Enumerates methods for fetching an association from the database, allowing a fetching method to be specified as a FetchOption of an attribute node of an entity graph.
interface	Locking	Support for various aspects of pessimistic locking.
interface	SessionCreationOption	Declares various for session and stateless session creation options.
interface	SessionEventListener	Implemented by custom listeners that respond to low-level events involving interactions between the Session and the database or second-level cache.
interface	SharedStatelessSessionBuilder	Allows creation of a child StatelessSession which shares some options with another pre-existing parent session.
interface	StatementObserver	Observation of (almost) all JDBC statements performed by Hibernate.
interface	Timeouts	Helpers for dealing with timeout values, including some "magic values".

Methods in org.hibernate with annotations of type Incubating

Modifier and Type	Method	Description
<R> TypedQueryReference<R>	SessionFactory.addNamedQuery(String name, TypedQuery<R> query)	Add or override the definition of a named query, returning a reference to the query.
AdjustableSettings	SessionFactory.getAdjustableSettings()	Access to runtime adjustment of a discrete set of Hibernate settings.
Collection<?>	Session.getManagedEntities()	Obtain the collection of all managed entities which belong to this persistence context.
<E> Collection<E>	Session.getManagedEntities(EntityType<E> entityType)	Obtain a collection of all managed entities of the given type which belong to this persistence context.
<E> Collection<E>	Session.getManagedEntities(Class<E> entityType)	Obtain a collection of all managed entities of the given type which belong to this persistence context.
Collection<?>	Session.getManagedEntities(String entityName)	Obtain a collection of all managed instances of the entity type with the given entity name which belong to this persistence context.
Object	Filter.getParameterValue(String name)	Obtain the argument currently bound to the filter parameter with the given name.
StatelessSessionBuilder	StatelessSessionBuilder.initialCacheMode(CacheMode cacheMode)
default boolean	Transaction.isComplete()	Is this transaction complete?
default boolean	Transaction.isInCompletionProcess()	Is this transaction currently in the completion process?
StatelessSessionBuilder	StatelessSessionBuilder.jdbcBatchSize(int batchSize)
<T> RootGraph<T>	SessionFactory.parseEntityGraph(CharSequence graphText)	Creates a RootGraph based on the passed string representation.
<T> RootGraph<T>	SessionFactory.parseEntityGraph(String rootEntityName, CharSequence graphText)	Creates a RootGraph for the given rootEntityName and parses the graph text into it.
default void	Interceptor.postMerge(Object source, Object target, Object id, Object[] targetState, Object[] originalState, String[] propertyNames, Type[] propertyTypes)	Called after copying the state of a merged entity to a managed entity belonging to the persistence context of a stateful Session.
default void	Interceptor.preMerge(Object entity, Object[] state, String[] propertyNames, Type[] propertyTypes)	Called before copying the state of a merged entity to a managed entity belonging to the persistence context of a stateful Session.
StatelessSessionBuilder	StatelessSessionBuilder.readOnly(boolean readOnly)
default void	Transaction.runAfterCompletion(Consumer<TransactionStatus> action)	Register an action which will be called during the "after completion" phase.
default void	Transaction.runBeforeCompletion(Runnable action)	Register an action which will be called during the "before completion" phase.
SharedStatelessSessionBuilder	SharedSessionContract.statelessWithOptions()	Obtain a StatelessSession builder with the ability to copy certain information from this session.
default boolean	Transaction.wasFailure()	Was this transaction a failure? Here we consider a successful rollback, a failed commit, or a failed rollback to amount to transaction failure.
default boolean	Transaction.wasStarted()	Was this transaction already started?
default boolean	Transaction.wasSuccessful()	Was this transaction already successfully committed?

Uses of Incubating in org.hibernate.action.queue.spi

Classes in org.hibernate.action.queue.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ActionQueue	Common interface for ActionQueue implementations.
interface	ActionQueueCheckpoint	An opaque checkpoint of an ActionQueue's state before speculative flush preparation.
interface	ActionQueueFactory	Factory for ActionQueue instances.
final record	CollectionEndpoint	Identifies one role/key endpoint of a collection transition.
final record	CollectionMutationId	Identifies one semantic collection mutation within a flush cycle.
final record	CollectionMutationInput	Queue-neutral collection mutation input produced by flush visitation.
enum	CollectionTransition	Describes the logical relationship between the loaded and current collection endpoints.
enum	MutationKind	Kind of table mutation
final record	PlanningOptions	Options for controlling operation planning and scheduling.
enum	QueueType	Indicates ActionQueue implementations.
final record	StatementShapeKey	Helps identify similar mutations more concretely that just type+table.

Uses of Incubating in org.hibernate.action.queue.spi.bind

Classes in org.hibernate.action.queue.spi.bind with annotations of type Incubating

Modifier and Type	Interface	Description
interface	BindPlan	Represents JDBC parameter binding for graph-based operation execution
class	ChainedPostExecutionCallback
class	Checkers
final class	DelayedValueAccess	Mutable value reference used when a JDBC value is not known at decomposition time.
final class	GeneratedValuesCollector	Used from EntityInsertBindPlan and EntityUpdateBindPlan to aggregate generated value collection across all tables.
interface	GroupedRowBindPlan	A binding plan whose immutable row bindings share one physical operation template and graph placement.
class	JdbcValueBindings	Used to track JDBC value bindings (generally parameters) used in mutation operations.
interface	OperationExecutionMonitor	Monitors the physical execution of one or more related flush operations.
interface	OperationResultChecker	Used to check the results of a statement execution
interface	PostExecutionCallback	Support for callbacks after the execution of a FlushOperation.
interface	PreExecutionCallback	Callback invoked immediately before executing a planned operation.

Uses of Incubating in org.hibernate.action.queue.spi.decompose

Classes in org.hibernate.action.queue.spi.decompose with annotations of type Incubating

Modifier and Type	Interface	Description
interface	DecompositionContext	Context for decomposition operations, providing information about entities being mutated in the current flush.

Uses of Incubating in org.hibernate.action.queue.spi.decompose.collection

Classes in org.hibernate.action.queue.spi.decompose.collection with annotations of type Incubating

Modifier and Type	Interface	Description
interface	CollectionDecomposer	Decomposer for prepared collection mutations.
final record	CollectionJdbcOperations	Manages standard MutationOperation, as well as parameter binding details, for collection mutations.
interface	CollectionMutationPlanContributor	Contributes state-management-specific collection mutation plans for graph queue decomposition.
interface	CollectionMutationTarget
interface	OneToManyDecomposer	Marker interface for one-to-many collection decomposers

Uses of Incubating in org.hibernate.action.queue.spi.decompose.entity

Classes in org.hibernate.action.queue.spi.decompose.entity with annotations of type Incubating

Modifier and Type	Class	Description
class	CancelledInsertPostDeleteHandling	Post-execution callback that performs only the essential persistence context cleanup after a delete action is processed.
interface	EntityActionDecomposer<A extends Executable>	Handles decomposing for a single action type (delegation).
interface	EntityMutationPlanContributor	Contributes state-management-specific graph mutation plans for entity actions.
interface	GraphEntityMutationTarget	Entity-specific mutation target for the graph-based action queue.
class	InsertCacheHandling	Second-level cache bookkeeping for graph-based entity inserts.
class	PostDeleteHandling	Post-execution callback for entity delete actions.
class	PreDeleteHandling	Pre-execution callback for entity delete actions.
class	UpdateCacheHandling	Second-level cache bookkeeping for graph-based entity updates.

Uses of Incubating in org.hibernate.action.queue.spi.meta

Classes in org.hibernate.action.queue.spi.meta with annotations of type Incubating

Modifier and Type	Class	Description
final record	CollectionTableDescriptor	TableDescriptor for collection tables.
final record	ColumnDescriptor	Immutable descriptor for a column involved in a mutation.
final record	EntityTableDescriptor	Immutable descriptor for a table involved in a mutation.
class	JdbcValueDescriptorImpl	Implementation of JdbcValueDescriptor.
interface	TableDescriptor	Details about a table in the domain model, used to creation mutation operations in the graph-based ActionQueue implementation.
final record	TableDescriptorAsTableMapping	Adapts a TableDescriptor to the TableMapping interface, allowing graph-based infrastructure to use standard SQL model mutation builders.
interface	TableInclusionChecker
final record	TableKeyDescriptor	Descriptor for primary key columns.

Uses of Incubating in org.hibernate.action.queue.spi.plan

Classes in org.hibernate.action.queue.spi.plan with annotations of type Incubating

Modifier and Type	Class	Description
class	FlushOperation	Represents a single SQL operation to be executed.
class	ValuesAnalysis

Uses of Incubating in org.hibernate.annotations

Classes in org.hibernate.annotations with annotations of type Incubating

Modifier and Type	Class	Description
@interface	AnyDiscriminatorImplicitValues	Defines how to handle discriminator values which are not explicitly mapped with AnyDiscriminatorValue.
@interface	Array	Specifies the maximum length of a SQL array type mapped by the annotated attribute.
@interface	AttributeBinderType	Associates a user-defined annotation with an AttributeBinder, allowing the annotation to drive some custom model binding.
@interface	Audited	Specifies that the annotated entity class is an audited entity or audited collection.
enum	CacheLayout	Describes the data layout used for storing an object into the query cache.
@interface	Changelog	Marks an entity as the changelog entity for audit logging.
@interface	Collate	Specifies a collation to use when generating DDL for the column mapped by the annotated field or property.
@interface	CollectionIdJavaClass	Specifies the Java class to use for the id of an id-bag mapping.
@interface	ConcreteProxy	Annotating ConcreteProxy on the root entity class of an inheritance hierarchy will allow types of that hierarchy to always produce proxies that resolve to the concrete subtype class.
@interface	DefaultListSemantics	Specifies the default semantics of persistent List attributes without explicit collection classification or ordering metadata.
interface	DialectOverride	Allows certain annotations to be overridden in a given SQL Dialect.
@interface	EmbeddedColumnNaming	Allows specifying a pattern to be applied to the naming of columns for a particular embedded mapping.
@interface	EmbeddedTable	An easier mechanism to declare the table to which an embedded value maps compared to the Jakarta Persistence compliant mechanism requiring multiple AttributeOverride and AssociationOverride annotations.
@interface	FractionalSeconds	Deprecated, for removal: This API element is subject to removal in a future version. Use Column.secondPrecision() which was introduced in JPA 3.2
@interface	GeneratorOptimizer	Explicitly selects a standard optimizer to use with identifier generation.
@interface	GenericGenerator	Specifies a generator used for generating entity identifiers, allowing the use of custom identifier generation strategies going beyond those provided by the four standard JPA-defined generation types.
@interface	Instantiator	Marks the canonical constructor to be used for instantiation of an embeddable.
@interface	NativeGenerator	Generator that picks a strategy based on the dialect.
@interface	PropertyRef	Allows to specify the target of a foreign-key using a "target attribute" as opposed to join column(s).
@interface	QueryCacheLayout	Configures the layout for the entity or collection data in a query cache.
@interface	SoftDelete	Describes a soft-delete indicator mapping.
@interface	Struct	Specifies the UDT (user defined type) name for the annotated embeddable type or embedded attribute.
@interface	Temporal	Specifies that the annotated entity class is a temporal entity or temporal collection.
@interface	TimeZoneColumn	Specifies the mapped column for storing the time zone information, for use in conjunction with TimeZoneStorageType.COLUMN or TimeZoneStorageType.AUTO.
@interface	TimeZoneStorage	Specifies how the time zone information of a persistent property or field should be persisted.
enum	TimeZoneStorageType	Describes the storage of timezone information for zoned datetime types, in particular, for the types OffsetDateTime and ZonedDateTime.
@interface	TypeBinderType	Associates a user-defined annotation with a TypeBinder, allowing the annotation to drive some custom model binding.
@interface	View	Maps an entity to a database view.

Uses of Incubating in org.hibernate.annotations.processing

Classes in org.hibernate.annotations.processing with annotations of type Incubating

Modifier and Type	Class	Description
@interface	CheckHQL	Indicates that a package or top-level type contains HQL or JPQL queries encoded as static strings that should be validated at compile time by the Metamodel Generator or Query Validator.
@interface	Exclude	Indicates that a package or top-level type should be ignored by the Hibernate annotation processor.
@interface	Find	Identifies a method of an abstract class or interface as defining the signature of a finder method, with an implementation generated automatically by the Hibernate Metamodel Generator.
@interface	HQL	Identifies a method of an abstract class or interface as defining the signature of a method which is used to execute the given HQL query, with an implementation generated automatically by the Hibernate Metamodel Generator.
@interface	Pattern	Indicates that a parameter of type String of a finder method is a pattern involving wildcard characters _ and %.
@interface	SQL	Identifies a method of an abstract class or interface as defining the signature of a method which is used to execute the given SQL query, with an implementation generated automatically by the Hibernate Metamodel Generator.

Uses of Incubating in org.hibernate.binder

Classes in org.hibernate.binder with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AttributeBinder<A extends Annotation>	Allows a user-written annotation to drive some customized model binding.
interface	TypeBinder<A extends Annotation>	Allows a user-written annotation to drive some customized model binding.

Uses of Incubating in org.hibernate.boot

Methods in org.hibernate.boot with annotations of type Incubating

Modifier and Type	Method	Description
SessionFactoryBuilder	SessionFactoryBuilder.applyJsonFormatMapper(FormatMapper jsonFormatMapper)	Specifies a format mapper to use for serialization/deserialization of JSON properties.
SessionFactoryBuilder	SessionFactoryBuilder.applyQueryCacheLayout(CacheLayout cacheLayout)	Specifies the default CacheLayout to use for query cache entries.
SessionFactoryBuilder	SessionFactoryBuilder.applyXmlFormatMapper(FormatMapper xmlFormatMapper)	Specifies a format mapper to use for serialization/deserialization of XML properties.

Uses of Incubating in org.hibernate.boot.model

Methods in org.hibernate.boot.model with annotations of type Incubating

Modifier and Type	Method	Description
default void	TypeContributions.contributeAttributeConverter(Class<? extends AttributeConverter<?,?>> converterClass)	Register an AttributeConverter class.
default void	TypeContributions.contributeType(CompositeUserType<?> type)	Register a CompositeUserType as the implicit (auto-applied) type for values of type CompositeUserType.returnedClass().

Uses of Incubating in org.hibernate.boot.model.convert.spi

Classes in org.hibernate.boot.model.convert.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ConverterAutoApplyHandler	Manages resolution of auto-applied AttributeConverter references for specific mappings
interface	ConverterRegistry	A registry for JPA converters.

Uses of Incubating in org.hibernate.boot.model.naming

Classes in org.hibernate.boot.model.naming with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ImplicitNamingStrategy	A set of rules for determining the logical name of a mapped relational database object when the mapping for an element of the Java domain model is not explicitly specified, neither in annotations of the Java code, nor in an XML-based mapping document.
interface	PhysicalNamingStrategy	A set of rules for determining the physical names of objects in a relational database schema from the logical names specified by the object/relational mappings.

Uses of Incubating in org.hibernate.boot.model.relational

Classes in org.hibernate.boot.model.relational with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ColumnOrderingStrategy	A pluggable contract that allows ordering of columns within Table, Constraint and UserDefinedObjectType.

Methods in org.hibernate.boot.model.relational with annotations of type Incubating

Modifier and Type	Method	Description
UserDefinedArrayType	Namespace.createUserDefinedArrayType(Identifier logicalTypeName, Function<Identifier, UserDefinedArrayType> creator)	Creates a mapping UDT instance.
UserDefinedObjectType	Namespace.createUserDefinedType(Identifier logicalTypeName, Function<Identifier, UserDefinedObjectType> creator)	Creates a mapping UDT instance.
List<UserDefinedType>	Namespace.getDependencyOrderedUserDefinedTypes()
Collection<UserDefinedType>	Namespace.getUserDefinedTypes()
UserDefinedArrayType	Namespace.locateUserDefinedArrayType(Identifier logicalTypeName)	Returns the array UDT with the specified logical UDT name.
UserDefinedObjectType	Namespace.locateUserDefinedType(Identifier logicalTypeName)	Returns the object UDT with the specified logical UDT name.

Uses of Incubating in org.hibernate.boot.spi

Classes in org.hibernate.boot.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AdditionalMappingContributions	Collector for contributions from contributors
interface	AdditionalMappingContributor	Contract allowing pluggable contributions of additional mapping objects.
interface	BootstrapContext	Defines a context for things available during the process of bootstrapping a SessionFactory which are expected to be cleaned up after the SessionFactory is built.

Methods in org.hibernate.boot.spi with annotations of type Incubating

Modifier and Type	Method	Description
ConfiguredInterceptor	SessionFactoryOptions.getConfiguredInterceptor()	Describes how an interceptor was configured, without resolving any CDI or managed beans.
default JavaType<Object>	SessionFactoryOptions.getDefaultTenantIdentifierJavaType()	The default tenant identifier java type to use, in case no explicit tenant identifier property is defined.
TimeZoneStorageStrategy	SessionFactoryOptions.getDefaultTimeZoneStorageStrategy()
default CheckHandling	SessionFactoryOptions.getFinalPersistentFieldsHandling()
FormatMapper	SessionFactoryOptions.getJsonFormatMapper()	The format mapper to use for serializing/deserializing JSON data.
org.hibernate.models.spi.ModelsContext	BootstrapContext.getModelsContext()	Access to the hibernate-models ModelsContext
default int	MetadataBuildingContext.getPreferredSqlTypeCodeForArray()
int	SessionFactoryOptions.getPreferredSqlTypeCodeForArray()
default int	MetadataBuildingContext.getPreferredSqlTypeCodeForBoolean()
int	SessionFactoryOptions.getPreferredSqlTypeCodeForBoolean()
default int	MetadataBuildingContext.getPreferredSqlTypeCodeForDuration()
int	SessionFactoryOptions.getPreferredSqlTypeCodeForDuration()
default int	MetadataBuildingContext.getPreferredSqlTypeCodeForInstant()
int	SessionFactoryOptions.getPreferredSqlTypeCodeForInstant()
default int	MetadataBuildingContext.getPreferredSqlTypeCodeForUuid()
int	SessionFactoryOptions.getPreferredSqlTypeCodeForUuid()
CacheLayout	SessionFactoryOptions.getQueryCacheLayout()	The layout of entries in the query cache.
FormatMapper	SessionFactoryOptions.getXmlFormatMapper()	The format mapper to use for serializing/deserializing XML data.
default boolean	MetadataBuildingContext.isDirectJavaTimeJdbcAccessEnabled(Class<?> javaTimeType)	Determines whether direct JDBC access using the exact Java Time class is enabled by configuration and supported by the Dialect and JDBC driver.
default boolean	MetadataBuildingContext.isPreferJavaTimeJdbcTypesEnabled()	Deprecated. Use MetadataBuildingContext.isDirectJavaTimeJdbcAccessEnabled(Class) when determining whether direct JDBC access should be used for a Java Time type.
default boolean	MetadataBuildingContext.isPreferLocaleLanguageTagEnabled()
default boolean	MetadataBuildingContext.isPreferNativeEnumTypesEnabled()
boolean	MetadataBuildingOptions.isXmlFormatMapperLegacyFormatEnabled()	Whether to use the legacy format for serializing/deserializing XML data.
boolean	SessionFactoryOptions.isXmlFormatMapperLegacyFormatEnabled()	Whether to use the legacy format for serializing/deserializing XML data.
void	MetadataImplementor.orderColumns(boolean forceOrdering)

Uses of Incubating in org.hibernate.bytecode.enhance.spi

Classes in org.hibernate.bytecode.enhance.spi with annotations of type Incubating

Modifier and Type	Class	Description
enum	UnsupportedEnhancementStrategy	The expected behavior when encountering a class that cannot be enhanced, in particular when attribute names don't match field names.

Uses of Incubating in org.hibernate.bytecode.enhance.spi.interceptor

Classes in org.hibernate.bytecode.enhance.spi.interceptor with annotations of type Incubating

Modifier and Type	Interface	Description
interface	BytecodeLazyAttributeInterceptor

Uses of Incubating in org.hibernate.callback.spi

Classes in org.hibernate.callback.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ConfiguredInterceptor	Describes how an Interceptor was configured, without resolving any CDI or managed beans.
interface	InterceptorStrategy	Strategy for resolving and managing Interceptor instances across session lifecycle boundaries.
enum	InterceptorType	Describes how an Interceptor was configured.

Uses of Incubating in org.hibernate.cfg

Classes in org.hibernate.cfg with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AccessorSettings	Settings related to the property accessor strategy.
enum	CheckHandling	Enumerates the possible reactions to a boot-time check.
interface	StateManagementSettings	Settings related to customized state management, temporal entities, and audited entities.

Fields in org.hibernate.cfg with annotations of type Incubating

Modifier and Type	Field	Description
static final String	AccessorSettings.ACCESSOR_STRATEGY	Specifies the accessor strategy to use for property access.
static final String	SchemaToolingSettings.APPLY_VALIDATION_CONSTRAINTS	Whether constraints from Jakarta Validation annotations (for example, @NotNull, @Size, @Digits) should influence the generated DDL schema — for example, by making a column non-nullable or setting its length, precision, or scale.
static final String	StateManagementSettings.AUDIT_STRATEGY	Specifies the audit strategy for audited entities.
static final String	PersistenceSettings.BIDIRECTIONALITY_MANAGEMENT	Enables flush-time management of bidirectional associations in the managed object graph.
static final String	JdbcSettings.DIALECT_NATIVE_PARAM_MARKERS	Controls whether to use JDBC markers (`?`) or dialect native markers for parameters within preparable SQL statements.
static final String	MappingSettings.FINAL_PERSISTENT_FIELDS	Specifies how to handle persistent fields declared final that will need to be set through reflection.
static final String	MappingSettings.ID_DB_STRUCTURE_NAMING_STRATEGY	An implicit naming strategy for database structures (tables, sequences) related to identifier generators.
static final String	MappingSettings.JAVA_TIME_USE_DIRECT_JDBC	Indicates whether to use Java Time references at the JDBC boundary for binding and extracting temporal values to/from the database using the support added in JDBC 4.2 via PreparedStatement.setObject(int, Object, int) and ResultSet.getObject(int, Class).
static final String	PersistenceSettings.JPA_CALLBACKS_ENABLED	Allows JPA callbacks (via PreUpdate and friends) to be completely disabled.
static final String	MappingSettings.JSON_FORMAT_MAPPER	Specifies a FormatMapper used for JSON serialization and deserialization, either: an instance of FormatMapper, a Class representing a class that implements FormatMapper, the name of a class that implements FormatMapper, or one of the shorthand constants jackson or jsonb.
static final String	JdbcSettings.LOG_JDBC_ERRORS	When enabled, specifies that JDBC errors should be logged before being rethrown.
static final String	MultiTenancySettings.MULTI_TENANT_CREDENTIALS_MAPPER	Specifies a TenantCredentialsMapper to use, either: an instance of TenantCredentialsMapper, a Class representing a class that implements TenantCredentialsMapper, or the name of a class that implements TenantCredentialsMapper.
static final String	MultiTenancySettings.MULTI_TENANT_RLS_ENABLED	Specifies whether database-level row-level security (RLS) for multi-tenancy is enabled.
static final String	MultiTenancySettings.MULTI_TENANT_SCHEMA_MAPPER	Specifies a TenantSchemaMapper to use, either: an instance of TenantSchemaMapper, a Class representing a class that implements TenantSchemaMapper, or the name of a class that implements TenantSchemaMapper.
static final String	MappingSettings.PREFER_LOCALE_LANGUAGE_TAG	Indicates whether Locale.toLanguageTag() should be preferred over Locale.toString() when converting a Locale to a String.
static final String	MappingSettings.PREFER_NATIVE_ENUM_TYPES	Indicates that named SQL enum types should be used by default instead of varchar on databases which support named enum types.
static final String	MappingSettings.PREFERRED_ARRAY_JDBC_TYPE	Specifies the preferred JDBC type for storing plural i.e.
static final String	MappingSettings.PREFERRED_BOOLEAN_JDBC_TYPE	Specifies the preferred JDBC type for storing boolean values.
static final String	MappingSettings.PREFERRED_DURATION_JDBC_TYPE	The preferred JDBC type to use for storing Duration values.
static final String	MappingSettings.PREFERRED_INSTANT_JDBC_TYPE	Specifies the preferred JDBC type for storing Instant values.
static final String	MappingSettings.PREFERRED_UUID_JDBC_TYPE	The preferred JDBC type to use for storing UUID values.
static final String	CacheSettings.QUERY_CACHE_LAYOUT	Specifies the default CacheLayout to use for the query cache.
static final String	QuerySettings.SAFE_MODE_ENABLED	Boolean setting to control whether safe mode validation for HQL and Criteria queries is enabled.
static final String	MappingSettings.WRAPPER_ARRAY_HANDLING	Configurable control over how to handle Byte[] and Character[] types encountered in the application domain model.
static final String	MappingSettings.XML_FORMAT_MAPPER	Specifies a FormatMapper used for XML serialization and deserialization, either: an instance of FormatMapper, a Class representing a class that implements FormatMapper, the name of a class that implements FormatMapper, or one of the shorthand constants jackson or jaxb.
static final String	MappingSettings.XML_FORMAT_MAPPER_LEGACY_FORMAT	Specifies whether to use the legacy provider-specific and non-portable XML format for collections and byte arrays for XML serialization/deserialization.

Methods in org.hibernate.cfg with annotations of type Incubating

Modifier and Type	Method	Description
Configuration	Configuration.addModule(Module module)	Read module-level metadata from the given module.
Configuration	Configuration.addModule(String moduleName)	Read module-level metadata for the named module.
ColumnOrderingStrategy	Configuration.getColumnOrderingStrategy()	The ColumnOrderingStrategy, if any, that was added to this configuration.
Configuration	Configuration.setColumnOrderingStrategy(ColumnOrderingStrategy columnOrderingStrategy)	Specify a ColumnOrderingStrategy to be added to this configuration.

Uses of Incubating in org.hibernate.collection.spi

Classes in org.hibernate.collection.spi with annotations of type Incubating

Modifier and Type	Class	Description
enum	CollectionBaseline	Identifies the reference state against which a CollectionDelta is expressed.
interface	CollectionChange	One ordered semantic change within a CollectionDelta.
final record	CollectionChangeSet	Represents the complete set of changes between a collection's snapshot state and its current state.
final record	CollectionDelta	An immutable semantic description of collection changes relative to an identified reference state.
interface	CollectionInitializerProducer	Functional contract to create a CollectionInitializer.
final record	CollectionInterpretationContext	Runtime and mapping facts used to interpret a collection mutation.
interface	CollectionInterpretationProduction	Outcome of interpreting a collection mutation.
final record	CollectionMutationInterpretation	A frozen, queue-neutral interpretation of one semantic collection mutation.
interface	CollectionMutationInterpreter	Interprets a logical transition using one collection's semantics and mapping facts.
interface	CollectionSemantics<CE,E>	Each instance of this interface describes the semantics of some sort of persistent collection so that Hibernate understands how to manage the lifecycle of instances of that sort of collection.
interface	CollectionSemanticsResolver	Resolve the collection semantics for the given mapped collection.
final record	DeferredCollectionIdentifier	A row identifier for an identifier-bag's collectio-id which is generated by collection pre-insert processing after the delta has been frozen.
final record	DeferredCollectionPosition	A list position calculated from persisted size plus a relative adjustment.
enum	DeltaCoverage	Describes how completely a CollectionDelta covers its reference state.
enum	DeltaSource	Identifies the provenance of facts represented by a CollectionDelta.
final class	FrozenCollectionRows	A validity-guarded projection of the current rows of a persistent collection.
class	InitializerProducerBuilder
interface	LazyInitializable	The most general abstraction over collections which may be fetched lazily.
final class	PersistedCollectionSize	Shared deferred handle for the persisted size of one collection mutation.
class	PersistentArrayHolder<E>	A dummy collection wrapper for an array.
class	PersistentBag<E>	An unordered, un-keyed collection that can contain the same element multiple times.
interface	PersistentCollection<E>	Persistent collections are treated as value objects by Hibernate.
class	PersistentIdentifierBag<E>	An "identifier bag" implements "bag" semantics more efficiently than a regular bag by adding a synthetic identifier column to the table.
class	PersistentList<E>	A persistent wrapper for a List.
class	PersistentMap<K,E>	A persistent wrapper for a Map.
class	PersistentSet<E>	A persistent wrapper for a Set.
class	PersistentSortedMap<K,E>	A persistent wrapper for a SortedMap.
class	PersistentSortedSet<E>	A persistent wrapper for a SortedSet.
interface	PhysicalCollectionMutation	The immutable physical realization selected for a semantic collection mutation.
final record	QueuedCollectionOperation	Immutable view of one command in an uninitialized collection's operation queue.
interface	SemanticCollectionChange	The semantic difference information retained by a collection mutation interpretation independently of its physical mutation strategy.
interface	SnapshotIndexed<K>	Marker interface for objects that carry both an element and its snapshot position/key.

Methods in org.hibernate.collection.spi with annotations of type Incubating

Modifier and Type	Method	Description
default void	PersistentCollection.afterInitializationSnapshot()	Complete initialization after the loaded-state snapshot has been captured.
default Iterator<?>	PersistentCollection.getAddedEntities(CollectionPersister persister)	Get entities (elements) that are present in the current collection but were not in the snapshot.
default CollectionChangeSet	PersistentCollection.getChangeSet(CollectionPersister persister)	Computes the complete set of changes between the collection's snapshot state and its current state.
default long	PersistentCollection.getMutationGeneration()	A monotonically increasing generation for changes which can invalidate a frozen collection comparison.
default List<QueuedCollectionOperation>	PersistentCollection.getQueuedOperations()	Obtain an immutable, ordered view of queued collection commands.

Uses of Incubating in org.hibernate.context.spi

Classes in org.hibernate.context.spi with annotations of type Incubating

Modifier and Type	Class	Description
class	MultiTenancy	Exposes useful multitenancy-related strategy objects to user-written components.
interface	TenantCredentialsMapper<T>	Supplies tenant-specific credential to use to connect to the database.
interface	TenantSchemaMapper<T>	Supplies the name of a database schema for a given tenant identifier when schema-based multitenancy is enabled.

Uses of Incubating in org.hibernate.dialect

Methods in org.hibernate.dialect with annotations of type Incubating

Modifier and Type	Method	Description
boolean	Dialect.addPartitionKeyToPrimaryKey()	Whether every table partition key must also occur in its primary key.
GenerationType	Dialect.getNativeValueGenerationStrategy()	Supply the semantic identifier-generation type used for native generation.
RowLevelSecurity	Dialect.getRowLevelSecurity()	Supplies the complete database-native row-level-security strategy for this Dialect.
TemporalTableSupport	Dialect.getTemporalTableSupport()	Supplies the complete temporal-table DDL and historical-query strategy for this Dialect.
protected String	Dialect.narrowCastType(int sqlTypeCode)	Return the complete type pattern for a cast or set-returning-function declaration position which rejects locator LOB names.
boolean	Dialect.throttleDdl()	Deprecated, for removal: This API element is subject to removal in a future version. This temporary schema-management workaround will be removed once affected databases no longer require it.

Uses of Incubating in org.hibernate.dialect.literal.spi

Classes in org.hibernate.dialect.literal.spi with annotations of type Incubating

Modifier and Type	Class	Description
final class	StandardDateTimeLiteralRendering	Appends the standard datetime body used while composing a SQL literal.
enum	ZeroOffsetLiteralStyle	Selects how a zero UTC offset is rendered in a SQL datetime literal.

Uses of Incubating in org.hibernate.dialect.lob.spi

Classes in org.hibernate.dialect.lob.spi with annotations of type Incubating

Modifier and Type	Class	Description
final class	LobDataExtraction	Materializes LOB data using Hibernate's standard resource-handling and exception-conversion semantics.

Uses of Incubating in org.hibernate.dialect.lock.spi

Classes in org.hibernate.dialect.lock.spi with annotations of type Incubating

Modifier and Type	Class	Description
final class	ConnectionLockTimeoutOperations	Executes the common JDBC operations used by connection-level lock-timeout strategies.
interface	ConnectionLockTimeoutStrategy	Reads and sets lock timeouts using the JDBC Connection, generally by executing a database command.
interface	LockingClauseStrategy	Per-translation strategy for collecting lock targets and rendering statement-level pessimistic locking.
interface	LockingSupport	Cohesive Dialect profile for pessimistic-locking capabilities and operations.
enum	OuterJoinLockingType	Indicates a Dialect's level of support for applying locks to select statements with joins.
final class	StandardConnectionLockTimeoutStrategies	Creates standard connection-level lock-timeout strategies.
final class	StandardLockingClauseStrategies	Creates the standard per-translation locking-clause strategies.
final class	StandardLockingSupports	Creates standard pessimistic-locking profiles for a custom Dialect.

Uses of Incubating in org.hibernate.dialect.schema.spi

Classes in org.hibernate.dialect.schema.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	TableCleaner	Produces the complete ordered SQL used to clean mapped tables.

Uses of Incubating in org.hibernate.dialect.sql.ast.spi

Methods in org.hibernate.dialect.sql.ast.spi with annotations of type Incubating

Modifier and Type	Method	Description
protected void	AbstractSqlAstTranslator.renderAssignmentValue(Assignable assignable, ColumnReference columnReference, Expression expression)
protected boolean	AbstractSqlAstTranslator.renderTenantRestriction(ColumnValueBinding binding, String qualifier)	Render an equality restriction whose null parameter denotes a root tenant.
protected boolean	AbstractSqlAstTranslator.supportsUnionInInsertTopLevelSelect()

Uses of Incubating in org.hibernate.dialect.testing

Classes in org.hibernate.dialect.testing with annotations of type Incubating

Modifier and Type	Class	Description
final class	DialectTestContext	A thread-confined, database-free context for inspecting SQL generated by one Dialect profile.
final class	DialectTestKit	Entry point for the provider-oriented, database-free Dialect contract test kit.
final record	GeneratedParameter	One JDBC parameter occurrence in generated SQL.
final record	GeneratedStatement	One immutable SQL statement generated by the test kit.
final record	Pagination	Pagination requested for a database-free SQL translation.
final record	SchemaGenerationResult	Immutable create and drop commands for the test kit's fixed mapping model.
final record	SqlGenerationRequest	Inputs for translating one HQL statement through the test kit's fixed internal mapping model.
final record	SqlGenerationResult	Immutable result of translating one HQL statement.

Uses of Incubating in org.hibernate.dialect.testing.spi

Classes in org.hibernate.dialect.testing.spi with annotations of type Incubating

Modifier and Type	Class	Description
final class	ContractApplicability	States whether an optional contract applies to a Dialect profile.
enum	DialectContract	A database-free behavior exercised by the Dialect contract test kit.
interface	DialectContractProfile	Defines one stable, database-free Dialect test profile supplied by a provider to DialectTestKit.

Uses of Incubating in org.hibernate.dialect.type.spi

Classes in org.hibernate.dialect.type.spi with annotations of type Incubating

Modifier and Type	Class	Description
final class	EnumRelationalValues	Resolves the relational strings represented by Java enum constants.
enum	TimeZoneSupport	Describes how a database stores SQL types declared with time zone.

Uses of Incubating in org.hibernate.engine.creation

Classes in org.hibernate.engine.creation with annotations of type Incubating

Modifier and Type	Interface	Description
interface	CommonBuilder	Common options for builders of stateful and stateless sessions.
interface	CommonSharedBuilder	Common options for builders of stateful and stateless sessions which share state from an underlying stateful/stateless session.

Methods in org.hibernate.engine.creation with annotations of type Incubating

Modifier and Type	Method	Description
CommonBuilder	CommonBuilder.asOf(Instant instant)	Specify the instant for reading temporal entity data.
CommonBuilder	CommonBuilder.atChangeset(Object changesetId)	Specify the changeset id for reading temporal of audited entity data.
CommonBuilder	CommonBuilder.readOnly(boolean readOnly)	Specify a read-only mode for the session.

Uses of Incubating in org.hibernate.engine.extension.spi

Classes in org.hibernate.engine.extension.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	Extension	A marker interface for Session extensions.
interface	ExtensionIntegration<E extends Extension>
interface	ExtensionIntegrationContext
interface	ExtensionIntegrationService
class	ExtensionIntegrationServiceInitiator

Uses of Incubating in org.hibernate.engine.jdbc.batch.spi

Classes in org.hibernate.engine.jdbc.batch.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	Batch	Represents the lifecycle of a batch of statements to be executed together.
interface	BatchBuilder	A builder for Batch instances.
interface	BatchedResultChecker	Checks the result for one row in a JDBC batch.
interface	GroupedBatch	Batch variant based on a group of prepared statements.
interface	SingleStatementBatch	Batch variant for a single JDBC statement shape.
interface	StatementBinder	Binds one row worth of values to a JDBC statement.

Uses of Incubating in org.hibernate.engine.jdbc.connections.spi

Methods in org.hibernate.engine.jdbc.connections.spi with annotations of type Incubating

Modifier and Type	Method	Description
default void	ConnectionProvider.closeReadOnlyConnection(Connection connection)	Release a connection to a read-only replica from Hibernate use.
default Connection	ConnectionProvider.getConnection(String user, String password)	Obtains a connection for Hibernate use according to the underlying strategy of this provider, using the given credentials.
default Connection	ConnectionProvider.getReadOnlyConnection()	Obtains a connection to a read-only replica for use according to the underlying strategy of this provider.
default Connection	MultiTenantConnectionProvider.getReadOnlyConnection(T tenantIdentifier)	Obtains a connection to a read-only replica for use according to the underlying strategy of this provider.
default boolean	ConnectionProvider.handlesConnectionReadOnly()	Does this connection provider correctly set the read-only mode of the returned JDBC connections?
default boolean	MultiTenantConnectionProvider.handlesConnectionReadOnly()	Does this connection provider correctly set the read-only mode of the returned JDBC connections?
default boolean	ConnectionProvider.handlesConnectionSchema()	Does this connection provider correctly set the schema of the returned JDBC connections?
default boolean	MultiTenantConnectionProvider.handlesConnectionSchema()	Does this connection provider correctly set the schema of the returned JDBC connections?
default void	MultiTenantConnectionProvider.releaseReadOnlyConnection(T tenantIdentifier, Connection connection)	Release a connection to a read-only replica from Hibernate use.

Uses of Incubating in org.hibernate.engine.jdbc.mutation

Classes in org.hibernate.engine.jdbc.mutation with annotations of type Incubating

Modifier and Type	Interface	Description
interface	JdbcValueBindings	The JDBC values for a mutation
interface	MutationExecutor	Main contract for performing the mutation.
interface	OperationResultChecker	Used to check the results of a statement execution

Uses of Incubating in org.hibernate.engine.jdbc.mutation.group

Classes in org.hibernate.engine.jdbc.mutation.group with annotations of type Incubating

Modifier and Type	Interface	Description
interface	PreparedStatementDetails	Descriptor for details about a PreparedStatement
interface	PreparedStatementGroup	Grouping of PreparedStatement references.

Uses of Incubating in org.hibernate.engine.jdbc.spi

Methods in org.hibernate.engine.jdbc.spi with annotations of type Incubating

Modifier and Type	Method	Description
ParameterMarkerStrategy	JdbcServices.getParameterMarkerStrategy()	Obtains the service used for marking SQL parameters

Uses of Incubating in org.hibernate.engine.query.spi

Classes in org.hibernate.engine.query.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	NativeQueryInterpreter	Service contract for dealing with native queries.

Uses of Incubating in org.hibernate.engine.spi

Classes in org.hibernate.engine.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	CollectionFlushActionTracker	Read-only view of collection processing state and actions planned during the current flush.
interface	EntityHolder	Holder for an entry in the PersistenceContext for an EntityKey.
interface	PersistentAttributeInterceptor	The base contract for interceptors that can be injected into enhanced entities for the purpose of intercepting attribute access
interface	TransactionCompletionCallbacks	Collection of before and after callbacks related to transaction completion.
interface	TransactionCompletionCallbacksImplementor

Methods in org.hibernate.engine.spi with annotations of type Incubating

Modifier and Type	Method	Description
EntityHolder	PersistenceContext.addEntityHolder(EntityKey key, Object entity)
EntityHolder	PersistenceContext.claimEntityHolderIfPossible(EntityKey key, Object entity, JdbcValuesSourceProcessingState processingState, EntityInitializer<?> initializer)	Return an existing entity holder for the entity key, possibly creating one if necessary.
AuditWorkQueue	SharedSessionContractImplementor.getAuditWorkQueue()	Access the transaction-scoped audit work queue for deferred audit row writes.
ClassLoaderService	SessionFactoryImplementor.getClassLoaderService()	Obtain the ClassLoaderService.
Transaction	SharedSessionContractImplementor.getCurrentTransaction()	The current Transaction object associated with this session, if it has already been created, or null otherwise.
EntityCopyObserverFactory	SessionFactoryImplementor.getEntityCopyObserver()	Obtain the EntityCopyObserverFactory service.
EventListenerRegistry	SessionFactoryImplementor.getEventListenerRegistry()	Obtain the EventListenerRegistry service.
<E extends Extension> E	SharedSessionContractImplementor.getExtension(Class<E> extension)	Allows accessing session scoped extension storages of the particular session instance.
InterceptorStrategy	SessionFactoryImplementor.getInterceptorStrategy()	The strategy for resolving and managing interceptor instances.
default JdbcSelectWithActionsBuilder	SessionFactoryImplementor.getJdbcSelectWithActionsBuilder()
JdbcValuesMappingProducerProvider	SessionFactoryImplementor.getJdbcValuesMappingProducerProvider()	Obtain the JdbcServices service.
ManagedBeanRegistry	SessionFactoryImplementor.getManagedBeanRegistry()	Obtain the ManagedBeanRegistry service.
ParameterMarkerStrategy	SessionFactoryImplementor.getParameterMarkerStrategy()	Obtain the ParameterMarkerStrategy service.
SessionAssociationMarkers	SharedSessionContractImplementor.getSessionAssociationMarkers()	Wrap all state that lazy loading interceptors might need to manage association with this session, or to handle lazy loading after detachment via the UUID of the SessionFactory.
TransactionCompletionCallbacks	SharedSessionContractImplementor.getTransactionCompletionCallbacks()	Access to register callbacks for transaction completion processing.
TransactionCompletionCallbacksImplementor	SharedSessionContractImplementor.getTransactionCompletionCallbacksImplementor()	Access to registered callbacks for transaction completion processing.
Object	SharedSessionContractImplementor.loadFromSecondLevelCache(EntityPersister persister, EntityKey entityKey, Object instanceToLoad, LockMode lockMode)	Attempts to load the entity from the second-level cache.
default <T> RootGraph<T>	SessionFactoryImplementor.parseEntityGraph(CharSequence graphText)
default <T> RootGraph<T>	SessionFactoryImplementor.parseEntityGraph(String rootEntityName, CharSequence graphText)
void	PersistenceContext.postLoad(JdbcValuesSourceProcessingState processingState, Consumer<EntityHolder> loadedConsumer)
Object	SessionFactoryImplementor.resolveTenantIdentifier()	Object the current tenant identifier using the resolver.

Constructors in org.hibernate.engine.spi with annotations of type Incubating

Modifier	Constructor	Description
	EffectiveEntityGraph()
	EffectiveEntityGraph(boolean allowOverwrite)

Uses of Incubating in org.hibernate.envers

Classes in org.hibernate.envers with annotations of type Incubating

Modifier and Type	Class	Description
@interface	CollectionAuditTable	Allows for the customization of an Envers audit collection table.

Uses of Incubating in org.hibernate.envers.boot.spi

Classes in org.hibernate.envers.boot.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ModifiedColumnNamingStrategy	Defines a naming strategy for applying modified columns to the audited entity metamodel.

Uses of Incubating in org.hibernate.envers.query

Classes in org.hibernate.envers.query with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AuditAssociationQuery<Q extends AuditQuery>

Methods in org.hibernate.envers.query with annotations of type Incubating

Modifier and Type	Method	Description
AuditQuery	AuditQueryCreator.forRevisionsOfEntity(Class<?> clazz, boolean selectDeletedEntities)	Creates a query that selects the revision entities associated with the specified entity.
AuditQuery	AuditQueryCreator.forRevisionsOfEntity(Class<?> clazz, String entityName, boolean selectDeletedEntities)	Creates a query that selects the revision entities associated with the specified entity.
AuditQuery	AuditQueryCreator.forRevisionsOfEntityWithChanges(Class<?> clazz, boolean selectDeletedEntities)	Creates a query that selects the revisions at which the given entity was modified.
AuditQuery	AuditQueryCreator.forRevisionsOfEntityWithChanges(Class<?> clazz, String entityName, boolean selectDeletedEntities)	Creates a query that selects the revisions at which the given entity was modified.
AuditAssociationQuery<? extends AuditQuery>	AuditQuery.traverseRelation(String associationName, JoinType joinType, String alias, AuditCriterion onClauseCriterion)

Uses of Incubating in org.hibernate.envers.strategy.spi

Classes in org.hibernate.envers.strategy.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AuditStrategy	A strategy abstraction for how to audit entity changes.
interface	AuditStrategyContext	A contract to initialize an AuditStrategy
class	MappingContext	Describes an audit mapping context.

Uses of Incubating in org.hibernate.event.monitor.spi

Classes in org.hibernate.event.monitor.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	DiagnosticEvent	An event which may be collected by the EventMonitor.
interface	EventMonitor	Contract implemented by services which collect, report, or monitor diagnostic events involving interactions between the session and the database or second-level cache.

Uses of Incubating in org.hibernate.event.service.spi

Classes in org.hibernate.event.service.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	EventActionWithParameter<T,U,X>

Methods in org.hibernate.event.service.spi with annotations of type Incubating

Modifier and Type	Method	Description
<U> void	EventListenerGroup.fireEventOnEachListener(U event, BiConsumer<T,U> actionOnEvent)	Similar as EventListenerGroup.fireLazyEventOnEachListener(Supplier, BiConsumer) except it doesn't use a {Supplier}.
<R,U,RL> CompletionStage<R>	EventListenerGroup.fireEventOnEachListener(U event, Function<RL, Function<U, CompletionStage<R>>> fun)	Similar to EventListenerGroup.fireEventOnEachListener(Object, BiConsumer), but Reactive friendly: it chains processing of the same event on each Reactive Listener, and returns a CompletionStage of type R.
<R,U,RL,X> CompletionStage<R>	EventListenerGroup.fireEventOnEachListener(U event, X param, Function<RL, BiFunction<U, X, CompletionStage<R>>> fun)	Similar to EventListenerGroup.fireEventOnEachListener(Object, Object, EventActionWithParameter), but Reactive friendly: it chains processing of the same event on each Reactive Listener, and returns a CompletionStage of type R.
<U,X> void	EventListenerGroup.fireEventOnEachListener(U event, X param, EventActionWithParameter<T,U,X> actionOnEvent)	Similar to EventListenerGroup.fireEventOnEachListener(Object, BiConsumer), but allows passing a third parameter to the consumer; our code based occasionally needs a third parameter: having this additional variant allows using the optimal iteration more extensively and reduce allocations.
<U> void	EventListenerGroup.fireLazyEventOnEachListener(Supplier<U> eventSupplier, BiConsumer<T,U> actionOnEvent)	Fires an event on each registered event listener of this group.
<R,U,RL> CompletionStage<R>	EventListenerGroup.fireLazyEventOnEachListener(Supplier<U> eventSupplier, Function<RL, Function<U, CompletionStage<R>>> fun)	Similar to EventListenerGroup.fireLazyEventOnEachListener(Supplier, BiConsumer), but Reactive friendly: it chains processing of the same event on each Reactive Listener, and returns a CompletionStage of type R.

Uses of Incubating in org.hibernate.event.spi

Classes in org.hibernate.event.spi with annotations of type Incubating

Modifier and Type	Class	Description
class	PreFlushEvent	An event that occurs just before arguments are bound to JDBC parameters during execution of HQL.
interface	PreFlushEventListener	A listener for events of type PreFlushEvent.

Uses of Incubating in org.hibernate.exception

Classes in org.hibernate.exception with annotations of type Incubating

Modifier and Type	Class	Description
class	SnapshotIsolationException	A JDBCException indicating that a request failed due to snapshot isolation.

Uses of Incubating in org.hibernate.generator

Classes in org.hibernate.generator with annotations of type Incubating

Modifier and Type	Interface	Description
interface	GeneratorCreationContext	Access to information useful during Generator creation and initialization.

Methods in org.hibernate.generator with annotations of type Incubating

Modifier and Type	Method	Description
default boolean	Generator.generatesOnForceIncrement()
default boolean[]	OnExecutionGenerator.getColumnInclusions(Dialect dialect, EventType eventType)	Indicates which columns should be included in SQL for the given event type.
default InsertGeneratedIdentifierDelegate	OnExecutionGenerator.getGeneratedIdentifierDelegate(EntityPersister persister)	The InsertGeneratedIdentifierDelegate used to retrieve the generated value if this object is an identifier generator.
default Class<?>	Generator.getGeneratedType()	The Java type of the generated values.
default String[]	OnExecutionGenerator.getReferencedColumnValues(Dialect dialect, EventType eventType)	A SQL expression indicating how to calculate the generated values when the mapped columns are included in the SQL statement for the given event type.
default String[]	OnExecutionGenerator.getUniqueKeyPropertyNames(EntityPersister persister)	The name of a property of the entity which may be used to locate the just-inserted row containing the generated value.
default boolean	OnExecutionGenerator.referenceColumnsInSql(Dialect dialect, EventType eventType)	Determines if the columns whose values are generated are included in the column list of the SQL insert or update statement for the given event type.
default boolean	Generator.requiresIdentityColumn()	Does this generator require an identity (autoincrement) column.
default boolean	OnExecutionGenerator.writePropertyValue(EventType eventType)	Determines if the property values are written to JDBC as the argument of a JDBC ? parameter for the given event type.

Uses of Incubating in org.hibernate.graph

Methods in org.hibernate.graph with annotations of type Incubating

Modifier and Type	Method	Description
<AJ> SubGraph<AJ>	Graph.addTreatedElementSubgraph(PluralAttribute<? super J, ?, ? super AJ> attribute, ManagedType<AJ> type)	Create and return a new (mutable) SubGraph associated with the element of the given collection, and with the given type, which may be a subtype of the attribute type, or return an existing such SubGraph if there is one.
<AJ> SubGraph<AJ>	Graph.addTreatedMapKeySubgraph(MapAttribute<? super J, ? super AJ, ?> attribute, ManagedType<AJ> type)	Create and return a new (mutable) SubGraph associated with the key of the named map, and with the given type, which may be a subtype of the attribute type, or return an existing such SubGraph if there is one.
<AJ> SubGraph<AJ>	Graph.addTreatedSubgraph(Attribute<? super J, ? super AJ> attribute, ManagedType<AJ> type)	Create and return a new (mutable) SubGraph associated with the given Attribute, and with the given type, which may be a subtype of the attribute type, or return an existing such SubGraph if there is one.
<Y extends J> SubGraph<Y>	Graph.addTreatedSubgraph(ManagedType<Y> type)	Create and return a new (mutable) SubGraph representing the given subtype of the type of this node, or return an existing such SubGraph if there is one.
static <T> RootGraph<T>	GraphParser.parse(CharSequence graphText, SessionFactory sessionFactory)	Creates a root graph based on the passed graphText.
static <T> RootGraph<T>	GraphParser.parse(String rootEntityName, CharSequence graphText, SessionFactory sessionFactory)	Creates a root graph based on the passed rootEntityName and parses graphText into the generated root graph.

Uses of Incubating in org.hibernate.graph.spi

Classes in org.hibernate.graph.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	GraphParserEntityClassResolver
interface	GraphParserEntityNameResolver

Uses of Incubating in org.hibernate.id.enhanced

Classes in org.hibernate.id.enhanced with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ImplicitDatabaseObjectNamingStrategy	A naming strategy specifically for determining the implicit naming of tables and sequences relating to enhanced identifier-generators.

Uses of Incubating in org.hibernate.integrator.spi

Classes in org.hibernate.integrator.spi with annotations of type Incubating

Modifier and Type	Interface	Description
static interface	Integrator.Context	Inputs which are valid during SessionFactory integration but are not represented by the finalized metadata or the in-flight SessionFactory.

Uses of Incubating in org.hibernate.jpa

Fields in org.hibernate.jpa with annotations of type Incubating

Modifier and Type	Field	Description
static final String	HibernateHints.HINT_LIMIT_IN_MEMORY	Hint that the limit and/or offset of the HQL or criteria query should be applied in Java instead of being passed to the database as part of the generated SQL.

Methods in org.hibernate.jpa with annotations of type Incubating

Modifier and Type	Method	Description
ClassTransformer	HibernatePersistenceProvider.getClientClassTransformer(PersistenceUnitInfo info, Map<?,?> properties)	Returns an optional client-code transformer for a container to install.

Uses of Incubating in org.hibernate.mapping

Classes in org.hibernate.mapping with annotations of type Incubating

Modifier and Type	Interface	Description
interface	GeneratorSettings	Exposes the default catalog and schema to the generator creation process.
interface	SoftDeletable	Deprecated, for removal: This API element is subject to removal in a future version. This is no longer needed after the introduction of Stateful.
class	UserDefinedArrayType	A mapping model object representing a named relational database array type.
class	UserDefinedObjectType	A mapping model object representing a relational database UDT.
interface	UserDefinedType	A mapping model object which represents a user defined type.

Methods in org.hibernate.mapping with annotations of type Incubating

Modifier and Type	Method	Description
Generator	KeyValue.createGenerator(Dialect dialect, RootClass rootClass, Property property, GeneratorSettings defaults)
default MetadataBuildingContext	Value.getBuildingContext()
default String	Value.getExtraCreateTableInfo()
Collection<ForeignKey>	Table.getForeignKeyCollection()
default JdbcMapping	Value.getSelectableType(MappingContext mappingContext, int index)
default String	Selectable.getWriteExpr()
default String	Selectable.getWriteExpr(JdbcMapping jdbcMapping, Dialect dialect, MappingContext mappingContext)
Type	BasicValue.impliedJavaType(TypeConfiguration typeConfiguration)
void	BasicValue.setExplicitJdbcTypeCode(Integer jdbcTypeCode)
void	Any.setImplicitDiscriminatorValueStrategy(ImplicitDiscriminatorStrategy implicitValueStrategy)	Set the strategy for dealing with discriminator mappings which are not explicitly defined by AnyDiscriminatorValue.

Uses of Incubating in org.hibernate.metamodel

Classes in org.hibernate.metamodel with annotations of type Incubating

Modifier and Type	Class	Description
enum	AttributeClassification	An extended set of Attribute.PersistentAttributeType adding AttributeClassification.ANY
enum	CollectionClassification	Classifications of the plurality.
interface	MappingMetamodel	Access to information about the runtime relational O/R mapping model.
interface	RuntimeMetamodels	Entry point providing access to the runtime metamodels: the domain model, our implementation of the JPA-defined model of the Java types, and our relational mapping model of how these types are made persistent.

Uses of Incubating in org.hibernate.metamodel.mapping

Classes in org.hibernate.metamodel.mapping with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AttributeMappingsList	This is essentially a List of AttributeMapping(s), but exposing an interface which is more suitable to our needs; in particular it expresses the immutable nature of this structure, and allows us to extend it with additional convenience methods such as AttributeMappingsList.indexedForEach(IndexedConsumer).
interface	AttributeMappingsMap	Similar to AttributeMappingsList, this is essentially an immutable Map of AttributeMapping(s), allowing iteration of all mappings but also retrieval by name (a String key).
interface	AuditMapping	Metadata about audit log tables for entities and collections enabled for audit logging.
interface	AuxiliaryMapping	Runtime mapping contract for state-management state associated with an entity or collection.
interface	Bindable	Contract for things at the domain mapping level that can be bound into a JDBC PreparedStatement.
interface	LegacyAuxiliaryMutationSupport	Optional legacy mutation support for an AuxiliaryMapping.
interface	NaturalIdMapping	Mapping for an entity's natural-id, if one is defined.
interface	SelectableMapping	Mapping of a selectable (column/formula)
class	SelectablePath	The path for a selectable.
interface	TemporalMapping	Metadata about temporal columns for entities enabled for temporal history.

Methods in org.hibernate.metamodel.mapping with annotations of type Incubating

Modifier and Type	Method	Description
default AuditMapping	EntityMappingType.getAuditMapping()	Mapping for audit support, or null if not defined.
default AuditMapping	PluralAttributeMapping.getAuditMapping()	Mapping for audit support, or null if audit not defined
default JavaType<?>	JdbcMapping.getJdbcJavaType()
default JdbcLiteralFormatter	JdbcMapping.getJdbcLiteralFormatter()	The strategy for formatting values of this expressible type to a SQL literal.
default SoftDeleteMapping	EntityMappingType.getSoftDeleteMapping()	Mapping for soft-delete support, or null if soft-delete not defined
default SoftDeleteMapping	PluralAttributeMapping.getSoftDeleteMapping()	Mapping for soft-delete support, or null if soft-delete not defined
default TemporalMapping	EntityMappingType.getTemporalMapping()	Mapping for temporal entity support, or null if not defined.
default TemporalMapping	PluralAttributeMapping.getTemporalMapping()	Mapping for temporal support, or null if temporal not defined
default BasicValueConverter<?,?>	JdbcMapping.getValueConverter()	Returns the converter that this basic type uses for transforming from the domain type, to the relational type, or null if there is no conversion.
default boolean	EntityMappingType.isConcreteProxy()	Returns true if this entity type's hierarchy is configured to return concrete-typed proxies.
default EntityMappingType	EntityMappingType.resolveConcreteProxyTypeForId(Object id, SharedSessionContractImplementor session)	If this entity is configured to return concrete-typed proxies, this method queries the entity table(s) do determine the concrete entity type associated with the provided id and returns its persister.

Uses of Incubating in org.hibernate.metamodel.model.domain

Classes in org.hibernate.metamodel.model.domain with annotations of type Incubating

Modifier and Type	Interface	Description
interface	JpaMetamodel	Extensions to the JPA-defined metamodel of persistent Java types.
final class	NavigableRole	A compound path which represents a ModelPart and uniquely identifies it with the runtime metamodel.
interface	ReturnableType<T>	Specialization of SimpleDomainType for types that can be used as function returns.

Uses of Incubating in org.hibernate.metamodel.spi

Classes in org.hibernate.metamodel.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	EmbeddableInstantiator	Instantiates embeddable values from the attribute values supplied by Hibernate.
interface	EmbeddableRepresentationStrategy	Describes the representation of a particular embeddable type.
interface	Instantiator	Strategy for instantiating a managed type
interface	ManagedTypeRepresentationResolver	Pluggable strategy handling resolution of ManagedTypeRepresentationStrategy to use.
interface	ManagedTypeRepresentationStrategy	Defines a singular extension point for capabilities pertaining to a representation mode.
interface	ValueAccess	Provides access to the values for a managed type (currently just embeddables).

Uses of Incubating in org.hibernate.persister.collection

Methods in org.hibernate.persister.collection with annotations of type Incubating

Modifier and Type	Method	Description
boolean	CollectionPersister.useShallowQueryCacheLayout()

Uses of Incubating in org.hibernate.persister.entity

Classes in org.hibernate.persister.entity with annotations of type Incubating

Modifier and Type	Class	Description
final class	EntityNameUse	Describes the kind of entity name use.

Methods in org.hibernate.persister.entity with annotations of type Incubating

Modifier and Type	Method	Description
boolean	EntityPersister.excludedFromTemporalVersioning(int[] dirtyAttributeIndexes, boolean hasDirtyCollection)
boolean	EntityPersister.storeDiscriminatorInShallowQueryCacheLayout()
Iterable<UniqueKeyEntry>	EntityPersister.uniqueKeyEntries()
boolean	EntityPersister.useShallowQueryCacheLayout()

Uses of Incubating in org.hibernate.persister.entity.mutation

Classes in org.hibernate.persister.entity.mutation with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AttributeAnalysis	Results of analyzing an attribute in terms of handling update operations
interface	EntityMutationTarget	Deprecated, for removal: This API element is subject to removal in a future version. Transitional interface - use LegacyEntityMutationTarget for legacy coordinators or GraphEntityMutationTarget for graph-based decomposers
interface	LegacyEntityMutationTarget	Entity-specific mutation target for the legacy (sequential) action queue.
interface	UpdateValuesAnalysis	Contains an aggregated analysis of the values for an update mutation to determine behavior such as skipping tables which contained no changes, etc.

Uses of Incubating in org.hibernate.persister.state.spi

Classes in org.hibernate.persister.state.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	StateManagement	Integrates a state-management strategy with Hibernate's mapping model and mutation execution infrastructure.
interface	StateManagementGraphIntegration	Graph action-queue integration for a state-management strategy.
interface	StateManagementLegacyIntegration	Legacy action-queue integration for a state-management strategy.

Uses of Incubating in org.hibernate.procedure

Classes in org.hibernate.procedure with annotations of type Incubating

Modifier and Type	Interface	Description
interface	FunctionReturn<T>	Describes the function return value of a ProcedureCall executed via a JDBC escape of form ("{? = call ...}.
interface	ProcedureParameter<T>

Methods in org.hibernate.procedure with annotations of type Incubating

Modifier and Type	Method	Description
FunctionReturn<?>	ProcedureCall.getFunctionReturn()	The FunctionReturn describing the return value of the function, or null if this ProcedureCall is not a function call.

Uses of Incubating in org.hibernate.procedure.spi

Classes in org.hibernate.procedure.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	NamedCallableQueryMemento	Represents a "memento" (disconnected, externalizable form) of a ProcedureCall.
interface	ProcedureParameterImplementor<T>	SPI extension for ProcedureParameter

Uses of Incubating in org.hibernate.property.access.spi

Classes in org.hibernate.property.access.spi with annotations of type Incubating

Modifier and Type	Class	Description
final class	PropertyValueAccessor	Monomorphic dispatcher for property value access.

Uses of Incubating in org.hibernate.query

Classes in org.hibernate.query with annotations of type Incubating

Modifier and Type	Class	Description
class	KeyedPage<R>	Support for pagination based on a unique key of the result set instead of the offset.
class	KeyedResultList<R>	Support for pagination based on a unique key of the result set instead of the offset.
interface	MutationOrSelectionQuery	Unifies StatementOrTypedQuery with Query, allowing backward compatibility with older versions of Hibernate and JPA which did not carefully distinguish selection queries from insert, update, and delete mutation statements.
interface	MutationQuery	Within the context of an active session, an instance of this type represents an executable mutation query, that is, an insert, update, or delete.
interface	Order<X>	A rule for sorting a query result set.
class	Page	Identifies a page of query results by page size and page number.
interface	ParameterMetadata	Information about the parameters of a query.
interface	Query<T>	Within the context of an active session, an instance of this type represents an executable query, either: a query written in HQL or native SQL, a named query written in HQL or native SQL, or a criteria query.
interface	QueryOption	Declares various selection query and mutation statement options.
interface	QueryParameter<T>	Represents a parameter defined in the source (HQL/JPQL or criteria) query.
interface	ResultListTransformer<T>	Defines some processing performed on the overall result List of a Query before the result list is returned to the caller.
interface	SelectionQuery<R>	Within the context of an active session, an instance of this type represents an executable selection query, that is, a select.
interface	TupleTransformer<T>	Defines some transformation applied to each result of a Query before the results are packaged as a List and returned to the caller.
interface	TypedTupleTransformer<T>	Extension to TupleTransformer exposing the transformation target type.

Methods in org.hibernate.query with annotations of type Incubating

Modifier and Type	Method	Description
default void	Order.apply(CriteriaQuery<?> query, Root<?> root, CriteriaBuilder builder)	Apply this order to the given root entity of the given criteria query.
FlushMode	CommonQueryContract.getEffectiveFlushMode()	The FlushMode in effect for this query, taking into account both the query flush mode and the flush mode of the session.
KeyedResultList<R>	SelectionQuery.getKeyedResultList(KeyedPage<R> page)	Execute the query and return the results for the given page, using key-based pagination.
SelectionQuery<R>	SelectionQuery.setPage(Page page)	Set the page of results to return.

Uses of Incubating in org.hibernate.query.assignment

Classes in org.hibernate.query.assignment with annotations of type Incubating

Modifier and Type	Interface	Description
interface	Assignment<T>	An assignment to a field or property of an entity or embeddable.

Uses of Incubating in org.hibernate.query.criteria

Classes in org.hibernate.query.criteria with annotations of type Incubating

Modifier and Type	Class	Description
class	CriteriaDefinition<R>	A utility class that makes it easier to build criteria queries.
interface	HibernateCriteriaBuilder	A JPA CriteriaBuilder is a source of objects which may be composed to express a criteria query.
interface	JpaCastTarget<T>	The target for cast.
interface	JpaConflictClause<T>	A conflict clause for insert statements.
interface	JpaConflictUpdateAction<T>	The update action that should happen on a unique constraint violation for an insert statement.
interface	JpaCriteriaInsert<T>	The commonalities between insert-select and insert-values.
interface	JpaCriteriaInsertSelect<T>	A representation of SqmInsertSelectStatement at the org.hibernate.query.criteria level, even though JPA does not define support for insert-select criteria.
interface	JpaCriteriaInsertValues<T>	A representation of SqmInsertValuesStatement at the org.hibernate.query.criteria level, even though JPA does not define support for insert-values criteria.
interface	JpaCrossJoin<L,T>
interface	JpaCteContainer	Common contract for criteria parts that can hold CTEs (common table expressions).
interface	JpaCteCriteria<T>	A CTE (common table expression) criteria.
interface	JpaCteCriteriaAttribute	Describes the attribute of a JpaCteCriteriaType.
interface	JpaCteCriteriaType<T>	A CTE (common table expression) criteria type.
interface	JpaDerivedFrom<T>
interface	JpaDerivedJoin<T>	Represents a derived join, that is, a subquery that occurs as the target of a join in the from clause of the query.
interface	JpaDerivedRoot<T>
interface	JpaFunctionFrom<O,T>
interface	JpaFunctionJoin<E>
interface	JpaFunctionRoot<E>
interface	JpaJsonExistsExpression	A special expression for the json_exists function.
interface	JpaJsonExistsNode	The base for json_exists function nodes.
interface	JpaJsonQueryExpression	A special expression for the json_query function.
interface	JpaJsonQueryNode	The base for json_query function nodes.
interface	JpaJsonTableColumnsNode	A special expression for the definition of columns within the json_table function.
interface	JpaJsonTableFunction	A special expression for the json_table function.
interface	JpaJsonValueExpression<T>	A special expression for the json_value function.
interface	JpaJsonValueNode<T>	The base for json_value function nodes.
interface	JpaSearchOrder	Represents the search order for a recursive CTE (common table expression).
interface	JpaSetReturningFunction<T>	A set returning function criteria.
interface	JpaValues	A tuple of values.
interface	JpaWindow	Common contract for window parts used in window and aggregate functions.
interface	JpaWindowFrame	Common contract for a JpaWindow frame specification.
interface	JpaXmlElementExpression	A special expression for the xmlelement function.
interface	JpaXmlTableColumnNode<T>	A special node for column defined for a xmltable function.
interface	JpaXmlTableFunction	A special expression for the xmltable function.

Methods in org.hibernate.query.criteria with annotations of type Incubating

Modifier and Type	Method	Description
JpaExpression<Double>	HibernateCriteriaBuilder.acos(Expression<? extends Number> x)	Create an expression that returns the inverse cosine of its argument.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayAgg(JpaOrder order, Expression<? extends T> argument)
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayAgg(JpaOrder order, JpaPredicate filter, Expression<? extends T> argument)
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayAgg(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<? extends T> argument)	Create a array_agg ordered set-aggregate function expression.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayAgg(JpaOrder order, JpaWindow window, Expression<? extends T> argument)
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayAppend(Expression<T[]> arrayExpression, Expression<T> elementExpression)	Appends element to array.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayAppend(Expression<T[]> arrayExpression, T element)	Appends element to array.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayConcat(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)	Concatenates arrays with each other in order.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayConcat(Expression<T[]> arrayExpression1, T[] array2)	Concatenates arrays with each other in order.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayConcat(T[] array1, Expression<T[]> arrayExpression2)	Concatenates arrays with each other in order.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayContains(Expression<T[]> arrayExpression, Expression<T> elementExpression)	Whether an array contains an element.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayContains(Expression<T[]> arrayExpression, T element)	Whether an array contains an element.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayContains(T[] array, Expression<T> elementExpression)	Whether an array contains an element.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsNullable(Expression<T[]> arrayExpression, Expression<T> elementExpression)	Whether an array contains a nullable element.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsNullable(Expression<T[]> arrayExpression, T element)	Whether an array contains a nullable element.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsNullable(T[] array, Expression<T> elementExpression)	Whether an array contains a nullable element.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayFill(Expression<T> elementExpression, Expression<Integer> elementCountExpression)	Creates array with the same element N times, as specified by the arguments.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayFill(Expression<T> elementExpression, Integer elementCount)	Creates array with the same element N times, as specified by the arguments.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayFill(T element, Expression<Integer> elementCountExpression)	Creates array with the same element N times, as specified by the arguments.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayFill(T element, Integer elementCount)	Creates array with the same element N times, as specified by the arguments.
<T> JpaExpression<T>	HibernateCriteriaBuilder.arrayGet(Expression<T[]> arrayExpression, Expression<Integer> indexExpression)	Accesses the element of an array by 1-based index.
<T> JpaExpression<T>	HibernateCriteriaBuilder.arrayGet(Expression<T[]> arrayExpression, Integer index)	Accesses the element of an array by 1-based index.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIncludes(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)	Whether an array is a subset of another array.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIncludes(Expression<T[]> arrayExpression, T[] subArray)	Whether an array is a subset of another array.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIncludes(T[] array, Expression<T[]> subArrayExpression)	Whether an array is a subset of another array.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIncludesNullable(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)	Whether an array is a subset of another array with nullable elements.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIncludesNullable(Expression<T[]> arrayExpression, T[] subArray)	Whether an array is a subset of another array with nullable elements.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIncludesNullable(T[] array, Expression<T[]> subArrayExpression)	Whether an array is a subset of another array with nullable elements.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIntersects(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)	Whether one array has any elements common with another array.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIntersects(Expression<T[]> arrayExpression1, T[] array2)	Whether one array has any elements common with another array.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIntersects(T[] array1, Expression<T[]> arrayExpression2)	Whether one array has any elements common with another array.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIntersectsNullable(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)	Whether one array has any elements common with another array, supporting null elements.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIntersectsNullable(Expression<T[]> arrayExpression1, T[] array2)	Whether one array has any elements common with another array, supporting null elements.
<T> JpaPredicate	HibernateCriteriaBuilder.arrayIntersectsNullable(T[] array1, Expression<T[]> arrayExpression2)	Whether one array has any elements common with another array, supporting null elements.
<T> JpaExpression<Integer>	HibernateCriteriaBuilder.arrayLength(Expression<T[]> arrayExpression)	Determines the length of an array.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayLiteral(T... elements)	Creates an array literal with the array constructor function.
<T> JpaExpression<Integer>	HibernateCriteriaBuilder.arrayPosition(Expression<T[]> arrayExpression, Expression<T> elementExpression)	Determines the 1-based position of an element in an array.
<T> JpaExpression<Integer>	HibernateCriteriaBuilder.arrayPosition(Expression<T[]> arrayExpression, T element)	Determines the 1-based position of an element in an array.
<T> JpaExpression<int[]>	HibernateCriteriaBuilder.arrayPositions(Expression<T[]> arrayExpression, Expression<T> elementExpression)	Determines all 1-based positions of an element in an array.
<T> JpaExpression<int[]>	HibernateCriteriaBuilder.arrayPositions(Expression<T[]> arrayExpression, T element)	Determines all 1-based positions of an element in an array.
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilder.arrayPositionsList(Expression<T[]> arrayExpression, Expression<T> elementExpression)	Determines all 1-based positions of an element in an array.
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilder.arrayPositionsList(Expression<T[]> arrayExpression, T element)	Determines all 1-based positions of an element in an array.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayPrepend(Expression<T> elementExpression, Expression<T[]> arrayExpression)	Prepends element to array.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayPrepend(T element, Expression<T[]> arrayExpression)	Prepends element to array.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayRemove(Expression<T[]> arrayExpression, Expression<T> elementExpression)	Creates array copy with given element removed.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayRemove(Expression<T[]> arrayExpression, T element)	Creates array copy with given element removed.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayRemoveIndex(Expression<T[]> arrayExpression, Expression<Integer> indexExpression)	Creates array copy with the element at the given 1-based index removed.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayRemoveIndex(Expression<T[]> arrayExpression, Integer index)	Creates array copy with the element at the given 1-based index removed.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayReplace(Expression<T[]> arrayExpression, Expression<T> oldElementExpression, Expression<T> newElementExpression)	Creates array copy replacing a given element with another.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayReplace(Expression<T[]> arrayExpression, Expression<T> oldElementExpression, T newElement)	Creates array copy replacing a given element with another.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayReplace(Expression<T[]> arrayExpression, T oldElement, Expression<T> newElementExpression)	Creates array copy replacing a given element with another.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayReplace(Expression<T[]> arrayExpression, T oldElement, T newElement)	Creates array copy replacing a given element with another.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayReverse(Expression<T[]> arrayExpression)	Reverses the order of elements in an array.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySet(Expression<T[]> arrayExpression, Expression<Integer> indexExpression, Expression<T> elementExpression)	Creates array copy with given element at given 1-based index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySet(Expression<T[]> arrayExpression, Expression<Integer> indexExpression, T element)	Creates array copy with given element at given 1-based index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySet(Expression<T[]> arrayExpression, Integer index, Expression<T> elementExpression)	Creates array copy with given element at given 1-based index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySet(Expression<T[]> arrayExpression, Integer index, T element)	Creates array copy with given element at given 1-based index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySlice(Expression<T[]> arrayExpression, Expression<Integer> lowerIndexExpression, Expression<Integer> upperIndexExpression)	Creates a sub-array of the based on 1-based lower and upper index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySlice(Expression<T[]> arrayExpression, Expression<Integer> lowerIndexExpression, Integer upperIndex)	Creates a sub-array of the based on 1-based lower and upper index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySlice(Expression<T[]> arrayExpression, Integer lowerIndex, Expression<Integer> upperIndexExpression)	Creates a sub-array of the based on 1-based lower and upper index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySlice(Expression<T[]> arrayExpression, Integer lowerIndex, Integer upperIndex)	Creates a sub-array of the based on 1-based lower and upper index.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySort(Expression<T[]> arrayExpression)	Sorts the elements of an array in ascending order.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySort(Expression<T[]> arrayExpression, boolean descending)	Sorts the elements of an array in the specified order.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySort(Expression<T[]> arrayExpression, boolean descending, boolean nullsFirst)	Create an expression that sorts the given array with explicit null ordering.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySort(Expression<T[]> arrayExpression, Expression<Boolean> descendingExpression)	Sorts the elements of an array in the specified order.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arraySort(Expression<T[]> arrayExpression, Expression<Boolean> descendingExpression, Expression<Boolean> nullsFirstExpression)	Create an expression that sorts the given array with explicit null ordering.
JpaExpression<String>	HibernateCriteriaBuilder.arrayToString(Expression<? extends Object[]> arrayExpression, Expression<String> separatorExpression)	Concatenates the non-null array elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.arrayToString(Expression<? extends Object[]> arrayExpression, Expression<String> separatorExpression, Expression<String> defaultExpression)	Concatenates the array elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.arrayToString(Expression<? extends Object[]> arrayExpression, Expression<String> separatorExpression, String defaultValue)	Concatenates the array elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.arrayToString(Expression<? extends Object[]> arrayExpression, String separator)	Concatenates the non-null array elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.arrayToString(Expression<? extends Object[]> arrayExpression, String separator, Expression<String> defaultExpression)	Concatenates the array elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.arrayToString(Expression<? extends Object[]> arrayExpression, String separator, String defaultValue)	Concatenates the array elements with a separator, as specified by the arguments.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayTrim(Expression<T[]> arrayExpression, Expression<Integer> elementCountExpression)	Creates array copy without the last N elements, specified by the second argument.
<T> JpaExpression<T[]>	HibernateCriteriaBuilder.arrayTrim(Expression<T[]> arrayExpression, Integer elementCount)	Creates array copy without the last N elements, specified by the second argument.
JpaSearchOrder	HibernateCriteriaBuilder.asc(JpaCteCriteriaAttribute x)	Create a search ordering by the ascending value of the CTE attribute.
JpaSearchOrder	HibernateCriteriaBuilder.asc(JpaCteCriteriaAttribute x, boolean nullsFirst)	Create a search ordering by the ascending value of the CTE attribute.
JpaExpression<Double>	HibernateCriteriaBuilder.asin(Expression<? extends Number> x)	Create an expression that returns the inverse sine of its argument.
JpaExpression<Double>	HibernateCriteriaBuilder.atan(Expression<? extends Number> x)	Create an expression that returns the inverse tangent of its argument.
JpaExpression<Double>	HibernateCriteriaBuilder.atan2(Expression<? extends Number> y, Expression<? extends Number> x)	Create an expression that returns the inverse tangent of y over x.
JpaExpression<Double>	HibernateCriteriaBuilder.atan2(Expression<? extends Number> y, Number x)
JpaExpression<Double>	HibernateCriteriaBuilder.atan2(Number y, Expression<? extends Number> x)
<N extends Number> JpaExpression<Double>	HibernateCriteriaBuilder.avg(Expression<N> argument, JpaPredicate filter)
<N extends Number> JpaExpression<Double>	HibernateCriteriaBuilder.avg(Expression<N> argument, JpaPredicate filter, JpaWindow window)	Create an avg aggregate function expression.
<N extends Number> JpaExpression<Double>	HibernateCriteriaBuilder.avg(Expression<N> argument, JpaWindow window)
JpaFunction<String>	HibernateCriteriaBuilder.collate(Expression<String> x, String collation)	Create an expression that applies the named collation to a string expression.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionAppend(Expression<C> collectionExpression, E element)	Appends element to basic collection.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionAppend(Expression<C> collectionExpression, Expression<? extends E> elementExpression)	Appends element to basic collection.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionConcat(C collection1, Expression<? extends Collection<? extends E>> collectionExpression2)	Concatenates basic collections with each other in order.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionConcat(Expression<C> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)	Concatenates basic collections with each other in order.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionConcat(Expression<C> collectionExpression1, Collection<? extends E> collection2)	Concatenates basic collections with each other in order.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionContains(Expression<? extends Collection<E>> collectionExpression, E element)	Whether a basic collection contains an element.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionContains(Expression<? extends Collection<E>> collectionExpression, Expression<? extends E> elementExpression)	Whether a basic collection contains an element.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionContains(Collection<E> collection, Expression<E> elementExpression)	Whether a basic collection contains an element.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsNullable(Expression<? extends Collection<E>> collectionExpression, E element)	Whether a basic collection contains a nullable element.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsNullable(Expression<? extends Collection<E>> collectionExpression, Expression<? extends E> elementExpression)	Whether a basic collection contains a nullable element.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsNullable(Collection<E> collection, Expression<E> elementExpression)	Whether a basic collection contains a nullable element.
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilder.collectionFill(Expression<T> elementExpression, Expression<Integer> elementCountExpression)	Creates basic collection with the same element N times, as specified by the arguments.
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilder.collectionFill(Expression<T> elementExpression, Integer elementCount)	Creates basic collection with the same element N times, as specified by the arguments.
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilder.collectionFill(T element, Expression<Integer> elementCountExpression)	Creates basic collection with the same element N times, as specified by the arguments.
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilder.collectionFill(T element, Integer elementCount)	Creates basic collection with the same element N times, as specified by the arguments.
<E> JpaExpression<E>	HibernateCriteriaBuilder.collectionGet(Expression<? extends Collection<E>> collectionExpression, Expression<Integer> indexExpression)	Accesses the element of the basic collection by 1-based index.
<E> JpaExpression<E>	HibernateCriteriaBuilder.collectionGet(Expression<? extends Collection<E>> collectionExpression, Integer index)	Accesses the element of the basic collection by 1-based index.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIncludes(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)	Whether a basic collection is a subset of another basic collection.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIncludes(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)	Whether a basic collection is a subset of another basic collection.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIncludes(Collection<E> collection, Expression<? extends Collection<? extends E>> subCollectionExpression)	Whether a basic collection is a subset of another basic collection.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIncludesNullable(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)	Whether a basic collection is a subset of another basic collection with nullable elements.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIncludesNullable(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)	Whether a basic collection is a subset of another basic collection with nullable elements.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIncludesNullable(Collection<E> collection, Expression<? extends Collection<? extends E>> subCollectionExpression)	Whether a basic collection is a subset of another basic collection with nullable elements.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIntersects(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)	Whether one basic collection has any elements common with another basic collection.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIntersects(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)	Whether one basic collection has any elements common with another basic collection.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIntersects(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)	Whether one basic collection has any elements common with another basic collection.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIntersectsNullable(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)	Whether one basic collection has any elements common with another basic collection, supporting null elements.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIntersectsNullable(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)	Whether one basic collection has any elements common with another basic collection, supporting null elements.
<E> JpaPredicate	HibernateCriteriaBuilder.collectionIntersectsNullable(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)	Whether one basic collection has any elements common with another basic collection, supporting null elements.
JpaExpression<Integer>	HibernateCriteriaBuilder.collectionLength(Expression<? extends Collection<?>> collectionExpression)	Determines the length of a basic collection.
<E, C extends Collection<E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionLiteral(E... elements)	Creates a basic collection literal with the array constructor function.
<E> JpaExpression<Integer>	HibernateCriteriaBuilder.collectionPosition(Expression<? extends Collection<? extends E>> collectionExpression, E element)	Determines the 1-based position of an element in a basic collection.
<E> JpaExpression<Integer>	HibernateCriteriaBuilder.collectionPosition(Expression<? extends Collection<? extends E>> collectionExpression, Expression<E> elementExpression)	Determines the 1-based position of an element in a basic collection.
<T> JpaExpression<int[]>	HibernateCriteriaBuilder.collectionPositions(Expression<? extends Collection<? super T>> collectionExpression, Expression<T> elementExpression)	Determines all 1-based positions of an element in a basic collection.
<T> JpaExpression<int[]>	HibernateCriteriaBuilder.collectionPositions(Expression<? extends Collection<? super T>> collectionExpression, T element)	Determines all 1-based positions of an element in a basic collection.
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilder.collectionPositionsList(Expression<? extends Collection<? super T>> collectionExpression, Expression<T> elementExpression)	Determines all 1-based positions of an element in a basic collection.
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilder.collectionPositionsList(Expression<? extends Collection<? super T>> collectionExpression, T element)	Determines all 1-based positions of an element in a basic collection.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionPrepend(E element, Expression<C> collectionExpression)	Prepends element to basic collection.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionPrepend(Expression<? extends E> elementExpression, Expression<C> collectionExpression)	Prepends element to basic collection.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionRemove(Expression<C> collectionExpression, E element)	Creates basic collection copy with given element removed.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionRemove(Expression<C> collectionExpression, Expression<? extends E> elementExpression)	Creates basic collection copy with given element removed.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionRemoveIndex(Expression<C> collectionExpression, Expression<Integer> indexExpression)	Creates basic collection copy with the element at the given 1-based index removed.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionRemoveIndex(Expression<C> collectionExpression, Integer index)	Creates basic collection copy with the element at the given 1-based index removed.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionReplace(Expression<C> collectionExpression, E oldElement, E newElement)	Creates basic collection copy replacing a given element with another.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionReplace(Expression<C> collectionExpression, E oldElement, Expression<? extends E> newElementExpression)	Creates basic collection copy replacing a given element with another.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionReplace(Expression<C> collectionExpression, Expression<? extends E> oldElementExpression, E newElement)	Creates basic collection copy replacing a given element with another.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionReplace(Expression<C> collectionExpression, Expression<? extends E> oldElementExpression, Expression<? extends E> newElementExpression)	Creates basic collection copy replacing a given element with another.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionReverse(Expression<C> collectionExpression)	Create an expression that reverses the order of the elements of a collection.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSet(Expression<C> collectionExpression, Expression<Integer> indexExpression, E element)	Creates basic collection copy with given element at given 1-based index.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSet(Expression<C> collectionExpression, Expression<Integer> indexExpression, Expression<? extends E> elementExpression)	Creates basic collection copy with given element at given 1-based index.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSet(Expression<C> collectionExpression, Integer index, E element)	Creates basic collection copy with given element at given 1-based index.
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSet(Expression<C> collectionExpression, Integer index, Expression<? extends E> elementExpression)	Creates basic collection copy with given element at given 1-based index.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSlice(Expression<C> collectionExpression, Expression<Integer> lowerIndexExpression, Expression<Integer> upperIndexExpression)	Creates a sub-collection of the based on 1-based lower and upper index.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSlice(Expression<C> collectionExpression, Expression<Integer> lowerIndexExpression, Integer upperIndex)	Creates a sub-collection of the based on 1-based lower and upper index.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSlice(Expression<C> collectionExpression, Integer lowerIndex, Expression<Integer> upperIndexExpression)	Creates a sub-collection of the based on 1-based lower and upper index.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSlice(Expression<C> collectionExpression, Integer lowerIndex, Integer upperIndex)	Creates a sub-collection of the based on 1-based lower and upper index.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSort(Expression<C> collectionExpression)	Create an expression that sorts the elements of a collection.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSort(Expression<C> collectionExpression, boolean descending)	Create an expression that sorts the given collection in specified order.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSort(Expression<C> collectionExpression, boolean descending, boolean nullsFirst)	Create an expression that sorts the given collection with explicit null ordering.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSort(Expression<C> collectionExpression, Expression<Boolean> descendingExpression)	Create an expression that sorts the given collection in specified order.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionSort(Expression<C> collectionExpression, Expression<Boolean> descendingExpression, Expression<Boolean> nullsFirstExpression)	Create an expression that sorts the given collection with explicit null ordering.
JpaExpression<String>	HibernateCriteriaBuilder.collectionToString(Expression<? extends Collection<?>> collectionExpression, Expression<String> separatorExpression)	Concatenates the non-null basic collection elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.collectionToString(Expression<? extends Collection<?>> collectionExpression, Expression<String> separatorExpression, Expression<String> defaultExpression)	Concatenates the collection elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.collectionToString(Expression<? extends Collection<?>> collectionExpression, Expression<String> separatorExpression, String defaultValue)	Concatenates the collection elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.collectionToString(Expression<? extends Collection<?>> collectionExpression, String separator)	Concatenates the non-null basic collection elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.collectionToString(Expression<? extends Collection<?>> collectionExpression, String separator, Expression<String> defaultExpression)	Concatenates the collection elements with a separator, as specified by the arguments.
JpaExpression<String>	HibernateCriteriaBuilder.collectionToString(Expression<? extends Collection<?>> collectionExpression, String separator, String defaultValue)	Concatenates the collection elements with a separator, as specified by the arguments.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionTrim(Expression<C> arrayExpression, Expression<Integer> elementCountExpression)	Creates basic collection copy without the last N elements, specified by the second argument.
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilder.collectionTrim(Expression<C> arrayExpression, Integer elementCount)	Creates basic collection copy without the last N elements, specified by the second argument.
JpaExpression<Double>	HibernateCriteriaBuilder.cos(Expression<? extends Number> x)	Create an expression that returns the cosine of its argument.
JpaExpression<Double>	HibernateCriteriaBuilder.cosh(Expression<? extends Number> x)	Create an expression that returns the hyperbolic cosine of its argument.
JpaExpression<Long>	HibernateCriteriaBuilder.count(Expression<?> argument, JpaPredicate filter)
JpaExpression<Long>	HibernateCriteriaBuilder.count(Expression<?> argument, JpaPredicate filter, JpaWindow window)	Create a count aggregate function expression.
JpaExpression<Long>	HibernateCriteriaBuilder.count(Expression<?> argument, JpaWindow window)
JpaCriteriaQuery<Boolean>	JpaCriteriaQuery.createExistsQuery()	A query that returns true if this query has any results.
JpaWindow	HibernateCriteriaBuilder.createWindow()	Create an empty JpaWindow to use with window and aggregate functions.
<X> JpaCrossJoin<T,X>	JpaFrom.crossJoin(Class<X> entityJavaType)	Create a cross join to the given entity type.
<X> JpaCrossJoin<T,X>	JpaFrom.crossJoin(EntityDomainType<X> entity)	Create a cross join to the given entity type.
JpaExpression<Double>	HibernateCriteriaBuilder.cumeDist(JpaWindow window)	Create a cume_dist window function expression.
JpaFunction<Integer>	HibernateCriteriaBuilder.day(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.DAY of a date, time, or datetime expression.
JpaExpression<Double>	HibernateCriteriaBuilder.degrees(Expression<? extends Number> x)	Create an expression that converts an angle measured in radians to an approximately equivalent angle measured in degrees.
JpaExpression<Long>	HibernateCriteriaBuilder.denseRank(JpaWindow window)	Create a dense_rank window function expression.
JpaSearchOrder	HibernateCriteriaBuilder.desc(JpaCteCriteriaAttribute x)	Create a search ordering by the descending value of the CTE attribute.
JpaSearchOrder	HibernateCriteriaBuilder.desc(JpaCteCriteriaAttribute x, boolean nullsFirst)	Create a search ordering by the descending value of the CTE attribute.
JpaExpression<Duration>	HibernateCriteriaBuilder.duration(long magnitude, TemporalUnit unit)	A literal Duration, for example, "five days" or "30 minutes".
JpaExpression<Long>	HibernateCriteriaBuilder.durationByUnit(TemporalUnit unit, Expression<Duration> duration)	Convert a Duration to a numeric magnitude in the given units.
<T> JpaExpression<T>	HibernateCriteriaBuilder.firstValue(Expression<T> argument, JpaWindow window)	Create a first_value window function expression.
JpaFunction<String>	HibernateCriteriaBuilder.format(Expression<? extends TemporalAccessor> datetime, String pattern)	Format a date, time, or datetime according to a pattern.
JpaWindowFrame	HibernateCriteriaBuilder.frameBetweenFollowing(int offset)
JpaWindowFrame	HibernateCriteriaBuilder.frameBetweenFollowing(Expression<?> offset)	Create a window frame of type FrameKind.OFFSET_FOLLOWING to use with JpaWindows.
JpaWindowFrame	HibernateCriteriaBuilder.frameBetweenPreceding(int offset)
JpaWindowFrame	HibernateCriteriaBuilder.frameBetweenPreceding(Expression<?> offset)	Create window frame of type FrameKind.OFFSET_PRECEDING to use with JpaWindows.
JpaWindowFrame	HibernateCriteriaBuilder.frameCurrentRow()	Create a window frame of type FrameKind.CURRENT_ROW to use with JpaWindows.
JpaWindowFrame	HibernateCriteriaBuilder.frameUnboundedFollowing()	Create a window frame of type FrameKind.UNBOUNDED_FOLLOWING to use with JpaWindows.
JpaWindowFrame	HibernateCriteriaBuilder.frameUnboundedPreceding()	Create a window frame of type FrameKind.UNBOUNDED_PRECEDING to use with JpaWindows.
<T> JpaExpression<T>	HibernateCriteriaBuilder.functionAggregate(String name, Class<T> type, JpaPredicate filter, Expression<?>... args)
<T> JpaExpression<T>	HibernateCriteriaBuilder.functionAggregate(String name, Class<T> type, JpaPredicate filter, JpaWindow window, Expression<?>... args)	Create a generic aggregate function expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.functionAggregate(String name, Class<T> type, JpaWindow window, Expression<?>... args)
<T> JpaExpression<T>	HibernateCriteriaBuilder.functionWithinGroup(String name, Class<T> type, JpaOrder order, Expression<?>... args)
<T> JpaExpression<T>	HibernateCriteriaBuilder.functionWithinGroup(String name, Class<T> type, JpaOrder order, JpaPredicate filter, Expression<?>... args)
<T> JpaExpression<T>	HibernateCriteriaBuilder.functionWithinGroup(String name, Class<T> type, JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<?>... args)	Create a generic ordered set-aggregate function expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.functionWithinGroup(String name, Class<T> type, JpaOrder order, JpaWindow window, Expression<?>... args)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(E start, E stop)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(E start, E stop, E step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(E start, E stop, Expression<E> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(E start, Expression<E> stop)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(E start, Expression<E> stop, E step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(E start, Expression<E> stop, Expression<E> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(Expression<E> start, E stop)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(Expression<E> start, E stop, E step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(Expression<E> start, E stop, Expression<E> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(Expression<E> start, Expression<E> stop)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(Expression<E> start, Expression<E> stop, E step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateSeries(Expression<E> start, Expression<E> stop, Expression<E> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(E start, E stop, Expression<? extends TemporalAmount> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(E start, E stop, TemporalAmount step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(E start, Expression<E> stop, Expression<? extends TemporalAmount> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(E start, Expression<E> stop, TemporalAmount step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(Expression<E> start, E stop, Expression<? extends TemporalAmount> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(Expression<E> start, E stop, TemporalAmount step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(Expression<E> start, Expression<E> stop, Expression<? extends TemporalAmount> step)	Creates a generate_series function expression to generate a set of values as rows.
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.generateTimeSeries(Expression<E> start, Expression<E> stop, TemporalAmount step)	Creates a generate_series function expression to generate a set of values as rows.
JpaFunction<Integer>	HibernateCriteriaBuilder.hour(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.HOUR of a date, time, or datetime expression.
JpaExpression<?>	JpaFrom.id()	Create an expression for the identifier of this from element.
<X> JpaDerivedJoin<X>	JpaFrom.join(Subquery<X> subquery)	Create a derived join for the given subquery.
<X> JpaJoin<?,X>	JpaFrom.join(JpaCteCriteria<X> cte)	Create a join to the given CTE.
<X> JpaFunctionJoin<X>	JpaFrom.join(JpaSetReturningFunction<X> function)	Like calling the overload JpaFrom.join(JpaSetReturningFunction, SqmJoinType) with SqmJoinType.INNER.
<X> JpaFunctionJoin<X>	JpaFrom.join(JpaSetReturningFunction<X> function, SqmJoinType joinType)	Like calling the overload JpaFrom.join(JpaSetReturningFunction, SqmJoinType, boolean) passing false for the lateral parameter.
<X> JpaFunctionJoin<X>	JpaFrom.join(JpaSetReturningFunction<X> function, SqmJoinType joinType, boolean lateral)	Creates and returns a join node for the given set returning function.
<X> JpaFunctionJoin<X>	JpaFrom.joinArray(SingularAttribute<? super T, X[]> arrayAttribute)	Like calling the overload JpaFrom.joinArray(SingularAttribute, SqmJoinType) with SqmJoinType.INNER.
<X> JpaFunctionJoin<X>	JpaFrom.joinArray(SingularAttribute<? super T, X[]> arrayAttribute, SqmJoinType joinType)	Like calling the overload JpaFrom.join(JpaSetReturningFunction, SqmJoinType) with HibernateCriteriaBuilder.unnestArray(Expression) with the given attribute.
<X> JpaFunctionJoin<X>	JpaFrom.joinArray(String arrayAttributeName)	Like calling the overload JpaFrom.joinArray(String, SqmJoinType) with SqmJoinType.INNER.
<X> JpaFunctionJoin<X>	JpaFrom.joinArray(String arrayAttributeName, SqmJoinType joinType)	Like calling the overload JpaFrom.join(JpaSetReturningFunction, SqmJoinType) with HibernateCriteriaBuilder.unnestArray(Expression) with the result of JpaPath.get(String) passing the given attribute name.
<X> JpaFunctionJoin<X>	JpaFrom.joinArrayCollection(SingularAttribute<? super T, ? extends Collection<X>> collectionAttribute)	Like calling the overload JpaFrom.joinArrayCollection(SingularAttribute, SqmJoinType) with SqmJoinType.INNER.
<X> JpaFunctionJoin<X>	JpaFrom.joinArrayCollection(SingularAttribute<? super T, ? extends Collection<X>> collectionAttribute, SqmJoinType joinType)	Like calling the overload JpaFrom.join(JpaSetReturningFunction, SqmJoinType) with HibernateCriteriaBuilder.unnestCollection(Expression) with the given attribute.
<X> JpaFunctionJoin<X>	JpaFrom.joinArrayCollection(String collectionAttributeName)	Like calling the overload JpaFrom.joinArrayCollection(String, SqmJoinType) with SqmJoinType.INNER.
<X> JpaFunctionJoin<X>	JpaFrom.joinArrayCollection(String collectionAttributeName, SqmJoinType joinType)	Like calling the overload JpaFrom.join(JpaSetReturningFunction, SqmJoinType) with HibernateCriteriaBuilder.unnestCollection(Expression) with the result of JpaPath.get(String) passing the given attribute name.
<X> JpaDerivedJoin<X>	JpaFrom.joinLateral(Subquery<X> subquery)	Create a lateral derived join for the given subquery.
<X> JpaFunctionJoin<X>	JpaFrom.joinLateral(JpaSetReturningFunction<X> function)	Like calling the overload JpaFrom.joinLateral(JpaSetReturningFunction, SqmJoinType) with SqmJoinType.INNER.
<X> JpaFunctionJoin<X>	JpaFrom.joinLateral(JpaSetReturningFunction<X> function, SqmJoinType joinType)	Like calling the overload JpaFrom.join(JpaSetReturningFunction, SqmJoinType, boolean) passing true for the lateral parameter.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArray(Expression<?>... values)	Create a JSON array from the array of values.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAgg(Expression<?> value)	Aggregates the given value into a JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAgg(Expression<?> value, Predicate filter)	Aggregates the given value into a JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAgg(Expression<?> value, Predicate filter, JpaOrder... orderBy)	Aggregates the given value into a JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAgg(Expression<?> value, JpaOrder... orderBy)	Aggregates the given value into a JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAggWithNulls(Expression<?> value)	Aggregates the given value into a JSON array, retaining null values in the JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAggWithNulls(Expression<?> value, Predicate filter)	Aggregates the given value into a JSON array, retaining null values in the JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAggWithNulls(Expression<?> value, Predicate filter, JpaOrder... orderBy)	Aggregates the given value into a JSON array, retaining null values in the JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayAggWithNulls(Expression<?> value, JpaOrder... orderBy)	Aggregates the given value into a JSON array, retaining null values in the JSON array.
JpaExpression<String>	HibernateCriteriaBuilder.jsonArrayWithNulls(Expression<?>... values)	Create a JSON object from the given array of values, retaining null values in the JSON array.
JpaJsonExistsExpression	HibernateCriteriaBuilder.jsonExists(Expression<?> jsonDocument, Expression<String> jsonPath)	Checks if a JSON document contains a node for the given JSON path.
JpaJsonExistsExpression	HibernateCriteriaBuilder.jsonExists(Expression<?> jsonDocument, String jsonPath)	Checks if a JSON document contains a node for the given JSON path.
JpaExpression<String>	HibernateCriteriaBuilder.jsonInsert(Expression<?> jsonDocument, Expression<String> jsonPath, Expression<?> value)	Inserts a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonInsert(Expression<?> jsonDocument, Expression<String> jsonPath, Object value)	Inserts a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonInsert(Expression<?> jsonDocument, String jsonPath, Expression<?> value)	Inserts a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonInsert(Expression<?> jsonDocument, String jsonPath, Object value)	Inserts a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonMergepatch(Expression<?> document, Expression<?> patch)	Applies the patch JSON document onto the other JSON document and returns that.
JpaExpression<String>	HibernateCriteriaBuilder.jsonMergepatch(Expression<?> document, String patch)	Applies the patch JSON document onto the other JSON document and returns that.
JpaExpression<String>	HibernateCriteriaBuilder.jsonMergepatch(String document, Expression<?> patch)	Applies the patch JSON document onto the other JSON document and returns that.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObject(Map<?, ? extends Expression<?>> keyValues)	Create a JSON object from the given map of key values.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAgg(Expression<?> key, Expression<?> value)	Aggregates the given value under the given key into a JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAgg(Expression<?> key, Expression<?> value, Predicate filter)	Aggregates the given value under the given key into a JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAggWithNulls(Expression<?> key, Expression<?> value)	Aggregates the given value under the given key into a JSON object, retaining null values in the JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAggWithNulls(Expression<?> key, Expression<?> value, Predicate filter)	Aggregates the given value under the given key into a JSON object, retaining null values in the JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAggWithUniqueKeys(Expression<?> key, Expression<?> value)	Aggregates the given value under the given key into a JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAggWithUniqueKeys(Expression<?> key, Expression<?> value, Predicate filter)	Aggregates the given value under the given key into a JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAggWithUniqueKeysAndNulls(Expression<?> key, Expression<?> value)	Aggregates the given value under the given key into a JSON object, retaining null values in the JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectAggWithUniqueKeysAndNulls(Expression<?> key, Expression<?> value, Predicate filter)	Aggregates the given value under the given key into a JSON object, retaining null values in the JSON object.
JpaExpression<String>	HibernateCriteriaBuilder.jsonObjectWithNulls(Map<?, ? extends Expression<?>> keyValues)	Create a JSON object from the given map of key values, retaining null values in the JSON.
JpaJsonQueryExpression	HibernateCriteriaBuilder.jsonQuery(Expression<?> jsonDocument, Expression<String> jsonPath)	Queries values by JSON path from a JSON document.
JpaJsonQueryExpression	HibernateCriteriaBuilder.jsonQuery(Expression<?> jsonDocument, String jsonPath)
JpaExpression<String>	HibernateCriteriaBuilder.jsonRemove(Expression<?> jsonDocument, Expression<String> jsonPath)	Removes a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonRemove(Expression<?> jsonDocument, String jsonPath)	Removes a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonReplace(Expression<?> jsonDocument, Expression<String> jsonPath, Expression<?> value)	Replaces a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonReplace(Expression<?> jsonDocument, Expression<String> jsonPath, Object value)	Replaces a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonReplace(Expression<?> jsonDocument, String jsonPath, Expression<?> value)	Replaces a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonReplace(Expression<?> jsonDocument, String jsonPath, Object value)	Replaces a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonSet(Expression<?> jsonDocument, Expression<String> jsonPath, Expression<?> value)	Inserts/Replaces a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonSet(Expression<?> jsonDocument, Expression<String> jsonPath, Object value)	Inserts/Replaces a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonSet(Expression<?> jsonDocument, String jsonPath, Expression<?> value)	Inserts/Replaces a value by JSON path within a JSON document.
JpaExpression<String>	HibernateCriteriaBuilder.jsonSet(Expression<?> jsonDocument, String jsonPath, Object value)	Inserts/Replaces a value by JSON path within a JSON document.
JpaJsonTableFunction	HibernateCriteriaBuilder.jsonTable(Expression<?> jsonDocument)	Creates a json_table function expression to generate rows from JSON array elements.
JpaJsonTableFunction	HibernateCriteriaBuilder.jsonTable(Expression<?> jsonDocument, Expression<String> jsonPath)	Creates a json_table function expression to generate rows from JSON array elements.
JpaJsonTableFunction	HibernateCriteriaBuilder.jsonTable(Expression<?> jsonDocument, String jsonPath)	Creates a json_table function expression to generate rows from JSON array elements.
JpaJsonValueExpression<String>	HibernateCriteriaBuilder.jsonValue(Expression<?> jsonDocument, Expression<String> jsonPath)
<T> JpaJsonValueExpression<T>	HibernateCriteriaBuilder.jsonValue(Expression<?> jsonDocument, Expression<String> jsonPath, Class<T> returningType)	Extracts a value by JSON path from a JSON document.
JpaJsonValueExpression<String>	HibernateCriteriaBuilder.jsonValue(Expression<?> jsonDocument, String jsonPath)
<T> JpaJsonValueExpression<T>	HibernateCriteriaBuilder.jsonValue(Expression<?> jsonDocument, String jsonPath, Class<T> returningType)	Extracts a value by JSON path from a JSON document.
<T> JpaExpression<T>	HibernateCriteriaBuilder.lastValue(Expression<T> argument, JpaWindow window)	Create a last_value window function expression.
JpaFunction<String>	HibernateCriteriaBuilder.left(Expression<String> x, int length)
JpaFunction<String>	HibernateCriteriaBuilder.left(Expression<String> x, Expression<Integer> length)	Extract the length leftmost characters of a string.
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, Expression<String> argument, Expression<String> separator)
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, Expression<String> argument, String separator)
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, JpaPredicate filter, Expression<String> argument, Expression<String> separator)
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, JpaPredicate filter, Expression<String> argument, String separator)
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<String> argument, Expression<String> separator)	Create a listagg ordered set-aggregate function expression.
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<String> argument, String separator)
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, JpaWindow window, Expression<String> argument, Expression<String> separator)
JpaExpression<String>	HibernateCriteriaBuilder.listagg(JpaOrder order, JpaWindow window, Expression<String> argument, String separator)
JpaExpression<Double>	HibernateCriteriaBuilder.log(Expression<? extends Number> b, Expression<? extends Number> x)	Create an expression that returns the logarithm of x to the base b.
JpaExpression<Double>	HibernateCriteriaBuilder.log(Number b, Expression<? extends Number> x)
JpaExpression<Double>	HibernateCriteriaBuilder.log10(Expression<? extends Number> x)	Create an expression that returns the base-10 logarithm of its argument.
JpaFunction<Integer>	HibernateCriteriaBuilder.minute(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.MINUTE of a date, time, or datetime expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.mode(Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.mode(JpaPredicate filter, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.mode(JpaPredicate filter, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)	Create a mode ordered set-aggregate function expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.mode(JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
JpaFunction<Integer>	HibernateCriteriaBuilder.month(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.MONTH of a date, time, or datetime expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.named(Expression<T> expression, String name)	Creates a named expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.nthValue(Expression<T> argument, int n, JpaWindow window)
<T> JpaExpression<T>	HibernateCriteriaBuilder.nthValue(Expression<T> argument, Expression<Integer> n, JpaWindow window)	Create a nth_value window function expression.
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, Expression<String> replacement, int start)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, Expression<String> replacement, int start, int length)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, Expression<String> replacement, int start, Expression<Integer> length)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, Expression<String> replacement, Expression<Integer> start)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, Expression<String> replacement, Expression<Integer> start, int length)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, Expression<String> replacement, Expression<Integer> start, Expression<Integer> length)	Overlay the string expression with the replacement expression, starting from index start and substituting a number of characters corresponding to the length of the replacement expression or the length parameter if specified.
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, String replacement, int start)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, String replacement, int start, int length)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, String replacement, int start, Expression<Integer> length)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, String replacement, Expression<Integer> start)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, String replacement, Expression<Integer> start, int length)
JpaFunction<String>	HibernateCriteriaBuilder.overlay(Expression<String> string, String replacement, Expression<Integer> start, Expression<Integer> length)
JpaFunction<String>	HibernateCriteriaBuilder.pad(CriteriaBuilder.Trimspec ts, Expression<String> x, int length)
JpaFunction<String>	HibernateCriteriaBuilder.pad(CriteriaBuilder.Trimspec ts, Expression<String> x, int length, char padChar)
JpaFunction<String>	HibernateCriteriaBuilder.pad(CriteriaBuilder.Trimspec ts, Expression<String> x, int length, Expression<Character> padChar)
JpaFunction<String>	HibernateCriteriaBuilder.pad(CriteriaBuilder.Trimspec ts, Expression<String> x, Expression<Integer> length)
JpaFunction<String>	HibernateCriteriaBuilder.pad(CriteriaBuilder.Trimspec ts, Expression<String> x, Expression<Integer> length, char padChar)
JpaFunction<String>	HibernateCriteriaBuilder.pad(CriteriaBuilder.Trimspec ts, Expression<String> x, Expression<Integer> length, Expression<Character> padChar)	Pad the specified string expression with whitespace or with the padChar character if specified.
JpaFunction<String>	HibernateCriteriaBuilder.pad(Expression<String> x, int length)
JpaFunction<String>	HibernateCriteriaBuilder.pad(Expression<String> x, int length, char padChar)
JpaFunction<String>	HibernateCriteriaBuilder.pad(Expression<String> x, int length, Expression<Character> padChar)
JpaFunction<String>	HibernateCriteriaBuilder.pad(Expression<String> x, Expression<Integer> length)
JpaFunction<String>	HibernateCriteriaBuilder.pad(Expression<String> x, Expression<Integer> length, char padChar)
JpaFunction<String>	HibernateCriteriaBuilder.pad(Expression<String> x, Expression<Integer> length, Expression<Character> padChar)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileCont(Expression<? extends Number> argument, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileCont(Expression<? extends Number> argument, JpaPredicate filter, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileCont(Expression<? extends Number> argument, JpaPredicate filter, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)	Create a percentile_cont ordered set-aggregate function expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileCont(Expression<? extends Number> argument, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileDisc(Expression<? extends Number> argument, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileDisc(Expression<? extends Number> argument, JpaPredicate filter, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileDisc(Expression<? extends Number> argument, JpaPredicate filter, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)	Create a percentile_disc ordered set-aggregate function expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileDisc(Expression<? extends Number> argument, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, Nulls nullPrecedence)
JpaExpression<Double>	HibernateCriteriaBuilder.percentRank(JpaOrder order, Expression<?>... arguments)
JpaExpression<Double>	HibernateCriteriaBuilder.percentRank(JpaOrder order, JpaPredicate filter, Expression<?>... arguments)
JpaExpression<Double>	HibernateCriteriaBuilder.percentRank(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<?>... arguments)	Create a percent_rank ordered set-aggregate function expression.
JpaExpression<Double>	HibernateCriteriaBuilder.percentRank(JpaOrder order, JpaWindow window, Expression<?>... arguments)
JpaExpression<Double>	HibernateCriteriaBuilder.percentRank(JpaWindow window)	Create a percent_rank window function expression.
JpaExpression<Double>	HibernateCriteriaBuilder.pi()	Literal expression corresponding to the value of pi.
JpaExpression<Double>	HibernateCriteriaBuilder.radians(Expression<? extends Number> x)	Create an expression that converts an angle measured in degrees to an approximately equivalent angle measured in radians.
JpaExpression<Long>	HibernateCriteriaBuilder.rank(JpaOrder order, Expression<?>... arguments)
JpaExpression<Long>	HibernateCriteriaBuilder.rank(JpaOrder order, JpaPredicate filter, Expression<?>... arguments)
JpaExpression<Long>	HibernateCriteriaBuilder.rank(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<?>... arguments)	Create a rank ordered set-aggregate function expression.
JpaExpression<Long>	HibernateCriteriaBuilder.rank(JpaOrder order, JpaWindow window, Expression<?>... arguments)
JpaExpression<Long>	HibernateCriteriaBuilder.rank(JpaWindow window)	Create a rank window function expression.
JpaFunction<String>	HibernateCriteriaBuilder.replace(Expression<String> x, Expression<String> pattern, Expression<String> replacement)	Replace all occurrences of pattern within the original string with replacement.
JpaFunction<String>	HibernateCriteriaBuilder.replace(Expression<String> x, Expression<String> pattern, String replacement)
JpaFunction<String>	HibernateCriteriaBuilder.replace(Expression<String> x, String pattern, Expression<String> replacement)
JpaFunction<String>	HibernateCriteriaBuilder.replace(Expression<String> x, String pattern, String replacement)
JpaCriteriaQuery<R>	CriteriaDefinition.restrict(Predicate predicate)
JpaFunction<String>	HibernateCriteriaBuilder.right(Expression<String> x, int length)
JpaFunction<String>	HibernateCriteriaBuilder.right(Expression<String> x, Expression<Integer> length)	Extract the length rightmost characters of a string.
JpaExpression<Long>	HibernateCriteriaBuilder.rowNumber(JpaWindow window)	Create a row_number window function expression.
JpaSearchOrder	HibernateCriteriaBuilder.search(JpaCteCriteriaAttribute cteAttribute)	Create a search ordering based on the ascending value of the CTE attribute.
JpaSearchOrder	HibernateCriteriaBuilder.search(JpaCteCriteriaAttribute cteAttribute, SortDirection sortOrder)	Create a search ordering based on the sort order of the value of the CTE attribute.
JpaSearchOrder	HibernateCriteriaBuilder.search(JpaCteCriteriaAttribute cteAttribute, SortDirection sortOrder, Nulls nullPrecedence)	Create a search ordering based on the sort order and null precedence of the value of the CTE attribute.
JpaFunction<Float>	HibernateCriteriaBuilder.second(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.SECOND of a date, time, or datetime expression.
<E> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.setReturningFunction(String name, Expression<?>... args)	Create a new set-returning function expression.
JpaExpression<Double>	HibernateCriteriaBuilder.sin(Expression<? extends Number> x)	Create an expression that returns the sine of its argument.
JpaExpression<Double>	HibernateCriteriaBuilder.sinh(Expression<? extends Number> x)	Create an expression that returns the hyperbolic sine of its argument.
<T> JpaExpression<T>	HibernateCriteriaBuilder.sql(String pattern, Class<T> type, Expression<?>... arguments)	Embed native pattern that will be unquoted and embedded in the generated SQL.
<N extends Number> JpaExpression<Number>	HibernateCriteriaBuilder.sum(Expression<N> argument, JpaPredicate filter)
<N extends Number> JpaExpression<Number>	HibernateCriteriaBuilder.sum(Expression<N> argument, JpaPredicate filter, JpaWindow window)	Create a sum aggregate function expression.
<N extends Number> JpaExpression<Number>	HibernateCriteriaBuilder.sum(Expression<N> argument, JpaWindow window)
JpaExpression<Double>	HibernateCriteriaBuilder.tan(Expression<? extends Number> x)	Create an expression that returns the tangent of its argument.
JpaExpression<Double>	HibernateCriteriaBuilder.tanh(Expression<? extends Number> x)	Create an expression that returns the hyperbolic tangent of its argument.
<T extends TemporalAccessor> JpaFunction<T>	HibernateCriteriaBuilder.truncate(Expression<T> datetime, TemporalUnit temporalUnit)	Truncates a date, time or datetime expression to the given TemporalUnit.
<E> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.unnestArray(Expression<E[]> array)	Creates an unnest function expression to turn an array into a set of rows.
<E> JpaSetReturningFunction<E>	HibernateCriteriaBuilder.unnestCollection(Expression<? extends Collection<E>> collection)	Creates an unnest function expression to turn an array into a set of rows.
JpaValues	HibernateCriteriaBuilder.values(Expression<?>... expressions)	Create a row of values for an insert-values criteria statement.
JpaValues	HibernateCriteriaBuilder.values(List<? extends Expression<?>> expressions)	Create a row of values for an insert-values criteria statement.
<T> JpaExpression<T>	HibernateCriteriaBuilder.windowFunction(String name, Class<T> type, JpaWindow window, Expression<?>... args)	Create a generic window function expression that will be applied over the specified window.
JpaExpression<String>	HibernateCriteriaBuilder.xmlagg(JpaOrder order, Expression<?> argument)
JpaExpression<String>	HibernateCriteriaBuilder.xmlagg(JpaOrder order, JpaPredicate filter, Expression<?> argument)
JpaExpression<String>	HibernateCriteriaBuilder.xmlagg(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<?> argument)	Create a xmlagg ordered set-aggregate function expression.
JpaExpression<String>	HibernateCriteriaBuilder.xmlagg(JpaOrder order, JpaWindow window, Expression<?> argument)
JpaExpression<String>	HibernateCriteriaBuilder.xmlcomment(String comment)	Creates an XML comment with the given argument as content.
JpaExpression<String>	HibernateCriteriaBuilder.xmlconcat(Expression<?>... elements)	Concatenates the given XML element expressions.
JpaExpression<String>	HibernateCriteriaBuilder.xmlconcat(List<? extends Expression<?>> elements)	Concatenates the given XML element expressions.
JpaXmlElementExpression	HibernateCriteriaBuilder.xmlelement(String elementName)	Creates an XML element with the given element name.
JpaExpression<Boolean>	HibernateCriteriaBuilder.xmlexists(Expression<String> query, Expression<?> xmlDocument)	Checks if the given XPath or XQuery query exists in the given XML document.
JpaExpression<Boolean>	HibernateCriteriaBuilder.xmlexists(String query, Expression<?> xmlDocument)	Checks if the given XPath or XQuery query exists in the given XML document.
JpaExpression<String>	HibernateCriteriaBuilder.xmlforest(Expression<?>... elements)	Creates an XML forest from the given XML element expressions.
JpaExpression<String>	HibernateCriteriaBuilder.xmlforest(List<? extends Expression<?>> elements)	Creates an XML forest from the given XML element expressions.
JpaExpression<String>	HibernateCriteriaBuilder.xmlpi(String elementName)	Creates an XML processing with the given name.
JpaExpression<String>	HibernateCriteriaBuilder.xmlpi(String elementName, Expression<String> content)	Creates an XML processing with the given name and content.
JpaExpression<String>	HibernateCriteriaBuilder.xmlquery(Expression<String> query, Expression<?> xmlDocument)	Queries the given XML document with the given XPath or XQuery query.
JpaExpression<String>	HibernateCriteriaBuilder.xmlquery(String query, Expression<?> xmlDocument)	Queries the given XML document with the given XPath or XQuery query.
JpaXmlTableFunction	HibernateCriteriaBuilder.xmlTable(Expression<String> xpath, Expression<?> xmlDocument)	Creates a xmltable function expression to generate rows from XML elements.
JpaXmlTableFunction	HibernateCriteriaBuilder.xmlTable(String xpath, Expression<?> xmlDocument)	Creates a xmltable function expression to generate rows from XML elements.
JpaFunction<Integer>	HibernateCriteriaBuilder.year(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.YEAR of a date, time, or datetime expression.

Uses of Incubating in org.hibernate.query.criteria.spi

Methods in org.hibernate.query.criteria.spi with annotations of type Incubating

Modifier and Type	Method	Description
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayAgg(JpaOrder order, Expression<? extends T> argument)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayAgg(JpaOrder order, JpaPredicate filter, Expression<? extends T> argument)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayAgg(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<? extends T> argument)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayAgg(JpaOrder order, JpaWindow window, Expression<? extends T> argument)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayAppend(Expression<T[]> arrayExpression, Expression<T> elementExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayAppend(Expression<T[]> arrayExpression, T element)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayConcat(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayConcat(Expression<T[]> arrayExpression1, T[] array2)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayConcat(T[] array1, Expression<T[]> arrayExpression2)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContains(Expression<T[]> arrayExpression, Expression<T> elementExpression)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContains(Expression<T[]> arrayExpression, T element)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContains(T[] array, Expression<T> elementExpression)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsNullable(Expression<T[]> arrayExpression, Expression<T> elementExpression)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsNullable(Expression<T[]> arrayExpression, T element)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsNullable(T[] array, Expression<T> elementExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayFill(Expression<T> elementExpression, Expression<Integer> elementCountExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayFill(Expression<T> elementExpression, Integer elementCount)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayFill(T element, Expression<Integer> elementCountExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayFill(T element, Integer elementCount)
<T> JpaExpression<T>	HibernateCriteriaBuilderDelegate.arrayGet(Expression<T[]> arrayExpression, Expression<Integer> indexExpression)
<T> JpaExpression<T>	HibernateCriteriaBuilderDelegate.arrayGet(Expression<T[]> arrayExpression, Integer index)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIncludes(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIncludes(Expression<T[]> arrayExpression, T[] subArray)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIncludes(T[] array, Expression<T[]> subArrayExpression)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIncludesNullable(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIncludesNullable(Expression<T[]> arrayExpression, T[] subArray)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIncludesNullable(T[] array, Expression<T[]> subArrayExpression)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIntersects(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIntersects(Expression<T[]> arrayExpression1, T[] array2)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIntersects(T[] array1, Expression<T[]> arrayExpression2)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIntersectsNullable(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIntersectsNullable(Expression<T[]> arrayExpression1, T[] array2)
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayIntersectsNullable(T[] array1, Expression<T[]> arrayExpression2)
<T> JpaExpression<Integer>	HibernateCriteriaBuilderDelegate.arrayLength(Expression<T[]> arrayExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayLiteral(T... elements)
<T> JpaExpression<Integer>	HibernateCriteriaBuilderDelegate.arrayPosition(Expression<T[]> arrayExpression, Expression<T> elementExpression)
<T> JpaExpression<Integer>	HibernateCriteriaBuilderDelegate.arrayPosition(Expression<T[]> arrayExpression, T element)
<T> JpaExpression<int[]>	HibernateCriteriaBuilderDelegate.arrayPositions(Expression<T[]> arrayExpression, Expression<T> elementExpression)
<T> JpaExpression<int[]>	HibernateCriteriaBuilderDelegate.arrayPositions(Expression<T[]> arrayExpression, T element)
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilderDelegate.arrayPositionsList(Expression<T[]> arrayExpression, Expression<T> elementExpression)
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilderDelegate.arrayPositionsList(Expression<T[]> arrayExpression, T element)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayPrepend(Expression<T> elementExpression, Expression<T[]> arrayExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayPrepend(T element, Expression<T[]> arrayExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayRemove(Expression<T[]> arrayExpression, Expression<T> elementExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayRemove(Expression<T[]> arrayExpression, T element)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayRemoveIndex(Expression<T[]> arrayExpression, Expression<Integer> indexExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayRemoveIndex(Expression<T[]> arrayExpression, Integer index)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayReplace(Expression<T[]> arrayExpression, Expression<T> oldElementExpression, Expression<T> newElementExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayReplace(Expression<T[]> arrayExpression, Expression<T> oldElementExpression, T newElement)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayReplace(Expression<T[]> arrayExpression, T oldElement, Expression<T> newElementExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayReplace(Expression<T[]> arrayExpression, T oldElement, T newElement)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayReverse(Expression<T[]> arrayExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySet(Expression<T[]> arrayExpression, Expression<Integer> indexExpression, Expression<T> elementExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySet(Expression<T[]> arrayExpression, Expression<Integer> indexExpression, T element)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySet(Expression<T[]> arrayExpression, Integer index, Expression<T> elementExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySet(Expression<T[]> arrayExpression, Integer index, T element)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySlice(Expression<T[]> arrayExpression, Expression<Integer> lowerIndexExpression, Expression<Integer> upperIndexExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySlice(Expression<T[]> arrayExpression, Expression<Integer> lowerIndexExpression, Integer upperIndex)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySlice(Expression<T[]> arrayExpression, Integer lowerIndex, Expression<Integer> upperIndexExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySlice(Expression<T[]> arrayExpression, Integer lowerIndex, Integer upperIndex)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySort(Expression<T[]> arrayExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySort(Expression<T[]> arrayExpression, boolean descending)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySort(Expression<T[]> arrayExpression, boolean descending, boolean nullsFirst)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySort(Expression<T[]> arrayExpression, Expression<Boolean> descendingExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arraySort(Expression<T[]> arrayExpression, Expression<Boolean> descendingExpression, Expression<Boolean> nullsFirstExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.arrayToString(Expression<? extends Object[]> arrayExpression, Expression<String> separatorExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.arrayToString(Expression<? extends Object[]> arrayExpression, Expression<String> separatorExpression, Expression<String> defaultExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.arrayToString(Expression<? extends Object[]> arrayExpression, Expression<String> separatorExpression, String defaultValue)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.arrayToString(Expression<? extends Object[]> arrayExpression, String separator)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.arrayToString(Expression<? extends Object[]> arrayExpression, String separator, Expression<String> defaultExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.arrayToString(Expression<? extends Object[]> arrayExpression, String separator, String defaultValue)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayTrim(Expression<T[]> arrayExpression, Expression<Integer> elementCountExpression)
<T> JpaExpression<T[]>	HibernateCriteriaBuilderDelegate.arrayTrim(Expression<T[]> arrayExpression, Integer elementCount)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.asc(JpaCteCriteriaAttribute x)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.asc(JpaCteCriteriaAttribute x, boolean nullsFirst)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionAppend(Expression<C> collectionExpression, E element)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionAppend(Expression<C> collectionExpression, Expression<? extends E> elementExpression)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionConcat(C collection1, Expression<? extends Collection<? extends E>> collectionExpression2)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionConcat(Expression<C> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionConcat(Expression<C> collectionExpression1, Collection<? extends E> collection2)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContains(Expression<? extends Collection<E>> collectionExpression, E element)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContains(Expression<? extends Collection<E>> collectionExpression, Expression<? extends E> elementExpression)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContains(Collection<E> collection, Expression<E> elementExpression)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsNullable(Expression<? extends Collection<E>> collectionExpression, E element)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsNullable(Expression<? extends Collection<E>> collectionExpression, Expression<? extends E> elementExpression)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsNullable(Collection<E> collection, Expression<E> elementExpression)
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilderDelegate.collectionFill(Expression<T> elementExpression, Expression<Integer> elementCountExpression)
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilderDelegate.collectionFill(Expression<T> elementExpression, Integer elementCount)
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilderDelegate.collectionFill(T element, Expression<Integer> elementCountExpression)
<T> JpaExpression<Collection<T>>	HibernateCriteriaBuilderDelegate.collectionFill(T element, Integer elementCount)
<E> JpaExpression<E>	HibernateCriteriaBuilderDelegate.collectionGet(Expression<? extends Collection<E>> collectionExpression, Expression<Integer> indexExpression)
<E> JpaExpression<E>	HibernateCriteriaBuilderDelegate.collectionGet(Expression<? extends Collection<E>> collectionExpression, Integer index)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIncludes(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIncludes(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIncludes(Collection<E> collection, Expression<? extends Collection<? extends E>> subArrayExpression)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIncludesNullable(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIncludesNullable(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIncludesNullable(Collection<E> collection, Expression<? extends Collection<? extends E>> subCollectionExpression)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIntersects(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIntersects(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIntersects(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIntersectsNullable(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIntersectsNullable(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionIntersectsNullable(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)
JpaExpression<Integer>	HibernateCriteriaBuilderDelegate.collectionLength(Expression<? extends Collection<?>> collectionExpression)
<E, C extends Collection<E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionLiteral(E... elements)
<E> JpaExpression<Integer>	HibernateCriteriaBuilderDelegate.collectionPosition(Expression<? extends Collection<? extends E>> collectionExpression, E element)
<E> JpaExpression<Integer>	HibernateCriteriaBuilderDelegate.collectionPosition(Expression<? extends Collection<? extends E>> collectionExpression, Expression<E> elementExpression)
<T> JpaExpression<int[]>	HibernateCriteriaBuilderDelegate.collectionPositions(Expression<? extends Collection<? super T>> collectionExpression, Expression<T> elementExpression)
<T> JpaExpression<int[]>	HibernateCriteriaBuilderDelegate.collectionPositions(Expression<? extends Collection<? super T>> collectionExpression, T element)
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilderDelegate.collectionPositionsList(Expression<? extends Collection<? super T>> collectionExpression, Expression<T> elementExpression)
<T> JpaExpression<List<Integer>>	HibernateCriteriaBuilderDelegate.collectionPositionsList(Expression<? extends Collection<? super T>> collectionExpression, T element)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionPrepend(E element, Expression<C> collectionExpression)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionPrepend(Expression<? extends E> elementExpression, Expression<C> collectionExpression)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionRemove(Expression<C> collectionExpression, E element)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionRemove(Expression<C> collectionExpression, Expression<? extends E> elementExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionRemoveIndex(Expression<C> collectionExpression, Expression<Integer> indexExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionRemoveIndex(Expression<C> collectionExpression, Integer index)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionReplace(Expression<C> collectionExpression, E oldElement, E newElement)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionReplace(Expression<C> collectionExpression, E oldElement, Expression<? extends E> newElementExpression)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionReplace(Expression<C> collectionExpression, Expression<? extends E> oldElementExpression, E newElement)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionReplace(Expression<C> collectionExpression, Expression<? extends E> oldElementExpression, Expression<? extends E> newElementExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionReverse(Expression<C> collectionExpression)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSet(Expression<C> collectionExpression, Expression<Integer> indexExpression, E element)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSet(Expression<C> collectionExpression, Expression<Integer> indexExpression, Expression<? extends E> elementExpression)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSet(Expression<C> collectionExpression, Integer index, E element)
<E, C extends Collection<? super E>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSet(Expression<C> collectionExpression, Integer index, Expression<? extends E> elementExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSlice(Expression<C> collectionExpression, Expression<Integer> lowerIndexExpression, Expression<Integer> upperIndexExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSlice(Expression<C> collectionExpression, Expression<Integer> lowerIndexExpression, Integer upperIndex)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSlice(Expression<C> collectionExpression, Integer lowerIndex, Expression<Integer> upperIndexExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSlice(Expression<C> collectionExpression, Integer lowerIndex, Integer upperIndex)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSort(Expression<C> collectionExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSort(Expression<C> collectionExpression, boolean descending)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSort(Expression<C> collectionExpression, boolean descending, boolean nullsFirst)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSort(Expression<C> collectionExpression, Expression<Boolean> descendingExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionSort(Expression<C> collectionExpression, Expression<Boolean> descendingExpression, Expression<Boolean> nullsFirstExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, Expression<String> separatorExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, Expression<String> separatorExpression, Expression<String> defaultExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, Expression<String> separatorExpression, String defaultValue)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, String separator)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, String separator, Expression<String> defaultExpression)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, String separator, String defaultValue)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionTrim(Expression<C> arrayExpression, Expression<Integer> elementCountExpression)
<C extends Collection<?>> JpaExpression<C>	HibernateCriteriaBuilderDelegate.collectionTrim(Expression<C> arrayExpression, Integer elementCount)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.desc(JpaCteCriteriaAttribute x)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.desc(JpaCteCriteriaAttribute x, boolean nullsFirst)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(E start, E stop)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(E start, E stop, E step)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(E start, E stop, Expression<E> step)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(E start, Expression<E> stop)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(E start, Expression<E> stop, E step)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(E start, Expression<E> stop, Expression<E> step)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(Expression<E> start, E stop)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(Expression<E> start, E stop, E step)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(Expression<E> start, E stop, Expression<E> step)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(Expression<E> start, Expression<E> stop)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(Expression<E> start, Expression<E> stop, E step)
<E extends Number> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateSeries(Expression<E> start, Expression<E> stop, Expression<E> step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(E start, E stop, Expression<? extends TemporalAmount> step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(E start, E stop, TemporalAmount step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(E start, Expression<E> stop, Expression<? extends TemporalAmount> step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(E start, Expression<E> stop, TemporalAmount step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(Expression<E> start, E stop, Expression<? extends TemporalAmount> step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(Expression<E> start, E stop, TemporalAmount step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(Expression<E> start, Expression<E> stop, Expression<? extends TemporalAmount> step)
<E extends Temporal> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.generateTimeSeries(Expression<E> start, Expression<E> stop, TemporalAmount step)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArray(Expression<?>... values)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAgg(Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAgg(Expression<?> value, Predicate filter)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAgg(Expression<?> value, Predicate filter, JpaOrder... orderBy)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAgg(Expression<?> value, JpaOrder... orderBy)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAggWithNulls(Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAggWithNulls(Expression<?> value, Predicate filter)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAggWithNulls(Expression<?> value, Predicate filter, JpaOrder... orderBy)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayAggWithNulls(Expression<?> value, JpaOrder... orderBy)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonArrayWithNulls(Expression<?>... values)
JpaJsonExistsExpression	HibernateCriteriaBuilderDelegate.jsonExists(Expression<?> jsonDocument, Expression<String> jsonPath)
JpaJsonExistsExpression	HibernateCriteriaBuilderDelegate.jsonExists(Expression<?> jsonDocument, String jsonPath)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonInsert(Expression<?> jsonDocument, Expression<String> jsonPath, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonInsert(Expression<?> jsonDocument, Expression<String> jsonPath, Object value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonInsert(Expression<?> jsonDocument, String jsonPath, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonInsert(Expression<?> jsonDocument, String jsonPath, Object value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonMergepatch(Expression<?> document, Expression<?> patch)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonMergepatch(Expression<?> document, String patch)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonMergepatch(String document, Expression<?> patch)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObject(Map<?, ? extends Expression<?>> keyValues)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAgg(Expression<?> key, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAgg(Expression<?> key, Expression<?> value, Predicate filter)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAggWithNulls(Expression<?> key, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAggWithNulls(Expression<?> key, Expression<?> value, Predicate filter)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAggWithUniqueKeys(Expression<?> key, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAggWithUniqueKeys(Expression<?> key, Expression<?> value, Predicate filter)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAggWithUniqueKeysAndNulls(Expression<?> key, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectAggWithUniqueKeysAndNulls(Expression<?> key, Expression<?> value, Predicate filter)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonObjectWithNulls(Map<?, ? extends Expression<?>> keyValues)
JpaJsonQueryExpression	HibernateCriteriaBuilderDelegate.jsonQuery(Expression<?> jsonDocument, Expression<String> jsonPath)
JpaJsonQueryExpression	HibernateCriteriaBuilderDelegate.jsonQuery(Expression<?> jsonDocument, String jsonPath)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonRemove(Expression<?> jsonDocument, Expression<String> jsonPath)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonRemove(Expression<?> jsonDocument, String jsonPath)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonReplace(Expression<?> jsonDocument, Expression<String> jsonPath, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonReplace(Expression<?> jsonDocument, Expression<String> jsonPath, Object value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonReplace(Expression<?> jsonDocument, String jsonPath, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonReplace(Expression<?> jsonDocument, String jsonPath, Object value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonSet(Expression<?> jsonDocument, Expression<String> jsonPath, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonSet(Expression<?> jsonDocument, Expression<String> jsonPath, Object value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonSet(Expression<?> jsonDocument, String jsonPath, Expression<?> value)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.jsonSet(Expression<?> jsonDocument, String jsonPath, Object value)
JpaJsonTableFunction	HibernateCriteriaBuilderDelegate.jsonTable(Expression<?> jsonDocument)
JpaJsonTableFunction	HibernateCriteriaBuilderDelegate.jsonTable(Expression<?> jsonDocument, Expression<String> jsonPath)
JpaJsonTableFunction	HibernateCriteriaBuilderDelegate.jsonTable(Expression<?> jsonDocument, String jsonPath)
JpaJsonValueExpression<String>	HibernateCriteriaBuilderDelegate.jsonValue(Expression<?> jsonDocument, Expression<String> jsonPath)
<T> JpaJsonValueExpression<T>	HibernateCriteriaBuilderDelegate.jsonValue(Expression<?> jsonDocument, Expression<String> jsonPath, Class<T> returningType)
JpaJsonValueExpression<String>	HibernateCriteriaBuilderDelegate.jsonValue(Expression<?> jsonDocument, String jsonPath)
<T> JpaJsonValueExpression<T>	HibernateCriteriaBuilderDelegate.jsonValue(Expression<?> jsonDocument, String jsonPath, Class<T> returningType)
<T> JpaExpression<T>	HibernateCriteriaBuilderDelegate.named(Expression<T> expression, String name)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.search(JpaCteCriteriaAttribute cteAttribute)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.search(JpaCteCriteriaAttribute cteAttribute, SortDirection sortOrder)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.search(JpaCteCriteriaAttribute cteAttribute, SortDirection sortOrder, Nulls nullPrecedence)
<E> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.setReturningFunction(String name, Expression<?>... args)
<E> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.unnestArray(Expression<E[]> array)
<E> JpaSetReturningFunction<E>	HibernateCriteriaBuilderDelegate.unnestCollection(Expression<? extends Collection<E>> collection)
JpaValues	HibernateCriteriaBuilderDelegate.values(Expression<?>... expressions)
JpaValues	HibernateCriteriaBuilderDelegate.values(List<? extends Expression<?>> expressions)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlagg(JpaOrder order, Expression<?> argument)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlagg(JpaOrder order, JpaPredicate filter, Expression<?> argument)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlagg(JpaOrder order, JpaPredicate filter, JpaWindow window, Expression<?> argument)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlagg(JpaOrder order, JpaWindow window, Expression<?> argument)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlcomment(String comment)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlconcat(Expression<?>... elements)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlconcat(List<? extends Expression<?>> elements)
JpaXmlElementExpression	HibernateCriteriaBuilderDelegate.xmlelement(String elementName)
JpaExpression<Boolean>	HibernateCriteriaBuilderDelegate.xmlexists(Expression<String> query, Expression<?> xmlDocument)
JpaExpression<Boolean>	HibernateCriteriaBuilderDelegate.xmlexists(String query, Expression<?> xmlDocument)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlforest(Expression<?>... elements)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlforest(List<? extends Expression<?>> elements)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlpi(String elementName)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlpi(String elementName, Expression<String> content)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlquery(Expression<String> query, Expression<?> xmlDocument)
JpaExpression<String>	HibernateCriteriaBuilderDelegate.xmlquery(String query, Expression<?> xmlDocument)
JpaXmlTableFunction	HibernateCriteriaBuilderDelegate.xmlTable(Expression<String> xpath, Expression<?> xmlDocument)
JpaXmlTableFunction	HibernateCriteriaBuilderDelegate.xmlTable(String xpath, Expression<?> xmlDocument)

Uses of Incubating in org.hibernate.query.hql.spi

Classes in org.hibernate.query.hql.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	HqlTranslator	Global integration contract for translating HQL or JPQL text to SQM.
interface	SqmCreationOptions	Options for semantic analysis
interface	SqmCreationProcessingState	State related to SQM creation, like SqmCreationState, but specific to its "current processing" - which generally means specific to each statement and sub-query
interface	SqmCreationState	Models the state pertaining to the creation of a single SQM.
interface	SqmPathRegistry	Registry for SqmPath references providing the ability to access them in multiple ways - by alias, by NavigablePath, etc

Uses of Incubating in org.hibernate.query.named.spi

Classes in org.hibernate.query.named.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	NameableQuery	Contract for query implementations which can be converted to named query mementos for storage in the NamedObjectRepository.
interface	NamedObjectRepository	Repository for references to named things related to queries.
interface	NamedResultSetMappingMemento	Used to keep information about named result mappings defined by the application which can then be applied to native-sql and stored-procedure queries.
interface	ResultMemento	Models a SQL ResultSet mapping generally defined via annotations.

Uses of Incubating in org.hibernate.query.range

Classes in org.hibernate.query.range with annotations of type Incubating

Modifier and Type	Interface	Description
interface	Range<U>	Specifies an allowed set or range of values for a value being restricted.

Uses of Incubating in org.hibernate.query.restriction

Classes in org.hibernate.query.restriction with annotations of type Incubating

Modifier and Type	Interface	Description
interface	Path<X,U>	Allows construction of a Restriction on a compound path.
interface	Restriction<X>	A rule for restricting query results.

Uses of Incubating in org.hibernate.query.results.spi

Classes in org.hibernate.query.results.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	FetchBuilder	Responsible for building a single Fetch instance.
interface	ResultBuilder	Builds one DomainResult for a native-query result-set mapping.
interface	ResultSetMapping	JdbcValuesMappingProducer implementation based on a graph of ResultBuilder and FetchBuilder reference.

Uses of Incubating in org.hibernate.query.specification

Classes in org.hibernate.query.specification with annotations of type Incubating

Modifier and Type	Interface	Description
interface	DeleteSpecification<T>	Specialization of MutationSpecification for programmatic customization of delete queries.
interface	MutationSpecification<T>	Specialization of QuerySpecification for programmatic customization of mutation queries.
interface	ProjectionSpecification<T>	Allows a SelectionSpecification to be augmented with the specification of a projection list.
interface	QuerySpecification<T>	Commonality for all query specifications which allow iterative, programmatic building of a query.
interface	SelectionSpecification<T>	Specialization of QuerySpecification for programmatic customization of selection queries with ordering and restriction criteria.
interface	SimpleProjectionSpecification<T,X>	Allows a SelectionSpecification to be augmented with the specification of a single projected attribute or path.
interface	UpdateSpecification<T>	Specialization of MutationSpecification for programmatic customization of update queries.

Methods in org.hibernate.query.specification with annotations of type Incubating

Modifier and Type	Method	Description
default SimpleProjectionSpecification<T,Long>	SelectionSpecification.createCountProjection()	Create a SimpleProjectionSpecification which projects the number of results which match the specified restrictions.
default SimpleProjectionSpecification<T,Boolean>	SelectionSpecification.createExistsProjection()	Create a SimpleProjectionSpecification which projects a boolean value indicating whether any results match the specified restrictions.
default ProjectionSpecification<T>	SelectionSpecification.createProjection()	Create a ProjectionSpecification allowing selection of specific fields and compound paths.
default <X> SimpleProjectionSpecification<T,X>	SelectionSpecification.createProjection(SingularAttribute<? super T, X> attribute)	Create a SimpleProjectionSpecification for the given field.
default <X> SimpleProjectionSpecification<T,X>	SelectionSpecification.createProjection(Path<T,X> path)	Create a SimpleProjectionSpecification for the given compound path.

Uses of Incubating in org.hibernate.query.spi

Classes in org.hibernate.query.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	CloseableIterator<T>	Unification of Iterator and AutoCloseable.
interface	QueryEngine	Aggregation and encapsulation of the components Hibernate uses to execute queries (HQL, Criteria and native)
interface	QueryImplementor<T>
interface	QueryInterpretationCache	Cache for various parts of translating or interpreting queries.
interface	QueryParameterBinding<T>	The value and type binding information for a particular query parameter.
interface	QueryParameterBindings	Manages all the parameter bindings for a particular query.
interface	QueryParameterBindingTypeResolver	A resolver for BindableType based on a parameter value being bound, when no explicit type information is supplied.
interface	QueryPlan	Common contract for select and mutation query plans
interface	SelectQueryPlan<R>	General contract for performing execution of a query returning results.

Uses of Incubating in org.hibernate.query.sql.spi

Classes in org.hibernate.query.sql.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	NativeQueryImplementor<R>
interface	SqlTranslationEngine	Introduced as an analog of QueryEngine and/or NodeBuilder for the SQL translation and rendering phases.

Uses of Incubating in org.hibernate.query.sqm.function

Classes in org.hibernate.query.sqm.function with annotations of type Incubating

Modifier and Type	Class	Description
class	AbstractSqmSelfRenderingSetReturningFunctionDescriptor
class	AbstractSqmSetReturningFunctionDescriptor
class	NamedSqmSetReturningFunctionDescriptor	Provides a standard implementation that supports the majority of the HQL functions that are translated to SQL.
class	SelfRenderingSqmSetReturningFunction<T>
interface	SqmSetReturningFunctionDescriptor	A factory for SQM nodes representing invocations of a certain named set-returning function.

Uses of Incubating in org.hibernate.query.sqm.produce.function

Classes in org.hibernate.query.sqm.produce.function with annotations of type Incubating

Modifier and Type	Class	Description
class	NamedSetReturningFunctionDescriptorBuilder
interface	SetReturningFunctionTypeResolver	Pluggable strategy for resolving a function return type for a specific call.
static interface	SetReturningFunctionTypeResolver.Builder	Pluggable strategy for resolving a function return type for a specific call.

Uses of Incubating in org.hibernate.query.sqm.spi

Classes in org.hibernate.query.sqm.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	SqmCreationContext	The context in which all SQM creations occur.

Uses of Incubating in org.hibernate.query.sqm.tree.spi

Methods in org.hibernate.query.sqm.tree.spi with annotations of type Incubating

Modifier and Type	Method	Description
default boolean	SqmCopyContext.copyFetchedFlag()	Returns whether the fetch flag for attribute joins should be copied over.
default SqmQuerySource	SqmCopyContext.getQuerySource()	Returns the query source to use for copied queries.

Uses of Incubating in org.hibernate.query.sqm.tree.spi.domain

Classes in org.hibernate.query.sqm.tree.spi.domain with annotations of type Incubating

Modifier and Type	Class	Description
class	SqmCteRoot<T>
class	SqmDerivedRoot<T>
interface	SqmDomainType<T>
interface	SqmEmbeddableDomainType<E>
interface	SqmEntityDomainType<E>
class	SqmFunctionRoot<E>
interface	SqmManagedDomainType<J>
interface	SqmMappedSuperclassDomainType<T>
interface	SqmPersistentAttribute<D,J>
interface	SqmPluralPersistentAttribute<D,C,E>
interface	SqmSingularPersistentAttribute<D,J>
interface	SqmTreatableDomainType<T>

Uses of Incubating in org.hibernate.query.sqm.tree.spi.expression

Classes in org.hibernate.query.sqm.tree.spi.expression with annotations of type Incubating

Modifier and Type	Class	Description
class	AbstractSqmJsonPathExpression<T>	Base class for expressions that contain a json path.
class	SqmJsonExistsExpression	Special expression for the json_exists function that also captures special syntax elements like error behavior and passing variables.
class	SqmJsonQueryExpression	Special expression for the json_query function that also captures special syntax elements like error and empty behavior.
class	SqmJsonValueExpression<T>	Special expression for the json_value function that also captures special syntax elements like error and empty behavior.
class	SqmNamedExpression<T>	A named expression.
class	SqmSetReturningFunction<T>	A SQM set-returning function
class	SqmWindow
class	SqmWindowFrame
class	SqmXmlAttributesExpression	Special expression for the json_query function that also captures special syntax elements like error and empty behavior.
class	SqmXmlElementExpression	Special expression for the xmlelement function that also captures special syntax elements like xmlattributes.

Uses of Incubating in org.hibernate.query.sqm.tree.spi.from

Classes in org.hibernate.query.sqm.tree.spi.from with annotations of type Incubating

Modifier and Type	Class	Description
class	SqmCteJoin<T>
class	SqmDerivedJoin<T>
class	SqmFunctionJoin<E>

Methods in org.hibernate.query.sqm.tree.spi.from with annotations of type Incubating

Modifier and Type	Method	Description
boolean	SqmFrom.hasImplicitlySelectableJoin()

Uses of Incubating in org.hibernate.query.sqm.tree.spi.insert

Classes in org.hibernate.query.sqm.tree.spi.insert with annotations of type Incubating

Modifier and Type	Class	Description
class	SqmInsertSelectStatement<T>

Uses of Incubating in org.hibernate.relational

Classes in org.hibernate.relational with annotations of type Incubating

Modifier and Type	Interface	Description
interface	SchemaManager	Allows programmatic schema export, schema validation, data cleanup, data population, and schema cleanup as a convenience for writing tests.

Methods in org.hibernate.relational with annotations of type Incubating

Modifier and Type	Method	Description
SchemaManager	SchemaManager.forCatalog(String catalogName)	Obtain an instance which targets the given catalog.
SchemaManager	SchemaManager.forSchema(String schemaName)	Obtain an instance which targets the given schema.
void	SchemaManager.resynchronizeGenerators()	Resynchronize sequences and table-based generators after importing entity data.
void	SchemaManager.truncateTable(String tableName)	Truncate the given database table, and reset any associated sequence or table backing a table generator.

Uses of Incubating in org.hibernate.resource.beans.spi

Classes in org.hibernate.resource.beans.spi with annotations of type Incubating

Modifier and Type	Class	Description
enum	BeanInstanceCaching	Controls caching of bean references obtained from the ManagedBeanRegistry.

Methods in org.hibernate.resource.beans.spi with annotations of type Incubating

Modifier and Type	Method	Description
<T> ManagedBean<T>	ManagedBeanRegistry.getBean(Class<T> beanClass, BeanInstanceCaching caching)	Get a bean reference by class, with control over bean instance caching.
<T> ManagedBean<T>	ManagedBeanRegistry.getBootstrapSafeBean(Class<T> beanClass)	Get a bean reference that is safe to acquire during bootstrap.
<T> ManagedBean<T>	ManagedBeanRegistry.getBootstrapSafeBean(Class<T> beanClass, BeanInstanceCaching caching)	Get a bean reference that is safe to acquire during bootstrap, with control over bean instance caching.
void	ManagedBeanRegistry.releaseBean(ManagedBean<?> bean)	Release and unregister a bean previously obtained from this registry.

Uses of Incubating in org.hibernate.resource.jdbc.spi

Methods in org.hibernate.resource.jdbc.spi with annotations of type Incubating

Modifier and Type	Method	Description
void	JdbcSessionOwner.afterObtainConnection(Connection connection)	Called after a managed JDBC connection is obtained.
void	JdbcSessionOwner.beforeReleaseConnection(Connection connection)	Called right before a managed JDBC connection is released.
default ConnectionReleaseMode	LogicalConnectionImplementor.resolvedConnectionReleaseMode()

Uses of Incubating in org.hibernate.settings

Classes in org.hibernate.settings with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AdjustableSettings	Allows runtime adjustment of a discrete set of Hibernate settings.

Uses of Incubating in org.hibernate.spi

Classes in org.hibernate.spi with annotations of type Incubating

Modifier and Type	Class	Description
class	EntityIdentifierNavigablePath	Specialized implementation of NavigablePath for handling special cases pertaining to entity identifiers.
class	NavigablePath	A compound name where the root path element is an entity name or a collection role and each the path sub-path from the root references a domain or mapping model part relative to a root path.
class	TreatedNavigablePath	An implementation of NavigablePath with special handling for treated paths.

Methods in org.hibernate.spi with annotations of type Incubating

Modifier and Type	Method	Description
<X,Y> X	Stack.findCurrentFirstWithParameter(Y parameter, BiFunction<T,Y,X> biFunction)	Runs a function on each couple defined as {Y,T} in which Y is fixed, and T is each instance of this stack.

Uses of Incubating in org.hibernate.sql.ast.spi.model.builder

Methods in org.hibernate.sql.ast.spi.model.builder with annotations of type Incubating

Modifier and Type	Method	Description
default void	AssigningTableMutationBuilder.addColumnAssignment(SelectableMapping columnMapping)	Adds a column assignment defined by columnMapping = {columnMapping.getWriteExpression()}
void	AssigningTableMutationBuilder.addColumnAssignment(SelectableMapping columnMapping, String assignment)	Adds a column assignment defined by columnMapping = assignment
void	AssigningTableMutationBuilder.addColumnAssignment(ColumnValueBinding columnValueBinding)	Adds a column assignment defined by the given columnValueBinding, which represents a column and its assignment .
boolean	AssigningTableMutationBuilder.hasAssignmentBindings()	Whether this builder currently contains any assignment bindings.

Uses of Incubating in org.hibernate.sql.ast.spi.query

Classes in org.hibernate.sql.ast.spi.query with annotations of type Incubating

Modifier and Type	Interface	Description
interface	SetReturningFunctionType	The semantic type information needed while rendering a set-returning function.

Uses of Incubating in org.hibernate.sql.ast.spi.query.expression

Classes in org.hibernate.sql.ast.spi.query.expression with annotations of type Incubating

Modifier and Type	Interface	Description
interface	QueryTransformer

Uses of Incubating in org.hibernate.sql.ast.spi.translation

Methods in org.hibernate.sql.ast.spi.translation with annotations of type Incubating

Modifier and Type	Method	Description
void	SqlAstTranslator.renderNamedSetReturningFunction(String functionName, List<? extends SqlAstNode> sqlAstArguments, SetReturningFunctionType tupleType, String tableIdentifierVariable, SqlAstNodeRenderingMode argumentRenderingMode)	Renders a named set returning function.

Uses of Incubating in org.hibernate.sql.exec.spi

Classes in org.hibernate.sql.exec.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	CacheableJdbcOperation	Optional contract for JdbcOperation implementors allowing them to be used with Query caching.
interface	Callback	Callback to allow SQM interpretation to trigger certain things within ORM.
interface	ExecutionContext	A context for execution of SQL statements expressed via SQL AST and JdbcOperation
interface	JdbcCallFunctionReturn	Models the function return when the JdbcOperationQueryCall represents a call to a database function.
interface	JdbcCallParameterExtractor<T>	Controls extracting values from OUT/INOUT parameters.
interface	JdbcCallParameterRegistration
interface	JdbcCallRefCursorExtractor
enum	JdbcLockingApplication	Records which stage owns pessimistic locking for a JDBC select plan.
interface	JdbcMutation	Primary operation, which is an (INSERT, UPDATE or DELETE) performed via JDBC.
interface	JdbcMutationExecutor	Executor for model-mutation operations
interface	JdbcOperation	A command to perform through JDBC, normally with a PreparedStatement or CallableStatement.
interface	JdbcOperationQuery	A JdbcOperation which (possibly) originated from a Query.
interface	JdbcOperationQueryAnonBlock	An anonymous call block (sometimes called an anonymous procedure) to be executed on the database.
interface	JdbcOperationQueryCall
interface	JdbcOperationQueryInsert	Basic contract for an insert operation
interface	JdbcOperationQueryMutation	A query-language insert, update, or delete operation performed through JDBC.
enum	JdbcPaginationApplication	Records which stage owns pagination for a JDBC select plan.
interface	JdbcParameterBinder	Performs parameter value binding to a JDBC PreparedStatement.
interface	JdbcParameterBinding
interface	JdbcParameterBindings	Access to all the externalized JDBC parameter bindings
interface	JdbcParameters	The collection
interface	JdbcParametersList	Conceptually similar to a List of JdbcParameters, but exposing a read-only immutable contract.
interface	JdbcSelect	Primary selection operation performed through JDBC.
interface	JdbcSelectExecutor	An executor for JdbcSelect operations.
interface	JdbcSelectWithActionsBuilder	Contract used while building a JdbcSelect which might potentially include pre- and/or post- actions.
interface	LoadedValuesCollector	Used to collect entity and collection values which are loaded as part of JdbcValues processing.
interface	PostAction	An action to be performed after a PrimaryOperation.
interface	PreAction	An action to be performed before a PrimaryOperation.
interface	PrimaryOperation	A primary operation to be executed using JDBC.
interface	SecondaryAction	Common marker interface for PreAction and PostAction.
interface	StatementAccess	Access to a JDBC Statement.

Uses of Incubating in org.hibernate.sql.model

Classes in org.hibernate.sql.model with annotations of type Incubating

Modifier and Type	Interface	Description
interface	GraphMutationTarget<TD extends TableDescriptor>	Mutation target contract for the graph-based action queue.
interface	LegacyMutationTarget<T extends TableMapping>	Mutation target contract for the legacy (sequential) action queue.
interface	MutationTarget<T extends TableMapping, TD extends TableDescriptor>	Deprecated, for removal: This API element is subject to removal in a future version. Transitional interface - use LegacyMutationTarget for legacy coordinators or GraphMutationTarget for graph-based decomposers

Uses of Incubating in org.hibernate.sql.results.graph

Classes in org.hibernate.sql.results.graph with annotations of type Incubating

Modifier and Type	Interface	Description
interface	DomainResult<J>	Represents a result value in the domain query results.
interface	DomainResultAssembler<J>	Responsible for "assembling" a result for inclusion in the domain query result.
interface	DomainResultCreationState	Contains state related to building DomainResult and Fetch graphs
interface	DomainResultGraphNode	Marker for all object types that can be part of a result mapping
interface	EntityGraphTraversalState	State used as part of applying entity graphs to Hibernate DomainResult / Fetch load graphs.
interface	Fetch	Contract for fetches including entity, collection and composite.
interface	Fetchable	Parts of the domain model that can be fetched.
interface	FetchList	This is essentially a List of Fetch(es), but exposing an interface which is more suitable to our needs; in particular it expresses the immutable nature of this structure, and allows us to extend it with additional convenience methods such as FetchList.indexedForEach(IndexedConsumer).
interface	FetchParent	Contract for things that can be the parent of a fetch
interface	Initializer<Data extends InitializerData>	Defines a multi-step process for initializing entity, collection and composite state.

Methods in org.hibernate.sql.results.graph with annotations of type Incubating

Modifier and Type	Method	Description
void	DomainResultGraphNode.collectValueIndexesToCache(BitSet valueIndexes)	Collect the JDBC value indexes used by this domain result that should be cached.

Uses of Incubating in org.hibernate.sql.results.graph.embeddable

Classes in org.hibernate.sql.results.graph.embeddable with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AggregateEmbeddableResultGraphNode	Specialized EmbeddableResultGraphNode for cases where we have an actual embeddable class.

Uses of Incubating in org.hibernate.sql.results.jdbc.spi

Classes in org.hibernate.sql.results.jdbc.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	JdbcValuesMappingProducer	Producer for JdbcValuesMapping references.
interface	JdbcValuesMappingProducerProvider	Pluggable contract for providing custom JdbcValuesMappingProducer implementations.

Uses of Incubating in org.hibernate.sql.results.spi

Classes in org.hibernate.sql.results.spi with annotations of type Incubating

Modifier and Type	Class	Description
class	ManagedResultConsumer	Reads rows without producing a result.
interface	RowTransformer<T>	Defines transformation of a raw row in the domain query result row.
class	SingleResultConsumer<T>	Used beneath SelectionQuery.getResultCount().

Uses of Incubating in org.hibernate.sql.spi.mutation

Classes in org.hibernate.sql.spi.mutation with annotations of type Incubating

Modifier and Type	Interface	Description
interface	MutationOperation	Mutation for a specific table as part of a logical mutation on the entity.

Uses of Incubating in org.hibernate.temporal

Classes in org.hibernate.temporal with annotations of type Incubating

Modifier and Type	Class	Description
enum	TemporalTableStrategy	Enumerates the possible mapping strategies for temporal entities and collections.

Uses of Incubating in org.hibernate.temporal.spi

Classes in org.hibernate.temporal.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ChangesetCoordinator	A source of changeset identifiers or timestamps for use with temporal or audited data.
interface	ChangesetIdentifierSupplier<T>	A source of changeset identifiers or timestamps for use with temporal or audited data.

Uses of Incubating in org.hibernate.tool.schema

Classes in org.hibernate.tool.schema with annotations of type Incubating

Modifier and Type	Class	Description
enum	ValidationConstraintDdlInfluence	Controls whether Jakarta Validation constraints (such as @NotNull, @Size, @Digits and others) influence the generated DDL schema.

Uses of Incubating in org.hibernate.tool.schema.extract.spi

Classes in org.hibernate.tool.schema.extract.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ColumnTypeInformation	Provides access to information about existing table columns
interface	DatabaseInformation	Provides access to information about existing schema objects (tables, sequences etc) of existing database.
interface	ExtractionContext	Defines a context for performing extraction including providing access to information about ongoing extraction as well as to delegates needed in performing extraction.
static interface	ExtractionContext.DatabaseObjectAccess	In conjunction with ExtractionContext.getDatabaseObjectAccess() provides access to information about known database objects to the extractor.
static interface	ExtractionContext.ResultSetProcessor<T>
interface	InformationExtractor	Extracts information about objects in database schemas.

Methods in org.hibernate.tool.schema.extract.spi with annotations of type Incubating

Modifier and Type	Method	Description
default <T> T	ExtractionContext.getQueryResults(String queryString, Object[] positionalParameters, ExtractionContext.ResultSetProcessor<T> resultSetProcessor)

Uses of Incubating in org.hibernate.tool.schema.spi

Classes in org.hibernate.tool.schema.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	ExecutionOptions	Parameter object representing options for schema management tool execution
interface	ExtractionTool	Encapsulates the functionality for extracting database metadata used by SchemaManagementTool.
interface	GeneratorSynchronizer	Service delegate for handling sequence resynchronization.
interface	SchemaCreator	Service delegate for handling schema creation.
interface	SchemaDropper	Service delegate for handling schema dropping.
interface	SchemaFilter	Defines a filter for Hibernate's schema tooling.
interface	SchemaFilterProvider	Used to specify the SchemaFilters to be used by create, drop, migrate and validate operations on the database schema.
interface	SchemaManagementTool	Contract for schema management tool integration.
interface	SchemaMigrator	Service delegate for handling schema migration.
interface	SchemaPopulator	Service delegate for handling schema population.
interface	SchemaTruncator	Service delegate for handling schema truncation.
interface	SchemaValidator	Service delegate for handling schema validations

Uses of Incubating in org.hibernate.type

Classes in org.hibernate.type with annotations of type Incubating

Modifier and Type	Interface	Description
interface	BasicPluralType<C,E>	A basic plural type.
interface	BindableType<J>	Represents a type of argument which can be bound to a positional or named query parameter.
interface	BindingContext	A context within which a BindableType can be resolved to an instance of SqmExpressible.
interface	OutputableType<J>	Specialization of DomainType for types that can be used as a parameter output for a ProcedureCall.
enum	TimeZoneStorageStrategy	Enumerates the possible storage strategies for offset or zoned datetimes.

Methods in org.hibernate.type with annotations of type Incubating

Modifier and Type	Method	Description
default String	BasicType.getCheckCondition(String columnName, Dialect dialect)	The check constraint that should be added to the column definition in generated DDL.
default BasicValueConverter<T,?>	BasicType.getValueConverter()

Uses of Incubating in org.hibernate.type.descriptor.converter.spi

Classes in org.hibernate.type.descriptor.converter.spi with annotations of type Incubating

Modifier and Type	Interface	Description
interface	BasicValueConverter<D,R>	Support for basic-typed value conversions.
interface	JpaAttributeConverter<O,R>	Adapts a JPA-standard AttributeConverter to the native BasicValueConverter.

Uses of Incubating in org.hibernate.type.descriptor.java

Classes in org.hibernate.type.descriptor.java with annotations of type Incubating

Modifier and Type	Interface	Description
interface	BasicPluralJavaType<T>	Describes a basic plural Java value mapped to one column, such as an SQL array or a JSON/XML collection.
interface	TemporalJavaType<T>	Specialized JavaType for temporal values and precision resolution.
interface	UuidCapableJavaType<T>	Specialization of BasicJavaType for types which model a representation of a UUID.

Methods in org.hibernate.type.descriptor.java with annotations of type Incubating

Modifier and Type	Method	Description
default Object	JavaType.coerce(Object value)	Coerce the given value to this type, if possible.
default Object	JavaType.coerceOrNull(Object value)	Like JavaType.coerce(Object) but returns null instead of throwing an exception when coercion fails.
default JavaType<T>	JavaType.createJavaType(ParameterizedType parameterizedType, TypeConfiguration typeConfiguration)
default String	JavaType.getCheckCondition(String columnName, JdbcType jdbcType, BasicValueConverter<T,?> converter, Dialect dialect)	The check constraint that should be added to the column definition in generated DDL.

Uses of Incubating in org.hibernate.type.descriptor.java.spi

Classes in org.hibernate.type.descriptor.java.spi with annotations of type Incubating

Modifier and Type	Class	Description
class	BasicCollectionJavaType<C extends Collection<E>, E>	Descriptor for handling persistent collections.
class	FormatMapperBasedJavaType<T>	Java type for FormatMapper based types i.e.
class	JsonJavaType<T>
class	XmlJavaType<T>

Uses of Incubating in org.hibernate.type.descriptor.jdbc

Classes in org.hibernate.type.descriptor.jdbc with annotations of type Incubating

Modifier and Type	Interface	Description
interface	StructuredJdbcType	An aggregate JdbcType represented by a named SQL structured type.

Methods in org.hibernate.type.descriptor.jdbc with annotations of type Incubating

Modifier and Type	Method	Description
default void	JdbcType.addAuxiliaryDatabaseObjects(JavaType<?> javaType, BasicValueConverter<?,?> valueConverter, Size columnSize, Database database, JdbcTypeIndicators context)	Add auxiliary database objects for this JdbcType to the Database object.
default void	JdbcType.appendWriteExpression(String writeExpression, Size size, SqlAppender appender, Dialect dialect)	Append the write expression wrapped in a way to be able to write values with this JdbcType's ValueBinder.
default String	JdbcType.castFromPattern(JdbcMapping sourceMapping, Size size)	Returns the cast pattern from the given source type to this type, or null if not possible.
default String	JdbcType.castToPattern(JdbcMapping targetJdbcMapping, Size size)	Returns the cast pattern from this type to the given target type, or null if not possible.
Integer	DelegatingJdbcTypeIndicators.getExplicitJdbcTypeCode()
default Integer	JdbcTypeIndicators.getExplicitJdbcTypeCode()	Used (for now) only to choose a container JdbcType for SQL arrays.
default String	JdbcType.getExtraCreateTableInfo(JavaType<?> javaType, String columnName, String tableName, Database database)
default Class<?>	JdbcType.getPreferredJavaTypeClass(WrapperOptions options)	The Java type class that is preferred by the binder or null.
default boolean	JdbcType.hasDatePart()
default boolean	JdbcType.hasTimePart()
default boolean	JdbcType.isBoolean()
default boolean	JdbcType.isComparable()
default boolean	JdbcType.isImplicitJson()
default boolean	JdbcType.isImplicitXml()
default boolean	JdbcType.isJson()
default boolean	JdbcType.isSmallInteger()
default boolean	JdbcType.isSpatial()
default boolean	JdbcType.isStringLikeExcludingClob()
default boolean	JdbcType.isWriteExpressionTyped(Dialect dialect)	Whether the write expression is typed.
default boolean	JdbcType.isXml()
boolean	DelegatingJdbcTypeIndicators.isXmlFormatMapperLegacyFormatEnabled()
default boolean	JdbcTypeIndicators.isXmlFormatMapperLegacyFormatEnabled()	Whether to use the legacy format for serializing/deserializing XML data.
default Expression	JdbcType.wrapTopLevelSelectionExpression(Expression expression)	Wraps the top level selection expression to be able to read values with this JdbcType's ValueExtractor.
default String	JdbcType.wrapWriteExpression(String writeExpression, Size size, Dialect dialect)	Wraps the write expression to be able to write values with this JdbcType's ValueBinder.

Uses of Incubating in org.hibernate.type.descriptor.jdbc.spi

Classes in org.hibernate.type.descriptor.jdbc.spi with annotations of type Incubating

Modifier and Type	Class	Description
final class	AggregateJdbcValueOrder	Describes the physical ordering of the component JDBC values of an aggregate relative to the logical ordering defined by its mapping.
final class	AggregateJdbcValues	Converts aggregate values between their mapped-domain representation and the component JDBC values consumed or produced by an AggregateJdbcType.

Uses of Incubating in org.hibernate.type.descriptor.sql

Methods in org.hibernate.type.descriptor.sql with annotations of type Incubating

Modifier and Type	Method	Description
String[]	DdlType.getRawTypeNames()	Deprecated. not appropriate for named enum or array types

Uses of Incubating in org.hibernate.type.format

Classes in org.hibernate.type.format with annotations of type Incubating

Modifier and Type	Interface	Description
interface	FormatMapper	Maps objects to and from a structured text format.
interface	FormatMapperCreationContext	The creation context for FormatMapper that is passed as constructor argument to implementations.

Uses of Incubating in org.hibernate.type.spi

Classes in org.hibernate.type.spi with annotations of type Incubating

Modifier and Type	Class	Description
class	TypeConfiguration	Each instance defines a set of types available in a given persistence unit, and isolates them from other configurations.

Uses of Incubating in org.hibernate.usertype

Classes in org.hibernate.usertype with annotations of type Incubating

Modifier and Type	Interface	Description
interface	AnnotationBasedUserType<A extends Annotation, J>	A UserType which receives parameters from a custom annotation.
interface	CompositeUserType<J>	This interface should be implemented by user-defined custom types that have persistent attributes and can be thought of as something more like an embeddable object.
interface	UserTypeCreationContext	Access to information useful during UserType creation and initialization.

Methods in org.hibernate.usertype with annotations of type Incubating

Modifier and Type	Method	Description
default Type	DynamicParameterizedType.ParameterType.getReturnedJavaType()
default AttributeConverter<J,?>	UserType.getValueConverter()	Returns the converter that this custom type uses for transforming from the domain type to the relational type, or null if there is no conversion.
default Boolean	UserType.isComparable()	Is this a comparable type in HQL? A type is comparable if it may be used with comparison operators like >=, and with max() and min().