All Classes and Interfaces
Class
Description
Abstract base class for the document builders.
Wrapper class containing all the meta data extracted out of a single entity.
A single facet (field value and count).
Implement the Hibernate Search controller responsible for processing the
work send through JMS by the slave nodes.
Abstract loader which will take care of taking object loading timings.
Define an Analyzer for a given entity, method, field or Field
The order of precedence is as such:
- @Field
- field / method
- entity
- default
Either describe an explicit implementation through the
impl parameter
or use an external @AnalyzerDef definition through the def parameterReusable analyzer definition.
Reusable analyzer definitions.
Allows to dynamically select a named analyzer through a
Discriminator implementation.A DocIdSet built as applying "AND" operation to a list of other DocIdSet(s).
For bridges implementing this interface, provide the type of the
object the bridge is applied on:
- the return type for a property
- the class itself for a class-level bridge
Interface for different types of queue processor factories.
Implementations of this interface are not drop-in replacements for the standard BackendQueueProcessorFactory,
but are meant to be used only during batch processing.
Makes sure that several different BatchIndexingWorkspace(s)
can be started concurrently, sharing the same batch-backend
and IndexWriters.
Batch work until
BatchedQueueingProcessor.performWorks(org.hibernate.search.backend.WorkQueue) is called.This runnable will prepare a pipeline for batch indexing
of entities, managing the lifecycle of several ThreadPools.
Map a BigDecimal element
Map a
BigInteger element.This backend does not do anything: the Documents are not
sent to any index but are discarded.
Map a boolean field
Represents a boolean query that can contains one or more elements to join
Apply a boost factor on a field or a whole entity
Interface to implement boost values as functions
of the object value being boosted.
This factory is responsible for creating and initializing build-in and custom FieldBridges.
Build context that can be used by some services at initialization
MultiReader ensuring equals returns true if the underlying readers are the same (and in the same order)
Especially useful when using
CachingWrapperFilterWhile extracting values from the index might be faster than extracting
them from a Database, it might still involve costly IO operations.
A slightly different version of Lucene's original
CachingWrapperFilter which
uses SoftReferences instead of WeakReferences in order to cache
the filter BitSet.Defines the temporal resolution of a given field
Calendar are stored as String in GMT
A Filter capable of chaining other filters, so that it's
possible to apply several filters on a Query.
Map a character element
Define a
CharFilterFactory and its parametersThis annotation allows a user to apply an implementation
class to a Lucene document to manipulate it in any way
the user sees fit.
Convert a Class back and forth
Utility class to load instances of other classes by using a fully qualified name,
or from a class type.
A
FieldCacheCollectorFactory requires two parameters which are inferred from
the type of field and it's applied bridges.Runnable to close the IndexWriter of a Workspace, if open.
Provides some methods for simplified collection instantiation.
We customize Lucene's ConcurrentMergeScheduler to route eventual exceptions to our configurable errorhandler.
Provides access to some default configuration settings (eg default
Analyzer or default
Similarity) and checks whether certain optional libraries are available.Helper class to avoid managing NumberFormatException and similar code
and ensure consistent error messages across Configuration parsing problems.
Assuming connection with the search factory
Assuming connection with the search factory
Describe the owning entity as being part of the target entity's
index (to be more accurate, being part of the indexed object graph).
Deprecated.
Wrap the exception with an exception provide contextual feedback
Wrap the exception with an exception provide contextual feedback
Initialize object using one or several criteria queries.
Defines the method used to initialize an object
Defines the temporal resolution of a given field
Date are stored as String in GMT
Bridge a java.util.Date to a String, truncated to the resolution
Date are stored GMT based
Delegate to a named analyzer.
Extension of
DeleteLuceneWork bound to a single entity.Set up and provide a Lucene
Directory
equals() and hashCode() must guaranty equality
between two providers pointing to the same underlying Lucene Store.Create a Lucene directory provider which can be configured
through the following properties:
hibernate.search.default.*
hibernate.search.<indexname>.*,
where <indexname> properties have precedence over default ones.
Returns the expected discriminator name to use on the element evaluated
Interface created to keep backwards compatibility.
Set up and provide a manager for classes which are indexed via
@IndexedEmbedded, but themselves do not
contain the @Indexed annotation.Set up and provide a manager for classes which are directly annotated with
@Indexed.DocumentExtractor is a traverser over the full-text results (EntityInfo)
This operation is as lazy as possible:
- the query is executed eagerly
- results are not retrieved until actually requested
DocumentExtractor.getFirstIndex() and DocumentExtractor.getMaxIndex() define the boundaries available to DocumentExtractor.extract(int).DocumentExtractor is a traverser over the full-text results (EntityInfo)
This operation is as lazy as possible:
- the query is executed eagerly
- results are not retrieved until actually requested
#getFirstIndex and #getMaxIndex define the boundaries available to #extract.
Declare a field as the document id.
Map a double element
We need a collection of similar implementations, one per each FieldCache.DEFAULT.accessmethod
to be able to deal with arrays of primitive values without autoboxing all of them.
Double numeric field bridge, capable of decoding double values from Field
This is the main client for IndexShardingStrategies.
Apply a dynamic boost factor on a field or a whole entity.
Component of batch-indexing pipeline, using chained producer-consumers.
Wrapper class describing the loading of an element.
Wrapper class describing the loading of an element.
Used to deal with proxies or lazily-initialized objects.
Entity state with regard to indexing possibilities
Map an Enum field
Helper methods initializing Hibernate Search event listeners.
Implementation of the transactional context on top of an EventSource (Session)
Helper class to create threads;
these threads are grouped and named to be identified in a profiler.
A handler for rejected tasks that will have the caller block until
space is available.
A single facet (field value and count).
A custom
Collector used for handling facet requests.Faceting request interface.
Base class for faceting requests.
Interface defining methods around faceting.
Default implementation of the
FacetManager implementation.Groups a set of
Facet to be applied onto a query.Specifies the order in which the facets are returned.
Marks a method as a factory method for a given type.
Annotation used for marking a property as indexable.
specifies a given field bridge implementation
Link between a java property and a Lucene Document
Usually a Java property will be linked to a Document Field.
Because Lucene's Collector is not an interface, we have to create extensions of it.
Every search needs a fresh instance of a Collector, still for
each field the same name and type are going to be used.
Just an indirection to different constructors, pointing to the proper
FieldCache extractor per type.
How should we interact with Lucene's
FieldCache.Using as composition in implementations of
FieldCacheCollector,
so that we can reuse different loading strategies in different kinds
of Collectors.Mark a property as indexable into different fields
Useful if the field is used for sorting and searching
Utility class for synchronizing files/directories.
Cache mode strategy for
FullTextFilterDefs.Defines the caching filter strategy
implementations of getCachedFilter and addCachedFilter must be thread-safe
A wrapper class which encapsulates all required information to create a defined filter.
The key object must implement equals / hashcode so that 2 keys are equals if and only if
the given Filter types are the same and the set of parameters are the same.
Helper class to apply some common optimizations when
several Filters are applied.
Map a float element
We need a collection of similar implementations, one per each FieldCache.DEFAULT.accessmethod
to be able to deal with arrays of primitive values without autoboxing all of them.
Float numeric field bridge, capable of decoding float values from Field
Use a Lucene
FSDirectory.File based DirectoryProvider that takes care of index copy
The base directory is represented by hibernate.search..indexBase
The index is created in
The source (aka copy) directory is built from /
A copy is triggered every refresh seconds
File based directory provider that takes care of getting a version of the index
from a given source.
Extends an EntityManager with Full-Text operations
represents a FullTextFilter that is about to be applied
Used to inject parameters
Defines a FullTextFilter that can be optionally applied to
every FullText Queries
While not related to a specific indexed entity, the annotation has to be set on one of them
Mapping class responsible for collecting data for constructing
FullTextFilterDef annotation.
A list of FullTextFilterDef
This listener supports setting a parent directory for all generated index files.
The base interface for Lucene powered searches.
The base interface for lucene powered searches.
Implements JPA 2 query interface and delegate the call to
a Hibernate Core FullTextQuery.
Implementation of
FullTextQuery.Extends the Hibernate
Session with fulltext search and indexing capabilities.Lucene full text search aware session.
This EntityInitializer is relative to a specific Hibernate Session,
so it's able to attach detached collections to it's Session.
To be used for Hibernate initializations which don't need a specific Session.
Defines and executes an Hibernate Search query (wrapping a Lucene query).
This Runnable is consuming entity identifiers and
producing loaded detached entities for the next queue.
This Runnable is going to feed the indexing queue
with the identifiers of all the entities going to be indexed.
This implementation use idInString as the hashKey.
This implementation is never directly exposed to the user, it is always wrapped into a
MutableSearchFactoryOptimization strategy triggered after a certain amount of operations
Defines how an Field should be indexed
Implementation of the
IndexControlMBean JMX attributes and operations.Defines the Hibernate Search exposed JMX attributes and operations for index creation and purging.
A JMX based mass indexer progress monitor.
A MBean for following the progress of mass indexing.
Defines how a given virtual index shards data into different DirectoryProviders
Represents possible options to be applied to an
org.apache.lucene.index.IndexWriter.Transaction context that contains transaction boundaries methods.
Map an integer element
Integer numeric field bridge, capable of decoding integer values from Field
We need a collection of similar implementations, one per each FieldCache.DEFAULT.accessmethod
to be able to deal with arrays of primitive values without autoboxing all of them.
Responsible for sending Lucene works from slave nodes to master node
Common base class for Master and Slave BackendQueueProcessorFactories
Common utility methods shared across subsystems dealing with JGroups
Listen for messages from slave nodes and apply them into
LuceneBackendQueueProcessorHelper class to register JMX beans.
Helper class for creating an JNDI
InitialContext.Marks a method as a key constructor for a given type.
Interface defining a set of operations in order to load entities which matched a query.
To use a custom implementation of org.apache.lucene.store.LockFactory
you need to implement this interface and define the fully qualified
classname of the factory implementation as a DirectoryProvider parameter
for the locking_strategy key.
A factory class for class loggers.
Map a long element
We need a collection of similar implementations, one per each FieldCache.DEFAULT.accessmethod
to be able to deal with arrays of primitive values without autoboxing all of them.
Long numeric field bridge, capable of decoding long values from Field
Initializes objects using lookup by it.
Copied from Hibernate Core's org.hibernate.util.LRUMap
A simple LRU cache that implements the
Map interface.This will actually contain the Workspace and LuceneWork visitor implementation,
reused per-DirectoryProvider.
This is not meant to be used as a regular
backend, only to apply batch changes to the index.
Implements a standalone full text service.
Wrapper class around the Lucene indexing parameters defined in IndexWriterSetting.
A helper class for building Field objects and associating them to Documents.
Represent a Serializable Lucene unit work
WARNING: This class aims to be serializable and passed in an asynchronous way across VMs
any non backward compatible serialization change should be done with great care
and publically announced.
A wrapper to Properties, to restrict the availability of
values to only those which have a key beginning with some
masking String.
A MassIndexer is useful to rebuild the indexes from the
data contained in the database.
Prepares and configures a BatchIndexingWorkspace to start rebuilding
the indexes for all entity instances in the database.
As a MassIndexer can take some time to finish it's job,
a MassIndexerProgressMonitor can be defined in the configuration
property hibernate.search.worker.indexing.monitor
implementing this interface to track indexing performance.
Backend factory used in JGroups clustering mode in master node.
Keep the most recently used Filters in the cache
The cache is at least as big as
hibernate.search.filter.cache_strategy.size
Above this limit, Filters are kept as soft referencesA loader which loads objects of multiple types.
Represents the context in which a must clause is described.
Factory delegating to a concrete implementation of another factory,
Useful to swap one factory for another.
Shared factory state
Open a reader each time
Base class for numbers - integer, double, etc.
Extension annotation for
@Field supporting Lucene's numeric field feature.Bridge to index numeric values using a Trie structure (multiple terms representing different precisions)
Numeric extension for Fields annotation
Utility class to handle Numeric Fields
Define whether or not to check if objects are already present in:
- the second level cache
- the persistence context
In most cases, no presence check is necessary.
Initializes a set of objects from EntityInfos
A unit of work triggering an optimize operation.
Wrap the subsequent Runnable in a JTA Transaction if necessary:
- if the existing Hibernate Core transaction strategy requires a TransactionManager
- if no JTA transaction is already started
Unfortunately at this time we need to have access to SessionFactoryImplementor
Parameter (basically key/value pattern)
Allow parameter injection to a given bridge.
Analyzer that applies no operation whatsoever to the flux
This is useful for queries operating on non tokenized fields.
Interface to implement visitor pattern in combination
with DpSelectionVisitor and DpSelectionDelegate to
send LuceneWork to the appropriate queues, as defined
by an IndexShardingStrategy.
Helper class which keeps track of all super classes and interfaces of the indexed entities.
Execute some work inside a transaction synchronization
Implements a blocking queue capable of storing
a "poison" token to signal consumer threads
that the task is finished.
Defined projection constants.
Implementation of the
Loader interface used for loading entities which are projected via
ProjectionConstants.THIS.Objects whose identifier is provided externally and not part of the object state
should be marked with this annotation
A unit of work used to purge an entire index.
Keep the query builder contextual information
Query builder that needs contextualization:
A query builder should know which entity or analyzer it relies on.
Operations common to all types of queries
A helper class which gives access to the current query and its hits.
Represent a timeout during a Fulltext search in the HSQuery.
Pile work operations
No thread safety has to be implemented, the queue being scoped already
The implementation must be "stateless" wrt the queue through (ie not store the queue state)
FIXME this Interface does not make much sense, since the impl will not be changed
Use a Lucene RAMDirectory
Responsible for providing and managing the lifecycle of a read only reader.
Date indexing resolution.
A
ScopedAnalyzer is a wrapper class containing all analyzers for a given class.Implements scrollable and paginated resultsets.
Helper class that should be used when building a FullTextEntityManager
Helper class to get a FullTextSession out of a regular session.
Provides configuration to Hibernate Search
Search configuration implementation wrapping an Hibernate Core configuration
Root of all search specific exceptions
Provide application wide operations as well as access to the underlying Lucene resources.
Build a search factory following the builder pattern.
Interface which gives access to the metadata.
Search Factory implementor exposing its sharable state.
This contract is considered experimental.
Represents the sharable state of a search factory
package class extracting the SearchMappingFactory if needed
Check if the entity is available in the second level cache and load it if there
before falling back to the delegate method.
Control the life cycle of a service attached and used by Hibernate Search
It allows to:
- start the service
- stop the service
- declare the key the service is exposed to
TODO should it be the implementation name itself?
- provide access tot he service
When using this class in @FullTextFilterDef.impl, Hibernate Search
considers the filter to be only influencing the sharding strategy.
Deprecated.
replaced by SharingBufferReaderProvider
This
ReaderProvider shares IndexReaders as long as they are "current";
main difference with SharedReaderProvider is the way to update the Readers when needed:
this uses IndexReader.reopen() which should improve performance on larger indexes
as it shares buffers with previous IndexReader generation for the segments which didn't change.Map a short element
A very simple implementation of
MassIndexerProgressMonitor which
uses the logger at INFO level to output indexing speed statistics.Simplest implementation of an ErrorContext, use it
to wrap single exceptions in the backend which are hard to relate
to the workqueue as a whole.
Cache following a "Most Recently Used" (MRU) algorithm for maintaining a
bounded in-memory size; the "Least Recently Used" (LRU) entry is the first
available for removal from the cache.
Implements a filter key usign all injected parameters to compute
equals and hashCode
the order the parameters are added is significant
Interface which defines several methods allowing to access statistical data.
A concurrent implementation of the
Statistics interface.Statistics SPI for the Search.
Whether or not the value is stored in the document
Bridge to use a StringBridge as a FieldBridge.
Map a string element
Transform an object into a string representation.
We need a collection of similar implementations, one per each FieldCache.DEFAULT.accessmethod
to be able to deal with arrays of primitive values without autoboxing all of them.
Defines the term vector storing strategy
The internal engine will use this exception factory to
throw exceptions of an appropriate type according to a
specific API.
Define a
TokenFilterFactory and its parameters.Define a
TokenizerFactory and its parameters.Queue works per transaction.
Contract needed by Hibernate Search to batch changes per transaction.
A
FieldBridge able to convert the index representation back into an object without losing information.Bridge to use a TwoWayStringBridge as a TwoWayFieldBridge
StringBridge allowing a translation from the string representation back to the Object.Wraps a FieldCacheCollector in such a way that
TwoWayTransformingFieldCacheCollector.getValue(int) returns objects as transformed
by a TwoWayStringBridge to transform from String form to the object.Allow a BackendQueueProcessorFactory to be notified of
DirectoryProvider changes.Bridge for
URIBridge for
URLs.A hashtable-based Map implementation with weak keys and
using reference-equality in place of object-equality when comparing keys
(and values).
A unit of work.
Perform work for a given context (eg a transaction).
Build context for the worker and other backend
Available after all index, entity metadata are built.
Represents the set of changes going to be applied to the index for the entities.
Lucene workspace for a DirectoryProvider.
Enumeration of the different types of Lucene work.
A visitor delegate to manipulate a LuceneWork
needs to implement this interface.
Build context where new built element can be registered.
A utility class to help with xml parsing
FullTextSession.getSearchFactory()instead.