All Classes and Interfaces
Class
Description
AbstractExtendedSearchQueryOptionsStep<S extends SearchQueryOptionsStep<S,H,LOS,SF,AF>,H,R extends SearchResult<H>,SCR extends SearchScroll<H>,LOS,PDF extends SearchPredicateFactory,SF extends SearchSortFactory,AF extends SearchAggregationFactory,SC extends SearchQueryIndexScope<?>>
AbstractIndexCompositeNodeType<SC extends SearchIndexScope<?>,N extends SearchIndexCompositeNodeContext<SC>>
AbstractIndexCompositeNodeType.Builder<SC extends SearchIndexScope<?>,N extends SearchIndexCompositeNodeContext<SC>>
AbstractIndexField<S extends AbstractIndexField<S,SC,?,C>,SC extends SearchIndexScope<?>,NT extends AbstractIndexNodeType<SC,? super S>,C extends IndexCompositeNode<SC,?,?>>
AbstractIndexFieldTemplate<M extends AbstractIndexModel<?,?,F>,F extends IndexField<?,C>,C extends IndexCompositeNode<?,?,?>,FT>
AbstractIndexModel<S extends AbstractIndexModel<?,R,F>,R extends IndexCompositeNode<?,?,?>,F extends IndexField<?,?>>
AbstractIndexNode<S extends AbstractIndexNode<S,SC,?>,SC extends SearchIndexScope<?>,NT extends SearchIndexNodeTypeContext<SC,? super S>>
AbstractIndexObjectField<S extends AbstractIndexObjectField<S,SC,NT,C,F>,SC extends SearchIndexScope<?>,NT extends AbstractIndexCompositeNodeType<SC,? super S>,C extends IndexCompositeNode<SC,NT,F>,F extends IndexField<SC,?>>
AbstractIndexRoot<S extends AbstractIndexRoot<S,SC,NT,F>,SC extends SearchIndexScope<?>,NT extends AbstractIndexCompositeNodeType<SC,? super S>,F extends IndexField<SC,?>>
AbstractIndexValueField<S extends AbstractIndexValueField<S,SC,FT,C,F>,SC extends SearchIndexScope<?>,FT extends AbstractIndexValueFieldType<SC,? super S,F>,C extends IndexCompositeNode<SC,?,?>,F>
AbstractIndexValueFieldType<SC extends SearchIndexScope<?>,N extends SearchIndexValueFieldContext<SC>,F>
AbstractIndexValueFieldType.Builder<SC extends SearchIndexScope<?>,N extends SearchIndexValueFieldContext<SC>,F>
AbstractMultiIndexSearchIndexCompositeNodeContext<S extends SearchIndexCompositeNodeContext<SC>,SC extends SearchIndexScope<?>,NT extends SearchIndexCompositeNodeTypeContext<SC,S>,F extends SearchIndexNodeContext<SC>>
AbstractMultiIndexSearchIndexNodeContext<S extends SearchIndexNodeContext<SC>,SC extends SearchIndexScope<?>,NT extends SearchIndexNodeTypeContext<SC,S>>
AbstractMultiIndexSearchIndexValueFieldContext<S extends SearchIndexValueFieldContext<SC>,SC extends SearchIndexScope<?>,FT extends SearchIndexValueFieldTypeContext<SC,S,F>,F>
An abstract base for implementations of a
PojoTypeModel
representing a type with generic type parameters.An abstract base for
PredicateFinalStep implementations.AbstractSearchAggregationFactory<S extends ExtendedSearchAggregationFactory<S,PDF>,SC extends SearchAggregationIndexScope<?>,PDF extends SearchPredicateFactory>
AbstractSearchIndexScope<S extends SearchQueryIndexScope<?>,M extends AbstractIndexModel<?,? extends C,? extends N>,N extends SearchIndexNodeContext<? super S>,C extends SearchIndexCompositeNodeContext<? super S>>
AbstractSearchPredicateFactory<S extends ExtendedSearchPredicateFactory<S>,SC extends SearchPredicateIndexScope<?>>
AbstractSearchProjectionFactory<S extends ExtendedSearchProjectionFactory<S,R,E>,SC extends SearchProjectionIndexScope<?>,R,E>
An abstract base for implementations of
SearchQuery.AbstractSearchQueryOptionsStep<S extends SearchQueryOptionsStep<S,H,LOS,SF,AF>,H,LOS,PDF extends SearchPredicateFactory,SF extends SearchSortFactory,AF extends SearchAggregationFactory,SC extends SearchQueryIndexScope<?>>
AbstractSearchQuerySelectStep<N extends SearchQueryOptionsStep<?,E,LOS,?,?>,R,E,LOS,PJF extends SearchProjectionFactory<R,E>,PDF extends SearchPredicateFactory>
AbstractSearchSortFactory<S extends ExtendedSearchSortFactory<S,PDF>,SC extends SearchSortIndexScope<?>,PDF extends SearchPredicateFactory>
An abstract base for orchestrator implementations,
implementing a thread-safe shutdown.
Whether the field can be used in projections.
A classloader which keeps an ordered list of aggregated classloaders.
The step in an aggregation definition where a filter can be set
to select nested objects from which values will be extracted for this aggregation.
The final step in an aggregation definition, where the aggregation can be retrieved.
A key allowing to retrieve an aggregation from the search result.
A source of property values for Hibernate Search with knowledge of the full set of properties.
The binder that sets up
AlternativeValueBridges.The component responsible for binding one field per alternative,
and creating an
AlternativeValueBridge.Mark the property as an alternative discriminator for use in
AlternativeBinder.A binder for markers that mark a property as the discriminator
for alternatives for an
Alternative bridge.A component that routes field values to one of multiple index fields
based on a discriminator.
Constants for the names of built-in analyzers.
A source of types to be processed for annotations by Hibernate Search.
A context to configure annotation mapping.
Given an association from an entity type
A to an entity type B,
defines the inverse side of an association,
i.e.The step in a "association inverse side" definition where optional parameters can be set.
A set of indexing events to be sent to an external queue.
Deprecated.
Deprecated.
This SPI was introduced by mistake and was never used.
Deprecated.
Deprecated.
Deprecated.
A backend as viewed by Hibernate Search users.
A build context for backends.
Provides visibility from the lower layers of Hibernate Search (engine, backend)
to the mapping defined in the upper layers.
Provides visibility from the lower layers of Hibernate Search (engine, backend)
to the session defined in the upper layers (mapping).
Configuration properties common to all Hibernate Search backends regardless of the underlying technology.
A start context for backends.
A work ready to be submitted to a
BatchingExecutor,
and eventually processed in a batch by a BatchedWorkProcessor.A processor of batched works submitted to a
BatchingExecutor.An executor of works that accepts works from multiple threads, puts them in a queue,
and processes them in batches in a single background thread.
An object responsible for defining beans that can then be resolved during Hibernate Search bootstrap.
An object holding a bean instance, and allowing to release it.
Indicates a bean was not found by a
BeanProvider.The interface to be implemented by components providing beans to Hibernate Search.
A reference to a bean, allowing the retrieval of that bean
when
passed a BeanResolver.The main entry point for components looking to resolve a bean reference into a (usually user-provided) bean.
Defines where beans are retrieved from.
The initial and final step in a boolean predicate definition, where clauses can be added.
An object where the clauses and options of a
boolean predicate can be set.Mapping-scoped information and operations for use in bridges.
Session-scoped information and operations for use in bridges.
The names of
container extractors available in Hibernate Search out of the box.Utility class to load instances of other classes by using a fully qualified name,
or from a class type.
Indicates a problem performing class loading.
A resolver of Java classes.
CommonQueryStringPredicateFieldMoreStep<S extends CommonQueryStringPredicateFieldMoreStep<?,N>,N extends CommonQueryStringPredicateOptionsStep<?>>
The step in a query string predicate definition, where the query string to match can be set
(see the superinterface
CommonQueryStringPredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a query string predicate definition, where the target field can be set.
The step in a query string predicate definition, where the query string to match can be set.
The final step in a query string predicate definition, where optional parameters can be set.
Maps a constructor parameter to a composite projection,
which will combine multiple inner projections.
Binds a constructor parameter to a composite projection,
which will combine multiple inner projections.
The step in a "multi-step" composite projection definition
where a single inner projection has been defined
and the result of the composite projection can be defined.
The step in a "multi-step" composite projection definition
where 2 inner projections have been defined
and the result of the composite projection can be defined.
The step in a "multi-step" composite projection definition
where 3 inner projections have been defined
and the result of the composite projection can be defined.
The step in a "multi-step" composite projection definition
where one or more inner projections have been defined
and the result of the composite projection can be defined.
A step in a "multi-step" composite projection definition
where one can define inner projections to get values from.
The final step in a composite projection definition
where optional parameters can be set.
The step in a composite projection definition
where the projection (optionally) can be marked as multi-valued (returning Lists),
and where optional parameters can be set.
The initial and final step in a composite sort definition, where sort elements can be added.
A utility that checks usage of property keys
by wrapping a
ConfigurationPropertySource
and requiring special hooks to be called before and after bootstrap.A source of property values for Hibernate Search.
Allows integrators to provide their default configuration properties for various scopes that would override
Hibernate Search specific ones.
Holds a configuration scope.
Names of configuration scope namespaces used to construct a
ConfigurationScope.Meta-annotation for annotations that apply mapping to a constructor.
A processor for mapping annotations applied to a Java constructor.
A reference to a
ConstructorMappingAnnotationProcessor.Class used as a marker for the default value of the
ConstructorMappingAnnotationProcessorRef.type() attribute.The step in a mapping definition where a constructor can be mapped.
Control how values are extracted from a POJO property of container type.
A definition of container value extractors to be applied to a property,
allowing reference to a specific value of a container property.
An extractor of values from a container.
A context to assign names to container extractor implementations.
A chain of
container extractors to be applied one after the other to a property value,
in order to extract other values.A failure collector with an implicit context.
The strategy for coordinating between threads of a single-node application,
or between nodes of a distributed application.
Common interface providing a deadline through the method
Deadline.checkRemainingTimeMillis().Default implementation of
ClassResolver relying on an AggregatedClassLoader.Default implementation of
ClassResolver relying on an AggregatedClassLoader.Default implementation of
ClassResolver relying on an AggregatedClassLoader.Deprecated.
SPIs should simply pass around a string representing the tenant ID instead of using this class.
The step in a sort definition where the behavior on missing values can be set.
DistanceSortOptionsStep<S extends DistanceSortOptionsStep<?,PDF>,PDF extends SearchPredicateFactory>
The initial and final step in a "distance" sort definition, where optional parameters can be set.
The initial and final step in a "distance to field" projection definition, where optional parameters can be set.
The initial step in a "distance to field" projection definition,
where the projection (optionally) can be marked as multi-valued (returning Lists),
and where optional parameters can be set.
Distance units.
Defines how to handle index commits after a document is written to the index,
i.e.
An element of a document.
Maps a property to the identifier of documents in the index.
A reference to an indexed document.
Maps a constructor parameter to a projection to a
DocumentReference representing the hit.Binds a constructor parameter to a projection to a
DocumentReference representing the hit.The initial and final step in a "document reference" projection definition, where optional parameters can be set.
Defines how to handle index refreshes after a document is written to the index,
i.e.
A route for an indexed document, i.e.
The object passed to a
RoutingBridge
to define where an entity should be indexed.A converter for values passed to the DSL.
A utility class holding the state of the extension contexts found in several DSLs.
Deprecated.
Implement
ElasticsearchAwsCredentialsProvider instead.The step in an analysis component definition where optional parameters can be set.
The step in an analysis component definition where the type of that component can be set.
A context allowing the definition of named analysis-related elements in an Elasticsearch backend:
analyzers, tokenizers, char filters, ...
An object responsible for configuring analysis in an Elasticsearch index,
providing analysis-related definitions that can be referenced from the mapping.
The step in an analyzer/normalizer definition
where optional components such as char filters or token filters can be added.
The step in an analyzer definition
where optional components such as char filters or token filters can be added.
The step in an analyzer definition where the tokenizer can be set.
The initial step in an analyzer definition, where the type of analyzer can be set.
AWS-specific configuration properties for Elasticsearch backends.
Default values for the different settings if no values are given.
Deprecated.
Use
ElasticsearchBackendImplSettings instead.Configuration properties for Elasticsearch backends.
Default values for the different settings if no values are given.
Configuration properties for the Elasticsearch backend that are considered SPI (and not API).
Configuration property keys without the
prefix.An Elasticsearch client, allowing to perform requests to a remote cluster.
Creates the Elasticsearch client.
An interface allowing to close an
ElasticsearchClient.Utils for integrations that require advanced checks on Elasticsearch versions,
i.e.
An extension for the Elasticsearch backend, giving access to Elasticsearch-specific features.
The context passed to
ElasticsearchHttpClientConfigurer.An extension point allowing fine tuning of the Apache HTTP Client used by the Elasticsearch integration.
A descriptor of an Elasticsearch backend index,
which exposes additional information specific to this backend.
Constants for the names of Elasticsearch-specific traits that can be exposed by index fields.
Extended version of an
SchemaExport that exposes any Elasticsearch-specific methods.Configuration properties for Elasticsearch indexes.
Default values for the different settings if no values are given.
Configuration property keys for indexing, without the
prefix.ElasticsearchNativeIndexFieldTypeOptionsStep<S extends ElasticsearchNativeIndexFieldTypeOptionsStep<?>>
The step in a normalizer definition
where optional components such as char filters or token filters can be added.
The initial step in an analyzer definition, where the type of normalizer can be set.
A factory for search predicates with some Elasticsearch-specific methods.
A factory for search projections with some Elasticsearch-specific methods.
A pluggable component that gets the chance to transform search requests (path, body, ...)
before they are sent to Elasticsearch.
A factory for search sorts with some Elasticsearch-specific methods.
ElasticsearchStandardIndexFieldTypeOptionsStep<S extends ElasticsearchStandardIndexFieldTypeOptionsStep<?,F>,F>
Configuration properties for the Hibernate Search engine.
Default values for the different settings if no values are given.
Configuration property keys without the
prefix.Configuration properties for the Hibernate Search engine that are considered SPI (and not API).
Default values for the different settings if no values are given.
Configuration property keys without the
prefix.Reads entity identifiers from the database.
Contextual information about a failure to index entities.
References a loading binder to use for an
entity.Class used as a marker for the default value of the
EntityLoadingBinderRef.type() attribute.Strategy for cache lookup before search query results are loaded.
An abstract contract allowing to retrieve an entity manager factory.
Maps a constructor parameter to a projection to the entity that was originally indexed,
which for the Hibernate ORM mapper is a managed entity loaded from the database.
Binds a constructor parameter to a projection to the entity that was originally indexed,
which for the Hibernate ORM mapper is a managed entity loaded from the database.
The initial and final step in an "entity" projection definition, where optional parameters can be set.
A reference to an indexed or contained entity.
Deprecated.
Use
EntityReference instead.Maps a constructor parameter to a projection to a reference to the entity that was originally indexed.
Binds a constructor parameter to a projection to a reference to the entity that was originally indexed.
The initial and final step in an "entity reference" projection definition, where optional parameters can be set.
A service allowing to postpone Hibernate Search initialization works
to a later time, when the environment (e.g.
A sequence of
EventContextElement.An atomic element of context when an event occurs:
a mapped type, or an index, or a field path, ...
The initial step in an "exists" predicate definition, where the target field can be set.
The final step in an "exists" predicate definition, where optional parameters can be set.
ExtendedSearchAggregationFactory<S extends ExtendedSearchAggregationFactory<?,PDF>,PDF extends SearchPredicateFactory>
A base interface for subtypes of
SearchAggregationFactory allowing to
easily override the self type and predicate factory type for all relevant methods.A base interface for subtypes of
SearchFetchable allowing to
easily override the result type for all relevant methods.A base interface for subtypes of
SearchPredicateFactory allowing to
easily override the self type for all relevant methods.A base interface for subtypes of
SearchProjectionFactory allowing to
easily override the self type for all relevant methods.A base interface for subtypes of
SearchQuery allowing to
easily override the result type for all relevant methods.A base interface for subtypes of
SearchScroll allowing to
easily override the result type for all relevant methods.ExtendedSearchSortFactory<S extends ExtendedSearchSortFactory<?,PDF>,PDF extends SearchPredicateFactory>
A base interface for subtypes of
SearchSortFactory allowing to
easily override the self type and predicate factory type for all relevant methods.A failure collector without any context.
Contextual information about a failing background operation.
A handler for failures occurring during background operations,
which may not have been reported to the caller due to being executed asynchronously.
Maps a constructor parameter to a projection to the value of a field in the indexed document.
Binds a constructor parameter to a projection to the value of a field in the indexed document.
The initial and final step in a "field" projection definition, where optional parameters can be set.
The initial step in a "field" projection definition,
where the projection (optionally) can be marked as multi-valued (returning Lists),
and where optional parameters can be set.
The step in a sort definition where the behavior on missing values can be set.
The initial and final step in a "field" sort definition, where optional parameters can be set.
Deprecated.
Use
FromDocumentValueConverter
with FromDocumentValueConvertContext instead.Deprecated.
Deprecated.
Implement
FromDocumentValueConverter instead.An extension to
FromDocumentValueConvertContext, allowing to access non-standard context
specific to a given mapper.A converter from a source value in the document model to a different value.
Maps a property to a full-text field in the index, potentially holding multiple tokens (words) of text.
A generic superinterface for Predicate DSL steps that involve collecting clauses and options of a boolean predicate.
An implementation of
PojoTypeModel that takes advantage of the context
in which a given property appears to derive more precise type information.Maps an entity property to a field in the index.
GenericSimpleBooleanPredicateClausesStep<S extends C,C extends SimpleBooleanPredicateClausesCollector<?>>
A generic superinterface for "simple boolean predicate" DSL steps that involve collecting
clauses.
A bounding box in the geocentric coordinate system.
A point in the geocentric coordinate system.
A binder from a type or property to a
GeoPoint field, representing a point on earth.A polygon in the geocentric coordinate system.
Centralizes the configuration of the Gson objects.
An extension for the Hibernate ORM mapper, giving access to Hibernate ORM-specific contexts.
Configuration property keys without the
prefix + HibernateOrmMapperOutboxPollingSettings.Radicals.COORDINATION_PREFIX.Default values for the different settings if no values are given.
Configuration property keys without the
prefix.SPI-related settings.
Configuration property keys without the
prefix.Deprecated.
Configuration property keys without the
prefix + HibernateOrmMapperSettings.Radicals.COORDINATION_PREFIX.Default values for the different settings if no values are given.
Configuration property keys without the
prefix + HibernateOrmMapperSettings.Radicals.INDEXING_PREFIX.Configuration property keys without the
prefix + HibernateOrmMapperSettings.Radicals.MULTI_TENANCY_PREFIX.Configuration property keys without the
prefix.Default values for the different settings if no values are given.
An object responsible for configuring the Hibernate Search mapping.
Constants for query hints accepted by Hibernate Search.
Scope for job execution, to be mapped to the scopes specific to each Jakarta Batch implementation.
Scope for partition execution, to be mapped to the scopes specific to each Jakarta Batch implementation.
Whether we want to be able to highlight this field.
The step in a highlighter definition where boundary scanner options can be set.
The final step in a highlighter definition where all boundary scanner options are already set.
HighlighterBoundaryScannerOptionsStep<T extends HighlighterBoundaryScannerOptionsStep<?,?>,N extends HighlighterOptionsStep<?>>
The step in a highlighter definition where the boundary scanner options can be set.
The step in a highlighter definition where the boundary scanner type can be set.
HighlighterBoundaryScannerTypeStep<T extends HighlighterBoundaryScannerOptionsStep<T,N>,N extends HighlighterOptionsStep<?>>
The step in a highlighter definition where the boundary scanner type can be set.
Defines how to encode the output snippets.
The step in a fast vector highlighter definition where options can be set.
The final step in highlighter definition.
Defines how to break up text into highlight snippets.
The step in a highlighter definition where options can be set.
The step in a plain highlighter definition where options can be set.
Defines a set of predefined pre-/post- tags.
The step in a unified highlighter definition where options can be set.
Maps a constructor parameter to a projection to highlights,
i.e.
Binds a constructor parameter to a projection to highlights,
i.e.
The final step in a highlight definition.
The initial and final step in a highlight definition, where optional parameters can be set.
A binder from a POJO property to a document identifier.
References the identifier binder to use for a
DocumentId.Class used as a marker for the default value of the
IdentifierBinderRef.type() attribute.The context provided to the
IdentifierBinder.bind(IdentifierBindingContext) method.A bridge between a POJO property of type
I and a document identifier.An extension to
IdentifierBridgeFromDocumentIdentifierContext, allowing to access non-standard context
specific to a given mapper.A reference to the identifier bridge to use for a
DocumentId.Class used as a marker for the default value of the
IdentifierBridgeRef.type() attribute.An extension to
IdentifierBridgeToDocumentIdentifierContext, allowing to access non-standard context
specific to a given mapper.Maps a constructor parameter to a projection to the identifier of the mapped entity,
i.e.
Binds a constructor parameter to a projection to the identifier of the mapped entity,
i.e.
The initial and final step in an "id" projection definition, where optional parameters can be set.
Opens an extension point to accept implicit fields.
Marks the annotated element as incubating.
The binding context associated to a specific node in the entity tree.
A composite element in the index.
IndexCompositeNode<SC extends SearchIndexScope<?>,NT extends AbstractIndexCompositeNodeType<SC,?>,F extends IndexField<SC,?>>
A descriptor of an index, exposing in particular the available fields and their characteristics.
Maps an entity type to an index.
Maps a property to an object field whose fields are the same as those defined in the property type.
The binding context associated to a specific non-root node in the entity tree.
The binding context associated to the root node in the entity tree.
A field in the index.
A reference to an "object" field of an indexed document,
allowing to add new values to this field for a given document.
Constants for the names of various traits that can be exposed by index fields.
Constants for the names of aggregation-related traits that can be exposed by index fields.
Constants for the names of predicate-related traits that can be exposed by index fields.
Constants for the names of projection-related traits that can be exposed by index fields.
Constants for the names of sort-related traits that can be exposed by index fields.
The type of a field in the index.
The step in an index field type definition where DSL converters (applied when using the search DSL)
and projection converters (applied when projecting in a search query) can be set.
The type of a field in the index,
exposing its various capabilities.
A factory for types of index fields.
An extension to the index field type DSL, allowing to create non-standard types in an index schema.
The final step in an index field type definition, where the type can be retrieved.
The final step in an index field type definition, where optional parameters can be set.
An indexer scoped to a single index.
A set of works to be executed on a single index.
Given a property, defines how a dependency of the indexing process to this property
should affect its reindexing.
The step in an "indexing dependency" definition where optional parameters can be set.
Determines how the thread will block upon committing a transaction
where indexed entities were modified.
The names of built-in indexing plan synchronization strategies.
Defines the layout of indexes on the Elasticsearch side:
the name of aliases to assign to Elasticsearch indexes,
as well as the structure of non-alias names.
An index manager as viewed by Hibernate Search users.
The object responsible for applying works and searches to a full-text index.
A start context for index managers.
IndexObjectField<SC extends SearchIndexScope<?>,NT extends AbstractIndexCompositeNodeType<SC,?>,C extends IndexCompositeNode<SC,NT,F>,F extends IndexField<SC,?>>
An "object" field in the index, i.e.
A reference to an "object" field of an indexed document,
allowing to add new values to this field for a given document.
The type of an "object" field in the index,
exposing its various capabilities.
An index schema collector that walks through an index schema exports of a schema manager this collector is passed to.
An element of the index schema,
allowing the definition of child fields.
The final step in the definition of a field in the index schema,
where a reference to the field can be retrieved.
The final step in the definition of a field in the index schema,
where a reference to the field can be retrieved,
optionally setting some parameters beforehand.
The final step in the definition of a field template in the index schema,
where options can be set.
A manager for the schema of a single index,
i.e.
The final step in the definition of a named predicate in the index schema.
An object field in the index schema,
allowing the definition of child fields,
customization of some characteristics of this object field such as
multi-valued-ness,
and the retrieval of a field reference to be used when indexing.The scope of an index-related operation, aware of the targeted indexes and of the underlying technology (backend).
An extension to the index scope, providing an extended index scope offering backend-specific utilities.
Configuration properties common to all Hibernate Search indexes regardless of the underlying technology.
IndexValueField<SC extends SearchIndexScope<?>,NT extends AbstractIndexValueFieldType<SC,?,?>,C extends IndexCompositeNode<SC,?,?>>
A "value" field in the index, i.e.
The type of a "value" field in the index,
exposing its various capabilities and accepted Java types.
The entry point for explicit index operations on a single index.
Listener before the start of the job.
Helpers allowing to log JSON.
A simpler, safer, read-only wrapper around
Map
that exposes only a few methods to retrieve a value from a given key.Maps a property to a keyword field in the index, holding a single token (word) of text.
The initial step in a "knn" predicate definition, where the target field can be set.
The final step in a "knn" predicate definition, where optional parameters can be set.
The step in a "knn" predicate definition where the vector to match is defined.
Mark the property hosting the latitude of a specific spatial coordinate.
A binder for markers that mark a property as the latitude or longitude
for a
GeoPoint bridge.The result of the loading of the entities by the
ProjectionHitMapper.Mark the property hosting the longitude of a specific spatial coordinate.
The step in an analysis component definition where optional parameters can be set.
A context allowing the definition of named analyzers and normalizers in a Lucene backend.
A provider of analysis-related definitions that can be referenced from the mapping,
e.g.
The step in an analyzer/normalizer definition
where optional components such as char filters or token filters can be added.
The step in an analyzer definition
where tokenizer paramaters can be set,
and where optional components such as char filters or token filters can be added.
The step in an analyzer definition where the tokenizer can be set.
The initial step in an analyzer definition, where the type of analyzer can be set.
Configuration properties for Lucene backends.
Default values for the different settings if no values are given.
Configuration properties for the Hibernate Search Lucene backend that are considered SPI (and not API).
Default values for the different settings if no values are given.
Configuration property keys without the
prefix.An extension for the Lucene backend, giving access to Lucene-specific features.
A contributor adding native Lucene fields to the index schema.
An extractor extracting the value from a native Lucene field.
Constants for the names of Lucene-specific traits that can be exposed by index fields.
Extended version of an
SchemaExport that exposes any Lucene-specific methods.The
LuceneIndexScope exposes IndexReaders directly, making it possible to query the Lucene
indexes directly bypassing Hibernate Search.Configuration properties for Lucene indexes.
Default values for the different settings if no values are given.
Configuration property keys for directories without the
prefix.Configuration property keys for indexing, without the
prefix.Configuration property keys for I/O, without the
prefix.Configuration property keys for merge options, without the
prefix.Configuration property keys for sharding, without the
prefix.Configuration property keys for index writer options, without the
prefix.The step in a normalizer definition
where optional components such as char filters or token filters can be added.
The initial step in an analyzer definition, where the type of normalizer can be set.
A factory for search predicates with some Lucene-specific methods.
A factory for search projections with some Lucene-specific methods.
A factory for search sorts with some Lucene-specific methods.
A representation of an entity type that can be mapped to an index.
The object responsible for applying works and searches to a full-text index.
A builder for
MappedIndexManager instances,
which will be the interface between the mapping and the index when indexing and searching.A factory for
MappedIndexManager instances,
which will be the interface between the mapping and the index when indexing and searching.An exception thrown by
Mapper.prepareBuild() when detecting that failures were
collected
and deciding to abort early to avoid a snowball effect creating too many failures,
which would make the failure report unclear.An element in the entity model annotated with a mapping annotation.
A method parameter in the entity model annotated with a mapping annotation.
A property in the entity model annotated with a mapping annotation.
A type in the entity model annotated with a mapping annotation.
A superinterface for contexts passed to mapping annotation processors.
A build context for mappings.
A unique representation of an element in the mapping.
The context passed to the mapper during the very last step of bootstrap.
An object responsible for finalizing a mapping.
Interface used by the engine to manipulate mappings
An object responsible for initiating a mapping by contributing its basic configuration (indexed types, type metadata),
then creating the mapper based on the configuration processed by the engine.
Tagging interface for objects used as a key to retrieve mappings at different states:
when finalizing the mapping in
SearchIntegrationFinalizer.finalizeMapping(MappingKey, MappingFinalizer).A pre-stop context for mappings.
A start context for mappings.
A binder of property markers.
References a
MarkerBinder.Class used as a marker for the default value of the
MarkerBinderRef.type() attribute.Applies a marker to a property using a
MarkerBinder.A MassIndexer is useful to rebuild the indexes from the
data contained in the database.
This step allows to define a filter on entities of a given type that has to be re-indexed
A step to define optional parameters for the JPQL/HQL conditional expression or other new expressions.
Contextual information about a failure to load or index a entities during mass indexing.
An interface for pluggable components that set up and tear down the environment of mass indexing threads,
for example, to initialize
ThreadLocals.Context provided to
MassIndexingEnvironment when configured hooks are considered for
execution around the identifier loading work.Context provided to
MassIndexingEnvironment when configured hooks are considered for
execution around the entity loading work.Contextual information about a failing operation during mass indexing.
Deprecated.
move to
MassIndexingFailureHandler.A handler for failures occurring during mass indexing.
A utility class to start the Hibernate Search Jakarta Batch mass indexing job.
Parameter builder for mass-indexing job.
Deprecated.
move to
MassIndexingMonitor.A component that monitors progress of mass indexing.
The initial and final step in "match all" predicate definition, where optional parameters can be set.
MatchIdPredicateMatchingMoreStep<S extends MatchIdPredicateMatchingMoreStep<?,N>,N extends MatchIdPredicateOptionsStep<?>>
The final step in a "match id" predicate definition,
where more IDs to match can be set.
The step in a "match id" predicate definition where the IDs to match can be set.
The final step in a "match id" predicate definition,
where optional parameters can be set.
The initial and final step in "match none" predicate definition.
MatchPredicateFieldMoreStep<S extends MatchPredicateFieldMoreStep<?,N>,N extends MatchPredicateOptionsStep<?>>
The step in a "match" predicate definition where the value to match can be set
(see the superinterface
MatchPredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "match" predicate definition, where the target field can be set.
The step in a "match" predicate definition where the value to match can be set.
The final step in a "match" predicate definition, where optional parameters can be set.
Meta-annotation for annotations that apply mapping to a method parameter.
A processor for mapping annotations applied to a Java method parameter.
A reference to a
MethodParameterMappingAnnotationProcessor.Class used as a marker for the default value of the
MethodParameterMappingAnnotationProcessorRef.type() attribute.The step in a mapping definition where a method parameter can be mapped.
The step in a "minimum should match" constraint definition
where a condition can be defined as necessary for the following requirements to be enforced.
The step in a "minimum should match" constraint definition
where the constraint definition can be
ended,
or more conditions can be added.The step in a "minimum should match" constraint definition
where the minimum required number or percentage of should clauses to match can be set.
The step in a predicate definition where the boost of the last added field(s) can be set.
The initial and final step in named predicate definition.
An object where the clauses
of a
nested predicate can be set.The step in a nested predicate definition where
clauses can be added.
Deprecated.
Use
SearchPredicateFactory.nested(String) instead.Deprecated.
Use
SearchPredicateFactory.nested(String) instead.Deprecated.
Use
SearchPredicateFactory.nested(String) instead.Maps a property to a non-standard field in the index.
Whether index-time scoring information for the field should be stored or not.
The initial and final step in "not" predicate definition.
A path from a root object to one or more target value(s).
Maps a constructor parameter to an object projection bound to a specific object field in the indexed document.
Binds a constructor parameter to an object projection bound to a specific object field in the indexed document.
Defines how the structure of an object field is preserved upon indexing.
Interface defining how operation should be submitted to the queue or executor.
An extension to the search mapping, giving access to features specific to the outbox polling coordination strategy.
Exposes some utilities to handle aborted events,
which are events that have been processed many times without success.
A param, i.e.
PhrasePredicateFieldMoreStep<S extends PhrasePredicateFieldMoreStep<?,N>,N extends PhrasePredicateOptionsStep<?>>
The step in a "phrase" predicate definition where the phrase to match can be set
(see the superinterface
PhrasePredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "phrase" predicate definition, where the target field can be set.
The step in a "phrase" predicate definition where the phrase to match can be set.
The final step in a "phrase" predicate definition, where optional parameters can be set.
A Pojo introspector used at bootstrap.
Allows to access to the
XProperty private field Member.A collector of extended mapping information.
An accessor allowing the retrieval of an element, for example a property, from a POJO.
A simple, default implementation for
EntityReference for POJO-based mappers.A delegate for the POJO implementation of
EntityReferenceFactory.Session-scoped information and operations for use in
PojoImplicitReindexingResolver.A collector of extended mapping information.
An interface for indexing entities in the context of a session in a POJO mapper,
immediately, asynchronously and without any sort of
planning
or handling of containing entities.An interface for indexing entities in the context of a session in a POJO mapper.
The context passed to a
PojoIndexingProcessor
and propagated to every node.Session-scoped information and operations for use in POJO indexing processors.
A set of indexing events to be sent to an external queue.
A delegate for the POJO mapper,
exposing hooks so that mappers based on the POJO mapper can consume metadata.
A loader for mass loading of entities, used in particular during mass indexing.
The context passed to
PojoMassLoadingStrategy.createEntityLoader(Set, PojoMassEntityLoadingContext).A sink for use by a
PojoMassIdentifierLoader.A loader of entity identifiers in batch, used in particular for mass indexing.
A sink for use by a
PojoMassIdentifierLoader.A MassIndexer is useful to rebuild the indexes from the
data contained in the database.
Contextual information about a mass indexing proccess.
Contextual information about a search mapping.
Context exposed to
PojoMassLoadingStrategy.A strategy for entity loading during mass indexing.
A potentially composite element in the POJO model.
A model element representing a constructor parameter to bind.
An element in the POJO model.
Represents an arbitrarily long access path when walking the POJO model.
A node in a
PojoModelPath representing a property.A node in a
PojoModelPath representing the value(s) of a property.A model element representing a property bound to a bridge.
A model element representing a type bound to a bridge.
A model element representing a value bound to a bridge.
A static definition of POJO paths for a given entity type, allowing the creation of path filters.
A static definition of POJO paths for a given entity type, allowing the creation of path filters.
Defines a set of paths that are of importance,
so that they can be detected at runtime when given a set of paths.
An identifier for POJO types.
A
PojoTypeModel representing a raw type,
where generic type parameters are ignored.A Pojo introspector used at runtime.
Mapping-scoped information and operations for use in POJO scopes.
A schema manager for all indexes targeted by a given POJO scope.
Mapping-scoped information and operations for use in POJO search sessions.
A loader for loading a small selection of entities, used in particular during search.
Context passed
PojoMassLoadingStrategy.A builder for
PojoSelectionLoadingContext,
allowing changes to the parameters of object loading,
for example while a query is being built.A strategy for entity loading during search and in indexing plans.
A collector of extended mapping information.
A model representing a POJO type: its structure (properties and their type),
its name, ...
Mapping-scoped information and operations for use in POJO work execution.
Session-scoped information and operations for use in POJO work execution.
A component able to define a predicate using the Hibernate Search Predicate DSL.
The context passed to
PredicateDefinition.create(PredicateDefinitionContext).The final step in a predicate definition, where the predicate can be retrieved.
The step in a predicate definition where score-related options can be set.
A context to configure programmatic mapping.
Whether or not we want to be able to obtain the value of the field as a projection.
A variation on
Collector suitable for projections on field values.Provides an accumulator for a given type of values to accumulate (
T).A component able to define a projection using the Hibernate Search Projection DSL.
References a
ProjectionBinder.Class used as a marker for the default value of the
ProjectionBinderRef.type() attribute.Maps a constructor parameter to a projection to the identifier of the mapped entity,
i.e.
The context passed to
ProjectionBinder.bind(ProjectionBindingContext).The context returned by
ProjectionBindingContext.multi().A variation on
Collector suitable for composing the result of inner projections
in a composite projection.Marks a constructor to use for projections from an index object (root or object field) to a Java object.
A converter from a value obtained from the backend to a projected value.
A component able to define a projection using the Hibernate Search Projection DSL.
The context passed to
ProjectionDefinition.create(SearchProjectionFactory, ProjectionDefinitionContext).The final step in a projection definition, where the projection can be retrieved.
Contract binding result hits and the mapper.
A binder from a POJO property to index fields.
References a
PropertyBinder.Class used as a marker for the default value of the
PropertyBinderRef.type() attribute.Maps a property to index fields using a
PropertyBinder,
which will define a PropertyBridge.The context provided to the
PropertyBinder.bind(PropertyBindingContext) method.A bridge between a POJO property and an element of the index schema.
The context passed to
PropertyBridge.write(DocumentElement, Object, PropertyBridgeWriteContext).An extension to
PropertyBridgeWriteContext, allowing to access non-standard context
specific to a given mapper.Meta-annotation for annotations that apply mapping to a property.
A processor for mapping annotations applied to a Java property.
A reference to a
PropertyMappingAnnotationProcessor.Class used as a marker for the default value of the
PropertyMappingAnnotationProcessorRef.type() attribute.The step in a property-to-document-ID mapping where optional parameters can be set.
The step in a property-to-index-field mapping where optional parameters can be set.
The step in a property-to-index-field mapping where optional parameters can be set,
when the index field is a full-text field.
The step in a property-to-index-field mapping where optional parameters can be set,
when the index field is a generic field.
The step in a property-to-indexed-embedded mapping where optional parameters can be set.
The step in a property-to-index-field mapping where optional parameters can be set,
when the index field is a keyword field.
The step in a property-to-index-field mapping where optional parameters can be set,
when the index field is not a full-text field.
The step in a property-to-index-field mapping where optional parameters can be set,
when the index field is a "scaled number" field.
The step in a property-to-index-field mapping where optional parameters can be set.
The step in a mapping definition where a property can be mapped.
The step in a property-to-index-field mapping where optional parameters can be set,
when the index field is a vector field.
A reference to a POJO property using its name,
and to one or more target value(s) in that property using a
ContainerExtraction.A context allowing the configuration of query caching in a Lucene backend.
A configurer for query caching.
QueryStringPredicateFieldMoreStep<S extends QueryStringPredicateFieldMoreStep<?,N>,N extends QueryStringPredicateOptionsStep<?>>
The step in a "query string" predicate definition where the query string to match can be set
(see the superinterface
QueryStringPredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "query string" predicate definition, where the target field can be set.
The step in a "query string" predicate definition where the query string to match can be set.
The final step in a "query string" predicate definition, where optional parameters can be set.
A representation of a range that can be used with any type.
The initial step in a "range" aggregation definition, where the target field can be set.
RangeAggregationOptionsStep<S extends RangeAggregationOptionsStep<?,PDF,F,A>,PDF extends SearchPredicateFactory,F,A>
The final step in a "range" aggregation definition, where optional parameters can be set.
RangeAggregationRangeMoreStep<S extends RangeAggregationRangeMoreStep<?,?,PDF,F>,N extends RangeAggregationOptionsStep<?,PDF,F,Map<Range<F>,Long>>,PDF extends SearchPredicateFactory,F>
The step in a "range" aggregation definition where optional parameters can be set,
(see the superinterface
RangeAggregationOptionsStep),
or more ranges can be added.RangeAggregationRangeStep<N extends RangeAggregationRangeMoreStep<?,?,PDF,F>,PDF extends SearchPredicateFactory,F>
The step in a "range" aggregation definition where the ranges can be set.
RangePredicateFieldMoreStep<S extends RangePredicateFieldMoreStep<?,N>,N extends RangePredicateOptionsStep<?>>
The step in a "range" predicate definition where the limits of the range to match can be set
(see the superinterface
RangePredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "range" predicate definition, where the target field can be set.
The step in a "range" predicate definition where the range to match can be set.
The final step in a "range" predicate definition, where optional parameters can be set.
RegexpPredicateFieldMoreStep<S extends RegexpPredicateFieldMoreStep<?,N>,N extends RegexpPredicateOptionsStep<?>>
The step in a "regexp" predicate definition where the pattern to match can be set
(see the superinterface
RegexpPredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "regexp" predicate definition, where the target field can be set.
The step in a "regexp" predicate definition where the pattern to match can be set.
The final step in a "regexp" predicate definition, where optional parameters can be set.
Defines the impact that an update to a value in an entity will have on reindexing of this entity and containing entities.
A resolver of Java resources.
The rewrite parameter determines:
How Lucene calculates the relevance scores for each matching document
Whether Lucene changes the original query to a bool query or bit set
If changed to a bool query, which term query clauses are included
Meta-annotation for annotations that Hibernate Search should attempt to discover on bootstrap,
in order to automatically detect mapped types,
without application developers having to explicitly list mapped types.
An object responsible for assigning a
RoutingBridge to an indexed entity.References a
RoutingBinder.Class used as a marker for the default value of the
RoutingBinderRef.type() attribute.An object responsible for routing an indexed entity to the correct index/shard.
The context passed to
RoutingBridge.route(DocumentRoutes, Object, Object, RoutingBridgeRouteContext).An extension to
RoutingBridgeRouteContext, allowing to access non-standard context
specific to a given mapper.Maps a property to a scaled number field in the index,
i.e.
The initial and final step in a "scaled number" index field type definition, where optional parameters can be set.
An extension to the index schema export, allowing to access backend-specific methods of a schema export.
Maps a constructor parameter to a projection to the score of the hit.
Binds a constructor parameter to a projection to the score of a hit.
The initial and final step in a "score" projection definition, where optional parameters can be set.
The initial and final step in a "score" sort definition, where optional parameters can be set.
Marks the annotated element as still present in Hibernate Search 5 APIs.
Whether or not we want to be able to search the document using this field.
SearchableProjectableIndexFieldTypeOptionsStep<S extends SearchableProjectableIndexFieldTypeOptionsStep<?,F>,F>
The initial and final step in a "searchable/projectable" index field type definition, where optional parameters can be set.
A search aggregation, i.e.
A search aggregation builder, i.e.
A factory for search aggregation builders.
SearchAggregationDslContext<SC extends SearchAggregationIndexScope<?>,PDF extends SearchPredicateFactory>
Represents the current context in the search DSL,
including in particular the search scope and the aggregation builder factory.
A factory for search aggregations.
An extension to the search aggregation DSL, allowing the use of non-standard aggregations in a query.
Given a type, marks this type as an entity type.
A component allowing to fetch search results.
A highlighter definition to be applied to a query.
Factory for search highlighters.
Types of supported highlighters.
Information about a composite index element targeted by search; either the index root or an object field.
SearchIndexCompositeNodeTypeContext<SC extends SearchIndexScope<?>,N extends SearchIndexCompositeNodeContext<SC>>
Information about the type of a composite (non-value) index element targeted by search,
be it in a projection, a predicate, a sort, ...
A descriptor of an indexed entity type,
exposing in particular the index manager for this entity.
Information about an identifier targeted by search.
An interface for indexing entities in the context of an ORM Session.
Deprecated.
Configurer implementers are responsible for specifying which types should be included/excluded from indexing.
A context that helps with the indexing plan filter configuration.
Information about an index node targeted by search,
be it the index root, a value field or an object field.
Information about the type of an composite index element targeted by search,
be it in a projection, a predicate, a sort, ...
Information about indexes targeted by search,
be it in a projection, a predicate, a sort, ...
Information about a value (non-object) field targeted by search,
be it in a projection, a predicate, a sort, ...
Information about the type of a value (non-object) field targeted by search,
be it in a projection, a predicate, a sort, ...
The environment of a search integration,
i.e.
An execution context for queries,
providing components allowing to load data from an external source (relational database, ...).
A builder for
SearchLoadingContext,
allowing to change the parameters of object loading while a query is being built.The DSL entry point passed to consumers in
SearchQueryOptionsStep.loading(Consumer),
allowing the definition of loading options (fetch size, cache lookups, ...).The Hibernate Search mapping between the Hibernate ORM model and the backend(s).
An extension to the search mapping, providing an extended search mapping offering mapper-specific utilities.
A query predicate that can be used to filter queries.
A search predicate builder, i.e.
A factory for search predicate builders.
Represents the current context in the search DSL,
including in particular the search scope and the predicate builder factory.
A factory for search predicates.
An extension to the search predicate DSL, allowing the use of non-standard predicates in a query.
The second and later step when attempting to apply multiple extensions
to a
SearchPredicateFactory.The initial step when attempting to apply multiple extensions
to a
SearchPredicateFactory.A query projection that can be used to obtain particular values of an indexed document.
A search projection builder, i.e.
A factory for search projection builders.
Represents the current context in the search DSL,
including in particular the search scope and the projection builder factory.
A factory for search projections.
An extension to the search projection DSL, allowing the use of non-standard projections in a query.
The second and later step when attempting to apply multiple extensions
to a
SearchProjectionFactory.The initial step when attempting to apply multiple extensions
to a
SearchProjectionFactory.A search query, allowing to fetch search results.
A builder for search queries.
An extension to the search query DSL, allowing to set non-standard options on a query.
A factory for query elements (predicates, sorts, projections, aggregations, ...) targeting index nodes
(root, value fields, object fields).
An extension to the search query, allowing to wrap a query.
The final step in a query definition,
where the query can be
executed or retrieved as an object.Defines the "service program contract" for
SearchQuery.SearchQueryOptionsStep<S extends SearchQueryOptionsStep<?,H,LOS,SF,AF>,H,LOS,SF extends SearchSortFactory,AF extends SearchAggregationFactory>
The final step in a query definition, where optional parameters such as
sorts can be set,
and where the query can be executed or retrieved as an object.SearchQuerySelectStep<N extends SearchQueryOptionsStep<?,E,LOS,?,?>,R,E,LOS,PJF extends SearchProjectionFactory<R,E>,PDF extends SearchPredicateFactory>
The initial step in a query definition, where the element used to represent query hits,
i.e.
SearchQueryWhereStep<N extends SearchQueryOptionsStep<?,H,LOS,?,?>,H,LOS,PDF extends SearchPredicateFactory>
The step in a query definition where the predicate, i.e.
The total for a search result, pertaining to all matched documents,
independently from the offset/limit used when fetching hits.
A schema collector that walks through all schema exports of a schema manager this collector is passed to.
The entry point for explicit schema management operations: creating indexes, dropping them, validating them, ...
Represents a set of types and the corresponding indexes.
A provider of
SearchScope instances.An ongoing query execution delivering hits continuously from a single snapshot of the index.
A Hibernate Search session, bound to a Hibernate ORM
Session/EntityManager.A search sort that can be used to sort search query results.
A search sort builder, i.e.
A factory for search sort builders.
Represents the current context in the search DSL,
including in particular the search scope, the sort builder factory
and the knowledge of previous sorts chained using
SortThenStep.then().A factory for search sorts.
An extension to the search sort DSL, allowing the use of non-standard sorts in a query.
The second and later step when attempting to apply multiple extensions
to a
SearchSortFactory.The initial step when attempting to apply multiple extensions
to a
SearchSortFactory.Represent a timeout during a Hibernate Search operation.
The entry point for explicit, large-scale index operations.
A resolver of Java services.
A helper to abstract away all the complexity of wrapping sections of code in a session (and transaction).
A strategy for translating routing keys into actual shard identifiers
The initial and final step in a "simple boolean predicate" definition,
where clauses
can be added and options can be set.
The initial and final step in a "simple boolean predicate" definition, where options can be set.
A simple glob pattern implementation that only supports the
* wildcard.SimpleQueryStringPredicateFieldMoreStep<S extends SimpleQueryStringPredicateFieldMoreStep<?,N>,N extends SimpleQueryStringPredicateOptionsStep<?>>
The step in a "simple query string" predicate definition where the query string to match can be set
(see the superinterface
SimpleQueryStringPredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "simple query string" predicate definition, where the target field can be set.
The step in a "simple query string" predicate definition where the query string to match can be set.
The final step in a "simple query string" predicate definition, where optional parameters can be set.
A task that can be scheduled for a run and is guaranteed to never run concurrently,
regardless of the thread pool it's submitted to.
Whether a field can be used in sorts.
The step in a sort definition where a filter can be set
to select nested objects from which values will be extracted for this sort.
The final step in a sort definition, where the sort can be retrieved.
Defines how to pick the value to sort on for multi-valued fields.
The step in a sort definition where the
SortMode can be set.The step in a sort definition where the order can be set.
The step in a sort definition where another sort can be chained.
The initial step of all spatial predicate definitions.
The step in a "within" predicate definition where the area to match can be set.
SpatialWithinPredicateFieldMoreStep<S extends SpatialWithinPredicateFieldMoreStep<?,N>,N extends SpatialWithinPredicateOptionsStep<?>>
The step in a "within" predicate definition where the area to match can be set
(see the superinterface
SpatialWithinPredicateAreaStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "within" predicate definition, where the target field can be set.
The final step in a "within" predicate definition, where optional parameters can be set.
The initial and final step in a "standard" index field type definition, where optional parameters can be set.
The initial and final step in a "string" index field type definition, where optional parameters can be set.
A synthetic implementation of
PojoTypeModel,
i.e.The initial step in a "terms" aggregation definition, where the target field can be set.
TermsAggregationOptionsStep<S extends TermsAggregationOptionsStep<?,PDF,F,A>,PDF extends SearchPredicateFactory,F,A>
The final step in a "terms" aggregation definition, where optional parameters can be set.
TermsPredicateFieldMoreStep<S extends TermsPredicateFieldMoreStep<?,N>,N extends TermsPredicateOptionsStep<?>>
The step in a "terms" predicate definition where the terms to match can be set
(see the superinterface
TermsPredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "terms" predicate definition, where the target field can be set.
The step in a "terms" predicate definition where the terms to match can be set.
The final step in a "terms" predicate definition, where optional parameters can be set.
Defines the term vector storing strategy.
The thread provider, used to customize thread groups and names.
Deprecated.
Use
ToDocumentValueConverter
with ToDocumentValueConvertContext instead.Deprecated.
Use
ToDocumentValueConverter
with ToDocumentValueConvertContext and ToDocumentValueConvertContextExtension instead.Deprecated.
Implement
ToDocumentValueConverter instead.An extension to
ToDocumentValueConvertContext, allowing to access non-standard context
specific to a given mapper.A converter from a source value to a target value in the document model.
Implemented by classes that can be rendered to a string representing a tree.
An appender for use in
ToStringTreeAppendable.A helper to abstract away all the complexity of starting transactions in different environments
(JTA/non-JTA in particular),
while accepting some JTA-specific settings (transaction timeout) on a best-effort basis.
A tracker for paths actually affected by a
TreeFilterDefinition.A binder from a POJO type to index fields.
References a
TypeBinder.Class used as a marker for the default value of the
TypeBinderRef.type() attribute.Maps a type to index fields using a
TypeBinder,
which will define a TypeBridge.The context provided to the
TypeBinder.bind(TypeBindingContext) method.A bridge between a POJO type and an element of the index schema.
The context passed to
TypeBridge.write(DocumentElement, Object, TypeBridgeWriteContext).An extension to
TypeBridgeWriteContext, allowing to access non-standard context
specific to a given mapper.Meta-annotation for annotations that apply mapping to a type.
A processor for mapping annotations applied to a Java type.
A reference to a
TypeMappingAnnotationProcessor.Class used as a marker for the default value of the
TypeMappingAnnotationProcessorRef.type() attribute.The step in a mapping definition where a type's indexing can be configured more precisely.
The step in a mapping definition where a type's entity metadata can be configured more precisely.
The step in a mapping definition where a type can be mapped,
and where properties of that type can be referenced to map them more precisely.
A provider of type metadata contributors, taking into account explicit contributions,
implicit discovery and inheritance.
To avoid re-encoding strings into URLs we have several opportunities
to reuse them and compose them more efficiently.
A binder from a value to a single index field.
A reference to the value bridge to use in a
@*Field annotation,
for example in GenericField.valueBridge(), KeywordField.valueBridge(),
or FullTextField.valueBridge().Class used as a marker for the default value of the
ValueBinderRef.type() attribute.The context provided to the
ValueBinder.bind(ValueBindingContext) method.A bridge between a POJO-extracted value of type
V and an index field of type F.The context passed to
ValueBridge.fromIndexedValue(Object, ValueBridgeFromIndexedValueContext).An extension to
ValueBridgeToIndexedValueContext, allowing to access non-standard context
specific to a given mapper.A reference to the value bridge to use in a
@*Field annotation,
for example in GenericField.valueBridge(), KeywordField.valueBridge(),
or FullTextField.valueBridge().Class used as a marker for the default value of the
ValueBridgeRef.type() attribute.The context passed to
ValueBridge.toIndexedValue(Object, ValueBridgeToIndexedValueContext).An extension to
ValueBridgeToIndexedValueContext, allowing to access non-standard context
specific to a given mapper.Specifies whether values should be converted during search queries.
A handle enabling the creation of a value from an array of arguments:
Java class constructor, ...
A processor of values extracted from a container.
A handle giving read access to a value from an object instance:
field, no-argument method, ...
Deprecated.
Use/implement
ValueHandleFactory instead.Maps an entity property to a vector field in the index.
The initial and final step in a "vector" index field type definition, where optional parameters can be set.
Defines a function to calculate the vector similarity, i.e.
WildcardPredicateFieldMoreStep<S extends WildcardPredicateFieldMoreStep<?,N>,N extends WildcardPredicateOptionsStep<?>>
The step in a "wildcard" predicate definition where the pattern to match can be set
(see the superinterface
WildcardPredicateMatchingStep),
or optional parameters for the last targeted field(s) can be set,
or more target fields can be added.The initial step in a "wildcard" predicate definition, where the target field can be set.
The step in a "wildcard" predicate definition where the pattern to match can be set.
The final step in a "wildcard" predicate definition, where optional parameters can be set.
HibernateOrmMapperSettings.INDEXING_LISTENERS_ENABLEDinstead.