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.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.archive.scan.spi	SPI for scanning archives to discover managed classes and named resources.
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.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.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.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	This package abstracts over the multifarious dialects of SQL understood by the databases supported by Hibernate.
org.hibernate.dialect.aggregate	Support for Dialect-specific aggregate column types, including user-defined composite types, and JSON or XML types.
org.hibernate.dialect.lock.spi
org.hibernate.engine.jdbc.batch.spi	Defines contracts for JDBC batching support.
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
org.hibernate.envers.boot.spi
org.hibernate.envers.query
org.hibernate.envers.query.internal.impl
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.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.id.enhanced	Enhanced/improved versions of table and sequence based identifier generators targeting portability and unified configuration.
org.hibernate.internal.util.collections
org.hibernate.internal.util.config
org.hibernate.loader.internal
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, which describes the mapping of the application's domain model parts (entities, attributes) to relational database objects (tables, columns).
org.hibernate.metamodel.mapping.internal
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.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.query	Everything related to HQL/JPQL, native SQL, and criteria queries.
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	Package defining support for HQL, including JPQL as a subset of HQL.
org.hibernate.query.hql.spi	SPIs for HQL support.
org.hibernate.query.internal
org.hibernate.query.named	Support for named queries
org.hibernate.query.range	The Range framework.
org.hibernate.query.restriction	The Restriction framework.
org.hibernate.query.results	Support for defining result set mappings used in NativeQuery, ProcedureCall, and StoredProcedureQuery.
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.produce.function.internal
org.hibernate.query.sqm.spi	SPI-level SQM contracts
org.hibernate.query.sqm.tree	This package contains the classes that make up the SQM tree nodes.
org.hibernate.query.sqm.tree.domain	Nodes representing path expressions in the SQM tree.
org.hibernate.query.sqm.tree.expression	Nodes representing expressions in the SQM tree.
org.hibernate.query.sqm.tree.from	Nodes representing root entities and joins in the SQM tree.
org.hibernate.query.sqm.tree.insert	Nodes representing insert statements in the SQM tree.
org.hibernate.query.sqm.tuple.internal
org.hibernate.relational	Programmatic access to the schema management tool.
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.spi	A tiny SPI for dealing with compound names and navigable paths.
org.hibernate.sql.ast	Package defining a SQL AST for use in generation of SQL.
org.hibernate.sql.ast.tree.expression	AST nodes representing expressions in a SQL tree.
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.model.ast	SQL AST extensions for model mutations.
org.hibernate.sql.model.ast.builder	Support for building TableMutation references for persisting entity mutation events
org.hibernate.sql.results.graph	Defines domain result graphs.
org.hibernate.sql.results.graph.embeddable
org.hibernate.sql.results.internal
org.hibernate.sql.results.jdbc.spi
org.hibernate.sql.results.spi
org.hibernate.tool.schema.extract.spi	Defines an SPI for schema information extraction from the database via JDBC.
org.hibernate.tool.schema.internal	An implementation of the SPI for the tooling related to DDL generation, export, migration, and validation.
org.hibernate.tool.schema.spi	An SPI for tooling related to DDL generation, export, migration, and validation.
org.hibernate.tuple.entity
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.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.sql.ast	Package defining a SQL AST for use in generation of SQL.
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 domain result graphs.
org.hibernate.type.descriptor.converter.internal	Implements the SPI for basic-typed value conversions.
org.hibernate.dialect.lock	Support for Dialect-specific locking strategies.
org.hibernate.metamodel.mapping	Defines the runtime mapping metamodel, which describes the mapping of the application's domain model parts (entities, attributes) to relational database objects (tables, columns).
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.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.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.results	Package for processing JDBC ResultSets into hydrated domain model graphs based on a "load plan" defined by a "domain result graph", that is, one or more DomainResult nodes with zero or more Fetch nodes.
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.sql.ast.spi	Package defining support for creating and consuming a SQL AST.
org.hibernate.sql.exec.spi	SPI for execution of SQL statements via JDBC.
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.sql.ast.tree	Package defining the SQL AST.
org.hibernate.query.sqm.tuple	Support for tuples in SQM.
org.hibernate.generator.values	Contains a framework of 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	Interface	Description
interface	Locking	Support for various aspects of pessimistic locking.
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	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.
void	StatelessSession.deleteMultiple(List<?> entities)	Delete multiple records.
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.
void	StatelessSession.insertMultiple(List<?> entities)	Insert multiple records.
default boolean	Transaction.isComplete()	Is this transaction complete?
default boolean	Transaction.isInCompletionProcess()	Is this transaction currently in the completion process?
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.
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.
void	StatelessSession.updateMultiple(List<?> entities)	Update multiple records.
void	StatelessSession.upsert(Object entity)	Use a SQL merge into statement to perform an upsert, that is, to insert the record if it does not exist, or update it if it already exists.
void	StatelessSession.upsert(String entityName, Object entity)	Use a SQL merge into statement to perform an upsert.
void	StatelessSession.upsertMultiple(List<?> entities)	Perform an upsert, that is, to insert the record if it does not exist, or update the record if it already exists, for each given record.
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.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.
enum	CacheLayout	Describes the data layout used for storing an object into the query cache.
@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	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	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	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	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.archive.scan.spi

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

