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.model	This package defines the boot-time metamodel, which is an interpretation of the domain model (entity classes, embeddable classes, and attributes) and the mapping of these "domain model parts" to the database.
org.hibernate.boot.model.convert.spi	Defines the SPI of a registry of JPA AttributeConverters.
org.hibernate.boot.model.naming	This API allows intervention by generic code in the process of determining the names of database objects (tables, columns, and constraints).
org.hibernate.boot.model.relational	Some SPIs related to DDL generation and schema management.
org.hibernate.boot.spi	A range of SPIs allowing integration with—and customization of—the process of building metadata.
org.hibernate.bytecode.enhance.spi.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.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.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.event.service.spi	An SPI for the event listener registration service.
org.hibernate.event.spi	Defines the event types and event listener interfaces for events produced by the stateful Session.
org.hibernate.generator	This package defines an abstraction over all kinds of automatic value generation, including id generation and version number generation.
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.ast.internal
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.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.derived
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.procedure	Support SQL functions in the SQM model.
org.hibernate.query.results	Support for defining result set mappings used in NativeQuery, ProcedureCall, and StoredProcedureQuery.
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.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.relational	Programmatic access to the schema management tool.
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.results.graph	Defines domain result graphs.
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
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.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.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.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.query.procedure	Support SQL functions in the SQM model.
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.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.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.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	SessionEventListener	Implemented by custom listeners that respond to low-level events involving interactions between the Session and the database or second-level cache.
enum	TimeZoneStorageStrategy	Enumerates the possible storage strategies for offset or zoned datetimes.

Methods in org.hibernate with annotations of type Incubating

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

Uses of Incubating in org.hibernate.annotations

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

Modifier and Type	Class	Description
@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	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	FractionalSeconds	Indicates that the associated temporal value should be stored with fractional seconds.
@interface	Instantiator	Marks the canonical constructor to be used for instantiation of an embeddable.
@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.model

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

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

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

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

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

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

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

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

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

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

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

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

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

Uses of Incubating in org.hibernate.boot.spi

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

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

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

Modifier and Type	Method	Description
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.
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()
FormatMapper	SessionFactoryOptions.getXmlFormatMapper()	The format mapper to use for serializing/deserializing XML data.
default boolean	MetadataBuildingContext.isPreferJavaTimeJdbcTypesEnabled()
default boolean	MetadataBuildingContext.isPreferNativeEnumTypesEnabled()
void	MetadataImplementor.orderColumns(boolean forceOrdering)

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	MappingSettings.PREFER_NATIVE_ENUM_TYPES	Indicates whether to prefer using SQL enums and the respective special JDBC types for binding/extracting of values.
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.

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

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

Modifier and Type	Class	Description
class	DialectDelegateWrapper	A wrapper of Dialect, to allow decorating some selected methods without having to extend the original class.
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
SchemaManagementTool	Dialect.getFallbackSchemaManagementTool(Map<String,Object> configurationValues, ServiceRegistryImplementor registry)	The SchemaManagementTool to use if none is explicitly specified.
SchemaManagementTool	DialectDelegateWrapper.getFallbackSchemaManagementTool(Map<String,Object> configurationValues, ServiceRegistryImplementor registry)

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.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.
void	PersistenceContext.postLoad(JdbcValuesSourceProcessingState processingState, Consumer<EntityHolder> loadedConsumer)

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

Modifier	Constructor	Description
	EffectiveEntityGraph()
	EffectiveEntityGraph(boolean allowOverwrite)

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

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

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

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

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

Uses of Incubating in org.hibernate.event.spi

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

Modifier and Type	Interface	Description
interface	EventManager	Defines the contract for monitoring low-level events involving interactions between the Session and the database or second-level cache.
interface	HibernateMonitoringEvent

Uses of Incubating in org.hibernate.generator

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

Modifier and Type	Interface	Description
interface	GeneratorCreationContext	An object passed as a parameter to the constructor or initialize method of a Generator which provides access to certain objects useful for initialization of the generator.

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

Modifier and Type	Method	Description
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.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.getPreferredSqlTypeCodeForDuration(StandardServiceRegistry serviceRegistry)
static int	ConfigurationHelper.getPreferredSqlTypeCodeForInstant(StandardServiceRegistry serviceRegistry)
static int	ConfigurationHelper.getPreferredSqlTypeCodeForUuid(StandardServiceRegistry serviceRegistry)

Uses of Incubating in org.hibernate.loader.ast.internal

Methods in org.hibernate.loader.ast.internal with annotations of type Incubating