Modifier and Type	Interface	Description
interface	ScannerFactory	Support for scanning various sources to detect managed resources for a persistence unit.

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.models

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

Modifier and Type	Class	Description
class	MultipleAttributeNaturesException	Condition where an attribute indicates multiple natures

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.
class	ClassmateContext	Exposes the Classmate TypeResolver and MemberResolver.

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

Modifier and Type	Method	Description
ClassmateContext	BootstrapContext.getClassmateContext()	Access to the shared ClassmateContext object used throughout the bootstrap process.
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()
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.isPreferJavaTimeJdbcTypesEnabled()
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.

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

Modifier and Type	Method	Description
default BytecodeProvider	EnhancementContext.getBytecodeProvider()	Allows to force the use of a specific instance of BytecodeProvider to perform the enhancement.
default UnsupportedEnhancementStrategy	EnhancementContext.getUnsupportedEnhancementStrategy()

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.cfg

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

Modifier and Type	Field	Description
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.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	QuerySettings.JSON_FUNCTIONS_ENABLED	Boolean setting to control if the use of tech preview JSON functions in HQL is enabled.
static final String	JdbcSettings.LOG_JDBC_ERRORS	When enabled, specifies that JDBC errors should be logged before being rethrown.
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	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.
static final String	QuerySettings.XML_FUNCTIONS_ENABLED	Boolean setting to control if the use of tech preview XML functions in HQL is enabled.

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

Modifier and Type	Method	Description
ColumnOrderingStrategy	Configuration.getColumnOrderingStrategy()	The CustomEntityDirtinessStrategy, if any, that was added to this configuration.
Configuration	Configuration.setColumnOrderingStrategy(ColumnOrderingStrategy columnOrderingStrategy)	Specify a CustomEntityDirtinessStrategy 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	Interface	Description
interface	CollectionInitializerProducer	Functional contract to create a CollectionInitializer.
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.
class	InitializerProducerBuilder
interface	LazyInitializable	The most general abstraction over collections which may be fetched lazily.
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.

Uses of Incubating in org.hibernate.context.spi

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

Modifier and Type	Interface	Description
interface	TenantSchemaMapper<T>	Obtains the name of a database schema for a given tenant identifier when schema-based multitenancy is enabled.

Uses of Incubating in org.hibernate.dialect

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

Modifier and Type	Class	Description
enum	TimeZoneSupport	Describes the extent to which a given database supports the SQL with time zone types.

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

Modifier and Type	Method	Description
boolean	Dialect.addPartitionKeyToPrimaryKey()	Does this dialect require that the columns listed in partition by also occur in the primary key, when defining table partitioning?
String	Dialect.appendCheckConstraintOptions(CheckConstraint checkConstraint, String sqlCheckConstraint)	Append the options to the given DDL string declaring a SQL check constraint.
SchemaManagementTool	Dialect.getFallbackSchemaManagementTool(Map<String,Object> configurationValues, ServiceRegistryImplementor registry)	The SchemaManagementTool to use if none is explicitly specified.
GenerationType	Dialect.getNativeValueGenerationStrategy()	The native type of generation supported by this Dialect.

Uses of Incubating in org.hibernate.dialect.aggregate

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

Modifier and Type	Interface	Description
interface	AggregateSupport	A set of operations providing support for aggregate column types in a certain SQL dialect.

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

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

Modifier and Type	Interface	Description
interface	ConnectionLockTimeoutStrategy	Contract for reading and setting lock timeouts using the JDBC connection, generally via execution of a command/statement.
interface	LockingSupport	Details and operations related to a Dialect's support for pessimistic locking.
enum	OuterJoinLockingType	Indicates a Dialect's level of support for applying locks to select statements with joins.

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 a batch of statements to be executed together.
interface	BatchBuilder	A builder for Batch instances.

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	Class	Description
class	AbstractParameterDescriptor<T>
class	NamedParameterDescriptor<T>	Descriptor regarding a named parameter.
interface	NativeQueryInterpreter	Service contract for dealing with native queries.
class	OrdinalParameterDescriptor<T>	Descriptor regarding an ordinal parameter.

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	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

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, @Nullable Object entity, JdbcValuesSourceProcessingState processingState, EntityInitializer<?> initializer)	Return an existing entity holder for the entity key, possibly creating one if necessary.
@Nullable ForeignKeyDirection	CascadingAction.directionAffectedByCascadeDelete()	The cascade direction in which we care whether the foreign key is declared with on delete cascade.
ClassLoaderService	SessionFactoryImplementor.getClassLoaderService()	Obtain the ClassLoaderService.
EntityCopyObserverFactory	SessionFactoryImplementor.getEntityCopyObserver()	Obtain the EntityCopyObserverFactory service.
EventListenerGroups	SessionFactoryImplementor.getEventListenerGroups()	Access to the event listener groups.
EventListenerRegistry	SessionFactoryImplementor.getEventListenerRegistry()	Obtain the EventListenerRegistry service.
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.
Object	SharedSessionContractImplementor.loadFromSecondLevelCache(EntityPersister persister, EntityKey entityKey, Object instanceToLoad, LockMode lockMode)	Attempts to load the entity from the second-level cache.
void	PersistenceContext.postLoad(JdbcValuesSourceProcessingState processingState, Consumer<EntityHolder> loadedConsumer)
void	SharedSessionContractImplementor.registerProcess(AfterTransactionCompletionProcess process)	Registers the given process for execution after transaction completion.

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.query.internal.impl

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

Modifier and Type	Class	Description
class	AbstractAuditAssociationQuery<Q extends org.hibernate.envers.query.internal.impl.AuditQueryImplementor>	An abstract base class for all AuditAssociationQuery implementations.
class	EntitiesAtRevisionAssociationQuery<Q extends org.hibernate.envers.query.internal.impl.AuditQueryImplementor>	An AuditAssociationQuery implementation for EntitiesAtRevisionQuery and EntitiesModifiedAtRevisionQuery query types.
class	RevisionsOfEntityAssociationQuery<Q extends org.hibernate.envers.query.internal.impl.AuditQueryImplementor>	An AuditAssociationQuery implementation for RevisionsOfEntityQuery.

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>
final class	EventListenerGroups	Holds the event listener groups for the various event types.

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.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 InsertGeneratedIdentifierDelegate	OnExecutionGenerator.getGeneratedIdentifierDelegate(EntityPersister persister)	The InsertGeneratedIdentifierDelegate used to retrieve the generated value if this object is an identifier generator.
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.

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.

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.internal.util.collections

Methods in org.hibernate.internal.util.collections 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.internal.util.config

Methods in org.hibernate.internal.util.config with annotations of type Incubating

Modifier and Type	Method	Description
static int	ConfigurationHelper.getPreferredSqlTypeCodeForArray(StandardServiceRegistry serviceRegistry)
static int	ConfigurationHelper.getPreferredSqlTypeCodeForBoolean(StandardServiceRegistry serviceRegistry)
static int	ConfigurationHelper.getPreferredSqlTypeCodeForBoolean(ServiceRegistry serviceRegistry, Dialect dialect)
static int	ConfigurationHelper.getPreferredSqlTypeCodeForDuration(StandardServiceRegistry serviceRegistry)
static int	ConfigurationHelper.getPreferredSqlTypeCodeForInstant(StandardServiceRegistry serviceRegistry)
static int	ConfigurationHelper.getPreferredSqlTypeCodeForUuid(StandardServiceRegistry serviceRegistry)

Uses of Incubating in org.hibernate.loader.internal

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

Modifier and Type	Interface	Description
interface	LoadAccessContext	Context for loader-access objects.

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.
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)
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	Bindable	Contract for things at the domain mapping level that can be bound into a JDBC PreparedStatement.
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.

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

Modifier and Type	Method	Description
default JavaType<?>	JdbcMapping.getJdbcJavaType()
default JdbcLiteralFormatter	JdbcMapping.getJdbcLiteralFormatter()	The strategy for formatting values of this expressible type to a SQL literal.
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.mapping.internal

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