Modifier and Type	Method	Description
CacheEntityLoaderHelper.PersistenceContextEntry	CacheEntityLoaderHelper.loadFromSessionCache(EntityKey keyToLoad, LoadEventListener.LoadType options, LockOptions lockOptions, EventSource session)

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	Class	Description
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
default MetadataBuildingContext	Value.getBuildingContext()
default String	Value.getExtraCreateTableInfo()
default JdbcMapping	Value.getSelectableType(Mapping factory, int index)
default String	Selectable.getWriteExpr()
default String	Selectable.getWriteExpr(JdbcMapping jdbcMapping, Dialect dialect)
void	BasicValue.setExplicitJdbcTypeCode(Integer jdbcTypeCode)

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.

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.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	Interface	Description
interface	BindableType<J>	Types that can be used to handle binding Query parameters
interface	JpaTuple	Hibernate extension to the Jakarta Persistence Tuple contract
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.
class	Order<X>	A rule for sorting a query result set.
interface	OutputableType<J>	Specialization of DomainType for types that can be used as a parameter output for a ProcedureCall.
class	Page	Identifies a page of query results by page size and page number.
interface	ParameterMetadata	Access to known information about the parameters for 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	ReturnableType<T>	Specialization of DomainType for types that can be used as function returns
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.
Query<R>	Query.setOrder(List<Order<? super R>> orderList)
Query<R>	Query.setOrder(Order<? super R> order)
SelectionQuery<R>	SelectionQuery.setOrder(List<Order<? super R>> orderList)	If the result type of this query is an entity class, add one or more rules for ordering the query results.
SelectionQuery<R>	SelectionQuery.setOrder(Order<? super R> order)	If the result type of this query is an entity class, add a rule for ordering the query results.
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	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	JpaSearchOrder	Represents the search order for a recursive CTE (common table expression).
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.

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, String separator)	Concatenates the non-null 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.
<T> 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.
<T> 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.
<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)
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)
JpaFunction<Integer>	HibernateCriteriaBuilder.hour(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.HOUR of a date, time, or datetime expression.
<X> JpaDerivedJoin<X>	JpaFrom.join(Subquery<X> subquery)
<X> JpaDerivedJoin<X>	JpaFrom.join(Subquery<X> subquery, SqmJoinType joinType)
<X> JpaDerivedJoin<X>	JpaFrom.join(Subquery<X> subquery, SqmJoinType joinType, boolean lateral)
<X> JpaJoin<?,X>	JpaFrom.join(JpaCteCriteria<X> cte)
<X> JpaJoin<?,X>	JpaFrom.join(JpaCteCriteria<X> cte, SqmJoinType joinType)
<X> JpaDerivedJoin<X>	JpaFrom.joinLateral(Subquery<X> subquery)
<X> JpaDerivedJoin<X>	JpaFrom.joinLateral(Subquery<X> subquery, SqmJoinType joinType)
<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, NullPrecedence nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.mode(JpaPredicate filter, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.mode(JpaPredicate filter, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence nullPrecedence)	Create a mode ordered set-aggregate function expression.
<T> JpaExpression<T>	HibernateCriteriaBuilder.mode(JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence nullPrecedence)
JpaFunction<Integer>	HibernateCriteriaBuilder.month(Expression<? extends TemporalAccessor> datetime)	Extracts the TemporalUnit.MONTH of a date, time, or datetime 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, NullPrecedence nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileCont(Expression<? extends Number> argument, JpaPredicate filter, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileCont(Expression<? extends Number> argument, JpaPredicate filter, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence 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, NullPrecedence nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileDisc(Expression<? extends Number> argument, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileDisc(Expression<? extends Number> argument, JpaPredicate filter, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence nullPrecedence)
<T> JpaExpression<T>	HibernateCriteriaBuilder.percentileDisc(Expression<? extends Number> argument, JpaPredicate filter, JpaWindow window, Expression<T> sortExpression, SortDirection sortOrder, NullPrecedence 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, NullPrecedence 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, NullPrecedence 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.
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.
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.
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, String separator)
<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)
<T> JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, Expression<String> separatorExpression)
<T> JpaExpression<String>	HibernateCriteriaBuilderDelegate.collectionToString(Expression<? extends Collection<?>> collectionExpression, String separator)
<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)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.search(JpaCteCriteriaAttribute cteAttribute)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.search(JpaCteCriteriaAttribute cteAttribute, SortDirection sortOrder)
JpaSearchOrder	HibernateCriteriaBuilderDelegate.search(JpaCteCriteriaAttribute cteAttribute, SortDirection sortOrder, NullPrecedence nullPrecedence)
JpaValues	HibernateCriteriaBuilderDelegate.values(Expression<?>... expressions)
JpaValues	HibernateCriteriaBuilderDelegate.values(List<? extends Expression<?>> expressions)

Uses of Incubating in org.hibernate.query.derived

Classes in org.hibernate.query.derived 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	AnonymousTupleSqmPathSource<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.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 impls that can be converted to a named query memento to be stored 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.procedure

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

Modifier and Type	Interface	Description
interface	ProcedureParameter<T>

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 DomainResult instance as part of the overall mapping of native / procedure query results.
interface	ResultBuilder	Responsible for building a single DomainResult instance as part of the overall mapping of native / procedure query results.
interface	ResultSetMapping	Acts as the JdbcValuesMappingProducer for NativeQuery or ProcedureCall / StoredProcedureQuery instances.
class	ResultSetMappingImpl

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>

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 (think SessionFactory).
interface	SqmSelectionQueryImplementor<R>

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

Modifier and Type	Method	Description
SqmSelectionQueryImplementor<R>	DelegatingSqmSelectionQueryImplementor.setOrder(List<Order<? super R>> orders)
SqmSelectionQueryImplementor<R>	DelegatingSqmSelectionQueryImplementor.setOrder(Order<? super R> order)
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.

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>

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	SqmWindow
class	SqmWindowFrame

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>

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

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

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

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>	BasicValueConverter extension for AttributeConverter-specific support

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

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

Modifier and Type	Method	Description
default void	JdbcType.addAuxiliaryDatabaseObjects(JavaType<?> javaType, Size columnSize, Database database, JdbcTypeIndicators context)	Add auxiliary database objects for this JdbcType to the Database object.
default void	JdbcType.addAuxiliaryDatabaseObjects(JavaType<?> javaType, Size columnSize, Database database, TypeConfiguration typeConfiguration)	Deprecated, for removal: This API element is subject to removal in a future version. Use JdbcType.addAuxiliaryDatabaseObjects(JavaType, Size, Database, JdbcTypeIndicators) instead
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.isSmallInteger()
default boolean	JdbcType.isSpatial()
default boolean	JdbcType.isStringLikeExcludingClob()
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.

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 JdbcType	UserType.getJdbcType(TypeConfiguration typeConfiguration)	A mapped JdbcType.
default Type	DynamicParameterizedType.ParameterType.getReturnedJavaType()
default BasicValueConverter<J,Object>	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.