Modifier and Type	Class	Description
class	GeneratedValuesProcessor	Responsible for retrieving database-generated attribute values after an insert or update statement is executed.

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	Contract for instantiating embeddable values.
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.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	Anything that can be the target of mutations
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.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.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	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<R>	Within the context of an active session, an instance of this type represents an executable query, either: a query written in HQL, a named query written in HQL or native SQL, or a criteria query.
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.

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

Modifier and Type	Method	Description
KeyedResultList<R>	SelectionQuery.getKeyedResultList(KeyedPage<R> page)	Execute the query and return the results for the given page, using key-based pagination.
long	SelectionQuery.getResultCount()	Determine the size of the query result list that would be returned by calling SelectionQuery.getResultList() with no offset or limit applied to the query.
default Query<R>	Query.setPage(Page page)
SelectionQuery<R>	SelectionQuery.setPage(Page page)	Set the page of results to return.

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<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>
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.
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsAll(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIncludes(Expression, Expression)
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsAll(Expression<T[]> arrayExpression, T[] subArray)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIncludes(Expression, Object[])
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsAll(T[] array, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIncludes(Object[], Expression)
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsAllNullable(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIncludesNullable(Expression, Expression)
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsAllNullable(Expression<T[]> arrayExpression, T[] subArray)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIncludesNullable(Expression, Object[])
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayContainsAllNullable(T[] array, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIncludesNullable(Object[], Expression)
<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.
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayOverlaps(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIntersects(Expression, Expression)
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayOverlaps(Expression<T[]> arrayExpression1, T[] array2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIntersects(Expression, Object[])
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayOverlaps(T[] array1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIntersects(Object[], Expression)
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayOverlapsNullable(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIntersectsNullable(Expression, Expression)
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayOverlapsNullable(Expression<T[]> arrayExpression1, T[] array2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIntersectsNullable(Expression, Object[])
default <T> JpaPredicate	HibernateCriteriaBuilder.arrayOverlapsNullable(T[] array1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.arrayIntersectsNullable(Object[], jakarta.persistence.criteria.Expression)
<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.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.
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)
<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.
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsAll(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIncludes(Expression, Expression)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsAll(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIncludes(Expression, Collection)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsAll(Collection<E> collection, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIncludes(Collection, Expression)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsAllNullable(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIncludesNullable(Expression, Expression)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsAllNullable(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIncludesNullable(Expression, Collection)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionContainsAllNullable(Collection<E> collection, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIncludesNullable(Collection, Expression)
<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.
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionOverlaps(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIntersects(Expression, Expression)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionOverlaps(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIntersects(Expression, Collection)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionOverlaps(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIntersects(Collection, Expression)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionOverlapsNullable(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIntersectsNullable(Expression, Expression)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionOverlapsNullable(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIntersectsNullable(Expression, Collection)
default <E> JpaPredicate	HibernateCriteriaBuilder.collectionOverlapsNullable(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version. Replaced with HibernateCriteriaBuilder.collectionIntersectsNullable(Collection, Expression)
<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.
<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.
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<X>	JpaFrom.crossJoin(Class<X> entityJavaType)
<X> JpaCrossJoin<X>	JpaFrom.crossJoin(EntityDomainType<X> entity)
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()
<X> JpaDerivedJoin<X>	JpaFrom.join(Subquery<X> subquery)
<X> JpaDerivedJoin<X>	JpaFrom.join(Subquery<X> subquery, SqmJoinType joinType)	Deprecated, for removal: This API element is subject to removal in a future version. This method is a layer-breaker, leaking the SQM type SqmJoinType onto an API.
<X> JpaDerivedJoin<X>	JpaFrom.join(Subquery<X> subquery, SqmJoinType joinType, boolean lateral)	Deprecated, for removal: This API element is subject to removal in a future version. This method is a layer-breaker, leaking the SQM type SqmJoinType onto an API.
<X> JpaJoin<?,X>	JpaFrom.join(JpaCteCriteria<X> cte)
<X> JpaJoin<?,X>	JpaFrom.join(JpaCteCriteria<X> cte, SqmJoinType joinType)	Deprecated, for removal: This API element is subject to removal in a future version. This method is a layer-breaker, leaking the SQM type SqmJoinType onto an API.
<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)
<X> JpaDerivedJoin<X>	JpaFrom.joinLateral(Subquery<X> subquery, SqmJoinType joinType)	Deprecated, for removal: This API element is subject to removal in a future version. This method is a layer-breaker, leaking the SQM type SqmJoinType onto an API.
<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)
JpaValues	HibernateCriteriaBuilder.values(List<? extends Expression<?>> expressions)
<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.arrayContainsAll(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsAll(Expression<T[]> arrayExpression, T[] subArray)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsAll(T[] array, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsAllNullable(Expression<T[]> arrayExpression, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsAllNullable(Expression<T[]> arrayExpression, T[] subArray)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayContainsAllNullable(T[] array, Expression<T[]> subArrayExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<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> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayOverlaps(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayOverlaps(Expression<T[]> arrayExpression1, T[] array2)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayOverlaps(T[] array1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayOverlapsNullable(Expression<T[]> arrayExpression1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayOverlapsNullable(Expression<T[]> arrayExpression1, T[] array2)	Deprecated, for removal: This API element is subject to removal in a future version.
<T> JpaPredicate	HibernateCriteriaBuilderDelegate.arrayOverlapsNullable(T[] array1, Expression<T[]> arrayExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<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.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)
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.collectionContainsAll(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsAll(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsAll(Collection<E> collection, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsAllNullable(Expression<? extends Collection<E>> collectionExpression, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsAllNullable(Expression<? extends Collection<E>> collectionExpression, Collection<? extends E> subCollection)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionContainsAllNullable(Collection<E> collection, Expression<? extends Collection<? extends E>> subCollectionExpression)	Deprecated, for removal: This API element is subject to removal in a future version.
<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> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionOverlaps(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionOverlaps(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionOverlaps(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionOverlapsNullable(Expression<? extends Collection<E>> collectionExpression1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionOverlapsNullable(Expression<? extends Collection<E>> collectionExpression1, Collection<? extends E> collection2)	Deprecated, for removal: This API element is subject to removal in a future version.
<E> JpaPredicate	HibernateCriteriaBuilderDelegate.collectionOverlapsNullable(Collection<E> collection1, Expression<? extends Collection<? extends E>> collectionExpression2)	Deprecated, for removal: This API element is subject to removal in a future version.
<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)
<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)
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

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

Modifier and Type	Interface	Description
interface	HqlTranslator	Main entry point into building semantic queries.

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	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.internal

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

Modifier and Type	Class	Description
class	QueryParameterBindingsImpl	Manages the group of QueryParameterBinding for a particular query.
class	ScrollableResultsIterator<T>

Uses of Incubating in org.hibernate.query.named

Classes in org.hibernate.query.named 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

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

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

Modifier and Type	Interface	Description
interface	FetchBuilder	Responsible for building a single Fetch instance.
interface	ResultBuilder	Responsible for building a single DomainResult.
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	MutationSpecification<T>	Specialization of QuerySpecification for programmatic customization of mutation queries.
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.

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<R>
interface	QueryInterpretationCache	Cache for various parts of translating or interpreting queries.
interface	QueryParameterBinding<T>	The value/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	QueryParameterListBinding<T>	Represents a "parameter list" binding: aka the binding of a collection of values for a single query parameter.
interface	QueryPlan	Common contract for select and mutation query plans
interface	ScrollableResultsImplementor<R>
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.produce.function.internal

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

Modifier and Type	Class	Description
class	SetReturningFunctionTypeResolverBuilder

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

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

Modifier and Type	Class	Description
class	DelegatingSqmSelectionQueryImplementor<R>
interface	SqmCreationContext	The context in which all SQM creations occur.
interface	SqmSelectionQueryImplementor<R>

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

Modifier and Type	Method	Description
SqmSelectionQueryImplementor<R>	DelegatingSqmSelectionQueryImplementor.setPage(Page page)

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

Methods in org.hibernate.query.sqm.tree 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 @Nullable SqmQuerySource	SqmCopyContext.getQuerySource()	Returns the query source to use for copied queries.

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

Classes in org.hibernate.query.sqm.tree.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.expression

Classes in org.hibernate.query.sqm.tree.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.from

Classes in org.hibernate.query.sqm.tree.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.from with annotations of type Incubating

Modifier and Type	Method	Description
boolean	SqmFrom.hasImplicitlySelectableJoin()

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

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

Modifier and Type	Class	Description
class	SqmInsertSelectStatement<T>

Uses of Incubating in org.hibernate.query.sqm.tuple.internal

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

Modifier and Type	Class	Description
class	AnonymousTupleBasicEntityIdentifierMapping
class	AnonymousTupleBasicValuedModelPart
class	AnonymousTupleEmbeddableValuedModelPart
class	AnonymousTupleEmbeddedEntityIdentifierMapping
class	AnonymousTupleEntityValuedModelPart
class	AnonymousTupleNonAggregatedEntityIdentifierMapping
class	AnonymousTupleSimpleSqmPathSource<J>
class	AnonymousTupleSqmAssociationPathSource<O,J>
class	AnonymousTupleSqmAssociationPathSourceNew<O,J>
class	AnonymousTupleSqmPathSource<J>
class	AnonymousTupleSqmPathSourceNew<J>
class	AnonymousTupleTableGroupProducer	The table group producer for an anonymous tuple type.
class	AnonymousTupleType<T>
class	CteTupleTableGroupProducer	The table group producer for a CTE tuple type.

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, 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.populate()	Populate the database by executing /import.sql and any other configured load script.

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.

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.

Uses of Incubating in org.hibernate.sql.ast

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

Modifier and Type	Class	Description
enum	Clause	Used to indicate which query clause we are currently processing
interface	SqlAstWalker

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

Modifier and Type	Method	Description
Statement	SqlAstTranslator.getSqlAst()	The SQL AST being translated.
void	SqlAstTranslator.renderNamedSetReturningFunction(String functionName, List<? extends SqlAstNode> sqlAstArguments, AnonymousTupleTableGroupProducer tupleType, String tableIdentifierVariable, SqlAstNodeRenderingMode argumentRenderingMode)	Renders a named set returning function.

Uses of Incubating in org.hibernate.sql.ast.tree.expression

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

Modifier and Type	Interface	Description
interface	QueryTransformer

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	JdbcSelectExecutor	An executor for JdbcSelect operations.

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	MutationOperation	Mutation for a specific table as part of a logical mutation on the entity.

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

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

Modifier and Type	Method	Description
void	ColumnValueBindingList.addRestriction(ColumnValueBinding valueBinding)

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

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

Modifier and Type	Method	Description
void	RestrictedTableMutationBuilder.addNonKeyRestriction(ColumnValueBinding valueBinding)	Adds a restriction, which is assumed to be based on a selectable that is NOT a table key, e.g.
void	ColumnValuesTableMutationBuilder.addValueColumn(ColumnValueBinding valueBinding)	Adds a restriction, which is assumed to be based on a table key.

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.internal

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

Modifier and Type	Class	Description
class	RowTransformerStandardImpl<T>	Returns the first object in each row, if there is exactly one item in the selection list, or the whole row otherwise.

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.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	Contract for extracting information about objects in the database schema(s).

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.internal

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

Modifier and Type	Class	Description
class	StandardTableCleaner	The basic implementation of Cleaner.
class	StandardTableMigrator	A TableMigrator that only knows how to add new columns.

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	Cleaner	An object that produces the SQL required to truncate the tables in a schema.
interface	ExecutionOptions	Parameter object representing options for schema management tool execution
interface	ExtractionTool	Encapsulates the functionality for extracting database metadata used by SchemaManagementTool.
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.tuple.entity

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

Modifier and Type	Class	Description
class	CompositeValueGenerationException

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()
boolean	CollectionType.isInverse(SessionFactoryImplementor factory)

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>	Descriptor for a basic plural Java type.
interface	TemporalJavaType<T>	Specialized JavaType for temporal types.

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

Modifier and Type	Method	Description
default JavaType<T>	JavaType.createJavaType(ParameterizedType parameterizedType, TypeConfiguration typeConfiguration)	Creates the JavaType for the given ParameterizedType based on this JavaType registered for the raw type.
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	Descriptor for aggregate handling like STRUCT, JSON and SQLXML.

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, SqlAppender appender, Dialect dialect)	Append the write expression wrapped in a way to be able to write values with this JdbcType's ValueBinder.
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.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, 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.sql

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

Modifier and Type	Method	Description
default 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	A mapper for mapping objects to and from a format.

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.

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

Modifier and Type	Method	Description
final FormatMapper	TypeConfiguration.getJsonFormatMapper()
final FormatMapper	TypeConfiguration.getXmlFormatMapper()

Uses of Incubating in org.hibernate.usertype

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

Modifier and Type	Interface	Description
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.

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().